int kind = 0;
if (parser.parseLess() || parser.parseInteger(kind) || parser.parseGreater())
return {};
- return TYPE::get(parser.getBuilder().getContext(), kind);
+ return TYPE::get(parser.getContext(), kind);
}
template <typename TYPE>
if (parser.parseKeyword(&typeTag))
return {};
mlir::Type genType;
- auto parseResult = generatedTypeParser(parser.getBuilder().getContext(),
- parser, typeTag, genType);
+ auto parseResult = generatedTypeParser(parser, typeTag, genType);
if (parseResult.hasValue())
return genType;
parser.emitError(parser.getNameLoc(), "unknown fir type: ") << typeTag;
//===----------------------------------------------------------------------===//
// `boxproc` `<` return-type `>`
-mlir::Type BoxProcType::parse(mlir::MLIRContext *context,
- mlir::DialectAsmParser &parser) {
+mlir::Type BoxProcType::parse(mlir::DialectAsmParser &parser) {
mlir::Type ty;
if (parser.parseLess() || parser.parseType(ty) || parser.parseGreater())
return {};
- return get(context, ty);
+ return get(parser.getContext(), ty);
}
void fir::BoxProcType::print(mlir::DialectAsmPrinter &printer) const {
//===----------------------------------------------------------------------===//
// `box` `<` type (',' affine-map)? `>`
-mlir::Type fir::BoxType::parse(mlir::MLIRContext *context,
- mlir::DialectAsmParser &parser) {
+mlir::Type fir::BoxType::parse(mlir::DialectAsmParser &parser) {
mlir::Type ofTy;
if (parser.parseLess() || parser.parseType(ofTy))
return {};
// BoxCharType
//===----------------------------------------------------------------------===//
-mlir::Type fir::BoxCharType::parse(mlir::MLIRContext *context,
- mlir::DialectAsmParser &parser) {
+mlir::Type fir::BoxCharType::parse(mlir::DialectAsmParser &parser) {
return parseKindSingleton<fir::BoxCharType>(parser);
}
//===----------------------------------------------------------------------===//
// `char` `<` kind [`,` `len`] `>`
-mlir::Type fir::CharacterType::parse(mlir::MLIRContext *context,
- mlir::DialectAsmParser &parser) {
+mlir::Type fir::CharacterType::parse(mlir::DialectAsmParser &parser) {
int kind = 0;
if (parser.parseLess() || parser.parseInteger(kind))
return {};
}
if (parser.parseGreater())
return {};
- return get(context, kind, len);
+ return get(parser.getContext(), kind, len);
}
void fir::CharacterType::print(mlir::DialectAsmPrinter &printer) const {
// ComplexType
//===----------------------------------------------------------------------===//
-mlir::Type fir::ComplexType::parse(mlir::MLIRContext *context,
- mlir::DialectAsmParser &parser) {
+mlir::Type fir::ComplexType::parse(mlir::DialectAsmParser &parser) {
return parseKindSingleton<fir::ComplexType>(parser);
}
//===----------------------------------------------------------------------===//
// `heap` `<` type `>`
-mlir::Type fir::HeapType::parse(mlir::MLIRContext *context,
- mlir::DialectAsmParser &parser) {
+mlir::Type fir::HeapType::parse(mlir::DialectAsmParser &parser) {
return parseTypeSingleton<HeapType>(parser);
}
//===----------------------------------------------------------------------===//
// `int` `<` kind `>`
-mlir::Type fir::IntegerType::parse(mlir::MLIRContext *context,
- mlir::DialectAsmParser &parser) {
+mlir::Type fir::IntegerType::parse(mlir::DialectAsmParser &parser) {
return parseKindSingleton<fir::IntegerType>(parser);
}
//===----------------------------------------------------------------------===//
// `logical` `<` kind `>`
-mlir::Type fir::LogicalType::parse(mlir::MLIRContext *context,
- mlir::DialectAsmParser &parser) {
+mlir::Type fir::LogicalType::parse(mlir::DialectAsmParser &parser) {
return parseKindSingleton<fir::LogicalType>(parser);
}
//===----------------------------------------------------------------------===//
// `ptr` `<` type `>`
-mlir::Type fir::PointerType::parse(mlir::MLIRContext *context,
- mlir::DialectAsmParser &parser) {
+mlir::Type fir::PointerType::parse(mlir::DialectAsmParser &parser) {
return parseTypeSingleton<fir::PointerType>(parser);
}
//===----------------------------------------------------------------------===//
// `real` `<` kind `>`
-mlir::Type fir::RealType::parse(mlir::MLIRContext *context,
- mlir::DialectAsmParser &parser) {
+mlir::Type fir::RealType::parse(mlir::DialectAsmParser &parser) {
return parseKindSingleton<fir::RealType>(parser);
}
// `type` `<` name
// (`(` id `:` type (`,` id `:` type)* `)`)?
// (`{` id `:` type (`,` id `:` type)* `}`)? '>'
-mlir::Type fir::RecordType::parse(mlir::MLIRContext *context,
- mlir::DialectAsmParser &parser) {
+mlir::Type fir::RecordType::parse(mlir::DialectAsmParser &parser) {
llvm::StringRef name;
if (parser.parseLess() || parser.parseKeyword(&name))
return {};
- RecordType result = RecordType::get(parser.getBuilder().getContext(), name);
+ RecordType result = RecordType::get(parser.getContext(), name);
RecordType::TypeList lenParamList;
if (!parser.parseOptionalLParen()) {
//===----------------------------------------------------------------------===//
// `ref` `<` type `>`
-mlir::Type fir::ReferenceType::parse(mlir::MLIRContext *context,
- mlir::DialectAsmParser &parser) {
+mlir::Type fir::ReferenceType::parse(mlir::DialectAsmParser &parser) {
return parseTypeSingleton<fir::ReferenceType>(parser);
}
// `array` `<` `*` | bounds (`x` bounds)* `:` type (',' affine-map)? `>`
// bounds ::= `?` | int-lit
-mlir::Type fir::SequenceType::parse(mlir::MLIRContext *context,
- mlir::DialectAsmParser &parser) {
+mlir::Type fir::SequenceType::parse(mlir::DialectAsmParser &parser) {
if (parser.parseLess())
return {};
SequenceType::Shape shape;
parser.emitError(parser.getNameLoc(), "expecting affine map");
return {};
}
- return SequenceType::get(context, shape, eleTy, map);
+ return SequenceType::get(parser.getContext(), shape, eleTy, map);
}
void fir::SequenceType::print(mlir::DialectAsmPrinter &printer) const {
// ShapeType
//===----------------------------------------------------------------------===//
-mlir::Type fir::ShapeType::parse(mlir::MLIRContext *context,
- mlir::DialectAsmParser &parser) {
+mlir::Type fir::ShapeType::parse(mlir::DialectAsmParser &parser) {
return parseRankSingleton<fir::ShapeType>(parser);
}
// ShapeShiftType
//===----------------------------------------------------------------------===//
-mlir::Type fir::ShapeShiftType::parse(mlir::MLIRContext *context,
- mlir::DialectAsmParser &parser) {
+mlir::Type fir::ShapeShiftType::parse(mlir::DialectAsmParser &parser) {
return parseRankSingleton<fir::ShapeShiftType>(parser);
}
// ShiftType
//===----------------------------------------------------------------------===//
-mlir::Type fir::ShiftType::parse(mlir::MLIRContext *context,
- mlir::DialectAsmParser &parser) {
+mlir::Type fir::ShiftType::parse(mlir::DialectAsmParser &parser) {
return parseRankSingleton<fir::ShiftType>(parser);
}
//===----------------------------------------------------------------------===//
// `slice` `<` rank `>`
-mlir::Type fir::SliceType::parse(mlir::MLIRContext *context,
- mlir::DialectAsmParser &parser) {
+mlir::Type fir::SliceType::parse(mlir::DialectAsmParser &parser) {
return parseRankSingleton<fir::SliceType>(parser);
}
//===----------------------------------------------------------------------===//
// `tdesc` `<` type `>`
-mlir::Type fir::TypeDescType::parse(mlir::MLIRContext *context,
- mlir::DialectAsmParser &parser) {
+mlir::Type fir::TypeDescType::parse(mlir::DialectAsmParser &parser) {
return parseTypeSingleton<fir::TypeDescType>(parser);
}
//===----------------------------------------------------------------------===//
// `vector` `<` len `:` type `>`
-mlir::Type fir::VectorType::parse(mlir::MLIRContext *context,
- mlir::DialectAsmParser &parser) {
+mlir::Type fir::VectorType::parse(mlir::DialectAsmParser &parser) {
int64_t len = 0;
mlir::Type eleTy;
if (parser.parseLess() || parser.parseInteger(len) || parser.parseColon() ||
#include "mlir/IR/OpDefinition.h"
#include "llvm/ADT/Twine.h"
#include "llvm/Support/SMLoc.h"
-#include "llvm/Support/raw_ostream.h"
namespace mlir {
AsmParser() = default;
virtual ~AsmParser();
+ MLIRContext *getContext() const;
+
/// Return the location of the original name token.
virtual llvm::SMLoc getNameLoc() const = 0;
uniqueOperands.push_back(operand);
replacements.push_back(
kind == AffineExprKind::DimId
- ? getAffineDimExpr(pos, parser.getBuilder().getContext())
- : getAffineSymbolExpr(pos, parser.getBuilder().getContext()));
+ ? getAffineDimExpr(pos, parser.getContext())
+ : getAffineSymbolExpr(pos, parser.getContext()));
}
}
}
Builder &builder = parser.getBuilder();
auto flatMap = AffineMap::get(totalNumDims, totalNumSyms, flatExprs,
- parser.getBuilder().getContext());
+ parser.getContext());
flatMap = flatMap.replaceDimsAndSymbols(
dimRplacements, symRepacements, dimOperands.size(), symOperands.size());
llvm::SMLoc typeLoc = parser.getCurrentLocation();
{
Type genType;
- auto parseResult = generatedTypeParser(parser.getBuilder().getContext(),
- parser, "vector", genType);
+ auto parseResult = generatedTypeParser(parser, "vector", genType);
if (parseResult.hasValue())
return genType;
}
printer << '>';
}
-Type ValueType::parse(mlir::MLIRContext *, mlir::DialectAsmParser &parser) {
+Type ValueType::parse(mlir::DialectAsmParser &parser) {
Type ty;
if (parser.parseLess() || parser.parseType(ty) || parser.parseGreater()) {
parser.emitError(parser.getNameLoc(), "failed to parse async value type");
if (parser.parseKeyword(&typeTag))
return Type();
Type genType;
- auto parseResult = generatedTypeParser(parser.getBuilder().getContext(),
- parser, typeTag, genType);
+ auto parseResult = generatedTypeParser(parser, typeTag, genType);
if (parseResult.hasValue())
return genType;
parser.emitError(parser.getNameLoc(), "unknown async type: ") << typeTag;
// Empty spec.
if (succeeded(parser.parseOptionalGreater()))
- return get(parser.getBuilder().getContext(), {});
+ return get(parser.getContext(), {});
SmallVector<DataLayoutEntryInterface> entries;
do {
if (failed(parser.parseGreater()))
return {};
return getChecked([&] { return parser.emitError(parser.getNameLoc()); },
- parser.getBuilder().getContext(), entries);
+ parser.getContext(), entries);
}
void DataLayoutSpecAttr::print(DialectAsmPrinter &os) const {
if (standardInclude)
result.addAttribute("is_standard_include",
- UnitAttr::get(parser.getBuilder().getContext()));
+ UnitAttr::get(parser.getContext()));
return success();
}
#define GET_ATTRDEF_CLASSES
#include "mlir/Dialect/EmitC/IR/EmitCAttributes.cpp.inc"
-Attribute emitc::OpaqueAttr::parse(MLIRContext *context,
- DialectAsmParser &parser, Type type) {
+Attribute emitc::OpaqueAttr::parse(DialectAsmParser &parser, Type type) {
if (parser.parseLess())
return Attribute();
std::string value;
}
if (parser.parseGreater())
return Attribute();
- return get(context, value);
+ return get(parser.getContext(), value);
}
Attribute EmitCDialect::parseAttribute(DialectAsmParser &parser,
return Attribute();
Attribute genAttr;
OptionalParseResult parseResult =
- generatedAttributeParser(getContext(), parser, mnemonic, type, genAttr);
+ generatedAttributeParser(parser, mnemonic, type, genAttr);
if (parseResult.hasValue())
return genAttr;
parser.emitError(typeLoc, "unknown attribute in EmitC dialect");
#define GET_TYPEDEF_CLASSES
#include "mlir/Dialect/EmitC/IR/EmitCTypes.cpp.inc"
-Type emitc::OpaqueType::parse(MLIRContext *context, DialectAsmParser &parser) {
+Type emitc::OpaqueType::parse(DialectAsmParser &parser) {
if (parser.parseLess())
return Type();
std::string value;
}
if (parser.parseGreater())
return Type();
- return get(context, value);
+ return get(parser.getContext(), value);
}
Type EmitCDialect::parseType(DialectAsmParser &parser) const {
return Type();
Type genType;
OptionalParseResult parseResult =
- generatedTypeParser(getContext(), parser, mnemonic, genType);
+ generatedTypeParser(parser, mnemonic, genType);
if (parseResult.hasValue())
return genType;
parser.emitError(typeLoc, "unknown type in EmitC dialect");
// The type can be omitted for string attributes, in which case it will be
// inferred from the value of the string as [strlen(value) x i8].
static ParseResult parseGlobalOp(OpAsmParser &parser, OperationState &result) {
- MLIRContext *ctx = parser.getBuilder().getContext();
+ MLIRContext *ctx = parser.getContext();
// Parse optional linkage, default to External.
result.addAttribute(getLinkageAttrName(),
LLVM::LinkageAttr::get(
Region &initRegion = *result.addRegion();
if (types.empty()) {
if (auto strAttr = value.dyn_cast_or_null<StringAttr>()) {
- MLIRContext *context = parser.getBuilder().getContext();
+ MLIRContext *context = parser.getContext();
auto arrayType = LLVM::LLVMArrayType::get(IntegerType::get(context, 8),
strAttr.getValue().size());
types.push_back(arrayType);
// Default to external linkage if no keyword is provided.
result.addAttribute(
getLinkageAttrName(),
- LinkageAttr::get(parser.getBuilder().getContext(),
+ LinkageAttr::get(parser.getContext(),
parseOptionalLLVMKeyword<Linkage>(
parser, result, LLVM::Linkage::External)));
printer << ">";
}
-Attribute FMFAttr::parse(MLIRContext *context, DialectAsmParser &parser,
- Type type) {
+Attribute FMFAttr::parse(DialectAsmParser &parser, Type type) {
if (failed(parser.parseLess()))
return {};
return {};
}
- return FMFAttr::get(parser.getBuilder().getContext(), flags);
+ return FMFAttr::get(parser.getContext(), flags);
}
void LinkageAttr::print(DialectAsmPrinter &printer) const {
printer << ">";
}
-Attribute LinkageAttr::parse(MLIRContext *context, DialectAsmParser &parser,
- Type type) {
+Attribute LinkageAttr::parse(DialectAsmParser &parser, Type type) {
StringRef elemName;
if (parser.parseLess() || parser.parseKeyword(&elemName) ||
parser.parseGreater())
return {};
}
Linkage linkage = *elem;
- return LinkageAttr::get(context, linkage);
+ return LinkageAttr::get(parser.getContext(), linkage);
}
LoopOptionsAttrBuilder::LoopOptionsAttrBuilder(LoopOptionsAttr attr)
printer << ">";
}
-Attribute LoopOptionsAttr::parse(MLIRContext *context, DialectAsmParser &parser,
- Type type) {
+Attribute LoopOptionsAttr::parse(DialectAsmParser &parser, Type type) {
if (failed(parser.parseLess()))
return {};
return {};
llvm::sort(options, llvm::less_first());
- return get(parser.getBuilder().getContext(), options);
+ return get(parser.getContext(), options);
}
Attribute LLVMDialect::parseAttribute(DialectAsmParser &parser,
return {};
{
Attribute attr;
- auto parseResult =
- generatedAttributeParser(getContext(), parser, attrKind, type, attr);
+ auto parseResult = generatedAttributeParser(parser, attrKind, type, attr);
if (parseResult.hasValue())
return attr;
}
if (failed(parser.parseKeyword(&key)))
return Type();
- MLIRContext *ctx = parser.getBuilder().getContext();
+ MLIRContext *ctx = parser.getContext();
return StringSwitch<function_ref<Type()>>(key)
.Case("void", [&] { return LLVMVoidType::get(ctx); })
.Case("ppc_fp128", [&] { return LLVMPPCFP128Type::get(ctx); })
break;
}
- auto int32Ty = IntegerType::get(parser.getBuilder().getContext(), 32);
+ auto int32Ty = IntegerType::get(parser.getContext(), 32);
return parser.resolveOperands(ops, {int32Ty, resultType, int32Ty, int32Ty},
parser.getNameLoc(), result.operands);
}
// <operation> ::= `llvm.nvvm.vote.ballot.sync %mask, %pred` : result_type
static ParseResult parseNVVMVoteBallotOp(OpAsmParser &parser,
OperationState &result) {
- MLIRContext *context = parser.getBuilder().getContext();
+ MLIRContext *context = parser.getContext();
auto int32Ty = IntegerType::get(context, 32);
auto int1Ty = IntegerType::get(context, 1);
parser.addTypeToList(type, result.types))
return failure();
- MLIRContext *context = parser.getBuilder().getContext();
+ MLIRContext *context = parser.getContext();
auto int32Ty = IntegerType::get(context, 32);
auto int1Ty = IntegerType::get(context, 1);
auto i32x4Ty = LLVM::getFixedVectorType(int32Ty, 4);
if (parser.parseOperandList(ops, 6) || parser.parseColonType(type))
return failure();
- MLIRContext *context = parser.getBuilder().getContext();
+ MLIRContext *context = parser.getContext();
auto int32Ty = IntegerType::get(context, 32);
auto int1Ty = IntegerType::get(context, 1);
auto i32x4Ty = LLVM::getFixedVectorType(int32Ty, 4);
ParseResult parseCopyOpRegion(OpAsmParser &parser, Region &r, Type inputType,
Type outputType) {
- OpBuilder opBuilder(parser.getBuilder().getContext());
+ OpBuilder opBuilder(parser.getContext());
fillStructuredOpRegion<CopyOp>(opBuilder, r, TypeRange{inputType},
TypeRange{outputType});
return success();
ParseResult parseFillOpRegion(OpAsmParser &parser, Region &r, Type valueType,
Type outputType) {
- OpBuilder opBuilder(parser.getBuilder().getContext());
+ OpBuilder opBuilder(parser.getContext());
fillStructuredOpRegion<FillOp>(opBuilder, r, TypeRange{valueType},
TypeRange{outputType});
return success();
parseNamedStructuredOpRegion(OpAsmParser &parser, Region ®ion,
TypeRange inputTypes, TypeRange outputTypes) {
ParseResult res = success();
- OpBuilder opBuilder(parser.getBuilder().getContext());
+ OpBuilder opBuilder(parser.getContext());
// Resolve `captures` into `capturedValues` at parse time so we can build the
// region with captures.
SmallVector<Value> capturedValues;
return success();
if (succeeded(parser.parseOptionalKeyword("uninitialized"))) {
- initialValue = UnitAttr::get(parser.getBuilder().getContext());
+ initialValue = UnitAttr::get(parser.getContext());
return success();
}
return failure();
result.addAttribute("collapse_val", attr);
} else if (keyword == "nowait") {
- auto attr = UnitAttr::get(parser.getBuilder().getContext());
+ auto attr = UnitAttr::get(parser.getContext());
result.addAttribute("nowait", attr);
} else if (keyword == "ordered") {
mlir::IntegerAttr attr;
auto attr = parser.getBuilder().getStringAttr(order);
result.addAttribute("order", attr);
} else if (keyword == "inclusive") {
- auto attr = UnitAttr::get(parser.getBuilder().getContext());
+ auto attr = UnitAttr::get(parser.getContext());
result.addAttribute("inclusive", attr);
} else if (keyword == "reduction") {
if (segments[reductionVarPos])
return Type();
{
Type genType;
- auto parseResult = generatedTypeParser(parser.getBuilder().getContext(),
- parser, typeTag, genType);
+ auto parseResult = generatedTypeParser(parser, typeTag, genType);
if (parseResult.hasValue())
return genType;
}
// RangeType
//===----------------------------------------------------------------------===//
-Type RangeType::parse(MLIRContext *context, DialectAsmParser &parser) {
+Type RangeType::parse(DialectAsmParser &parser) {
if (parser.parseLess())
return Type();
if (parseEnumStrAttr(imageOperands, parser))
return failure();
- attr = spirv::ImageOperandsAttr::get(parser.getBuilder().getContext(),
- imageOperands);
+ attr = spirv::ImageOperandsAttr::get(parser.getContext(), imageOperands);
return parser.parseRSquare();
}
if (!wrappedOp)
return failure();
- OpBuilder builder(parser.getBuilder().getContext());
+ OpBuilder builder(parser.getContext());
builder.setInsertionPointToEnd(&block);
builder.create<spirv::YieldOp>(wrappedOp->getLoc(), wrappedOp->getResult(0));
state.location = wrappedOp->getLoc();
}
}
-Attribute SparseTensorEncodingAttr::parse(MLIRContext *context,
- DialectAsmParser &parser, Type type) {
+Attribute SparseTensorEncodingAttr::parse(DialectAsmParser &parser, Type type) {
if (failed(parser.parseLess()))
return {};
// Parse the data as a dictionary.
}
}
// Construct struct-like storage for attribute.
- return parser.getChecked<SparseTensorEncodingAttr>(context, dlt, map, ptr,
- ind);
+ return parser.getChecked<SparseTensorEncodingAttr>(parser.getContext(), dlt,
+ map, ptr, ind);
}
void SparseTensorEncodingAttr::print(DialectAsmPrinter &printer) const {
if (failed(parser.parseKeyword(&attrTag)))
return Attribute();
Attribute attr;
- auto parseResult =
- generatedAttributeParser(getContext(), parser, attrTag, type, attr);
+ auto parseResult = generatedAttributeParser(parser, attrTag, type, attr);
if (parseResult.hasValue())
return attr;
parser.emitError(parser.getNameLoc(), "unknown sparse tensor attribute");
if (failed(parser.parseGreater()))
return {};
- return CombiningKindAttr::get(kind.getValue(),
- parser.getBuilder().getContext());
+ return CombiningKindAttr::get(kind.getValue(), parser.getContext());
}
Attribute VectorDialect::parseAttribute(DialectAsmParser &parser,
return op;
}
+MLIRContext *AsmParser::getContext() const { return getBuilder().getContext(); }
+
namespace {
class CustomOpAsmParser : public AsmParserImpl<OpAsmParser> {
public:
// AttrWithSelfTypeParamAttr
//===----------------------------------------------------------------------===//
-Attribute AttrWithSelfTypeParamAttr::parse(MLIRContext *context,
- DialectAsmParser &parser,
+Attribute AttrWithSelfTypeParamAttr::parse(DialectAsmParser &parser,
Type type) {
Type selfType;
if (parser.parseType(selfType))
return Attribute();
- return get(context, selfType);
+ return get(parser.getContext(), selfType);
}
void AttrWithSelfTypeParamAttr::print(DialectAsmPrinter &printer) const {
// AttrWithTypeBuilderAttr
//===----------------------------------------------------------------------===//
-Attribute AttrWithTypeBuilderAttr::parse(MLIRContext *context,
- DialectAsmParser &parser, Type type) {
+Attribute AttrWithTypeBuilderAttr::parse(DialectAsmParser &parser, Type type) {
IntegerAttr element;
if (parser.parseAttribute(element))
return Attribute();
- return get(context, element);
+ return get(parser.getContext(), element);
}
void AttrWithTypeBuilderAttr::print(DialectAsmPrinter &printer) const {
// CompoundAAttr
//===----------------------------------------------------------------------===//
-Attribute CompoundAAttr::parse(MLIRContext *context, DialectAsmParser &parser,
- Type type) {
+Attribute CompoundAAttr::parse(DialectAsmParser &parser, Type type) {
int widthOfSomething;
Type oneType;
SmallVector<int, 4> arrayOfInts;
if (parser.parseRSquare() || parser.parseGreater())
return Attribute();
- return get(context, widthOfSomething, oneType, arrayOfInts);
+ return get(parser.getContext(), widthOfSomething, oneType, arrayOfInts);
}
void CompoundAAttr::print(DialectAsmPrinter &printer) const {
// CompoundAAttr
//===----------------------------------------------------------------------===//
-Attribute TestI64ElementsAttr::parse(MLIRContext *context,
- DialectAsmParser &parser, Type type) {
+Attribute TestI64ElementsAttr::parse(DialectAsmParser &parser, Type type) {
SmallVector<uint64_t> elements;
if (parser.parseLess() || parser.parseLSquare())
return Attribute();
if (parser.parseRSquare() || parser.parseGreater())
return Attribute();
return parser.getChecked<TestI64ElementsAttr>(
- context, type.cast<ShapedType>(), elements);
+ parser.getContext(), type.cast<ShapedType>(), elements);
}
void TestI64ElementsAttr::print(DialectAsmPrinter &printer) const {
return Attribute();
{
Attribute attr;
- auto parseResult =
- generatedAttributeParser(getContext(), parser, attrTag, type, attr);
+ auto parseResult = generatedAttributeParser(parser, attrTag, type, attr);
if (parseResult.hasValue())
return attr;
}
// Create a return terminator in the inner region, pass as operand to the
// terminator the returned values from the wrapped operation.
SmallVector<Value, 8> return_operands(wrapped_op->getResults());
- OpBuilder builder(parser.getBuilder().getContext());
+ OpBuilder builder(parser.getContext());
builder.setInsertionPointToEnd(&block);
builder.create<TestReturnOp>(wrapped_op->getLoc(), return_operands);
// CompoundAType
//===----------------------------------------------------------------------===//
-Type CompoundAType::parse(MLIRContext *ctxt, DialectAsmParser &parser) {
+Type CompoundAType::parse(DialectAsmParser &parser) {
int widthOfSomething;
Type oneType;
SmallVector<int, 4> arrayOfInts;
if (parser.parseRSquare() || parser.parseGreater())
return Type();
- return get(ctxt, widthOfSomething, oneType, arrayOfInts);
+ return get(parser.getContext(), widthOfSomething, oneType, arrayOfInts);
}
void CompoundAType::print(DialectAsmPrinter &printer) const {
printer << "cmpnd_a<" << getWidthOfSomething() << ", " << getOneType()
// TestTypeWithLayout
//===----------------------------------------------------------------------===//
-Type TestTypeWithLayoutType::parse(MLIRContext *ctx, DialectAsmParser &parser) {
+Type TestTypeWithLayoutType::parse(DialectAsmParser &parser) {
unsigned val;
if (parser.parseLess() || parser.parseInteger(val) || parser.parseGreater())
return Type();
- return TestTypeWithLayoutType::get(ctx, val);
+ return TestTypeWithLayoutType::get(parser.getContext(), val);
}
void TestTypeWithLayoutType::print(DialectAsmPrinter &printer) const {
SimpleAType::attachInterface<PtrElementModel>(*getContext());
}
-static Type parseTestType(MLIRContext *ctxt, DialectAsmParser &parser,
- SetVector<Type> &stack) {
+static Type parseTestType(DialectAsmParser &parser, SetVector<Type> &stack) {
StringRef typeTag;
if (failed(parser.parseKeyword(&typeTag)))
return Type();
{
Type genType;
- auto parseResult = generatedTypeParser(ctxt, parser, typeTag, genType);
+ auto parseResult = generatedTypeParser(parser, typeTag, genType);
if (parseResult.hasValue())
return genType;
}
StringRef name;
if (parser.parseLess() || parser.parseKeyword(&name))
return Type();
- auto rec = TestRecursiveType::get(parser.getBuilder().getContext(), name);
+ auto rec = TestRecursiveType::get(parser.getContext(), name);
// If this type already has been parsed above in the stack, expect just the
// name.
if (failed(parser.parseComma()))
return Type();
stack.insert(rec);
- Type subtype = parseTestType(ctxt, parser, stack);
+ Type subtype = parseTestType(parser, stack);
stack.pop_back();
if (!subtype || failed(parser.parseGreater()) || failed(rec.setBody(subtype)))
return Type();
Type TestDialect::parseType(DialectAsmParser &parser) const {
SetVector<Type> stack;
- return parseTestType(getContext(), parser, stack);
+ return parseTestType(parser, stack);
}
static void printTestType(Type type, DialectAsmPrinter &printer,
// DEF: ::test::IndexAttr,
// DEF: ::test::SingleParameterAttr
-// DEF-LABEL: ::mlir::OptionalParseResult generatedAttributeParser(::mlir::MLIRContext *context,
+// DEF-LABEL: ::mlir::OptionalParseResult generatedAttributeParser(
// DEF-NEXT: ::mlir::DialectAsmParser &parser,
// DEF-NEXT: ::llvm::StringRef mnemonic, ::mlir::Type type,
// DEF-NEXT: ::mlir::Attribute &value) {
// DEF: if (mnemonic == ::test::CompoundAAttr::getMnemonic()) {
-// DEF-NEXT: value = ::test::CompoundAAttr::parse(context, parser, type);
+// DEF-NEXT: value = ::test::CompoundAAttr::parse(parser, type);
// DEF-NEXT: return ::mlir::success(!!value);
// DEF-NEXT: }
// DEF-NEXT: if (mnemonic == ::test::IndexAttr::getMnemonic()) {
-// DEF-NEXT: value = ::test::IndexAttr::parse(context, parser, type);
+// DEF-NEXT: value = ::test::IndexAttr::parse(parser, type);
// DEF-NEXT: return ::mlir::success(!!value);
// DEF: return {};
// DECL: static constexpr ::llvm::StringLiteral getMnemonic() {
// DECL: return ::llvm::StringLiteral("cmpnd_a");
// DECL: }
-// DECL: static ::mlir::Attribute parse(::mlir::MLIRContext *context,
-// DECL-NEXT: ::mlir::DialectAsmParser &parser, ::mlir::Type type);
+// DECL: static ::mlir::Attribute parse(
+// DECL-SAME: ::mlir::DialectAsmParser &parser, ::mlir::Type type);
// DECL: void print(::mlir::DialectAsmPrinter &printer) const;
// DECL: int getWidthOfSomething() const;
// DECL: ::test::SimpleTypeA getExampleTdType() const;
// DECL: static constexpr ::llvm::StringLiteral getMnemonic() {
// DECL: return ::llvm::StringLiteral("index");
// DECL: }
-// DECL: static ::mlir::Attribute parse(::mlir::MLIRContext *context,
-// DECL-NEXT: ::mlir::DialectAsmParser &parser, ::mlir::Type type);
+// DECL: static ::mlir::Attribute parse(
+// DECL-SAME: ::mlir::DialectAsmParser &parser, ::mlir::Type type);
// DECL: void print(::mlir::DialectAsmPrinter &printer) const;
}
// DEF: ::test::SingleParameterType,
// DEF: ::test::IntegerType
-// DEF-LABEL: ::mlir::OptionalParseResult generatedTypeParser(::mlir::MLIRContext *context,
+// DEF-LABEL: ::mlir::OptionalParseResult generatedTypeParser(
// DEF-NEXT: ::mlir::DialectAsmParser &parser,
// DEF-NEXT: ::llvm::StringRef mnemonic,
// DEF-NEXT: ::mlir::Type &value) {
// DEF: if (mnemonic == ::test::CompoundAType::getMnemonic()) {
-// DEF-NEXT: value = ::test::CompoundAType::parse(context, parser);
+// DEF-NEXT: value = ::test::CompoundAType::parse(parser);
// DEF-NEXT: return ::mlir::success(!!value);
// DEF-NEXT: }
// DEF-NEXT: if (mnemonic == ::test::IndexType::getMnemonic()) {
-// DEF-NEXT: value = ::test::IndexType::parse(context, parser);
+// DEF-NEXT: value = ::test::IndexType::parse(parser);
// DEF-NEXT: return ::mlir::success(!!value);
// DEF: return {};
// DECL: static constexpr ::llvm::StringLiteral getMnemonic() {
// DECL: return ::llvm::StringLiteral("cmpnd_a");
// DECL: }
-// DECL: static ::mlir::Type parse(::mlir::MLIRContext *context,
-// DECL-NEXT: ::mlir::DialectAsmParser &parser);
+// DECL: static ::mlir::Type parse(::mlir::DialectAsmParser &parser);
// DECL: void print(::mlir::DialectAsmPrinter &printer) const;
// DECL: int getWidthOfSomething() const;
// DECL: ::test::SimpleTypeA getExampleTdType() const;
// DECL: static constexpr ::llvm::StringLiteral getMnemonic() {
// DECL: return ::llvm::StringLiteral("index");
// DECL: }
-// DECL: static ::mlir::Type parse(::mlir::MLIRContext *context,
-// DECL-NEXT: ::mlir::DialectAsmParser &parser);
+// DECL: static ::mlir::Type parse(::mlir::DialectAsmParser &parser);
// DECL: void print(::mlir::DialectAsmPrinter &printer) const;
}
/// {0}: The name of the base value type, e.g. Attribute or Type.
/// {1}: Extra parser parameters.
static const char *const defDeclParsePrintStr = R"(
- static ::mlir::{0} parse(::mlir::MLIRContext *context,
- ::mlir::DialectAsmParser &parser{1});
+ static ::mlir::{0} parse(::mlir::DialectAsmParser &parser{1});
void print(::mlir::DialectAsmPrinter &printer) const;
)";
/// {0}: The name of the base value type, e.g. Attribute or Type.
/// {1}: Additional parser parameters.
static const char *const defParserDispatchStartStr = R"(
-static ::mlir::OptionalParseResult generated{0}Parser(::mlir::MLIRContext *context,
+static ::mlir::OptionalParseResult generated{0}Parser(
::mlir::DialectAsmParser &parser,
::llvm::StringRef mnemonic{1},
::mlir::{0} &value) {{
// Emit the parser code, if specified.
if (Optional<StringRef> parserCode = def.getParserCode()) {
FmtContext fmtCtxt;
- fmtCtxt.addSubst("_parser", "parser").addSubst("_ctxt", "context");
+ fmtCtxt.addSubst("_parser", "parser")
+ .addSubst("_ctxt", "parser.getContext()");
// The mnenomic must be defined so the dispatcher knows how to dispatch.
- os << llvm::formatv("::mlir::{0} {1}::parse(::mlir::MLIRContext *context, "
+ os << llvm::formatv("::mlir::{0} {1}::parse("
"::mlir::DialectAsmParser &parser",
valueType, def.getCppClassName());
if (isAttrGenerator) {
// If the def has no parameters and no parser code, just invoke a normal
// `get`.
if (def.getNumParameters() == 0 && !def.getParserCode()) {
- os << "get(context);\n return ::mlir::success(!!value);\n }\n";
+ os << "get(parser.getContext());\n";
+ os << " return ::mlir::success(!!value);\n }\n";
continue;
}
- os << "parse(context, parser" << (isAttrGenerator ? ", type" : "")
+ os << "parse(parser" << (isAttrGenerator ? ", type" : "")
<< ");\n return ::mlir::success(!!value);\n }\n";
}
}
} else if (const NamedTypeConstraint *var = resolver.getVariable()) {
if (Optional<StringRef> tform = resolver.getVarTransformer()) {
FmtContext fmtContext;
- fmtContext.addSubst("_ctxt", "parser.getBuilder().getContext()");
+ fmtContext.addSubst("_ctxt", "parser.getContext()");
if (var->isVariadic())
fmtContext.withSelf(var->name + "Types");
else
(void)ok;
assert(ok);
if (succeeded(parser.parseOptionalGreater()))
- return CustomDataLayoutSpec::get(parser.getBuilder().getContext(), {});
+ return CustomDataLayoutSpec::get(parser.getContext(), {});
SmallVector<DataLayoutEntryInterface> entries;
do {
} while (succeeded(parser.parseOptionalComma()));
ok = succeeded(parser.parseGreater());
assert(ok);
- return CustomDataLayoutSpec::get(parser.getBuilder().getContext(), entries);
+ return CustomDataLayoutSpec::get(parser.getContext(), entries);
}
void printType(Type type, DialectAsmPrinter &printer) const override {
bool ok = succeeded(parser.parseKeyword("single_query"));
(void)ok;
assert(ok);
- return SingleQueryType::get(parser.getBuilder().getContext());
+ return SingleQueryType::get(parser.getContext());
}
};
projects / platform / upstream / llvm.git / commitdiff