MLIR  20.0.0git
AsmParserImpl.h
Go to the documentation of this file.
1 //===- AsmParserImpl.h - MLIR AsmParserImpl Class ---------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #ifndef MLIR_LIB_ASMPARSER_ASMPARSERIMPL_H
10 #define MLIR_LIB_ASMPARSER_ASMPARSERIMPL_H
11 
12 #include "Parser.h"
14 #include "mlir/IR/Builders.h"
16 #include "llvm/Support/Base64.h"
17 #include <optional>
18 
19 namespace mlir {
20 namespace detail {
21 //===----------------------------------------------------------------------===//
22 // AsmParserImpl
23 //===----------------------------------------------------------------------===//
24 
25 /// This class provides the implementation of the generic parser methods within
26 /// AsmParser.
27 template <typename BaseT>
28 class AsmParserImpl : public BaseT {
29 public:
32  ~AsmParserImpl() override = default;
33 
34  /// Return the location of the original name token.
35  SMLoc getNameLoc() const override { return nameLoc; }
36 
37  //===--------------------------------------------------------------------===//
38  // Utilities
39  //===--------------------------------------------------------------------===//
40 
41  /// Return if any errors were emitted during parsing.
42  bool didEmitError() const { return emittedError; }
43 
44  /// Emit a diagnostic at the specified location and return failure.
45  InFlightDiagnostic emitError(SMLoc loc, const Twine &message) override {
46  emittedError = true;
47  return parser.emitError(loc, message);
48  }
49 
50  /// Return a builder which provides useful access to MLIRContext, global
51  /// objects like types and attributes.
52  Builder &getBuilder() const override { return parser.builder; }
53 
54  /// Get the location of the next token and store it into the argument. This
55  /// always succeeds.
56  SMLoc getCurrentLocation() override { return parser.getToken().getLoc(); }
57 
58  /// Re-encode the given source location as an MLIR location and return it.
59  Location getEncodedSourceLoc(SMLoc loc) override {
60  return parser.getEncodedSourceLocation(loc);
61  }
62 
63  //===--------------------------------------------------------------------===//
64  // Token Parsing
65  //===--------------------------------------------------------------------===//
66 
68 
69  /// Parse a `->` token.
70  ParseResult parseArrow() override {
71  return parser.parseToken(Token::arrow, "expected '->'");
72  }
73 
74  /// Parses a `->` if present.
75  ParseResult parseOptionalArrow() override {
76  return success(parser.consumeIf(Token::arrow));
77  }
78 
79  /// Parse a '{' token.
80  ParseResult parseLBrace() override {
81  return parser.parseToken(Token::l_brace, "expected '{'");
82  }
83 
84  /// Parse a '{' token if present
85  ParseResult parseOptionalLBrace() override {
86  return success(parser.consumeIf(Token::l_brace));
87  }
88 
89  /// Parse a `}` token.
90  ParseResult parseRBrace() override {
91  return parser.parseToken(Token::r_brace, "expected '}'");
92  }
93 
94  /// Parse a `}` token if present
95  ParseResult parseOptionalRBrace() override {
96  return success(parser.consumeIf(Token::r_brace));
97  }
98 
99  /// Parse a `:` token.
100  ParseResult parseColon() override {
101  return parser.parseToken(Token::colon, "expected ':'");
102  }
103 
104  /// Parse a `:` token if present.
105  ParseResult parseOptionalColon() override {
106  return success(parser.consumeIf(Token::colon));
107  }
108 
109  /// Parse a `,` token.
110  ParseResult parseComma() override {
111  return parser.parseToken(Token::comma, "expected ','");
112  }
113 
114  /// Parse a `,` token if present.
115  ParseResult parseOptionalComma() override {
116  return success(parser.consumeIf(Token::comma));
117  }
118 
119  /// Parses a `...`.
120  ParseResult parseEllipsis() override {
121  return parser.parseToken(Token::ellipsis, "expected '...'");
122  }
123 
124  /// Parses a `...` if present.
125  ParseResult parseOptionalEllipsis() override {
126  return success(parser.consumeIf(Token::ellipsis));
127  }
128 
129  /// Parse a `=` token.
130  ParseResult parseEqual() override {
131  return parser.parseToken(Token::equal, "expected '='");
132  }
133 
134  /// Parse a `=` token if present.
135  ParseResult parseOptionalEqual() override {
136  return success(parser.consumeIf(Token::equal));
137  }
138 
139  /// Parse a '<' token.
140  ParseResult parseLess() override {
141  return parser.parseToken(Token::less, "expected '<'");
142  }
143 
144  /// Parse a `<` token if present.
145  ParseResult parseOptionalLess() override {
146  return success(parser.consumeIf(Token::less));
147  }
148 
149  /// Parse a '>' token.
150  ParseResult parseGreater() override {
151  return parser.parseToken(Token::greater, "expected '>'");
152  }
153 
154  /// Parse a `>` token if present.
155  ParseResult parseOptionalGreater() override {
156  return success(parser.consumeIf(Token::greater));
157  }
158 
159  /// Parse a `(` token.
160  ParseResult parseLParen() override {
161  return parser.parseToken(Token::l_paren, "expected '('");
162  }
163 
164  /// Parses a '(' if present.
165  ParseResult parseOptionalLParen() override {
166  return success(parser.consumeIf(Token::l_paren));
167  }
168 
169  /// Parse a `)` token.
170  ParseResult parseRParen() override {
171  return parser.parseToken(Token::r_paren, "expected ')'");
172  }
173 
174  /// Parses a ')' if present.
175  ParseResult parseOptionalRParen() override {
176  return success(parser.consumeIf(Token::r_paren));
177  }
178 
179  /// Parse a `[` token.
180  ParseResult parseLSquare() override {
181  return parser.parseToken(Token::l_square, "expected '['");
182  }
183 
184  /// Parses a '[' if present.
185  ParseResult parseOptionalLSquare() override {
186  return success(parser.consumeIf(Token::l_square));
187  }
188 
189  /// Parse a `]` token.
190  ParseResult parseRSquare() override {
191  return parser.parseToken(Token::r_square, "expected ']'");
192  }
193 
194  /// Parses a ']' if present.
195  ParseResult parseOptionalRSquare() override {
196  return success(parser.consumeIf(Token::r_square));
197  }
198 
199  /// Parses a '?' token.
200  ParseResult parseQuestion() override {
201  return parser.parseToken(Token::question, "expected '?'");
202  }
203 
204  /// Parses a '?' if present.
205  ParseResult parseOptionalQuestion() override {
206  return success(parser.consumeIf(Token::question));
207  }
208 
209  /// Parses a '*' token.
210  ParseResult parseStar() override {
211  return parser.parseToken(Token::star, "expected '*'");
212  }
213 
214  /// Parses a '*' if present.
215  ParseResult parseOptionalStar() override {
216  return success(parser.consumeIf(Token::star));
217  }
218 
219  /// Parses a '+' token.
220  ParseResult parsePlus() override {
221  return parser.parseToken(Token::plus, "expected '+'");
222  }
223 
224  /// Parses a '+' token if present.
225  ParseResult parseOptionalPlus() override {
226  return success(parser.consumeIf(Token::plus));
227  }
228 
229  /// Parses a '-' token.
230  ParseResult parseMinus() override {
231  return parser.parseToken(Token::minus, "expected '-'");
232  }
233 
234  /// Parses a '-' token if present.
235  ParseResult parseOptionalMinus() override {
236  return success(parser.consumeIf(Token::minus));
237  }
238 
239  /// Parse a '|' token.
240  ParseResult parseVerticalBar() override {
241  return parser.parseToken(Token::vertical_bar, "expected '|'");
242  }
243 
244  /// Parse a '|' token if present.
245  ParseResult parseOptionalVerticalBar() override {
246  return success(parser.consumeIf(Token::vertical_bar));
247  }
248 
249  /// Parses a quoted string token if present.
250  ParseResult parseOptionalString(std::string *string) override {
251  if (!parser.getToken().is(Token::string))
252  return failure();
253 
254  if (string)
255  *string = parser.getToken().getStringValue();
257  return success();
258  }
259 
260  /// Parses a Base64 encoded string of bytes.
261  ParseResult parseBase64Bytes(std::vector<char> *bytes) override {
262  auto loc = getCurrentLocation();
263  if (!parser.getToken().is(Token::string))
264  return emitError(loc, "expected string");
265 
266  if (bytes) {
267  // decodeBase64 doesn't modify its input so we can use the token spelling
268  // and just slice off the quotes/whitespaces if there are any. Whitespace
269  // and quotes cannot appear as part of a (standard) base64 encoded string,
270  // so this is safe to do.
271  StringRef b64QuotedString = parser.getTokenSpelling();
272  StringRef b64String =
273  b64QuotedString.ltrim("\" \t\n\v\f\r").rtrim("\" \t\n\v\f\r");
274  if (auto err = llvm::decodeBase64(b64String, *bytes))
275  return emitError(loc, toString(std::move(err)));
276  }
277 
279  return success();
280  }
281 
282  /// Parse a floating point value with given semantics from the stream. Since
283  /// this implementation parses the string as double precision and only
284  /// afterwards converts the value to the requested semantic, precision may be
285  /// lost.
286  ParseResult parseFloat(const llvm::fltSemantics &semantics,
287  APFloat &result) override {
288  bool isNegative = parser.consumeIf(Token::minus);
289  Token curTok = parser.getToken();
290  std::optional<APFloat> apResult;
291  if (failed(parser.parseFloatFromLiteral(apResult, curTok, isNegative,
292  semantics)))
293  return failure();
295  result = *apResult;
296  return success();
297  }
298 
299  /// Parse a floating point value from the stream.
300  ParseResult parseFloat(double &result) override {
301  llvm::APFloat apResult(0.0);
302  if (parseFloat(APFloat::IEEEdouble(), apResult))
303  return failure();
304 
305  result = apResult.convertToDouble();
306  return success();
307  }
308 
309  /// Parse an optional integer value from the stream.
310  OptionalParseResult parseOptionalInteger(APInt &result) override {
311  return parser.parseOptionalInteger(result);
312  }
313 
314  /// Parse an optional integer value from the stream.
316  return parser.parseOptionalDecimalInteger(result);
317  }
318 
319  /// Parse a list of comma-separated items with an optional delimiter. If a
320  /// delimiter is provided, then an empty list is allowed. If not, then at
321  /// least one element will be parsed.
322  ParseResult parseCommaSeparatedList(Delimiter delimiter,
323  function_ref<ParseResult()> parseElt,
324  StringRef contextMessage) override {
325  return parser.parseCommaSeparatedList(delimiter, parseElt, contextMessage);
326  }
327 
328  //===--------------------------------------------------------------------===//
329  // Keyword Parsing
330  //===--------------------------------------------------------------------===//
331 
332  ParseResult parseKeyword(StringRef keyword, const Twine &msg) override {
334  return parser.codeCompleteExpectedTokens(keyword);
335 
336  auto loc = getCurrentLocation();
337  if (parseOptionalKeyword(keyword))
338  return emitError(loc, "expected '") << keyword << "'" << msg;
339  return success();
340  }
342 
343  /// Parse the given keyword if present.
344  ParseResult parseOptionalKeyword(StringRef keyword) override {
346  return parser.codeCompleteOptionalTokens(keyword);
347 
348  // Check that the current token has the same spelling.
350  parser.getTokenSpelling() != keyword)
351  return failure();
353  return success();
354  }
355 
356  /// Parse a keyword, if present, into 'keyword'.
357  ParseResult parseOptionalKeyword(StringRef *keyword) override {
358  // Check that the current token is a keyword.
360  return failure();
361 
362  *keyword = parser.getTokenSpelling();
364  return success();
365  }
366 
367  /// Parse a keyword if it is one of the 'allowedKeywords'.
368  ParseResult
369  parseOptionalKeyword(StringRef *keyword,
370  ArrayRef<StringRef> allowedKeywords) override {
372  return parser.codeCompleteOptionalTokens(allowedKeywords);
373 
374  // Check that the current token is a keyword.
376  return failure();
377 
378  StringRef currentKeyword = parser.getTokenSpelling();
379  if (llvm::is_contained(allowedKeywords, currentKeyword)) {
380  *keyword = currentKeyword;
382  return success();
383  }
384 
385  return failure();
386  }
387 
388  /// Parse an optional keyword or string and set instance into 'result'.`
389  ParseResult parseOptionalKeywordOrString(std::string *result) override {
390  StringRef keyword;
391  if (succeeded(parseOptionalKeyword(&keyword))) {
392  *result = keyword.str();
393  return success();
394  }
395 
396  return parseOptionalString(result);
397  }
398 
399  //===--------------------------------------------------------------------===//
400  // Attribute Parsing
401  //===--------------------------------------------------------------------===//
402 
403  /// Parse an arbitrary attribute and return it in result.
404  ParseResult parseAttribute(Attribute &result, Type type) override {
405  result = parser.parseAttribute(type);
406  return success(static_cast<bool>(result));
407  }
408 
409  /// Parse a custom attribute with the provided callback, unless the next
410  /// token is `#`, in which case the generic parser is invoked.
412  Attribute &result, Type type,
413  function_ref<ParseResult(Attribute &result, Type type)> parseAttribute)
414  override {
415  if (parser.getToken().isNot(Token::hash_identifier))
416  return parseAttribute(result, type);
417  result = parser.parseAttribute(type);
418  return success(static_cast<bool>(result));
419  }
420 
421  /// Parse a custom attribute with the provided callback, unless the next
422  /// token is `#`, in which case the generic parser is invoked.
424  Type &result,
425  function_ref<ParseResult(Type &result)> parseType) override {
426  if (parser.getToken().isNot(Token::exclamation_identifier))
427  return parseType(result);
428  result = parser.parseType();
429  return success(static_cast<bool>(result));
430  }
431 
433  Type type) override {
434  return parser.parseOptionalAttribute(result, type);
435  }
437  Type type) override {
438  return parser.parseOptionalAttribute(result, type);
439  }
441  Type type) override {
442  return parser.parseOptionalAttribute(result, type);
443  }
445  Type type) override {
446  return parser.parseOptionalAttribute(result, type);
447  }
448 
449  /// Parse a named dictionary into 'result' if it is present.
450  ParseResult parseOptionalAttrDict(NamedAttrList &result) override {
451  if (parser.getToken().isNot(Token::l_brace))
452  return success();
453  return parser.parseAttributeDict(result);
454  }
455 
456  /// Parse a named dictionary into 'result' if the `attributes` keyword is
457  /// present.
458  ParseResult parseOptionalAttrDictWithKeyword(NamedAttrList &result) override {
459  if (failed(parseOptionalKeyword("attributes")))
460  return success();
461  return parser.parseAttributeDict(result);
462  }
463 
464  /// Parse an affine map instance into 'map'.
465  ParseResult parseAffineMap(AffineMap &map) override {
466  return parser.parseAffineMapReference(map);
467  }
468 
469  /// Parse an affine expr instance into 'expr' using the already computed
470  /// mapping from symbols to affine expressions in 'symbolSet'.
471  ParseResult
472  parseAffineExpr(ArrayRef<std::pair<StringRef, AffineExpr>> symbolSet,
473  AffineExpr &expr) override {
474  return parser.parseAffineExprReference(symbolSet, expr);
475  }
476 
477  /// Parse an integer set instance into 'set'.
478  ParseResult parseIntegerSet(IntegerSet &set) override {
479  return parser.parseIntegerSetReference(set);
480  }
481 
482  //===--------------------------------------------------------------------===//
483  // Identifier Parsing
484  //===--------------------------------------------------------------------===//
485 
486  /// Parse an optional @-identifier and store it (without the '@' symbol) in a
487  /// string attribute named 'attrName'.
488  ParseResult parseOptionalSymbolName(StringAttr &result) override {
489  Token atToken = parser.getToken();
490  if (atToken.isNot(Token::at_identifier))
491  return failure();
492 
493  result = getBuilder().getStringAttr(atToken.getSymbolReference());
495 
496  // If we are populating the assembly parser state, record this as a symbol
497  // reference.
498  if (parser.getState().asmState) {
500  atToken.getLocRange());
501  }
502  return success();
503  }
504 
505  //===--------------------------------------------------------------------===//
506  // Resource Parsing
507  //===--------------------------------------------------------------------===//
508 
509  /// Parse a handle to a resource within the assembly format.
510  FailureOr<AsmDialectResourceHandle>
511  parseResourceHandle(Dialect *dialect) override {
512  const auto *interface = dyn_cast<OpAsmDialectInterface>(dialect);
513  if (!interface) {
514  return parser.emitError() << "dialect '" << dialect->getNamespace()
515  << "' does not expect resource handles";
516  }
517  StringRef resourceName;
518  return parser.parseResourceHandle(interface, resourceName);
519  }
520 
521  //===--------------------------------------------------------------------===//
522  // Type Parsing
523  //===--------------------------------------------------------------------===//
524 
525  /// Parse a type.
526  ParseResult parseType(Type &result) override {
527  return failure(!(result = parser.parseType()));
528  }
529 
530  /// Parse an optional type.
532  return parser.parseOptionalType(result);
533  }
534 
535  /// Parse an arrow followed by a type list.
536  ParseResult parseArrowTypeList(SmallVectorImpl<Type> &result) override {
537  if (parseArrow() || parser.parseFunctionResultTypes(result))
538  return failure();
539  return success();
540  }
541 
542  /// Parse an optional arrow followed by a type list.
543  ParseResult
545  if (!parser.consumeIf(Token::arrow))
546  return success();
547  return parser.parseFunctionResultTypes(result);
548  }
549 
550  /// Parse a colon followed by a type.
551  ParseResult parseColonType(Type &result) override {
552  return failure(parser.parseToken(Token::colon, "expected ':'") ||
553  !(result = parser.parseType()));
554  }
555 
556  /// Parse a colon followed by a type list, which must have at least one type.
557  ParseResult parseColonTypeList(SmallVectorImpl<Type> &result) override {
558  if (parser.parseToken(Token::colon, "expected ':'"))
559  return failure();
560  return parser.parseTypeListNoParens(result);
561  }
562 
563  /// Parse an optional colon followed by a type list, which if present must
564  /// have at least one type.
565  ParseResult
567  if (!parser.consumeIf(Token::colon))
568  return success();
569  return parser.parseTypeListNoParens(result);
570  }
571 
573  bool allowDynamic,
574  bool withTrailingX) override {
575  return parser.parseDimensionListRanked(dimensions, allowDynamic,
576  withTrailingX);
577  }
578 
579  ParseResult parseXInDimensionList() override {
580  return parser.parseXInDimensionList();
581  }
582 
583  LogicalResult pushCyclicParsing(const void *opaquePointer) override {
584  return success(parser.getState().cyclicParsingStack.insert(opaquePointer));
585  }
586 
587  void popCyclicParsing() override {
588  parser.getState().cyclicParsingStack.pop_back();
589  }
590 
591  //===--------------------------------------------------------------------===//
592  // Code Completion
593  //===--------------------------------------------------------------------===//
594 
595  /// Parse a keyword, or an empty string if the current location signals a code
596  /// completion.
597  ParseResult parseKeywordOrCompletion(StringRef *keyword) override {
598  Token tok = parser.getToken();
599  if (tok.isCodeCompletion() && tok.getSpelling().empty()) {
600  *keyword = "";
601  return success();
602  }
603  return parseKeyword(keyword);
604  }
605 
606  /// Signal the code completion of a set of expected tokens.
608  Token tok = parser.getToken();
609  if (tok.isCodeCompletion() && tok.getSpelling().empty())
610  (void)parser.codeCompleteExpectedTokens(tokens);
611  }
612 
613 protected:
614  /// The source location of the dialect symbol.
615  SMLoc nameLoc;
616 
617  /// The main parser.
619 
620  /// A flag that indicates if any errors were emitted during parsing.
621  bool emittedError = false;
622 };
623 } // namespace detail
624 } // namespace mlir
625 
626 #endif // MLIR_LIB_ASMPARSER_ASMPARSERIMPL_H
Base type for affine expression.
Definition: AffineExpr.h:68
A multi-dimensional affine map Affine map's are immutable like Type's, and they are uniqued.
Definition: AffineMap.h:46
void addUses(Value value, ArrayRef< SMLoc > locations)
Add a source uses of the given value.
Delimiter
These are the supported delimiters around operand lists and region argument lists,...
ParseResult parseKeyword(StringRef keyword)
Parse a given keyword.
Attributes are known-constant values of operations.
Definition: Attributes.h:25
This class is a general helper class for creating context-global objects like types,...
Definition: Builders.h:51
StringAttr getStringAttr(const Twine &bytes)
Definition: Builders.cpp:302
Dialects are groups of MLIR operations, types and attributes, as well as behavior associated with the...
Definition: Dialect.h:38
StringRef getNamespace() const
Definition: Dialect.h:54
This class represents a diagnostic that is inflight and set to be reported.
Definition: Diagnostics.h:314
An integer set representing a conjunction of one or more affine equalities and inequalities.
Definition: IntegerSet.h:44
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
Definition: Location.h:66
NamedAttrList is array of NamedAttributes that tracks whether it is sorted and does some basic work t...
This class implements Optional functionality for ParseResult.
Definition: OpDefinition.h:39
This represents a token in the MLIR syntax.
Definition: Token.h:20
SMRange getLocRange() const
Definition: Token.cpp:30
SMLoc getLoc() const
Definition: Token.cpp:24
bool is(Kind k) const
Definition: Token.h:38
std::string getStringValue() const
Given a token containing a string literal, return its value, including removing the quote characters ...
Definition: Token.cpp:86
std::string getSymbolReference() const
Given a token containing a symbol reference, return the unescaped string value.
Definition: Token.cpp:153
bool isNot(Kind k) const
Definition: Token.h:50
bool isCodeCompletion() const
Returns true if the current token represents a code completion.
Definition: Token.h:62
StringRef getSpelling() const
Definition: Token.h:34
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
Definition: Types.h:74
This class provides the implementation of the generic parser methods within AsmParser.
Definition: AsmParserImpl.h:28
ParseResult parseOptionalPlus() override
Parses a '+' token if present.
ParseResult parseOptionalLBrace() override
Parse a '{' token if present.
Definition: AsmParserImpl.h:85
ParseResult parseOptionalArrowTypeList(SmallVectorImpl< Type > &result) override
Parse an optional arrow followed by a type list.
ParseResult parseOptionalStar() override
Parses a '*' if present.
ParseResult parseOptionalMinus() override
Parses a '-' token if present.
ParseResult parseColon() override
Parse a : token.
ParseResult parseFloat(double &result) override
Parse a floating point value from the stream.
InFlightDiagnostic emitError(SMLoc loc, const Twine &message) override
Emit a diagnostic at the specified location and return failure.
Definition: AsmParserImpl.h:45
ParseResult parseMinus() override
Parses a '-' token.
ParseResult parseOptionalGreater() override
Parse a > token if present.
ParseResult parseOptionalEllipsis() override
Parses a ... if present.
ParseResult parseColonType(Type &result) override
Parse a colon followed by a type.
ParseResult parseArrow() override
Parse a -> token.
Definition: AsmParserImpl.h:70
void codeCompleteExpectedTokens(ArrayRef< StringRef > tokens) override
Signal the code completion of a set of expected tokens.
ParseResult parseEllipsis() override
Parses a ....
ParseResult parseLParen() override
Parse a ( token.
ParseResult parseOptionalKeywordOrString(std::string *result) override
Parse an optional keyword or string and set instance into 'result'.`.
Location getEncodedSourceLoc(SMLoc loc) override
Re-encode the given source location as an MLIR location and return it.
Definition: AsmParserImpl.h:59
ParseResult parseOptionalAttrDict(NamedAttrList &result) override
Parse a named dictionary into 'result' if it is present.
SMLoc nameLoc
The source location of the dialect symbol.
ParseResult parseRParen() override
Parse a ) token.
ParseResult parseQuestion() override
Parses a '?' token.
OptionalParseResult parseOptionalAttribute(ArrayAttr &result, Type type) override
ParseResult parseCustomAttributeWithFallback(Attribute &result, Type type, function_ref< ParseResult(Attribute &result, Type type)> parseAttribute) override
Parse a custom attribute with the provided callback, unless the next token is #, in which case the ge...
OptionalParseResult parseOptionalType(Type &result) override
Parse an optional type.
ParseResult parseIntegerSet(IntegerSet &set) override
Parse an integer set instance into 'set'.
ParseResult parseFloat(const llvm::fltSemantics &semantics, APFloat &result) override
Parse a floating point value with given semantics from the stream.
SMLoc getNameLoc() const override
Return the location of the original name token.
Definition: AsmParserImpl.h:35
ParseResult parseOptionalQuestion() override
Parses a '?' if present.
ParseResult parseLBrace() override
Parse a '{' token.
Definition: AsmParserImpl.h:80
ParseResult parseAffineExpr(ArrayRef< std::pair< StringRef, AffineExpr >> symbolSet, AffineExpr &expr) override
Parse an affine expr instance into 'expr' using the already computed mapping from symbols to affine e...
ParseResult parseOptionalComma() override
Parse a , token if present.
ParseResult parsePlus() override
Parses a '+' token.
ParseResult parseLess() override
Parse a '<' token.
ParseResult parseOptionalKeyword(StringRef *keyword, ArrayRef< StringRef > allowedKeywords) override
Parse a keyword if it is one of the 'allowedKeywords'.
OptionalParseResult parseOptionalDecimalInteger(APInt &result) override
Parse an optional integer value from the stream.
ParseResult parseRBrace() override
Parse a } token.
Definition: AsmParserImpl.h:90
ParseResult parseOptionalRBrace() override
Parse a } token if present.
Definition: AsmParserImpl.h:95
ParseResult parseGreater() override
Parse a '>' token.
FailureOr< AsmDialectResourceHandle > parseResourceHandle(Dialect *dialect) override
Parse a handle to a resource within the assembly format.
ParseResult parseColonTypeList(SmallVectorImpl< Type > &result) override
Parse a colon followed by a type list, which must have at least one type.
ParseResult parseOptionalLess() override
Parse a < token if present.
OptionalParseResult parseOptionalAttribute(StringAttr &result, Type type) override
OptionalParseResult parseOptionalAttribute(Attribute &result, Type type) override
ParseResult parseAttribute(Attribute &result, Type type) override
Parse an arbitrary attribute and return it in result.
Parser & parser
The main parser.
LogicalResult pushCyclicParsing(const void *opaquePointer) override
ParseResult parseKeywordOrCompletion(StringRef *keyword) override
Parse a keyword, or an empty string if the current location signals a code completion.
AsmParserImpl(SMLoc nameLoc, Parser &parser)
Definition: AsmParserImpl.h:30
ParseResult parseOptionalKeyword(StringRef keyword) override
Parse the given keyword if present.
bool didEmitError() const
Return if any errors were emitted during parsing.
Definition: AsmParserImpl.h:42
ParseResult parseComma() override
Parse a , token.
OptionalParseResult parseOptionalInteger(APInt &result) override
Parse an optional integer value from the stream.
ParseResult parseRSquare() override
Parse a ] token.
Builder & getBuilder() const override
Return a builder which provides useful access to MLIRContext, global objects like types and attribute...
Definition: AsmParserImpl.h:52
ParseResult parseLSquare() override
Parse a [ token.
ParseResult parseBase64Bytes(std::vector< char > *bytes) override
Parses a Base64 encoded string of bytes.
ParseResult parseOptionalArrow() override
Parses a -> if present.
Definition: AsmParserImpl.h:75
~AsmParserImpl() override=default
ParseResult parseDimensionList(SmallVectorImpl< int64_t > &dimensions, bool allowDynamic, bool withTrailingX) override
ParseResult parseEqual() override
Parse a = token.
ParseResult parseCustomTypeWithFallback(Type &result, function_ref< ParseResult(Type &result)> parseType) override
Parse a custom attribute with the provided callback, unless the next token is #, in which case the ge...
ParseResult parseOptionalColonTypeList(SmallVectorImpl< Type > &result) override
Parse an optional colon followed by a type list, which if present must have at least one type.
ParseResult parseOptionalVerticalBar() override
Parse a '|' token if present.
ParseResult parseOptionalAttrDictWithKeyword(NamedAttrList &result) override
Parse a named dictionary into 'result' if the attributes keyword is present.
ParseResult parseStar() override
Parses a '*' token.
ParseResult parseOptionalLParen() override
Parses a '(' if present.
ParseResult parseOptionalEqual() override
Parse a = token if present.
void popCyclicParsing() override
ParseResult parseOptionalLSquare() override
Parses a '[' if present.
ParseResult parseOptionalKeyword(StringRef *keyword) override
Parse a keyword, if present, into 'keyword'.
ParseResult parseAffineMap(AffineMap &map) override
Parse an affine map instance into 'map'.
ParseResult parseOptionalSymbolName(StringAttr &result) override
Parse an optional -identifier and store it (without the '@' symbol) in a string attribute named 'attr...
ParseResult parseVerticalBar() override
Parse a '|' token.
OptionalParseResult parseOptionalAttribute(SymbolRefAttr &result, Type type) override
SMLoc getCurrentLocation() override
Get the location of the next token and store it into the argument.
Definition: AsmParserImpl.h:56
bool emittedError
A flag that indicates if any errors were emitted during parsing.
ParseResult parseKeyword(StringRef keyword)
Parse a given keyword.
ParseResult parseOptionalColon() override
Parse a : token if present.
ParseResult parseOptionalString(std::string *string) override
Parses a quoted string token if present.
ParseResult parseOptionalRParen() override
Parses a ')' if present.
ParseResult parseXInDimensionList() override
ParseResult parseKeyword(StringRef keyword, const Twine &msg) override
ParseResult parseType(Type &result) override
Parse a type.
ParseResult parseCommaSeparatedList(Delimiter delimiter, function_ref< ParseResult()> parseElt, StringRef contextMessage) override
Parse a list of comma-separated items with an optional delimiter.
ParseResult parseOptionalRSquare() override
Parses a ']' if present.
ParseResult parseArrowTypeList(SmallVectorImpl< Type > &result) override
Parse an arrow followed by a type list.
This class implement support for parsing global entities like attributes and types.
Definition: Parser.h:27
ParseResult parseFloatFromLiteral(std::optional< APFloat > &result, const Token &tok, bool isNegative, const llvm::fltSemantics &semantics)
Parse a floating point value from a literal.
Definition: Parser.cpp:350
ParseResult parseXInDimensionList()
Parse an 'x' token in a dimension list, handling the case where the x is juxtaposed with an element t...
Definition: TypeParser.cpp:608
OptionalParseResult parseOptionalType(Type &type)
Optionally parse a type.
Definition: TypeParser.cpp:32
ParseResult parseToken(Token::Kind expectedToken, const Twine &message)
Consume the specified token if present and return success.
Definition: Parser.cpp:267
OptionalParseResult parseOptionalDecimalInteger(APInt &result)
Parse an optional integer value only in decimal format from the stream.
Definition: Parser.cpp:312
Builder builder
Definition: Parser.h:31
Type parseType()
Parse an arbitrary type.
Definition: TypeParser.cpp:75
ParserState & getState() const
Definition: Parser.h:37
ParseResult parseAffineMapReference(AffineMap &map)
Location getEncodedSourceLocation(SMLoc loc)
Encode the specified source location information into an attribute for attachment to the IR.
Definition: Parser.h:94
InFlightDiagnostic emitError(const Twine &message={})
Emit an error and return failure.
Definition: Parser.cpp:192
ParseResult parseAffineExprReference(ArrayRef< std::pair< StringRef, AffineExpr >> symbolSet, AffineExpr &expr)
Attribute parseAttribute(Type type={})
Parse an arbitrary attribute with an optional type.
StringRef getTokenSpelling() const
Definition: Parser.h:104
void consumeToken()
Advance the current lexer onto the next token.
Definition: Parser.h:119
ParseResult codeCompleteExpectedTokens(ArrayRef< StringRef > tokens)
Definition: Parser.cpp:512
ParseResult parseAttributeDict(NamedAttrList &attributes)
Parse an attribute dictionary.
ParseResult parseDimensionListRanked(SmallVectorImpl< int64_t > &dimensions, bool allowDynamic=true, bool withTrailingX=true)
Parse a dimension list of a tensor or memref type.
Definition: TypeParser.cpp:543
ParseResult parseFunctionResultTypes(SmallVectorImpl< Type > &elements)
Parse a function result type.
Definition: TypeParser.cpp:86
ParseResult parseCommaSeparatedList(Delimiter delimiter, function_ref< ParseResult()> parseElementFn, StringRef contextMessage=StringRef())
Parse a list of comma-separated items with an optional delimiter.
Definition: Parser.cpp:84
OptionalParseResult parseOptionalInteger(APInt &result)
Parse an optional integer value from the stream.
Definition: Parser.cpp:275
OptionalParseResult parseOptionalAttribute(Attribute &attribute, Type type={})
Parse an optional attribute with the provided type.
bool isCurrentTokenAKeyword() const
Returns true if the current token corresponds to a keyword.
Definition: Parser.h:166
ParseResult codeCompleteOptionalTokens(ArrayRef< StringRef > tokens)
Definition: Parser.cpp:516
ParseResult parseIntegerSetReference(IntegerSet &set)
ParseResult parseTypeListNoParens(SmallVectorImpl< Type > &elements)
Parse a list of types without an enclosing parenthesis.
Definition: TypeParser.cpp:102
const Token & getToken() const
Return the current token the parser is inspecting.
Definition: Parser.h:103
FailureOr< AsmDialectResourceHandle > parseResourceHandle(const OpAsmDialectInterface *dialect, StringRef &name)
Parse a handle to a dialect resource within the assembly format.
Definition: Parser.cpp:419
bool consumeIf(Token::Kind kind)
If the current token has the specified kind, consume it and return true.
Definition: Parser.h:111
Include the generated interface declarations.
StringRef toString(AsmResourceEntryKind kind)
auto get(MLIRContext *context, Ts &&...params)
Helper method that injects context only if needed, this helps unify some of the attribute constructio...
SetVector< const void * > cyclicParsingStack
Stack of potentially cyclic mutable attributes or type currently being parsed.
Definition: ParserState.h:79
AsmParserState * asmState
An optional pointer to a struct containing high level parser state to be populated during parsing.
Definition: ParserState.h:83