35 case Token::kw_memref:
36 case Token::kw_tensor:
37 case Token::kw_complex:
39 case Token::kw_vector:
41 case Token::kw_f4E2M1FN:
42 case Token::kw_f6E2M3FN:
43 case Token::kw_f6E3M2FN:
44 case Token::kw_f8E5M2:
45 case Token::kw_f8E4M3:
46 case Token::kw_f8E4M3FN:
47 case Token::kw_f8E5M2FNUZ:
48 case Token::kw_f8E4M3FNUZ:
49 case Token::kw_f8E4M3B11FNUZ:
50 case Token::kw_f8E3M4:
51 case Token::kw_f8E8M0FNU:
61 case Token::exclamation_identifier:
92 elements.push_back(t);
102 auto parseElt = [&]() -> ParseResult {
104 elements.push_back(elt);
105 return elt ? success() : failure();
117 if (
parseToken(Token::l_paren,
"expected '('"))
138 if (
parseToken(Token::less,
"expected '<' in complex type"))
144 parseToken(Token::greater,
"expected '>' in complex type"))
146 if (!isa<FloatType>(elementType) && !isa<IntegerType>(elementType))
147 return emitError(elementTypeLoc,
"invalid element type for complex"),
158 assert(
getToken().is(Token::l_paren));
162 parseToken(Token::arrow,
"expected '->' in function type") ||
187 if (
parseToken(Token::less,
"expected '<' in memref type"))
213 return emitError(typeLoc,
"invalid memref element type"),
nullptr;
215 MemRefLayoutAttrInterface layout;
218 auto parseElt = [&]() -> ParseResult {
224 if (isa<MemRefLayoutAttrInterface>(attr)) {
225 layout = cast<MemRefLayoutAttrInterface>(attr);
226 }
else if (memorySpace) {
227 return emitError(
"multiple memory spaces specified in memref type");
234 return emitError(
"cannot have affine map for unranked memref type");
236 return emitError(
"expected memory space to be last in memref type");
244 if (
parseToken(Token::comma,
"expected ',' or '>' in memref type") ||
252 return getChecked<UnrankedMemRefType>(loc, elementType, memorySpace);
254 return getChecked<MemRefType>(loc, dimensions, elementType, layout,
279 case Token::kw_memref:
281 case Token::kw_tensor:
283 case Token::kw_complex:
285 case Token::kw_tuple:
287 case Token::kw_vector:
290 case Token::inttype: {
292 if (!width.has_value())
293 return (
emitError(
"invalid integer width"),
nullptr);
294 if (*width > IntegerType::kMaxWidth) {
296 << IntegerType::kMaxWidth <<
" bits";
300 IntegerType::SignednessSemantics signSemantics = IntegerType::Signless;
301 if (std::optional<bool> signedness =
getToken().getIntTypeSignedness())
309 case Token::kw_f4E2M1FN:
312 case Token::kw_f6E2M3FN:
315 case Token::kw_f6E3M2FN:
318 case Token::kw_f8E5M2:
321 case Token::kw_f8E4M3:
324 case Token::kw_f8E4M3FN:
327 case Token::kw_f8E5M2FNUZ:
330 case Token::kw_f8E4M3FNUZ:
333 case Token::kw_f8E4M3B11FNUZ:
336 case Token::kw_f8E3M4:
339 case Token::kw_f8E8M0FNU:
365 case Token::kw_index:
375 case Token::exclamation_identifier:
379 case Token::code_complete:
380 if (
getToken().isCodeCompletionFor(Token::exclamation_identifier))
394 if (
parseToken(Token::less,
"expected '<' in tensor type"))
421 if (parseResult.has_value()) {
422 if (failed(parseResult.value()))
424 if (
auto v = dyn_cast_or_null<VerifiableTensorEncoding>(encoding)) {
425 if (failed(v.verifyEncoding(dimensions, elementType,
426 [&] { return emitError(); })))
432 if (!elementType ||
parseToken(Token::greater,
"expected '>' in tensor type"))
435 return emitError(elementTypeLoc,
"invalid tensor element type"),
nullptr;
439 return emitError(
"cannot apply encoding to unranked tensor"),
nullptr;
453 if (
parseToken(Token::less,
"expected '<' in tuple type"))
463 parseToken(Token::greater,
"expected '>' in tuple type"))
479 if (
parseToken(Token::less,
"expected '<' in vector type"))
490 if (!elementType ||
parseToken(Token::greater,
"expected '>' in vector type"))
493 return getChecked<VectorType>(loc, dimensions, elementType, scalableDims);
511 bool scalable =
consumeIf(Token::l_square);
514 dimensions.push_back(value);
519 scalableDims.push_back(scalable);
543 bool allowDynamic,
bool withTrailingX) {
544 auto parseDim = [&]() -> LogicalResult {
548 return emitError(loc,
"expected static shape");
549 dimensions.push_back(ShapedType::kDynamic);
554 dimensions.push_back(value);
560 while (
getToken().isAny(Token::integer, Token::question)) {
567 if (
getToken().isAny(Token::integer, Token::question)) {
568 if (failed(parseDim()))
570 while (
getToken().is(Token::bare_identifier) &&
598 value = (int64_t)*dimension;
static Value max(ImplicitLocOpBuilder &builder, Value value, Value bound)
Attributes are known-constant values of operations.
static bool isValidElementType(Type type)
Return true if the specified element type is ok in a memref.
FunctionType getFunctionType(TypeRange inputs, TypeRange results)
Ty getType(Args &&...args)
Get or construct an instance of the type Ty with provided arguments.
void resetPointer(const char *newPointer)
Change the position of the lexer cursor.
This class implements Optional functionality for ParseResult.
static bool isValidElementType(Type type)
Return true if the specified element type is ok in a tensor.
static std::optional< uint64_t > getUInt64IntegerValue(StringRef spelling)
For an integer token, return its value as an uint64_t.
std::optional< unsigned > getIntTypeBitwidth() const
For an inttype token, return its bitwidth.
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
ParseResult parseXInDimensionList()
Parse an 'x' token in a dimension list, handling the case where the x is juxtaposed with an element t...
OptionalParseResult parseOptionalType(Type &type)
Optionally parse a type.
ParseResult parseToken(Token::Kind expectedToken, const Twine &message)
Consume the specified token if present and return success.
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.
Type parseType()
Parse an arbitrary type.
ParseResult parseTypeListParens(SmallVectorImpl< Type > &elements)
Parse a parenthesized list of types.
ParseResult parseVectorDimensionList(SmallVectorImpl< int64_t > &dimensions, SmallVectorImpl< bool > &scalableDims)
Parse a dimension list in a vector type.
Type parseMemRefType()
Parse a memref type.
Type parseNonFunctionType()
Parse a non function type.
Type parseExtendedType()
Parse an extended type.
Type parseTupleType()
Parse a tuple type.
InFlightDiagnostic emitError(const Twine &message={})
Emit an error and return failure.
ParserState & state
The Parser is subclassed and reinstantiated.
Attribute parseAttribute(Type type={})
Parse an arbitrary attribute with an optional type.
StringRef getTokenSpelling() const
void consumeToken()
Advance the current lexer onto the next token.
ParseResult parseIntegerInDimensionList(int64_t &value)
Type parseComplexType()
Parse a complex type.
ParseResult parseDimensionListRanked(SmallVectorImpl< int64_t > &dimensions, bool allowDynamic=true, bool withTrailingX=true)
Parse a dimension list of a tensor or memref type.
ParseResult parseFunctionResultTypes(SmallVectorImpl< Type > &elements)
Parse a function result type.
MLIRContext * getContext() const
InFlightDiagnostic emitWrongTokenError(const Twine &message={})
Emit an error about a "wrong token".
ParseResult parseCommaSeparatedList(Delimiter delimiter, function_ref< ParseResult()> parseElementFn, StringRef contextMessage=StringRef())
Parse a list of comma-separated items with an optional delimiter.
VectorType parseVectorType()
Parse a vector type.
Type parseFunctionType()
Parse a function type.
OptionalParseResult parseOptionalAttribute(Attribute &attribute, Type type={})
Parse an optional attribute with the provided type.
ParseResult parseTypeListNoParens(SmallVectorImpl< Type > &elements)
Parse a list of types without an enclosing parenthesis.
const Token & getToken() const
Return the current token the parser is inspecting.
Type parseTensorType()
Parse a tensor type.
bool consumeIf(Token::Kind kind)
If the current token has the specified kind, consume it and return true.
Include the generated interface declarations.
auto get(MLIRContext *context, Ts &&...params)
Helper method that injects context only if needed, this helps unify some of the attribute constructio...
Lexer lex
The lexer for the source file we're parsing.