Lines Matching full:token
55 case Token::kw_affine_map: {
56 consumeToken(Token::kw_affine_map);
59 if (parseToken(Token::less, "expected '<' in affine map") ||
61 parseToken(Token::greater, "expected '>' in affine map"))
65 case Token::kw_affine_set: {
66 consumeToken(Token::kw_affine_set);
69 if (parseToken(Token::less, "expected '<' in integer set") ||
71 parseToken(Token::greater, "expected '>' in integer set"))
77 case Token::l_square: {
78 consumeToken(Token::l_square);
85 if (parseCommaSeparatedListUntil(Token::r_square, parseElt))
91 case Token::kw_false:
92 consumeToken(Token::kw_false);
94 case Token::kw_true:
95 consumeToken(Token::kw_true);
99 case Token::kw_dense:
103 case Token::kw_dense_resource:
107 case Token::kw_array:
111 case Token::l_brace: {
119 case Token::hash_identifier:
123 case Token::floatliteral:
125 case Token::integer:
127 case Token::minus: {
128 consumeToken(Token::minus);
129 if (getToken().is(Token::integer))
131 if (getToken().is(Token::floatliteral))
140 case Token::kw_loc: {
141 consumeToken(Token::kw_loc);
144 if (parseToken(Token::l_paren, "expected '(' in inline location") ||
146 parseToken(Token::r_paren, "expected ')' in inline location"))
152 case Token::kw_sparse:
156 case Token::kw_strided:
160 case Token::kw_distinct:
164 case Token::string: {
166 consumeToken(Token::string);
168 if (!type && consumeIf(Token::colon) && !(type = parseType()))
176 case Token::at_identifier: {
185 consumeToken(Token::at_identifier);
189 while (getToken().is(Token::colon)) {
192 consumeToken(Token::colon);
193 if (!consumeIf(Token::colon)) {
194 if (getToken().isNot(Token::eof, Token::error)) {
202 if (getToken().isNot(Token::at_identifier)) {
213 consumeToken(Token::at_identifier);
226 case Token::kw_unit:
227 consumeToken(Token::kw_unit);
231 case Token::code_complete:
232 if (getToken().isCodeCompletionFor(Token::hash_identifier))
251 case Token::at_identifier:
252 case Token::floatliteral:
253 case Token::integer:
254 case Token::hash_identifier:
255 case Token::kw_affine_map:
256 case Token::kw_affine_set:
257 case Token::kw_dense:
258 case Token::kw_dense_resource:
259 case Token::kw_false:
260 case Token::kw_loc:
261 case Token::kw_sparse:
262 case Token::kw_true:
263 case Token::kw_unit:
264 case Token::l_brace:
265 case Token::l_square:
266 case Token::minus:
267 case Token::string:
282 return parseOptionalAttributeWithToken(Token::l_square, attribute, type);
286 return parseOptionalAttributeWithToken(Token::string, attribute, type);
290 return parseOptionalAttributeWithToken(Token::at_identifier, result, type);
304 if (getToken().is(Token::string))
306 else if (getToken().isAny(Token::bare_identifier, Token::inttype) ||
326 if (!consumeIf(Token::equal)) {
348 consumeToken(Token::floatliteral);
351 if (!consumeIf(Token::colon))
411 Token tok = getToken();
415 consumeToken(Token::integer);
418 if (!consumeIf(Token::colon))
455 static ParseResult parseElementAttrHexValues(Parser &parser, Token tok,
520 /// Storage used when parsing elements, this is a pair of <is_negated, token>.
521 std::vector<std::pair<bool, Token>> storage;
524 std::optional<Token> hexStorage;
532 if (allowHex && p.getToken().is(Token::string)) {
534 p.consumeToken(Token::string);
538 if (p.getToken().is(Token::l_square))
616 const Token &token = signAndToken.second;
617 auto tokenLoc = token.getLoc();
625 if (token.is(Token::floatliteral)) {
630 assert(token.isAny(Token::integer, Token::kw_true, Token::kw_false) &&
631 "unexpected token type");
632 if (token.isAny(Token::kw_true, Token::kw_false)) {
637 APInt apInt(1, token.is(Token::kw_true), /*isSigned=*/false);
644 buildAttributeAPInt(eltTy, isNegative, token.getSpelling());
659 const Token &token = signAndToken.second;
661 if (failed(p.parseFloatFromLiteral(result, token, isNegative,
730 case Token::kw_true:
731 case Token::kw_false:
732 case Token::floatliteral:
733 case Token::integer:
739 case Token::minus:
740 p.consumeToken(Token::minus);
741 if (!p.getToken().isAny(Token::floatliteral, Token::integer))
747 case Token::string:
753 case Token::l_paren:
754 p.consumeToken(Token::l_paren);
756 p.parseToken(Token::comma, "expected ',' between complex elements") ||
758 p.parseToken(Token::r_paren, "expected ')' after complex elements"))
789 if (p.getToken().getKind() == Token::l_square) {
858 bool isNegative = p.consumeIf(Token::minus);
863 if (p.getToken().isAny(Token::kw_true, Token::kw_false)) {
866 value = APInt(/*numBits=*/8, p.getToken().is(Token::kw_true),
869 } else if (p.consumeIf(Token::integer)) {
881 bool isNegative = p.consumeIf(Token::minus);
882 Token token = p.getToken();
885 p.parseFloatFromLiteral(fromIntLit, token, isNegative,
895 consumeToken(Token::kw_array);
896 if (parseToken(Token::less, "expected '<' after 'array'"))
918 if (consumeIf(Token::greater))
921 if (parseToken(Token::colon, "expected ':' after dense array type"))
934 if (parseToken(Token::greater, "expected '>' to close an array attribute"))
942 consumeToken(Token::kw_dense);
943 if (parseToken(Token::less, "expected '<' after 'dense'"))
948 if (!consumeIf(Token::greater)) {
950 parseToken(Token::greater, "expected '>'"))
966 consumeToken(Token::kw_dense_resource);
967 if (parseToken(Token::less, "expected '<' after 'dense_resource'"))
973 if (failed(rawHandle) || parseToken(Token::greater, "expected '>'"))
984 if (parseToken(Token::colon, "expected ':'") || !(attrType = parseType()))
1005 if (parseToken(Token::colon, "expected ':'"))
1026 consumeToken(Token::kw_sparse);
1027 if (parseToken(Token::less, "Expected '<' after 'sparse'"))
1034 if (consumeIf(Token::greater)) {
1056 if (parseToken(Token::comma, "expected ','"))
1065 if (parseToken(Token::greater, "expected '>'"))
1101 // Callback for error emissing at the keyword token location.
1105 consumeToken(Token::kw_strided);
1106 if (failed(parseToken(Token::less, "expected '<' after 'strided'")) ||
1107 failed(parseToken(Token::l_square, "expected '['")))
1110 // Parses either an integer token or a question mark token. Reports an error
1111 // and returns std::nullopt if the current token is neither. The integer token
1114 if (consumeIf(Token::question))
1123 bool negative = consumeIf(Token::minus);
1125 if (getToken().is(Token::integer)) {
1143 if (!getToken().is(Token::r_square)) {
1149 } while (consumeIf(Token::comma));
1152 if (failed(parseToken(Token::r_square, "expected ']'")))
1156 if (consumeIf(Token::greater)) {
1163 if (failed(parseToken(Token::comma, "expected ','")) ||
1164 failed(parseToken(Token::kw_offset, "expected 'offset' after comma")) ||
1165 failed(parseToken(Token::colon, "expected ':' after 'offset'")))
1169 if (!offset || failed(parseToken(Token::greater, "expected '>'")))
1185 consumeToken(Token::kw_distinct);
1186 if (parseToken(Token::l_square, "expected '[' after 'distinct'"))
1190 Token token = getToken();
1191 if (parseToken(Token::integer, "expected distinct ID"))
1193 std::optional<uint64_t> value = token.getUInt64IntegerValue();
1200 if (parseToken(Token::r_square, "expected ']' to close distinct ID") ||
1201 parseToken(Token::less, "expected '<' after distinct ID"))
1205 if (getToken().is(Token::greater)) {
1215 if (parseToken(Token::greater, "expected '>' to close distinct attribute"))