MLIR  19.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.
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
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
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.
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.
116  return success(parser.consumeIf(Token::comma));
117  }
118 
119  /// Parses a `...`.
121  return parser.parseToken(Token::ellipsis, "expected '...'");
122  }
123 
124  /// Parses a `...` if present.
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.
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.
146  return success(parser.consumeIf(Token::less));
147  }
148 
149  /// Parse a '>' token.
151  return parser.parseToken(Token::greater, "expected '>'");
152  }
153 
154  /// Parse a `>` token if present.
156  return success(parser.consumeIf(Token::greater));
157  }
158 
159  /// Parse a `(` token.
161  return parser.parseToken(Token::l_paren, "expected '('");
162  }
163 
164  /// Parses a '(' if present.
166  return success(parser.consumeIf(Token::l_paren));
167  }
168 
169  /// Parse a `)` token.
171  return parser.parseToken(Token::r_paren, "expected ')'");
172  }
173 
174  /// Parses a ')' if present.
176  return success(parser.consumeIf(Token::r_paren));
177  }
178 
179  /// Parse a `[` token.
181  return parser.parseToken(Token::l_square, "expected '['");
182  }
183 
184  /// Parses a '[' if present.
186  return success(parser.consumeIf(Token::l_square));
187  }
188 
189  /// Parse a `]` token.
191  return parser.parseToken(Token::r_square, "expected ']'");
192  }
193 
194  /// Parses a ']' if present.
196  return success(parser.consumeIf(Token::r_square));
197  }
198 
199  /// Parses a '?' token.
201  return parser.parseToken(Token::question, "expected '?'");
202  }
203 
204  /// Parses a '?' if present.
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.
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.
226  return success(parser.consumeIf(Token::plus));
227  }
228 
229  /// Parse a '|' token.
231  return parser.parseToken(Token::vertical_bar, "expected '|'");
232  }
233 
234  /// Parse a '|' token if present.
236  return success(parser.consumeIf(Token::vertical_bar));
237  }
238 
239  /// Parses a quoted string token if present.
240  ParseResult parseOptionalString(std::string *string) override {
241  if (!parser.getToken().is(Token::string))
242  return failure();
243 
244  if (string)
245  *string = parser.getToken().getStringValue();
247  return success();
248  }
249 
250  /// Parses a Base64 encoded string of bytes.
251  ParseResult parseBase64Bytes(std::vector<char> *bytes) override {
252  auto loc = getCurrentLocation();
253  if (!parser.getToken().is(Token::string))
254  return emitError(loc, "expected string");
255 
256  if (bytes) {
257  // decodeBase64 doesn't modify its input so we can use the token spelling
258  // and just slice off the quotes/whitespaces if there are any. Whitespace
259  // and quotes cannot appear as part of a (standard) base64 encoded string,
260  // so this is safe to do.
261  StringRef b64QuotedString = parser.getTokenSpelling();
262  StringRef b64String =
263  b64QuotedString.ltrim("\" \t\n\v\f\r").rtrim("\" \t\n\v\f\r");
264  if (auto err = llvm::decodeBase64(b64String, *bytes))
265  return emitError(loc, toString(std::move(err)));
266  }
267 
269  return success();
270  }
271 
272  /// Parse a floating point value with given semantics from the stream. Since
273  /// this implementation parses the string as double precision and only
274  /// afterwards converts the value to the requested semantic, precision may be
275  /// lost.
276  ParseResult parseFloat(const llvm::fltSemantics &semantics,
277  APFloat &result) override {
278  bool isNegative = parser.consumeIf(Token::minus);
279  Token curTok = parser.getToken();
280  SMLoc loc = curTok.getLoc();
281 
282  // Check for a floating point value.
283  if (curTok.is(Token::floatliteral)) {
284  auto val = curTok.getFloatingPointValue();
285  if (!val)
286  return emitError(loc, "floating point value too large");
287  parser.consumeToken(Token::floatliteral);
288  result = APFloat(isNegative ? -*val : *val);
289  bool losesInfo;
290  result.convert(semantics, APFloat::rmNearestTiesToEven, &losesInfo);
291  return success();
292  }
293 
294  // Check for a hexadecimal float value.
295  if (curTok.is(Token::integer)) {
296  std::optional<APFloat> apResult;
298  apResult, curTok, isNegative, semantics,
299  APFloat::semanticsSizeInBits(semantics))))
300  return failure();
301 
302  result = *apResult;
303  parser.consumeToken(Token::integer);
304  return success();
305  }
306 
307  return emitError(loc, "expected floating point literal");
308  }
309 
310  /// Parse a floating point value from the stream.
311  ParseResult parseFloat(double &result) override {
312  llvm::APFloat apResult(0.0);
313  if (parseFloat(APFloat::IEEEdouble(), apResult))
314  return failure();
315 
316  result = apResult.convertToDouble();
317  return success();
318  }
319 
320  /// Parse an optional integer value from the stream.
321  OptionalParseResult parseOptionalInteger(APInt &result) override {
322  return parser.parseOptionalInteger(result);
323  }
324 
325  /// Parse a list of comma-separated items with an optional delimiter. If a
326  /// delimiter is provided, then an empty list is allowed. If not, then at
327  /// least one element will be parsed.
329  function_ref<ParseResult()> parseElt,
330  StringRef contextMessage) override {
331  return parser.parseCommaSeparatedList(delimiter, parseElt, contextMessage);
332  }
333 
334  //===--------------------------------------------------------------------===//
335  // Keyword Parsing
336  //===--------------------------------------------------------------------===//
337 
338  ParseResult parseKeyword(StringRef keyword, const Twine &msg) override {
340  return parser.codeCompleteExpectedTokens(keyword);
341 
342  auto loc = getCurrentLocation();
343  if (parseOptionalKeyword(keyword))
344  return emitError(loc, "expected '") << keyword << "'" << msg;
345  return success();
346  }
348 
349  /// Parse the given keyword if present.
350  ParseResult parseOptionalKeyword(StringRef keyword) override {
352  return parser.codeCompleteOptionalTokens(keyword);
353 
354  // Check that the current token has the same spelling.
356  parser.getTokenSpelling() != keyword)
357  return failure();
359  return success();
360  }
361 
362  /// Parse a keyword, if present, into 'keyword'.
363  ParseResult parseOptionalKeyword(StringRef *keyword) override {
364  // Check that the current token is a keyword.
366  return failure();
367 
368  *keyword = parser.getTokenSpelling();
370  return success();
371  }
372 
373  /// Parse a keyword if it is one of the 'allowedKeywords'.
375  parseOptionalKeyword(StringRef *keyword,
376  ArrayRef<StringRef> allowedKeywords) override {
378  return parser.codeCompleteOptionalTokens(allowedKeywords);
379 
380  // Check that the current token is a keyword.
382  return failure();
383 
384  StringRef currentKeyword = parser.getTokenSpelling();
385  if (llvm::is_contained(allowedKeywords, currentKeyword)) {
386  *keyword = currentKeyword;
388  return success();
389  }
390 
391  return failure();
392  }
393 
394  /// Parse an optional keyword or string and set instance into 'result'.`
395  ParseResult parseOptionalKeywordOrString(std::string *result) override {
396  StringRef keyword;
397  if (succeeded(parseOptionalKeyword(&keyword))) {
398  *result = keyword.str();
399  return success();
400  }
401 
402  return parseOptionalString(result);
403  }
404 
405  //===--------------------------------------------------------------------===//
406  // Attribute Parsing
407  //===--------------------------------------------------------------------===//
408 
409  /// Parse an arbitrary attribute and return it in result.
410  ParseResult parseAttribute(Attribute &result, Type type) override {
411  result = parser.parseAttribute(type);
412  return success(static_cast<bool>(result));
413  }
414 
415  /// Parse a custom attribute with the provided callback, unless the next
416  /// token is `#`, in which case the generic parser is invoked.
418  Attribute &result, Type type,
420  override {
421  if (parser.getToken().isNot(Token::hash_identifier))
422  return parseAttribute(result, type);
423  result = parser.parseAttribute(type);
424  return success(static_cast<bool>(result));
425  }
426 
427  /// Parse a custom attribute with the provided callback, unless the next
428  /// token is `#`, in which case the generic parser is invoked.
430  Type &result,
431  function_ref<ParseResult(Type &result)> parseType) override {
432  if (parser.getToken().isNot(Token::exclamation_identifier))
433  return parseType(result);
434  result = parser.parseType();
435  return success(static_cast<bool>(result));
436  }
437 
439  Type type) override {
440  return parser.parseOptionalAttribute(result, type);
441  }
443  Type type) override {
444  return parser.parseOptionalAttribute(result, type);
445  }
447  Type type) override {
448  return parser.parseOptionalAttribute(result, type);
449  }
451  Type type) override {
452  return parser.parseOptionalAttribute(result, type);
453  }
454 
455  /// Parse a named dictionary into 'result' if it is present.
457  if (parser.getToken().isNot(Token::l_brace))
458  return success();
459  return parser.parseAttributeDict(result);
460  }
461 
462  /// Parse a named dictionary into 'result' if the `attributes` keyword is
463  /// present.
465  if (failed(parseOptionalKeyword("attributes")))
466  return success();
467  return parser.parseAttributeDict(result);
468  }
469 
470  /// Parse an affine map instance into 'map'.
472  return parser.parseAffineMapReference(map);
473  }
474 
475  /// Parse an affine expr instance into 'expr' using the already computed
476  /// mapping from symbols to affine expressions in 'symbolSet'.
478  parseAffineExpr(ArrayRef<std::pair<StringRef, AffineExpr>> symbolSet,
479  AffineExpr &expr) override {
480  return parser.parseAffineExprReference(symbolSet, expr);
481  }
482 
483  /// Parse an integer set instance into 'set'.
485  return parser.parseIntegerSetReference(set);
486  }
487 
488  //===--------------------------------------------------------------------===//
489  // Identifier Parsing
490  //===--------------------------------------------------------------------===//
491 
492  /// Parse an optional @-identifier and store it (without the '@' symbol) in a
493  /// string attribute named 'attrName'.
494  ParseResult parseOptionalSymbolName(StringAttr &result) override {
495  Token atToken = parser.getToken();
496  if (atToken.isNot(Token::at_identifier))
497  return failure();
498 
499  result = getBuilder().getStringAttr(atToken.getSymbolReference());
501 
502  // If we are populating the assembly parser state, record this as a symbol
503  // reference.
504  if (parser.getState().asmState) {
506  atToken.getLocRange());
507  }
508  return success();
509  }
510 
511  //===--------------------------------------------------------------------===//
512  // Resource Parsing
513  //===--------------------------------------------------------------------===//
514 
515  /// Parse a handle to a resource within the assembly format.
517  parseResourceHandle(Dialect *dialect) override {
518  const auto *interface = dyn_cast<OpAsmDialectInterface>(dialect);
519  if (!interface) {
520  return parser.emitError() << "dialect '" << dialect->getNamespace()
521  << "' does not expect resource handles";
522  }
523  StringRef resourceName;
524  return parser.parseResourceHandle(interface, resourceName);
525  }
526 
527  //===--------------------------------------------------------------------===//
528  // Type Parsing
529  //===--------------------------------------------------------------------===//
530 
531  /// Parse a type.
532  ParseResult parseType(Type &result) override {
533  return failure(!(result = parser.parseType()));
534  }
535 
536  /// Parse an optional type.
538  return parser.parseOptionalType(result);
539  }
540 
541  /// Parse an arrow followed by a type list.
543  if (parseArrow() || parser.parseFunctionResultTypes(result))
544  return failure();
545  return success();
546  }
547 
548  /// Parse an optional arrow followed by a type list.
551  if (!parser.consumeIf(Token::arrow))
552  return success();
553  return parser.parseFunctionResultTypes(result);
554  }
555 
556  /// Parse a colon followed by a type.
557  ParseResult parseColonType(Type &result) override {
558  return failure(parser.parseToken(Token::colon, "expected ':'") ||
559  !(result = parser.parseType()));
560  }
561 
562  /// Parse a colon followed by a type list, which must have at least one type.
564  if (parser.parseToken(Token::colon, "expected ':'"))
565  return failure();
566  return parser.parseTypeListNoParens(result);
567  }
568 
569  /// Parse an optional colon followed by a type list, which if present must
570  /// have at least one type.
573  if (!parser.consumeIf(Token::colon))
574  return success();
575  return parser.parseTypeListNoParens(result);
576  }
577 
579  bool allowDynamic,
580  bool withTrailingX) override {
581  return parser.parseDimensionListRanked(dimensions, allowDynamic,
582  withTrailingX);
583  }
584 
586  return parser.parseXInDimensionList();
587  }
588 
589  LogicalResult pushCyclicParsing(const void *opaquePointer) override {
590  return success(parser.getState().cyclicParsingStack.insert(opaquePointer));
591  }
592 
593  void popCyclicParsing() override {
594  parser.getState().cyclicParsingStack.pop_back();
595  }
596 
597  //===--------------------------------------------------------------------===//
598  // Code Completion
599  //===--------------------------------------------------------------------===//
600 
601  /// Parse a keyword, or an empty string if the current location signals a code
602  /// completion.
603  ParseResult parseKeywordOrCompletion(StringRef *keyword) override {
604  Token tok = parser.getToken();
605  if (tok.isCodeCompletion() && tok.getSpelling().empty()) {
606  *keyword = "";
607  return success();
608  }
609  return parseKeyword(keyword);
610  }
611 
612  /// Signal the code completion of a set of expected tokens.
614  Token tok = parser.getToken();
615  if (tok.isCodeCompletion() && tok.getSpelling().empty())
616  (void)parser.codeCompleteExpectedTokens(tokens);
617  }
618 
619 protected:
620  /// The source location of the dialect symbol.
621  SMLoc nameLoc;
622 
623  /// The main parser.
625 
626  /// A flag that indicates if any errors were emitted during parsing.
627  bool emittedError = false;
628 };
629 } // namespace detail
630 } // namespace mlir
631 
632 #endif // MLIR_LIB_ASMPARSER_ASMPARSERIMPL_H
Base type for affine expression.
Definition: AffineExpr.h:69
A multi-dimensional affine map Affine map's are immutable like Type's, and they are uniqued.
Definition: AffineMap.h:47
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:50
StringAttr getStringAttr(const Twine &bytes)
Definition: Builders.cpp:269
Dialects are groups of MLIR operations, types and attributes, as well as behavior associated with the...
Definition: Dialect.h:41
StringRef getNamespace() const
Definition: Dialect.h:57
This class provides support for representing a failure result, or a valid value of type T.
Definition: LogicalResult.h:78
This class represents a diagnostic that is inflight and set to be reported.
Definition: Diagnostics.h:308
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:63
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 class represents success/failure for parsing-like operations that find it important to chain tog...
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
std::optional< double > getFloatingPointValue() const
For a floatliteral token, return its value as a double.
Definition: Token.cpp:56
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 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 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'.
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:26
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:592
OptionalParseResult parseOptionalType(Type &type)
Optionally parse a type.
Definition: TypeParser.cpp:33
ParseResult parseToken(Token::Kind expectedToken, const Twine &message)
Consume the specified token if present and return success.
Definition: Parser.cpp:267
Builder builder
Definition: Parser.h:30
Type parseType()
Parse an arbitrary type.
Definition: TypeParser.cpp:70
ParserState & getState() const
Definition: Parser.h:36
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:93
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:103
void consumeToken()
Advance the current lexer onto the next token.
Definition: Parser.h:118
ParseResult codeCompleteExpectedTokens(ArrayRef< StringRef > tokens)
Definition: Parser.cpp:449
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:527
ParseResult parseFunctionResultTypes(SmallVectorImpl< Type > &elements)
Parse a function result type.
Definition: TypeParser.cpp:81
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:154
ParseResult parseFloatFromIntegerLiteral(std::optional< APFloat > &result, const Token &tok, bool isNegative, const llvm::fltSemantics &semantics, size_t typeSizeInBits)
Parse a floating point value from an integer literal token.
Definition: Parser.cpp:312
ParseResult codeCompleteOptionalTokens(ArrayRef< StringRef > tokens)
Definition: Parser.cpp:453
ParseResult parseIntegerSetReference(IntegerSet &set)
ParseResult parseTypeListNoParens(SmallVectorImpl< Type > &elements)
Parse a list of types without an enclosing parenthesis.
Definition: TypeParser.cpp:97
const Token & getToken() const
Return the current token the parser is inspecting.
Definition: Parser.h:102
FailureOr< AsmDialectResourceHandle > parseResourceHandle(const OpAsmDialectInterface *dialect, StringRef &name)
Parse a handle to a dialect resource within the assembly format.
Definition: Parser.cpp:356
bool consumeIf(Token::Kind kind)
If the current token has the specified kind, consume it and return true.
Definition: Parser.h:110
Include the generated interface declarations.
LogicalResult failure(bool isFailure=true)
Utility function to generate a LogicalResult.
Definition: LogicalResult.h:62
StringRef toString(AsmResourceEntryKind kind)
bool succeeded(LogicalResult result)
Utility function that returns true if the provided LogicalResult corresponds to a success value.
Definition: LogicalResult.h:68
LogicalResult success(bool isSuccess=true)
Utility function to generate a LogicalResult.
Definition: LogicalResult.h:56
auto get(MLIRContext *context, Ts &&...params)
Helper method that injects context only if needed, this helps unify some of the attribute constructio...
bool failed(LogicalResult result)
Utility function that returns true if the provided LogicalResult corresponds to a failure value.
Definition: LogicalResult.h:72
This class represents an efficient way to signal success or failure.
Definition: LogicalResult.h:26
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