MLIR  21.0.0git
Parser.h
Go to the documentation of this file.
1 //===- Parser.h - MLIR Base Parser 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_PARSER_H
10 #define MLIR_LIB_ASMPARSER_PARSER_H
11 
12 #include "ParserState.h"
13 #include "mlir/IR/Builders.h"
15 #include <optional>
16 
17 namespace mlir {
18 namespace detail {
19 
20 //===----------------------------------------------------------------------===//
21 // Parser
22 //===----------------------------------------------------------------------===//
23 
24 /// This class implement support for parsing global entities like attributes and
25 /// types. It is intended to be subclassed by specialized subparsers that
26 /// include state.
27 class Parser {
28 public:
30 
32 
35 
36  // Helper methods to get stuff from the parser-global state.
37  ParserState &getState() const { return state; }
38  MLIRContext *getContext() const { return state.config.getContext(); }
39  const llvm::SourceMgr &getSourceMgr() { return state.lex.getSourceMgr(); }
40 
41  /// Parse a comma-separated list of elements up until the specified end token.
42  ParseResult
44  function_ref<ParseResult()> parseElement,
45  bool allowEmptyList = true);
46 
47  /// Parse a list of comma-separated items with an optional delimiter. If a
48  /// delimiter is provided, then an empty list is allowed. If not, then at
49  /// least one element will be parsed.
50  ParseResult
52  function_ref<ParseResult()> parseElementFn,
53  StringRef contextMessage = StringRef());
54 
55  /// Parse a comma separated list of elements that must have at least one entry
56  /// in it.
57  ParseResult
58  parseCommaSeparatedList(function_ref<ParseResult()> parseElementFn) {
59  return parseCommaSeparatedList(Delimiter::None, parseElementFn);
60  }
61 
62  /// Parse the body of a dialect symbol, which starts and ends with <>'s, and
63  /// may be recursive. Return with the 'body' StringRef encompassing the entire
64  /// body. `isCodeCompletion` is set to true if the body contained a code
65  /// completion location, in which case the body is only populated up to the
66  /// completion.
67  ParseResult parseDialectSymbolBody(StringRef &body, bool &isCodeCompletion);
68  ParseResult parseDialectSymbolBody(StringRef &body) {
69  bool isCodeCompletion = false;
70  return parseDialectSymbolBody(body, isCodeCompletion);
71  }
72 
73  // We have two forms of parsing methods - those that return a non-null
74  // pointer on success, and those that return a ParseResult to indicate whether
75  // they returned a failure. The second class fills in by-reference arguments
76  // as the results of their action.
77 
78  //===--------------------------------------------------------------------===//
79  // Error Handling
80  //===--------------------------------------------------------------------===//
81 
82  /// Emit an error and return failure.
83  InFlightDiagnostic emitError(const Twine &message = {});
84  InFlightDiagnostic emitError(SMLoc loc, const Twine &message = {});
85 
86  /// Emit an error about a "wrong token". If the current token is at the
87  /// start of a source line, this will apply heuristics to back up and report
88  /// the error at the end of the previous line, which is where the expected
89  /// token is supposed to be.
90  InFlightDiagnostic emitWrongTokenError(const Twine &message = {});
91 
92  /// Encode the specified source location information into an attribute for
93  /// attachment to the IR.
96  }
97 
98  //===--------------------------------------------------------------------===//
99  // Token Parsing
100  //===--------------------------------------------------------------------===//
101 
102  /// Return the current token the parser is inspecting.
103  const Token &getToken() const { return state.curToken; }
104  StringRef getTokenSpelling() const { return state.curToken.getSpelling(); }
105 
106  /// Return the last parsed token.
107  const Token &getLastToken() const { return state.lastToken; }
108 
109  /// If the current token has the specified kind, consume it and return true.
110  /// If not, return false.
112  if (state.curToken.isNot(kind))
113  return false;
115  return true;
116  }
117 
118  /// Advance the current lexer onto the next token.
119  void consumeToken() {
120  assert(state.curToken.isNot(Token::eof, Token::error) &&
121  "shouldn't advance past EOF or errors");
124  }
125 
126  /// Advance the current lexer onto the next token, asserting what the expected
127  /// current token is. This is preferred to the above method because it leads
128  /// to more self-documenting code with better checking.
130  assert(state.curToken.is(kind) && "consumed an unexpected token");
131  consumeToken();
132  }
133 
134  /// Reset the parser to the given lexer position. Resetting the parser/lexer
135  /// position does not update 'state.lastToken'. 'state.lastToken' is the
136  /// last parsed token, and is used to provide the scope end location for
137  /// OperationDefinitions. To ensure the correctness of the end location, the
138  /// last consumed token of an OperationDefinition needs to be the last token
139  /// belonging to it.
140  void resetToken(const char *tokPos) {
141  state.lex.resetPointer(tokPos);
143  }
144 
145  /// Consume the specified token if present and return success. On failure,
146  /// output a diagnostic and return failure.
147  ParseResult parseToken(Token::Kind expectedToken, const Twine &message);
148 
149  /// Parses a quoted string token if present.
150  ParseResult parseOptionalString(std::string *string);
151 
152  /// Parse an optional integer value from the stream.
154 
155  /// Parse an optional integer value only in decimal format from the stream.
157 
158  /// Parse a floating point value from a literal.
159  ParseResult parseFloatFromLiteral(std::optional<APFloat> &result,
160  const Token &tok, bool isNegative,
161  const llvm::fltSemantics &semantics);
162 
163  /// Parse a floating point value from an integer literal token.
164  ParseResult parseFloatFromIntegerLiteral(std::optional<APFloat> &result,
165  const Token &tok, bool isNegative,
166  const llvm::fltSemantics &semantics);
167 
168  /// Returns true if the current token corresponds to a keyword.
169  bool isCurrentTokenAKeyword() const {
170  return getToken().isAny(Token::bare_identifier, Token::inttype) ||
171  getToken().isKeyword();
172  }
173 
174  /// Parse a keyword, if present, into 'keyword'.
175  ParseResult parseOptionalKeyword(StringRef *keyword);
176 
177  /// Parse an optional keyword or string and set instance into 'result'.`
178  ParseResult parseOptionalKeywordOrString(std::string *result);
179 
180  //===--------------------------------------------------------------------===//
181  // Resource Parsing
182  //===--------------------------------------------------------------------===//
183 
184  /// Parse a handle to a dialect resource within the assembly format.
185  FailureOr<AsmDialectResourceHandle>
186  parseResourceHandle(const OpAsmDialectInterface *dialect, std::string &name);
187  FailureOr<AsmDialectResourceHandle> parseResourceHandle(Dialect *dialect);
188 
189  //===--------------------------------------------------------------------===//
190  // Type Parsing
191  //===--------------------------------------------------------------------===//
192 
193  /// Invoke the `getChecked` method of the given Attribute or Type class, using
194  /// the provided location to emit errors in the case of failure. Note that
195  /// unlike `OpBuilder::getType`, this method does not implicitly insert a
196  /// context parameter.
197  template <typename T, typename... ParamsT>
198  T getChecked(SMLoc loc, ParamsT &&...params) {
199  return T::getChecked([&] { return emitError(loc); },
200  std::forward<ParamsT>(params)...);
201  }
202 
203  ParseResult parseFunctionResultTypes(SmallVectorImpl<Type> &elements);
204  ParseResult parseTypeListNoParens(SmallVectorImpl<Type> &elements);
205  ParseResult parseTypeListParens(SmallVectorImpl<Type> &elements);
206 
207  /// Optionally parse a type.
209 
210  /// Parse an arbitrary type.
211  Type parseType();
212 
213  /// Parse a complex type.
215 
216  /// Parse an extended type.
218 
219  /// Parse a function type.
221 
222  /// Parse a memref type.
224 
225  /// Parse a non function type.
227 
228  /// Parse a tensor type.
230 
231  /// Parse a tuple type.
233 
234  /// Parse a vector type.
235  VectorType parseVectorType();
236  ParseResult parseVectorDimensionList(SmallVectorImpl<int64_t> &dimensions,
237  SmallVectorImpl<bool> &scalableDims);
238  ParseResult parseDimensionListRanked(SmallVectorImpl<int64_t> &dimensions,
239  bool allowDynamic = true,
240  bool withTrailingX = true);
241  ParseResult parseIntegerInDimensionList(int64_t &value);
242  ParseResult parseXInDimensionList();
243 
244  //===--------------------------------------------------------------------===//
245  // Attribute Parsing
246  //===--------------------------------------------------------------------===//
247 
248  /// Parse an arbitrary attribute with an optional type.
249  Attribute parseAttribute(Type type = {});
250 
251  /// Parse an optional attribute with the provided type.
253  Type type = {});
254  OptionalParseResult parseOptionalAttribute(ArrayAttr &attribute, Type type);
255  OptionalParseResult parseOptionalAttribute(StringAttr &attribute, Type type);
256  OptionalParseResult parseOptionalAttribute(SymbolRefAttr &result, Type type);
257 
258  /// Parse an optional attribute that is demarcated by a specific token.
259  template <typename AttributeT>
261  AttributeT &attr,
262  Type type = {}) {
263  if (getToken().isNot(kind))
264  return std::nullopt;
265 
266  if (Attribute parsedAttr = parseAttribute(type)) {
267  attr = cast<AttributeT>(parsedAttr);
268  return success();
269  }
270  return failure();
271  }
272 
273  /// Parse an attribute dictionary.
274  ParseResult parseAttributeDict(NamedAttrList &attributes);
275 
276  /// Parse a distinct attribute.
277  Attribute parseDistinctAttr(Type type);
278 
279  /// Parse an extended attribute.
280  Attribute parseExtendedAttr(Type type);
281 
282  /// Parse a float attribute.
283  Attribute parseFloatAttr(Type type, bool isNegative);
284 
285  /// Parse a decimal or a hexadecimal literal, which can be either an integer
286  /// or a float attribute.
287  Attribute parseDecOrHexAttr(Type type, bool isNegative);
288 
289  /// Parse a dense elements attribute.
290  Attribute parseDenseElementsAttr(Type attrType);
291  ShapedType parseElementsLiteralType(SMLoc loc, Type type);
292 
293  /// Parse a dense resource elements attribute.
294  Attribute parseDenseResourceElementsAttr(Type attrType);
295 
296  /// Parse a DenseArrayAttr.
297  Attribute parseDenseArrayAttr(Type type);
298 
299  /// Parse a sparse elements attribute.
300  Attribute parseSparseElementsAttr(Type attrType);
301 
302  /// Parse a strided layout attribute.
303  Attribute parseStridedLayoutAttr();
304 
305  //===--------------------------------------------------------------------===//
306  // Location Parsing
307  //===--------------------------------------------------------------------===//
308 
309  /// Parse a raw location instance.
310  ParseResult parseLocationInstance(LocationAttr &loc);
311 
312  /// Parse a callsite location instance.
313  ParseResult parseCallSiteLocation(LocationAttr &loc);
314 
315  /// Parse a fused location instance.
316  ParseResult parseFusedLocation(LocationAttr &loc);
317 
318  /// Parse a name or FileLineCol location instance.
319  ParseResult parseNameOrFileLineColRange(LocationAttr &loc);
320 
321  //===--------------------------------------------------------------------===//
322  // Affine Parsing
323  //===--------------------------------------------------------------------===//
324 
325  /// Parse a reference to either an affine map, expr, or an integer set.
326  ParseResult parseAffineMapOrIntegerSetReference(AffineMap &map,
327  IntegerSet &set);
328  ParseResult parseAffineMapReference(AffineMap &map);
329  ParseResult
330  parseAffineExprReference(ArrayRef<std::pair<StringRef, AffineExpr>> symbolSet,
331  AffineExpr &expr);
332  ParseResult parseIntegerSetReference(IntegerSet &set);
333 
334  /// Parse an AffineMap where the dim and symbol identifiers are SSA ids.
335  ParseResult
336  parseAffineMapOfSSAIds(AffineMap &map,
337  function_ref<ParseResult(bool)> parseElement,
338  Delimiter delimiter);
339 
340  /// Parse an AffineExpr where dim and symbol identifiers are SSA ids.
341  ParseResult
342  parseAffineExprOfSSAIds(AffineExpr &expr,
343  function_ref<ParseResult(bool)> parseElement);
344 
345  //===--------------------------------------------------------------------===//
346  // Code Completion
347  //===--------------------------------------------------------------------===//
348 
349  /// The set of various code completion methods. Every completion method
350  /// returns `failure` to signal that parsing should abort after any desired
351  /// completions have been enqueued. Note that `failure` is does not mean
352  /// completion failed, it's just a signal to the parser to stop.
353 
354  ParseResult codeCompleteDialectName();
355  ParseResult codeCompleteOperationName(StringRef dialectName);
356  ParseResult codeCompleteDialectOrElidedOpName(SMLoc loc);
357  ParseResult codeCompleteStringDialectOrOperationName(StringRef name);
358  ParseResult codeCompleteExpectedTokens(ArrayRef<StringRef> tokens);
359  ParseResult codeCompleteOptionalTokens(ArrayRef<StringRef> tokens);
360 
361  Attribute codeCompleteAttribute();
362  Type codeCompleteType();
363  Attribute
364  codeCompleteDialectSymbol(const llvm::StringMap<Attribute> &aliases);
365  Type codeCompleteDialectSymbol(const llvm::StringMap<Type> &aliases);
366 
367 protected:
368  /// The Parser is subclassed and reinstantiated. Do not add additional
369  /// non-trivial state here, add it to the ParserState class.
371 };
372 } // namespace detail
373 } // namespace mlir
374 
375 #endif // MLIR_LIB_ASMPARSER_PARSER_H
union mlir::linalg::@1196::ArityGroupAndKind::Kind kind
Delimiter
These are the supported delimiters around operand lists and region argument lists,...
@ None
Zero or more operands with no delimiters.
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
Dialects are groups of MLIR operations, types and attributes, as well as behavior associated with the...
Definition: Dialect.h:38
This class represents a diagnostic that is inflight and set to be reported.
Definition: Diagnostics.h:314
Token lexToken()
Definition: Lexer.cpp:73
const llvm::SourceMgr & getSourceMgr()
Definition: Lexer.h:28
Location getEncodedSourceLocation(SMLoc loc)
Encode the specified source location information into a Location object for attachment to the IR or e...
Definition: Lexer.cpp:50
void resetPointer(const char *newPointer)
Change the position of the lexer cursor.
Definition: Lexer.h:38
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
Definition: Location.h:66
MLIRContext is the top-level object for a collection of MLIR operations.
Definition: MLIRContext.h:60
This class implements Optional functionality for ParseResult.
Definition: OpDefinition.h:39
MLIRContext * getContext() const
Return the MLIRContext to be used when parsing.
Definition: AsmState.h:483
This represents a token in the MLIR syntax.
Definition: Token.h:20
bool isKeyword() const
Return true if this is one of the keyword token kinds (e.g. kw_if).
Definition: Token.cpp:192
bool is(Kind k) const
Definition: Token.h:38
bool isAny(Kind k1, Kind k2) const
Definition: Token.h:40
bool isNot(Kind k) const
Definition: Token.h:50
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 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:361
ParseResult parseOptionalKeywordOrString(std::string *result)
Parse an optional keyword or string and set instance into 'result'.`.
Definition: Parser.cpp:426
ParseResult parseOptionalKeyword(StringRef *keyword)
Parse a keyword, if present, into 'keyword'.
Definition: Parser.cpp:416
const Token & getLastToken() const
Return the last parsed token.
Definition: Parser.h:107
Attribute parseDenseArrayAttr(Type type)
Parse a DenseArrayAttr.
Attribute parseStridedLayoutAttr()
Parse a strided layout attribute.
Attribute parseDecOrHexAttr(Type type, bool isNegative)
Parse a decimal or a hexadecimal literal, which can be either an integer or a float attribute.
OpAsmParser::Delimiter Delimiter
Definition: Parser.h:29
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
T getChecked(SMLoc loc, ParamsT &&...params)
Invoke the getChecked method of the given Attribute or Type class, using the provided location to emi...
Definition: Parser.h:198
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
ParseResult parseCommaSeparatedListUntil(Token::Kind rightToken, function_ref< ParseResult()> parseElement, bool allowEmptyList=true)
Parse a comma-separated list of elements up until the specified end token.
Definition: Parser.cpp:173
ParseResult codeCompleteOperationName(StringRef dialectName)
Definition: Parser.cpp:489
OptionalParseResult parseOptionalDecimalInteger(APInt &result)
Parse an optional integer value only in decimal format from the stream.
Definition: Parser.cpp:323
Builder builder
Definition: Parser.h:31
Type parseType()
Parse an arbitrary type.
Definition: TypeParser.cpp:75
Attribute parseDenseElementsAttr(Type attrType)
Parse a dense elements attribute.
void consumeToken(Token::Kind kind)
Advance the current lexer onto the next token, asserting what the expected current token is.
Definition: Parser.h:129
ParseResult parseTypeListParens(SmallVectorImpl< Type > &elements)
Parse a parenthesized list of types.
Definition: TypeParser.cpp:117
ParserState & getState() const
Definition: Parser.h:37
Attribute parseDenseResourceElementsAttr(Type attrType)
Parse a dense resource elements attribute.
ParseResult parseVectorDimensionList(SmallVectorImpl< int64_t > &dimensions, SmallVectorImpl< bool > &scalableDims)
Parse a dimension list in a vector type.
Definition: TypeParser.cpp:507
Type parseMemRefType()
Parse a memref type.
Definition: TypeParser.cpp:184
Type parseNonFunctionType()
Parse a non function type.
Definition: TypeParser.cpp:276
Parser(ParserState &state)
Definition: Parser.h:33
Type codeCompleteType()
Definition: Parser.cpp:549
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
Type parseExtendedType()
Parse an extended type.
Type parseTupleType()
Parse a tuple type.
Definition: TypeParser.cpp:450
InFlightDiagnostic emitError(const Twine &message={})
Emit an error and return failure.
Definition: Parser.cpp:192
ParserState & state
The Parser is subclassed and reinstantiated.
Definition: Parser.h:370
ParseResult codeCompleteDialectName()
The set of various code completion methods.
Definition: Parser.cpp:484
ParseResult parseAffineExprReference(ArrayRef< std::pair< StringRef, AffineExpr >> symbolSet, AffineExpr &expr)
Attribute parseAttribute(Type type={})
Parse an arbitrary attribute with an optional type.
const llvm::SourceMgr & getSourceMgr()
Definition: Parser.h:39
StringRef getTokenSpelling() const
Definition: Parser.h:104
FailureOr< AsmDialectResourceHandle > parseResourceHandle(const OpAsmDialectInterface *dialect, std::string &name)
Parse a handle to a dialect resource within the assembly format.
Definition: Parser.cpp:441
ParseResult parseLocationInstance(LocationAttr &loc)
Parse a raw location instance.
void consumeToken()
Advance the current lexer onto the next token.
Definition: Parser.h:119
ParseResult codeCompleteExpectedTokens(ArrayRef< StringRef > tokens)
Definition: Parser.cpp:535
Attribute codeCompleteAttribute()
Definition: Parser.cpp:544
ParseResult parseIntegerInDimensionList(int64_t &value)
Definition: TypeParser.cpp:580
ParseResult parseAttributeDict(NamedAttrList &attributes)
Parse an attribute dictionary.
ParseResult parseDialectSymbolBody(StringRef &body, bool &isCodeCompletion)
Parse the body of a dialect symbol, which starts and ends with <>'s, and may be recursive.
ParseResult parseOptionalString(std::string *string)
Parses a quoted string token if present.
Definition: Parser.cpp:275
Type parseComplexType()
Parse a complex type.
Definition: TypeParser.cpp:135
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 codeCompleteDialectOrElidedOpName(SMLoc loc)
Definition: Parser.cpp:499
ParseResult parseDialectSymbolBody(StringRef &body)
Definition: Parser.h:68
MLIRContext * getContext() const
Definition: Parser.h:38
Attribute parseDistinctAttr(Type type)
Parse a distinct attribute.
InFlightDiagnostic emitWrongTokenError(const Twine &message={})
Emit an error about a "wrong token".
Definition: Parser.cpp:215
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
VectorType parseVectorType()
Parse a vector type.
Definition: TypeParser.cpp:476
ParseResult parseNameOrFileLineColRange(LocationAttr &loc)
Parse a name or FileLineCol location instance.
OptionalParseResult parseOptionalInteger(APInt &result)
Parse an optional integer value from the stream.
Definition: Parser.cpp:286
ParseResult parseFusedLocation(LocationAttr &loc)
Parse a fused location instance.
Type parseFunctionType()
Parse a function type.
Definition: TypeParser.cpp:158
Attribute parseSparseElementsAttr(Type attrType)
Parse a sparse elements attribute.
ParseResult parseAffineMapOrIntegerSetReference(AffineMap &map, IntegerSet &set)
Parse a reference to either an affine map, expr, or an integer set.
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:169
ParseResult codeCompleteStringDialectOrOperationName(StringRef name)
Definition: Parser.cpp:522
ParseResult codeCompleteOptionalTokens(ArrayRef< StringRef > tokens)
Definition: Parser.cpp:539
ParseResult parseAffineMapOfSSAIds(AffineMap &map, function_ref< ParseResult(bool)> parseElement, Delimiter delimiter)
Parse an AffineMap where the dim and symbol identifiers are SSA ids.
Attribute parseFloatAttr(Type type, bool isNegative)
Parse a float attribute.
ParseResult parseCallSiteLocation(LocationAttr &loc)
Parse a callsite location instance.
ParseResult parseFloatFromIntegerLiteral(std::optional< APFloat > &result, const Token &tok, bool isNegative, const llvm::fltSemantics &semantics)
Parse a floating point value from an integer literal token.
Definition: Parser.cpp:385
ParseResult parseIntegerSetReference(IntegerSet &set)
ParseResult parseTypeListNoParens(SmallVectorImpl< Type > &elements)
Parse a list of types without an enclosing parenthesis.
Definition: TypeParser.cpp:102
void resetToken(const char *tokPos)
Reset the parser to the given lexer position.
Definition: Parser.h:140
ParseResult parseAffineExprOfSSAIds(AffineExpr &expr, function_ref< ParseResult(bool)> parseElement)
Parse an AffineExpr where dim and symbol identifiers are SSA ids.
Attribute parseExtendedAttr(Type type)
Parse an extended attribute.
const Token & getToken() const
Return the current token the parser is inspecting.
Definition: Parser.h:103
ParseResult parseCommaSeparatedList(function_ref< ParseResult()> parseElementFn)
Parse a comma separated list of elements that must have at least one entry in it.
Definition: Parser.h:58
ShapedType parseElementsLiteralType(SMLoc loc, Type type)
Shaped type for elements attribute.
Type parseTensorType()
Parse a tensor type.
Definition: TypeParser.cpp:392
bool consumeIf(Token::Kind kind)
If the current token has the specified kind, consume it and return true.
Definition: Parser.h:111
OptionalParseResult parseOptionalAttributeWithToken(Token::Kind kind, AttributeT &attr, Type type={})
Parse an optional attribute that is demarcated by a specific token.
Definition: Parser.h:260
Attribute codeCompleteDialectSymbol(const llvm::StringMap< Attribute > &aliases)
Definition: Parser.cpp:555
Include the generated interface declarations.
llvm::function_ref< Fn > function_ref
Definition: LLVM.h:152
const FrozenRewritePatternSet GreedyRewriteConfig config
This class refers to all of the state maintained globally by the parser, such as the current lexer po...
Definition: ParserState.h:51
const ParserConfig & config
The configuration used to setup the parser.
Definition: ParserState.h:63
Lexer lex
The lexer for the source file we're parsing.
Definition: ParserState.h:66
Token curToken
This is the next token that hasn't been consumed yet.
Definition: ParserState.h:69
Token lastToken
This is the last token that has been consumed.
Definition: ParserState.h:72