[ODS/AsmParser] Don't pass MLIRContext with DialectAsmParser.

[lattner]

Summary

The former is redundant because the later carries it as part of
its builder. Add a getContext() helper method to DialectAsmParser
to make this more convenient, and stop passing the context around
explicitly. This simplifies ODS generated parser hooks for attrs
and types.

This resolves PR51985

[rriddle]

mlir/include/mlir/IR/OpImplementation.h

20–21

Can we remove this?

572–587

Can we add a get version of these and use it in the places we are generally using getContext in this patch? Kind of like what we have on Builder (https://github.com/llvm/llvm-project/blob/27451a05ed4d13294182ec7e999a9d4f90bc0d12/mlir/include/mlir/IR/Builders.h#L85)

[lattner]

Remove commented out #include I inadvertantly left in.

[lattner]

mlir/include/mlir/IR/OpImplementation.h

20–21

Yeah of course, good catch thanks.

572–587

Perhaps, but you're merely talking to the boilerplate garbage man, not to the design guy here. Why does AsmParser have these methods in the first place?

How would such a think work with get methods that don't take a context parameter? In any case, such a thing would be a different patch. Can you file a bugzilla and cc me on it if you think this is a good thing, I can investigate.

[lattner]

In fact, I wasn't aware of, and I've never seen code that uses that builder.getType<Thing>(... method. Most of the cases touched in this patch would be better off using parser.getBuilder().getIntType(..) or whatever, rather than passing context's around. I don't know that the getType<> thing is a very general pattern.

[rriddle]

mlir/include/mlir/IR/OpImplementation.h

572–587

The getChecked ones are there to better facilitate verifying attributes/types during parsing (the verification errors get emitted via the parser, which is the lambda being passed in).

How would such a think work with get methods that don't take a context parameter?

It wouldn't be used for such get methods. The only intention of it would be (much like what Builder::getType is/was intended for) to remove the need to explicitly pass in the context for the get methods that do (the ones that don't should keep using the MyType::get methods like normal.

[mehdi_amini]

sorry I had to revert, this broke the bot: https://lab.llvm.org/buildbot/#/builders/61/builds/15454

Likely due to -DDBUILD_SHARED_LIBS=ON being stricter on dependencies (I haven't look with more details yet)

[lattner]

It looks like we just crossed each other, I committed a change, which will pretty surely be broken now. Could you help get both applied again? I'm not sure how to do the git-fu.

[mehdi_amini]

OK, I just cherry-picked your original commit on top of main and pushed it again as-is: git cherry-pick 4b32f8bac40dcd1535bfe95757c3de0911bf6d1a

[lattner]

Thank you! You need to delete the implementation of AsmParser::getContext() in Parser.cpp. I'll take care of it.

[lattner]

d104db531ee6

[mehdi_amini]

We're back green :)
https://lab.llvm.org/buildbot/#/builders/61/builds/15456

[lattner]

Thank you Mehdi!

flang/lib/Optimizer/Dialect/FIRType.cpp

 
 namespace {
 
 template <typename TYPE>
 TYPE parseIntSingleton(mlir::DialectAsmParser &parser) {
   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>
 TYPE parseKindSingleton(mlir::DialectAsmParser &parser) {
   return parseIntSingleton<TYPE>(parser);
 }
 
 template <typename TYPE>

 // Implementation of the thin interface from dialect to type parser
 
 mlir::Type fir::parseFirType(FIROpsDialect *dialect,
                              mlir::DialectAsmParser &parser) {
   mlir::StringRef typeTag;
   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;
   return {};
 }
 
 namespace fir {
 namespace detail {
bool fir::isa_unknown_size_box(mlir::Type t) {
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // BoxProcType
 //===----------------------------------------------------------------------===//
 
 // `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 {
   printer << getMnemonic() << "<" << getEleTy() << '>';
 }
 
 mlir::LogicalResult
 BoxProcType::verify(llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
return eleTy.isa<BoxType, BoxCharType, BoxProcType, ShapeType, ShapeShiftType,
                    ReferenceType, TypeDescType>();
 }
 
 //===----------------------------------------------------------------------===//
 // BoxType
 //===----------------------------------------------------------------------===//
 
 // `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 {};
 
   mlir::AffineMapAttr map;
   if (!parser.parseOptionalComma()) {
     if (parser.parseAttribute(map)) {
       parser.emitError(parser.getCurrentLocation(), "expected affine map");
fir::BoxType::verify(llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
   // TODO
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // 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);
 }
 
 void fir::BoxCharType::print(mlir::DialectAsmPrinter &printer) const {
   printer << getMnemonic() << "<" << getKind() << ">";
 }
 
 CharacterType
 fir::BoxCharType::getElementType(mlir::MLIRContext *context) const {
   return CharacterType::getUnknownLen(context, getKind());
 }
 
 CharacterType fir::BoxCharType::getEleTy() const {
   return getElementType(getContext());
 }
 
 //===----------------------------------------------------------------------===//
 // CharacterType
 //===----------------------------------------------------------------------===//
 
 // `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 {};
   CharacterType::LenType len = 1;
   if (mlir::succeeded(parser.parseOptionalComma())) {
     if (mlir::succeeded(parser.parseOptionalQuestion())) {
       len = fir::CharacterType::unknownLen();
     } else if (!mlir::succeeded(parser.parseInteger(len))) {
       return {};
     }
   }
   if (parser.parseGreater())
     return {};
-  return get(context, kind, len);
+  return get(parser.getContext(), kind, len);
 }
 
 void fir::CharacterType::print(mlir::DialectAsmPrinter &printer) const {
   printer << getMnemonic() << "<" << getFKind();
   auto len = getLen();
   if (len != fir::CharacterType::singleton()) {
     printer << ',';
     if (len == fir::CharacterType::unknownLen())
       printer << '?';
     else
       printer << len;
   }
   printer << '>';
 }
 
 //===----------------------------------------------------------------------===//
 // 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);
 }
 
 void fir::ComplexType::print(mlir::DialectAsmPrinter &printer) const {
   printer << getMnemonic() << "<" << getFKind() << '>';
 }
 
 mlir::Type fir::ComplexType::getElementType() const {
   return fir::RealType::get(getContext(), getFKind());
 }
 
 //===----------------------------------------------------------------------===//
 // HeapType
 //===----------------------------------------------------------------------===//
 
 // `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);
 }
 
 void fir::HeapType::print(mlir::DialectAsmPrinter &printer) const {
   printer << getMnemonic() << "<" << getEleTy() << '>';
 }
 
 mlir::LogicalResult
 fir::HeapType::verify(llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
                       mlir::Type eleTy) {
   if (cannotBePointerOrHeapElementType(eleTy))
     return emitError() << "cannot build a heap pointer to type: " << eleTy
                        << '\n';
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // IntegerType
 //===----------------------------------------------------------------------===//
 
 // `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);
 }
 
 void fir::IntegerType::print(mlir::DialectAsmPrinter &printer) const {
   printer << getMnemonic() << "<" << getFKind() << '>';
 }
 
 //===----------------------------------------------------------------------===//
 // LogicalType
 //===----------------------------------------------------------------------===//
 
 // `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);
 }
 
 void fir::LogicalType::print(mlir::DialectAsmPrinter &printer) const {
   printer << getMnemonic() << "<" << getFKind() << '>';
 }
 
 //===----------------------------------------------------------------------===//
 // PointerType
 //===----------------------------------------------------------------------===//
 
 // `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);
 }
 
 void fir::PointerType::print(mlir::DialectAsmPrinter &printer) const {
   printer << getMnemonic() << "<" << getEleTy() << '>';
 }
 
 mlir::LogicalResult fir::PointerType::verify(
     llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
     mlir::Type eleTy) {
   if (cannotBePointerOrHeapElementType(eleTy))
     return emitError() << "cannot build a pointer to type: " << eleTy << '\n';
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // RealType
 //===----------------------------------------------------------------------===//
 
 // `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);
 }
 
 void fir::RealType::print(mlir::DialectAsmPrinter &printer) const {
   printer << getMnemonic() << "<" << getFKind() << '>';
 }
 
 mlir::LogicalResult
 fir::RealType::verify(llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
                       KindTy fKind) {
   // TODO
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // RecordType
 //===----------------------------------------------------------------------===//
 
 // Fortran derived type
 // `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()) {
     while (true) {
       llvm::StringRef lenparam;
       mlir::Type intTy;
       if (parser.parseKeyword(&lenparam) || parser.parseColon() ||
           parser.parseType(intTy)) {
unsigned fir::RecordType::getFieldIndex(llvm::StringRef ident) {
   return std::numeric_limits<unsigned>::max();
 }
 
 //===----------------------------------------------------------------------===//
 // ReferenceType
 //===----------------------------------------------------------------------===//
 
 // `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);
 }
 
 void fir::ReferenceType::print(mlir::DialectAsmPrinter &printer) const {
   printer << getMnemonic() << "<" << getEleTy() << '>';
 }
 
 mlir::LogicalResult fir::ReferenceType::verify(
     llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
     mlir::Type eleTy) {
   if (eleTy.isa<ShapeType, ShapeShiftType, SliceType, FieldType, LenType,
                 ReferenceType, TypeDescType>())
     return emitError() << "cannot build a reference to type: " << eleTy << '\n';
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // SequenceType
 //===----------------------------------------------------------------------===//
 
 // `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;
   if (parser.parseOptionalStar()) {
     if (parser.parseDimensionList(shape, /*allowDynamic=*/true))
       return {};
   } else if (parser.parseColon()) {
     return {};
   }
   mlir::Type eleTy;
   if (parser.parseType(eleTy) || parser.parseGreater())
     return {};
   mlir::AffineMapAttr map;
   if (!parser.parseOptionalComma())
     if (parser.parseAttribute(map)) {
       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 {
   printer << getMnemonic();
   auto shape = getShape();
   if (shape.size()) {
     printer << '<';
     for (const auto &b : shape) {
return emitError() << "cannot build an array of this element type: "
                        << eleTy << '\n';
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // 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);
 }
 
 void fir::ShapeType::print(mlir::DialectAsmPrinter &printer) const {
   printer << getMnemonic() << "<" << getImpl()->rank << ">";
 }
 
 //===----------------------------------------------------------------------===//
 // 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);
 }
 
 void fir::ShapeShiftType::print(mlir::DialectAsmPrinter &printer) const {
   printer << getMnemonic() << "<" << getRank() << ">";
 }
 
 //===----------------------------------------------------------------------===//
 // 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);
 }
 
 void fir::ShiftType::print(mlir::DialectAsmPrinter &printer) const {
   printer << getMnemonic() << "<" << getRank() << ">";
 }
 
 //===----------------------------------------------------------------------===//
 // SliceType
 //===----------------------------------------------------------------------===//
 
 // `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);
 }
 
 void fir::SliceType::print(mlir::DialectAsmPrinter &printer) const {
   printer << getMnemonic() << "<" << getRank() << '>';
 }
 
 //===----------------------------------------------------------------------===//
 // TypeDescType
 //===----------------------------------------------------------------------===//
 
 // `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);
 }
 
 void fir::TypeDescType::print(mlir::DialectAsmPrinter &printer) const {
   printer << getMnemonic() << "<" << getOfTy() << '>';
 }
 
 mlir::LogicalResult fir::TypeDescType::verify(
     llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
     mlir::Type eleTy) {
   if (eleTy.isa<BoxType, BoxCharType, BoxProcType, ShapeType, ShapeShiftType,
                 ShiftType, SliceType, FieldType, LenType, ReferenceType,
                 TypeDescType>())
     return emitError() << "cannot build a type descriptor of type: " << eleTy
                        << '\n';
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // VectorType
 //===----------------------------------------------------------------------===//
 
 // `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() ||
       parser.parseType(eleTy) || parser.parseGreater())
     return {};
   return fir::VectorType::get(len, eleTy);
 }
 

mlir/include/mlir/IR/OpImplementation.h

 
 #ifndef MLIR_IR_OPIMPLEMENTATION_H
 #define MLIR_IR_OPIMPLEMENTATION_H
 
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/DialectInterface.h"
 #include "mlir/IR/OpDefinition.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/SMLoc.h"
-#include "llvm/Support/raw_ostream.h"
 
 namespace mlir {
 
 class Builder;
 
 //===----------------------------------------------------------------------===//
 // AsmPrinter
 //===----------------------------------------------------------------------===//
 

 
 /// This base class exposes generic asm parser hooks, usable across the various
 /// derived parsers.
 class AsmParser {
 public:
   AsmParser() = default;
   virtual ~AsmParser();
 
+  MLIRContext *getContext() const;
+
   /// Return the location of the original name token.
   virtual llvm::SMLoc getNameLoc() const = 0;
 
   //===--------------------------------------------------------------------===//
   // Utilities
   //===--------------------------------------------------------------------===//
 
   /// Emit a diagnostic at the specified location and return failure.
public:
   parseCommaSeparatedList(function_ref<ParseResult()> parseElementFn) {
     return parseCommaSeparatedList(Delimiter::None, parseElementFn);
   }
 
   //===--------------------------------------------------------------------===//
   // Attribute/Type Parsing
   //===--------------------------------------------------------------------===//
 
   /// Invoke the `getChecked` method of the given Attribute or Type class, using
   /// the provided location to emit errors in the case of failure. Note that
   /// unlike `OpBuilder::getType`, this method does not implicitly insert a
   /// context parameter.
   template <typename T, typename... ParamsT>
   T getChecked(llvm::SMLoc loc, ParamsT &&... params) {
     return T::getChecked([&] { return emitError(loc); },
                          std::forward<ParamsT>(params)...);
   }
   /// A variant of `getChecked` that uses the result of `getNameLoc` to emit
   /// errors.
   template <typename T, typename... ParamsT>
   T getChecked(ParamsT &&... params) {
     return T::getChecked([&] { return emitError(getNameLoc()); },
                          std::forward<ParamsT>(params)...);
   }
 
   //===--------------------------------------------------------------------===//
   // Attribute Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse an arbitrary attribute of a given type and return it in result.
   virtual ParseResult parseAttribute(Attribute &result, Type type = {}) = 0;
 

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

for (const auto &list : operands) {
     parser.resolveOperands(list, indexType, valueOperands);
     for (Value operand : valueOperands) {
       unsigned pos = std::distance(uniqueOperands.begin(),
                                    llvm::find(uniqueOperands, operand));
       if (pos == uniqueOperands.size())
         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()));
     }
   }
 }
 
 namespace {
 enum class MinMaxKind { Min, Max };
 } // namespace
 
static ParseResult parseAffineMapWithMinMax(OpAsmParser &parser,
   deduplicateAndResolveOperands(parser, flatSymOperands, symOperands,
                                 symRepacements, AffineExprKind::SymbolId);
 
   result.operands.append(dimOperands.begin(), dimOperands.end());
   result.operands.append(symOperands.begin(), symOperands.end());
 
   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());
 
   result.addAttribute(mapName, AffineMapAttr::get(flatMap));
   result.addAttribute(groupsName, builder.getI32TensorAttr(numMapsPerGroup));
   return success();
 }
 

mlir/lib/Dialect/ArmSVE/IR/ArmSVEDialect.cpp

 //===----------------------------------------------------------------------===//
 // ScalableVectorType
 //===----------------------------------------------------------------------===//
 
 Type ArmSVEDialect::parseType(DialectAsmParser &parser) const {
   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;
   }
   parser.emitError(typeLoc, "unknown type in ArmSVE dialect");
   return Type();
 }
 
 void ArmSVEDialect::printType(Type type, DialectAsmPrinter &os) const {

mlir/lib/Dialect/Async/IR/Async.cpp

 
 void ValueType::print(DialectAsmPrinter &printer) const {
   printer << getMnemonic();
   printer << "<";
   printer.printType(getValueType());
   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");
     return Type();
   }
   return ValueType::get(ty);
 }
 
 /// Print a type registered to this dialect.
 void AsyncDialect::printType(Type type, DialectAsmPrinter &os) const {
   if (failed(generatedTypePrinter(type, os)))
     llvm_unreachable("unexpected 'async' type kind");
 }
 
 /// Parse a type registered to this dialect.
 Type AsyncDialect::parseType(DialectAsmParser &parser) const {
   StringRef typeTag;
   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;
   return {};
 }

mlir/lib/Dialect/DLTI/DLTI.cpp

 ///   attr-list ::= attr
 ///               | attr `,` attr-list
 DataLayoutSpecAttr DataLayoutSpecAttr::parse(DialectAsmParser &parser) {
   if (failed(parser.parseLess()))
     return {};
 
   // Empty spec.
   if (succeeded(parser.parseOptionalGreater()))
-    return get(parser.getBuilder().getContext(), {});
+    return get(parser.getContext(), {});
 
   SmallVector<DataLayoutEntryInterface> entries;
   do {
     entries.emplace_back();
     if (failed(parser.parseAttribute(entries.back())))
       return {};
   } while (succeeded(parser.parseOptionalComma()));
 
   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 {
   os << DataLayoutSpecAttr::kAttrKeyword << "<";
   llvm::interleaveComma(getEntries(), os);
   os << ">";
 }
 

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

if (!includeParseResult.hasValue())
     return parser.emitError(parser.getNameLoc()) << "expected string attribute";
 
   if (standardInclude && parser.parseOptionalGreater())
     return parser.emitError(parser.getNameLoc())
            << "expected trailing '>' for standard include";
 
   if (standardInclude)
     result.addAttribute("is_standard_include",
-                        UnitAttr::get(parser.getBuilder().getContext()));
+                        UnitAttr::get(parser.getContext()));
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // TableGen'd op method definitions
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/EmitC/IR/EmitC.cpp.inc"
 
 //===----------------------------------------------------------------------===//
 // EmitC Attributes
 //===----------------------------------------------------------------------===//
 
 #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;
   llvm::SMLoc loc = parser.getCurrentLocation();
   if (parser.parseOptionalString(&value)) {
     parser.emitError(loc) << "expected string";
     return Attribute();
   }
   if (parser.parseGreater())
     return Attribute();
-  return get(context, value);
+  return get(parser.getContext(), value);
 }
 
 Attribute EmitCDialect::parseAttribute(DialectAsmParser &parser,
                                        Type type) const {
   llvm::SMLoc typeLoc = parser.getCurrentLocation();
   StringRef mnemonic;
   if (parser.parseKeyword(&mnemonic))
     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");
   return Attribute();
 }
 
 void EmitCDialect::printAttribute(Attribute attr, DialectAsmPrinter &os) const {
   if (failed(generatedAttributePrinter(attr, os)))
     llvm_unreachable("unexpected 'EmitC' attribute kind");
 }
 
 void emitc::OpaqueAttr::print(DialectAsmPrinter &printer) const {
   printer << "opaque<\"";
   llvm::printEscapedString(getValue(), printer.getStream());
   printer << "\">";
 }
 
 //===----------------------------------------------------------------------===//
 // EmitC Types
 //===----------------------------------------------------------------------===//
 
 #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;
   llvm::SMLoc loc = parser.getCurrentLocation();
   if (parser.parseOptionalString(&value) || value.empty()) {
     parser.emitError(loc) << "expected non empty string";
     return Type();
   }
   if (parser.parseGreater())
     return Type();
-  return get(context, value);
+  return get(parser.getContext(), value);
 }
 
 Type EmitCDialect::parseType(DialectAsmParser &parser) const {
   llvm::SMLoc typeLoc = parser.getCurrentLocation();
   StringRef mnemonic;
   if (parser.parseKeyword(&mnemonic))
     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");
   return Type();
 }
 
 void EmitCDialect::printType(Type type, DialectAsmPrinter &os) const {
   if (failed(generatedTypePrinter(type, os)))
     llvm_unreachable("unexpected 'EmitC' type kind");
 }
 
 void emitc::OpaqueType::print(DialectAsmPrinter &printer) const {
   printer << "opaque<\"";
   llvm::printEscapedString(getValue(), printer.getStream());
   printer << "\">";
 }

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

 
 // operation ::= `llvm.mlir.global` linkage? `constant`? `@` identifier
 //               `(` attribute? `)` align? attribute-list? (`:` type)? region?
 // align     ::= `align` `=` UINT64
 //
 // 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(
                           ctx, parseOptionalLLVMKeyword<Linkage>(
                                    parser, result, LLVM::Linkage::External)));
   // Parse optional UnnamedAddr, default to None.
   result.addAttribute(getUnnamedAddrAttrName(),
                       parser.getBuilder().getI64IntegerAttr(
if (parser.parseOptionalAttrDict(result.attributes) ||
     return failure();
 
   if (types.size() > 1)
     return parser.emitError(parser.getNameLoc(), "expected zero or one type");
 
   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);
     } else {
       return parser.emitError(parser.getNameLoc(),
                               "type can only be omitted for string globals");
     }
   } else {

 // operation ::= `llvm.func` linkage? function-signature function-attributes?
 //               function-body
 //
 static ParseResult parseLLVMFuncOp(OpAsmParser &parser,
                                    OperationState &result) {
   // 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)));
 
   StringAttr nameAttr;
   SmallVector<OpAsmParser::OperandType, 8> entryArgs;
   SmallVector<NamedAttrList, 1> argAttrs;
   SmallVector<NamedAttrList, 1> resultAttrs;
   SmallVector<Type, 8> argTypes;
void FMFAttr::print(DialectAsmPrinter &printer) const {
   auto flags = llvm::make_filter_range(FastmathFlagsList, [&](auto flag) {
     return bitEnumContains(this->getFlags(), flag);
   });
   llvm::interleaveComma(flags, printer,
                         [&](auto flag) { printer << stringifyEnum(flag); });
   printer << ">";
 }
 
-Attribute FMFAttr::parse(MLIRContext *context, DialectAsmParser &parser,
-                         Type type) {
+Attribute FMFAttr::parse(DialectAsmParser &parser, Type type) {
   if (failed(parser.parseLess()))
     return {};
 
   FastmathFlags flags = {};
   if (failed(parser.parseOptionalGreater())) {
     do {
       StringRef elemName;
       if (failed(parser.parseKeyword(&elemName)))
         return {};
 
       auto elem = symbolizeFastmathFlags(elemName);
       if (!elem) {
         parser.emitError(parser.getNameLoc(), "Unknown fastmath flag: ")
             << elemName;
         return {};
       }
 
       flags = flags | *elem;
     } while (succeeded(parser.parseOptionalComma()));
 
     if (failed(parser.parseGreater()))
       return {};
   }
 
-  return FMFAttr::get(parser.getBuilder().getContext(), flags);
+  return FMFAttr::get(parser.getContext(), flags);
 }
 
 void LinkageAttr::print(DialectAsmPrinter &printer) const {
   printer << "linkage<";
   if (static_cast<uint64_t>(getLinkage()) <= getMaxEnumValForLinkage())
     printer << stringifyEnum(getLinkage());
   else
     printer << static_cast<uint64_t>(getLinkage());
   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 {};
   auto elem = linkage::symbolizeLinkage(elemName);
   if (!elem) {
     parser.emitError(parser.getNameLoc(), "Unknown linkage: ") << elemName;
     return {};
   }
   Linkage linkage = *elem;
-  return LinkageAttr::get(context, linkage);
+  return LinkageAttr::get(parser.getContext(), linkage);
 }
 
 LoopOptionsAttrBuilder::LoopOptionsAttrBuilder(LoopOptionsAttr attr)
     : options(attr.getOptions().begin(), attr.getOptions().end()) {}
 
 template <typename T>
 LoopOptionsAttrBuilder &LoopOptionsAttrBuilder::setOption(LoopOptionCase tag,
                                                           Optional<T> value) {
llvm::interleaveComma(getOptions(), printer, [&](auto option) {
     case LoopOptionCase::pipeline_initiation_interval:
       printer << option.second;
       break;
     }
   });
   printer << ">";
 }
 
-Attribute LoopOptionsAttr::parse(MLIRContext *context, DialectAsmParser &parser,
-                                 Type type) {
+Attribute LoopOptionsAttr::parse(DialectAsmParser &parser, Type type) {
   if (failed(parser.parseLess()))
     return {};
 
   SmallVector<std::pair<LoopOptionCase, int64_t>> options;
   llvm::SmallDenseSet<LoopOptionCase> seenOptions;
   do {
     StringRef optionName;
     if (parser.parseKeyword(&optionName))
case LoopOptionCase::pipeline_initiation_interval:
       break;
     }
     options.push_back(std::make_pair(*option, value));
   } while (succeeded(parser.parseOptionalComma()));
   if (failed(parser.parseGreater()))
     return {};
 
   llvm::sort(options, llvm::less_first());
-  return get(parser.getBuilder().getContext(), options);
+  return get(parser.getContext(), options);
 }
 
 Attribute LLVMDialect::parseAttribute(DialectAsmParser &parser,
                                       Type type) const {
   if (type) {
     parser.emitError(parser.getNameLoc(), "unexpected type");
     return {};
   }
   StringRef attrKind;
   if (parser.parseKeyword(&attrKind))
     return {};
   {
     Attribute attr;
-    auto parseResult =
-        generatedAttributeParser(getContext(), parser, attrKind, type, attr);
+    auto parseResult = generatedAttributeParser(parser, attrKind, type, attr);
     if (parseResult.hasValue())
       return attr;
   }
   parser.emitError(parser.getNameLoc(), "unknown attribute type: ") << attrKind;
   return {};
 }
 
 void LLVMDialect::printAttribute(Attribute attr, DialectAsmPrinter &os) const {
   if (succeeded(generatedAttributePrinter(attr, os)))
     return;
   llvm_unreachable("Unknown attribute type");
 }

mlir/lib/Dialect/LLVMIR/IR/LLVMTypeSyntax.cpp

if (result.hasValue()) {
     return type;
   }
 
   // If no type found, fallback to the shorthand form.
   StringRef key;
   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); })
       .Case("x86_mmx", [&] { return LLVMX86MMXType::get(ctx); })
       .Case("token", [&] { return LLVMTokenType::get(ctx); })
       .Case("label", [&] { return LLVMLabelType::get(ctx); })
       .Case("metadata", [&] { return LLVMMetadataType::get(ctx); })
       .Case("func", [&] { return parseFunctionType(parser); })

mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp

for (auto &attr : result.attributes) {
     if (attr.first != "return_value_and_is_valid")
       continue;
     auto structType = resultType.dyn_cast<LLVM::LLVMStructType>();
     if (structType && !structType.getBody().empty())
       resultType = structType.getBody()[0];
     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);
 
   SmallVector<OpAsmParser::OperandType, 8> ops;
   Type type;
   return failure(parser.parseOperandList(ops) ||
                  parser.parseOptionalAttrDict(result.attributes) ||
                  parser.parseColonType(type) ||

mlir/lib/Dialect/LLVMIR/IR/ROCDLDialect.cpp

 static ParseResult parseROCDLMubufLoadOp(OpAsmParser &parser,
                                          OperationState &result) {
   SmallVector<OpAsmParser::OperandType, 8> ops;
   Type type;
   if (parser.parseOperandList(ops, 5) || parser.parseColonType(type) ||
       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);
   return parser.resolveOperands(ops,
                                 {i32x4Ty, int32Ty, int32Ty, int1Ty, int1Ty},
                                 parser.getNameLoc(), result.operands);
 }
 
 // <operation> ::=
 //     `llvm.amdgcn.buffer.store.* %vdata, %rsrc, %vindex, %offset, %glc, %slc :
 //     result_type`
 static ParseResult parseROCDLMubufStoreOp(OpAsmParser &parser,
                                           OperationState &result) {
   SmallVector<OpAsmParser::OperandType, 8> ops;
   Type type;
   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);
 
   if (parser.resolveOperands(ops,
                              {type, i32x4Ty, int32Ty, int32Ty, int1Ty, int1Ty},
                              parser.getNameLoc(), result.operands))
     return failure();

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

void CopyOp::build(OpBuilder &builder, OperationState &result, Value input,
   result.addRegion();
   fillStructuredOpRegion<CopyOp>(builder, *result.regions.front(),
                                  TypeRange{input.getType()},
                                  TypeRange{output.getType()});
 }
 
 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();
 }
 
 /// CopyOp region is elided when printing.
 void printCopyOpRegion(OpAsmPrinter &, Operation *, Region &, Type, Type) {}
 
build(builder, result, output.getType().dyn_cast<RankedTensorType>(), value,
         output);
   fillStructuredOpRegion<FillOp>(builder, *result.regions.front(),
                                  TypeRange{value.getType()},
                                  TypeRange{output.getType()}, {});
 }
 
 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();
 }
 
 /// FillOp region is elided when printing.
 void printFillOpRegion(OpAsmPrinter &, Operation *, Region &, Type, Type) {}
 

 // Specific parsing and printing for named structured ops created by ods-gen.
 //===----------------------------------------------------------------------===//
 
 template <typename NamedStructuredOpType>
 static ParseResult
 parseNamedStructuredOpRegion(OpAsmParser &parser, Region &region,
                              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;
   fillStructuredOpRegion<NamedStructuredOpType>(
       opBuilder, region, inputTypes, outputTypes,
       [&](unsigned expected, unsigned actual) {
         res = parser.emitError(
             parser.getCurrentLocation(),

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

if (!memrefType || !memrefType.hasStaticShape())
     return parser.emitError(parser.getNameLoc())
            << "type should be static shaped memref, but got " << type;
   typeAttr = TypeAttr::get(type);
 
   if (parser.parseOptionalEqual())
     return success();
 
   if (succeeded(parser.parseOptionalKeyword("uninitialized"))) {
-    initialValue = UnitAttr::get(parser.getBuilder().getContext());
+    initialValue = UnitAttr::get(parser.getContext());
     return success();
   }
 
   Type tensorType = getTensorTypeFromMemRefType(memrefType);
   if (parser.parseAttribute(initialValue, tensorType))
     return failure();
   if (!initialValue.isa<ElementsAttr>())
     return parser.emitError(parser.getNameLoc())

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

while (succeeded(parser.parseOptionalKeyword(&keyword))) {
     } else if (keyword == "collapse") {
       auto type = parser.getBuilder().getI64Type();
       mlir::IntegerAttr attr;
       if (parser.parseLParen() || parser.parseAttribute(attr, type) ||
           parser.parseRParen())
         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;
       if (succeeded(parser.parseOptionalLParen())) {
         auto type = parser.getBuilder().getI64Type();
         if (parser.parseAttribute(attr, type))
           return failure();
         if (parser.parseRParen())
           return failure();
       } else {
         // Use 0 to represent no ordered parameter was specified
         attr = parser.getBuilder().getI64IntegerAttr(0);
       }
       result.addAttribute("ordered_val", attr);
     } else if (keyword == "order") {
       StringRef order;
       if (parser.parseLParen() || parser.parseKeyword(&order) ||
           parser.parseRParen())
         return failure();
       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 allowedOnce(parser, "reduction", opName);
       if (failed(parseReductionVarList(parser, reductionSymbols, reductionVars,
                                        reductionVarTypes)))
         return failure();
       segments[reductionVarPos] = reductionVars.size();

mlir/lib/Dialect/PDL/IR/PDLTypes.cpp

 }
 
 static Type parsePDLType(DialectAsmParser &parser) {
   StringRef typeTag;
   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;
   }
 
   // FIXME: This ends up with a double error being emitted if `RangeType` also
   // emits an error. We should rework the `generatedTypeParser` to better
   // support when the keyword is valid but the individual type parser itself
   // emits an error.

 bool PDLType::classof(Type type) {
   return llvm::isa<PDLDialect>(type.getDialect());
 }
 
 //===----------------------------------------------------------------------===//
 // RangeType
 //===----------------------------------------------------------------------===//
 
-Type RangeType::parse(MLIRContext *context, DialectAsmParser &parser) {
+Type RangeType::parse(DialectAsmParser &parser) {
   if (parser.parseLess())
     return Type();
 
   llvm::SMLoc elementLoc = parser.getCurrentLocation();
   Type elementType = parsePDLType(parser);
   if (!elementType || parser.parseGreater())
     return Type();
 

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

static ParseResult parseImageOperands(OpAsmParser &parser,
   // Expect image operands
   if (parser.parseOptionalLSquare())
     return success();
 
   spirv::ImageOperands imageOperands;
   if (parseEnumStrAttr(imageOperands, parser))
     return failure();
 
-  attr = spirv::ImageOperandsAttr::get(parser.getBuilder().getContext(),
-                                       imageOperands);
+  attr = spirv::ImageOperandsAttr::get(parser.getContext(), imageOperands);
 
   return parser.parseRSquare();
 }
 
 static void printImageOperands(OpAsmPrinter &printer, Operation *imageOp,
                                spirv::ImageOperandsAttr attr) {
   if (attr) {
     auto strImageOperands = stringifyImageOperands(attr.getValue());
static ParseResult parseSpecConstantOperationOp(OpAsmParser &parser,
 
   body->push_back(new Block);
   Block &block = body->back();
   Operation *wrappedOp = parser.parseGenericOperation(&block, block.begin());
 
   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();
 
   state.addTypes(wrappedOp->getResult(0).getType());
 
   if (parser.parseOptionalAttrDict(state.attributes))
     return failure();

mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp

static bool acceptBitWidth(unsigned bitWidth) {
   case 32:
   case 64:
     return true;
   default:
     return false;
   }
 }
 
-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.
   DictionaryAttr dict;
   if (failed(parser.parseAttribute(dict)))
     return {};
   if (failed(parser.parseGreater()))
     return {};
if (attr.first == "dimLevelType") {
       ind = intAttr.getInt();
     } else {
       parser.emitError(parser.getNameLoc(), "unexpected key: ")
           << attr.first.str();
       return {};
     }
   }
   // 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 {
   // Print the struct-like storage in dictionary fashion.
   printer << "encoding<{ dimLevelType = [ ";
   for (unsigned i = 0, e = getDimLevelType().size(); i < e; i++) {
     switch (getDimLevelType()[i]) {
     case DimLevelType::Dense:

 #include "mlir/Dialect/SparseTensor/IR/SparseTensorOps.cpp.inc"
 
 Attribute SparseTensorDialect::parseAttribute(DialectAsmParser &parser,
                                               Type type) const {
   StringRef attrTag;
   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");
   return Attribute();
 }
 
 void SparseTensorDialect::printAttribute(Attribute attr,
                                          DialectAsmPrinter &printer) const {
   if (succeeded(generatedAttributePrinter(attr, printer)))
     return;
 }

mlir/lib/Dialect/Vector/VectorOps.cpp

if (!kind) {
     parser.emitError(parser.getNameLoc(), "Unknown combining kind: ")
         << elemName;
     return {};
   }
 
   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,
                                         Type type) const {
   StringRef attrKind;
   if (parser.parseKeyword(&attrKind))
     return {};
 

mlir/lib/Parser/Parser.cpp

Operation *OperationParser::parseGenericOperation(Block *insertBlock,
   // If we are populating the parser asm state, finalize this operation
   // definition.
   if (state.asmState)
     state.asmState->finalizeOperationDefinition(op, nameToken.getLocRange(),
                                                 /*endLoc=*/getToken().getLoc());
   return op;
 }
 
+MLIRContext *AsmParser::getContext() const { return getBuilder().getContext(); }
+
 namespace {
 class CustomOpAsmParser : public AsmParserImpl<OpAsmParser> {
 public:
   CustomOpAsmParser(
       SMLoc nameLoc, ArrayRef<OperationParser::ResultRecord> resultIDs,
       function_ref<ParseResult(OpAsmParser &, OperationState &)> parseAssembly,
       bool isIsolatedFromAbove, StringRef opName, OperationParser &parser)
       : AsmParserImpl<OpAsmParser>(nameLoc, parser), resultIDs(resultIDs),

mlir/test/lib/Dialect/Test/TestAttributes.cpp

 
 using namespace mlir;
 using namespace test;
 
 //===----------------------------------------------------------------------===//
 // 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 {
   printer << "attr_with_self_type_param " << getType();
 }
 
 //===----------------------------------------------------------------------===//
 // 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 {
   printer << "attr_with_type_builder " << getAttr();
 }
 
 //===----------------------------------------------------------------------===//
 // 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.parseLess() || parser.parseInteger(widthOfSomething) ||
       parser.parseComma() || parser.parseType(oneType) || parser.parseComma() ||
       parser.parseLSquare())
     return Attribute();
 
   int intVal;
   while (!*parser.parseOptionalInteger(intVal)) {
     arrayOfInts.push_back(intVal);
     if (parser.parseOptionalComma())
       break;
   }
 
   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 {
   printer << "cmpnd_a<" << getWidthOfSomething() << ", " << getOneType()
           << ", [";
   llvm::interleaveComma(getArrayOfInts(), printer);
   printer << "]>";
 }
 
 //===----------------------------------------------------------------------===//
 // 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();
   uint64_t intVal;
   while (succeeded(*parser.parseOptionalInteger(intVal))) {
     elements.push_back(intVal);
     if (parser.parseOptionalComma())
       break;
   }
 
   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 {
   printer << "i64_elements<[";
   llvm::interleaveComma(getElements(), printer);
   printer << "] : " << getType() << ">";
 }
 

 
 Attribute TestDialect::parseAttribute(DialectAsmParser &parser,
                                       Type type) const {
   StringRef attrTag;
   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 test attribute");
   return Attribute();
 }
 
 void TestDialect::printAttribute(Attribute attr,
                                  DialectAsmPrinter &printer) const {
   if (succeeded(generatedAttributePrinter(attr, printer)))
     return;
 }

mlir/test/lib/Dialect/Test/TestDialect.cpp

static ParseResult parseWrappingRegionOp(OpAsmParser &parser,
   Block &block = body.back();
   Operation *wrapped_op = parser.parseGenericOperation(&block, block.begin());
   if (!wrapped_op)
     return failure();
 
   // 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);
 
   // Get the results type for the wrapping op from the terminator operands.
   Operation &return_op = body.back().back();
   result.types.append(return_op.operand_type_begin(),
                       return_op.operand_type_end());
 

mlir/test/lib/Dialect/Test/TestTypes.cpp

 static llvm::hash_code test::hash_value(const FieldInfo &fi) { // NOLINT
   return llvm::hash_combine(fi.name, fi.type);
 }
 
 //===----------------------------------------------------------------------===//
 // CompoundAType
 //===----------------------------------------------------------------------===//
 
-Type CompoundAType::parse(MLIRContext *ctxt, DialectAsmParser &parser) {
+Type CompoundAType::parse(DialectAsmParser &parser) {
   int widthOfSomething;
   Type oneType;
   SmallVector<int, 4> arrayOfInts;
   if (parser.parseLess() || parser.parseInteger(widthOfSomething) ||
       parser.parseComma() || parser.parseType(oneType) || parser.parseComma() ||
       parser.parseLSquare())
     return Type();
 
   int i;
   while (!*parser.parseOptionalInteger(i)) {
     arrayOfInts.push_back(i);
     if (parser.parseOptionalComma())
       break;
   }
 
   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()
           << ", [";
   auto intArray = getArrayOfInts();
   llvm::interleaveComma(intArray, printer);
   printer << "]>";
 }

 void TestType::printTypeC(Location loc) const {
   emitRemark(loc) << *this << " - TestC";
 }
 
 //===----------------------------------------------------------------------===//
 // 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 {
   printer << "test_type_with_layout<" << getKey() << ">";
 }
 
 unsigned
 TestTypeWithLayoutType::getTypeSizeInBits(const DataLayout &dataLayout,

 void TestDialect::registerTypes() {
   addTypes<TestRecursiveType,
 #define GET_TYPEDEF_LIST
 #include "TestTypeDefs.cpp.inc"
            >();
   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;
   }
 
   if (typeTag != "test_rec") {
     parser.emitError(parser.getNameLoc()) << "unknown type!";
     return Type();
   }
 
   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 (stack.contains(rec)) {
     if (failed(parser.parseGreater()))
       return Type();
     return rec;
   }
 
   // Otherwise, parse the body and update the type.
   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();
 
   return rec;
 }
 
 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,
                           SetVector<Type> &stack) {
   if (succeeded(generatedTypePrinter(type, printer)))
     return;
 
   auto rec = type.cast<TestRecursiveType>();

mlir/test/mlir-tblgen/attrdefs.td

 
 // DEF: #ifdef GET_ATTRDEF_LIST
 // DEF: #undef GET_ATTRDEF_LIST
 // DEF: ::test::SimpleAAttr,
 // DEF: ::test::CompoundAAttr,
 // 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 {};
 
 def Test_Dialect: Dialect {
 // DECL-NOT: TestDialect
 // DEF-NOT: TestDialect
     let name = "TestDialect";
     let cppNamespace = "::test";
def B_CompoundAttrA : TestAttr<"CompoundA"> {
   let genVerifyDecl = 1;
 
 // DECL-LABEL: class CompoundAAttr : public ::mlir::Attribute
 // DECL: static CompoundAAttr getChecked(llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, int widthOfSomething, ::test::SimpleTypeA exampleTdType, ::llvm::APFloat apFloat, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
 // DECL: static ::mlir::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, int widthOfSomething, ::test::SimpleTypeA exampleTdType, ::llvm::APFloat apFloat, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
 // 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: ::llvm::APFloat getApFloat() const;
 
 // Check that AttributeSelfTypeParameter is handled properly.
 // DEF-LABEL: struct CompoundAAttrStorage
 // DEF: CompoundAAttrStorage (
let parameters = (
       ins
       StringRefParameter<"Label for index">:$label
     );
 
 // DECL-LABEL: class IndexAttr : public ::mlir::Attribute
 // 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 D_SingleParameterAttr : TestAttr<"SingleParameter"> {
   let parameters = (
     ins
     "int": $num
   );

mlir/test/mlir-tblgen/typedefs.td

 // DEF: #ifdef GET_TYPEDEF_LIST
 // DEF: #undef GET_TYPEDEF_LIST
 // DEF: ::test::SimpleAType,
 // DEF: ::test::CompoundAType,
 // DEF: ::test::IndexType,
 // 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 {};
 
 def Test_Dialect: Dialect {
 // DECL-NOT: TestDialect
 // DEF-NOT: TestDialect
     let name = "TestDialect";
     let cppNamespace = "::test";
def B_CompoundTypeA : TestType<"CompoundA"> {
   let genVerifyDecl = 1;
 
 // DECL-LABEL: class CompoundAType : public ::mlir::Type
 // DECL: static CompoundAType getChecked(llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, int widthOfSomething, ::test::SimpleTypeA exampleTdType, SomeCppStruct exampleCppType, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
 // DECL: static ::mlir::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, int widthOfSomething, ::test::SimpleTypeA exampleTdType, SomeCppStruct exampleCppType, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
 // 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: SomeCppStruct getExampleCppType() const;
 }
 
 def C_IndexType : TestType<"Index"> {
     let mnemonic = "index";
 
     let parameters = (
       ins
       StringRefParameter<"Label for index">:$label
     );
 
 // DECL-LABEL: class IndexType : public ::mlir::Type
 // 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;
 }
 
 def D_SingleParameterType : TestType<"SingleParameter"> {
   let parameters = (
     ins
     "int": $num
   );

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

 
 )";
 
 /// The code snippet for print/parse of an Attribute/Type.
 ///
 /// {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;
 )";
 
 /// The code block for the verify method declaration.
 ///
 /// {0}: List of parameters, parameters style.
 static const char *const defDeclVerifyStr = R"(
     using Base::getChecked;

 // GEN: Definitions
 //===----------------------------------------------------------------------===//
 
 /// The code block used to start the auto-generated parser function.
 ///
 /// {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) {{
 )";
 
 /// The code block used to start the auto-generated printer function.
 ///
 /// {0}: The name of the base value type, e.g. Attribute or Type.
if (Optional<StringRef> printerCode = def.getPrinterCode()) {
     }
     FmtContext fmtCtxt = FmtContext().addSubst("_printer", "printer");
     os << tgfmt(*printerCode, &fmtCtxt) << "\n}\n";
   }
 
   // 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) {
       // Attributes also accept a type parameter instead of a context.
       os << ", ::mlir::Type type";
       fmtCtxt.addSubst("_type", "type");
     }
     os << ") {\n";
for (const AttrOrTypeDef &def : defs) {
     if (def.getMnemonic()) {
       os << formatv("  if (mnemonic == {0}::{1}::getMnemonic()) { \n"
                     "    value = {0}::{1}::",
                     def.getDialect().getCppNamespace(), def.getCppClassName());
 
       // 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";
     }
   }
   os << "  return {};\n";
   os << "}\n\n";
 
   // The printer dispatch uses llvm::TypeSwitch to find and call the correct
   // printer.

mlir/tools/mlir-tblgen/OpFormatGen.cpp

void OperationFormat::genParserTypeResolution(Operator &op,
 
   // Emit the code necessary for a type resolver.
   auto emitTypeResolver = [&](TypeResolution &resolver, StringRef curVar) {
     if (Optional<int> val = resolver.getBuilderIdx()) {
       body << "odsBuildableType" << *val;
     } 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
           fmtContext.withSelf(var->name + "Types[0]");
         body << tgfmt(*tform, &fmtContext);
       } else {
         body << var->name << "Types";
       }

mlir/unittests/Interfaces/DataLayoutInterfacesTest.cpp

struct DLTestDialect : Dialect {
   }
 
   Attribute parseAttribute(DialectAsmParser &parser, Type type) const override {
     bool ok =
         succeeded(parser.parseKeyword("spec")) && succeeded(parser.parseLess());
     (void)ok;
     assert(ok);
     if (succeeded(parser.parseOptionalGreater()))
-      return CustomDataLayoutSpec::get(parser.getBuilder().getContext(), {});
+      return CustomDataLayoutSpec::get(parser.getContext(), {});
 
     SmallVector<DataLayoutEntryInterface> entries;
     do {
       entries.emplace_back();
       ok = succeeded(parser.parseAttribute(entries.back()));
       assert(ok);
     } 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 {
     if (type.isa<SingleQueryType>())
       printer << "single_query";
     else
       printer << "no_layout";
   }
 
   Type parseType(DialectAsmParser &parser) const override {
     bool ok = succeeded(parser.parseKeyword("single_query"));
     (void)ok;
     assert(ok);
-    return SingleQueryType::get(parser.getBuilder().getContext());
+    return SingleQueryType::get(parser.getContext());
   }
 };
 
 } // end namespace
 
 TEST(DataLayout, FallbackDefault) {
   const char *ir = R"MLIR(
 module {}