diff --git a/flang/lib/Optimizer/Dialect/FIRType.cpp b/flang/lib/Optimizer/Dialect/FIRType.cpp
--- a/flang/lib/Optimizer/Dialect/FIRType.cpp
+++ b/flang/lib/Optimizer/Dialect/FIRType.cpp
@@ -33,7 +33,7 @@
   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>
@@ -117,8 +117,7 @@
   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;
@@ -259,12 +258,11 @@
 //===----------------------------------------------------------------------===//
 
 // `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 {
@@ -293,8 +291,7 @@
 //===----------------------------------------------------------------------===//
 
 // `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 {};
@@ -330,8 +327,7 @@
 // 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);
 }
 
@@ -353,8 +349,7 @@
 //===----------------------------------------------------------------------===//
 
 // `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 {};
@@ -368,7 +363,7 @@
   }
   if (parser.parseGreater())
     return {};
-  return get(context, kind, len);
+  return get(parser.getContext(), kind, len);
 }
 
 void fir::CharacterType::print(mlir::DialectAsmPrinter &printer) const {
@@ -388,8 +383,7 @@
 // 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);
 }
 
@@ -406,8 +400,7 @@
 //===----------------------------------------------------------------------===//
 
 // `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);
 }
 
@@ -429,8 +422,7 @@
 //===----------------------------------------------------------------------===//
 
 // `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);
 }
 
@@ -443,8 +435,7 @@
 //===----------------------------------------------------------------------===//
 
 // `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);
 }
 
@@ -457,8 +448,7 @@
 //===----------------------------------------------------------------------===//
 
 // `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);
 }
 
@@ -479,8 +469,7 @@
 //===----------------------------------------------------------------------===//
 
 // `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);
 }
 
@@ -503,12 +492,11 @@
 // `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()) {
@@ -631,8 +619,7 @@
 //===----------------------------------------------------------------------===//
 
 // `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);
 }
 
@@ -655,8 +642,7 @@
 
 // `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;
@@ -675,7 +661,7 @@
       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 {
@@ -745,8 +731,7 @@
 // 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);
 }
 
@@ -758,8 +743,7 @@
 // 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);
 }
 
@@ -771,8 +755,7 @@
 // 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);
 }
 
@@ -785,8 +768,7 @@
 //===----------------------------------------------------------------------===//
 
 // `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);
 }
 
@@ -799,8 +781,7 @@
 //===----------------------------------------------------------------------===//
 
 // `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);
 }
 
@@ -824,8 +805,7 @@
 //===----------------------------------------------------------------------===//
 
 // `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() ||
diff --git a/mlir/include/mlir/IR/OpImplementation.h b/mlir/include/mlir/IR/OpImplementation.h
--- a/mlir/include/mlir/IR/OpImplementation.h
+++ b/mlir/include/mlir/IR/OpImplementation.h
@@ -18,7 +18,6 @@
 #include "mlir/IR/OpDefinition.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/SMLoc.h"
-#include "llvm/Support/raw_ostream.h"
 
 namespace mlir {
 
@@ -323,6 +322,8 @@
   AsmParser() = default;
   virtual ~AsmParser();
 
+  MLIRContext *getContext() const;
+
   /// Return the location of the original name token.
   virtual llvm::SMLoc getNameLoc() const = 0;
 
diff --git a/mlir/lib/Dialect/Affine/IR/AffineOps.cpp b/mlir/lib/Dialect/Affine/IR/AffineOps.cpp
--- a/mlir/lib/Dialect/Affine/IR/AffineOps.cpp
+++ b/mlir/lib/Dialect/Affine/IR/AffineOps.cpp
@@ -3165,8 +3165,8 @@
         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()));
     }
   }
 }
@@ -3276,7 +3276,7 @@
 
   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());
 
diff --git a/mlir/lib/Dialect/ArmSVE/IR/ArmSVEDialect.cpp b/mlir/lib/Dialect/ArmSVE/IR/ArmSVEDialect.cpp
--- a/mlir/lib/Dialect/ArmSVE/IR/ArmSVEDialect.cpp
+++ b/mlir/lib/Dialect/ArmSVE/IR/ArmSVEDialect.cpp
@@ -55,8 +55,7 @@
   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;
   }
diff --git a/mlir/lib/Dialect/Async/IR/Async.cpp b/mlir/lib/Dialect/Async/IR/Async.cpp
--- a/mlir/lib/Dialect/Async/IR/Async.cpp
+++ b/mlir/lib/Dialect/Async/IR/Async.cpp
@@ -345,7 +345,7 @@
   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");
@@ -366,8 +366,7 @@
   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;
diff --git a/mlir/lib/Dialect/DLTI/DLTI.cpp b/mlir/lib/Dialect/DLTI/DLTI.cpp
--- a/mlir/lib/Dialect/DLTI/DLTI.cpp
+++ b/mlir/lib/Dialect/DLTI/DLTI.cpp
@@ -283,7 +283,7 @@
 
   // Empty spec.
   if (succeeded(parser.parseOptionalGreater()))
-    return get(parser.getBuilder().getContext(), {});
+    return get(parser.getContext(), {});
 
   SmallVector<DataLayoutEntryInterface> entries;
   do {
@@ -295,7 +295,7 @@
   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 {
diff --git a/mlir/lib/Dialect/EmitC/IR/EmitC.cpp b/mlir/lib/Dialect/EmitC/IR/EmitC.cpp
--- a/mlir/lib/Dialect/EmitC/IR/EmitC.cpp
+++ b/mlir/lib/Dialect/EmitC/IR/EmitC.cpp
@@ -147,7 +147,7 @@
 
   if (standardInclude)
     result.addAttribute("is_standard_include",
-                        UnitAttr::get(parser.getBuilder().getContext()));
+                        UnitAttr::get(parser.getContext()));
 
   return success();
 }
@@ -166,8 +166,7 @@
 #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;
@@ -178,7 +177,7 @@
   }
   if (parser.parseGreater())
     return Attribute();
-  return get(context, value);
+  return get(parser.getContext(), value);
 }
 
 Attribute EmitCDialect::parseAttribute(DialectAsmParser &parser,
@@ -189,7 +188,7 @@
     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");
@@ -214,7 +213,7 @@
 #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;
@@ -225,7 +224,7 @@
   }
   if (parser.parseGreater())
     return Type();
-  return get(context, value);
+  return get(parser.getContext(), value);
 }
 
 Type EmitCDialect::parseType(DialectAsmParser &parser) const {
@@ -235,7 +234,7 @@
     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");
diff --git a/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp b/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp
--- a/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp
+++ b/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp
@@ -1491,7 +1491,7 @@
 // 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(
@@ -1530,7 +1530,7 @@
   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);
@@ -1759,7 +1759,7 @@
   // 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)));
 
@@ -2374,8 +2374,7 @@
   printer << ">";
 }
 
-Attribute FMFAttr::parse(MLIRContext *context, DialectAsmParser &parser,
-                         Type type) {
+Attribute FMFAttr::parse(DialectAsmParser &parser, Type type) {
   if (failed(parser.parseLess()))
     return {};
 
@@ -2400,7 +2399,7 @@
       return {};
   }
 
-  return FMFAttr::get(parser.getBuilder().getContext(), flags);
+  return FMFAttr::get(parser.getContext(), flags);
 }
 
 void LinkageAttr::print(DialectAsmPrinter &printer) const {
@@ -2412,8 +2411,7 @@
   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())
@@ -2424,7 +2422,7 @@
     return {};
   }
   Linkage linkage = *elem;
-  return LinkageAttr::get(context, linkage);
+  return LinkageAttr::get(parser.getContext(), linkage);
 }
 
 LoopOptionsAttrBuilder::LoopOptionsAttrBuilder(LoopOptionsAttr attr)
@@ -2539,8 +2537,7 @@
   printer << ">";
 }
 
-Attribute LoopOptionsAttr::parse(MLIRContext *context, DialectAsmParser &parser,
-                                 Type type) {
+Attribute LoopOptionsAttr::parse(DialectAsmParser &parser, Type type) {
   if (failed(parser.parseLess()))
     return {};
 
@@ -2593,7 +2590,7 @@
     return {};
 
   llvm::sort(options, llvm::less_first());
-  return get(parser.getBuilder().getContext(), options);
+  return get(parser.getContext(), options);
 }
 
 Attribute LLVMDialect::parseAttribute(DialectAsmParser &parser,
@@ -2607,8 +2604,7 @@
     return {};
   {
     Attribute attr;
-    auto parseResult =
-        generatedAttributeParser(getContext(), parser, attrKind, type, attr);
+    auto parseResult = generatedAttributeParser(parser, attrKind, type, attr);
     if (parseResult.hasValue())
       return attr;
   }
diff --git a/mlir/lib/Dialect/LLVMIR/IR/LLVMTypeSyntax.cpp b/mlir/lib/Dialect/LLVMIR/IR/LLVMTypeSyntax.cpp
--- a/mlir/lib/Dialect/LLVMIR/IR/LLVMTypeSyntax.cpp
+++ b/mlir/lib/Dialect/LLVMIR/IR/LLVMTypeSyntax.cpp
@@ -438,7 +438,7 @@
   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); })
diff --git a/mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp b/mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp
--- a/mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp
+++ b/mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp
@@ -64,7 +64,7 @@
     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);
 }
@@ -72,7 +72,7 @@
 // <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);
 
diff --git a/mlir/lib/Dialect/LLVMIR/IR/ROCDLDialect.cpp b/mlir/lib/Dialect/LLVMIR/IR/ROCDLDialect.cpp
--- a/mlir/lib/Dialect/LLVMIR/IR/ROCDLDialect.cpp
+++ b/mlir/lib/Dialect/LLVMIR/IR/ROCDLDialect.cpp
@@ -47,7 +47,7 @@
       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);
@@ -66,7 +66,7 @@
   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);
diff --git a/mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp b/mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp
--- a/mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp
+++ b/mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp
@@ -375,7 +375,7 @@
 
 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();
@@ -470,7 +470,7 @@
 
 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();
@@ -2934,7 +2934,7 @@
 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;
diff --git a/mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp b/mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp
--- a/mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp
+++ b/mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp
@@ -1137,7 +1137,7 @@
     return success();
 
   if (succeeded(parser.parseOptionalKeyword("uninitialized"))) {
-    initialValue = UnitAttr::get(parser.getBuilder().getContext());
+    initialValue = UnitAttr::get(parser.getContext());
     return success();
   }
 
diff --git a/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp b/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
--- a/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
+++ b/mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp
@@ -595,7 +595,7 @@
         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;
@@ -618,7 +618,7 @@
       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])
diff --git a/mlir/lib/Dialect/PDL/IR/PDLTypes.cpp b/mlir/lib/Dialect/PDL/IR/PDLTypes.cpp
--- a/mlir/lib/Dialect/PDL/IR/PDLTypes.cpp
+++ b/mlir/lib/Dialect/PDL/IR/PDLTypes.cpp
@@ -39,8 +39,7 @@
     return Type();
   {
     Type genType;
-    auto parseResult = generatedTypeParser(parser.getBuilder().getContext(),
-                                           parser, typeTag, genType);
+    auto parseResult = generatedTypeParser(parser, typeTag, genType);
     if (parseResult.hasValue())
       return genType;
   }
@@ -75,7 +74,7 @@
 // RangeType
 //===----------------------------------------------------------------------===//
 
-Type RangeType::parse(MLIRContext *context, DialectAsmParser &parser) {
+Type RangeType::parse(DialectAsmParser &parser) {
   if (parser.parseLess())
     return Type();
 
diff --git a/mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp b/mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp
--- a/mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp
+++ b/mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp
@@ -321,8 +321,7 @@
   if (parseEnumStrAttr(imageOperands, parser))
     return failure();
 
-  attr = spirv::ImageOperandsAttr::get(parser.getBuilder().getContext(),
-                                       imageOperands);
+  attr = spirv::ImageOperandsAttr::get(parser.getContext(), imageOperands);
 
   return parser.parseRSquare();
 }
@@ -3590,7 +3589,7 @@
   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();
diff --git a/mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp b/mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp
--- a/mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp
+++ b/mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp
@@ -38,8 +38,7 @@
   }
 }
 
-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.
@@ -113,8 +112,8 @@
     }
   }
   // 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 {
@@ -298,8 +297,7 @@
   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");
diff --git a/mlir/lib/Dialect/Vector/VectorOps.cpp b/mlir/lib/Dialect/Vector/VectorOps.cpp
--- a/mlir/lib/Dialect/Vector/VectorOps.cpp
+++ b/mlir/lib/Dialect/Vector/VectorOps.cpp
@@ -187,8 +187,7 @@
   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,
diff --git a/mlir/lib/Parser/Parser.cpp b/mlir/lib/Parser/Parser.cpp
--- a/mlir/lib/Parser/Parser.cpp
+++ b/mlir/lib/Parser/Parser.cpp
@@ -1093,6 +1093,8 @@
   return op;
 }
 
+MLIRContext *AsmParser::getContext() const { return getBuilder().getContext(); }
+
 namespace {
 class CustomOpAsmParser : public AsmParserImpl<OpAsmParser> {
 public:
diff --git a/mlir/test/lib/Dialect/Test/TestAttributes.cpp b/mlir/test/lib/Dialect/Test/TestAttributes.cpp
--- a/mlir/test/lib/Dialect/Test/TestAttributes.cpp
+++ b/mlir/test/lib/Dialect/Test/TestAttributes.cpp
@@ -27,13 +27,12 @@
 // 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 {
@@ -44,12 +43,11 @@
 // 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 {
@@ -60,8 +58,7 @@
 // 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;
@@ -79,7 +76,7 @@
 
   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 {
@@ -93,8 +90,7 @@
 // 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();
@@ -108,7 +104,7 @@
   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 {
@@ -158,8 +154,7 @@
     return Attribute();
   {
     Attribute attr;
-    auto parseResult =
-        generatedAttributeParser(getContext(), parser, attrTag, type, attr);
+    auto parseResult = generatedAttributeParser(parser, attrTag, type, attr);
     if (parseResult.hasValue())
       return attr;
   }
diff --git a/mlir/test/lib/Dialect/Test/TestDialect.cpp b/mlir/test/lib/Dialect/Test/TestDialect.cpp
--- a/mlir/test/lib/Dialect/Test/TestDialect.cpp
+++ b/mlir/test/lib/Dialect/Test/TestDialect.cpp
@@ -691,7 +691,7 @@
   // 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);
 
diff --git a/mlir/test/lib/Dialect/Test/TestTypes.cpp b/mlir/test/lib/Dialect/Test/TestTypes.cpp
--- a/mlir/test/lib/Dialect/Test/TestTypes.cpp
+++ b/mlir/test/lib/Dialect/Test/TestTypes.cpp
@@ -88,7 +88,7 @@
 // CompoundAType
 //===----------------------------------------------------------------------===//
 
-Type CompoundAType::parse(MLIRContext *ctxt, DialectAsmParser &parser) {
+Type CompoundAType::parse(DialectAsmParser &parser) {
   int widthOfSomething;
   Type oneType;
   SmallVector<int, 4> arrayOfInts;
@@ -107,7 +107,7 @@
   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()
@@ -143,11 +143,11 @@
 // 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 {
@@ -236,15 +236,14 @@
   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;
   }
@@ -257,7 +256,7 @@
   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.
@@ -271,7 +270,7 @@
   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();
@@ -281,7 +280,7 @@
 
 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,
diff --git a/mlir/test/mlir-tblgen/attrdefs.td b/mlir/test/mlir-tblgen/attrdefs.td
--- a/mlir/test/mlir-tblgen/attrdefs.td
+++ b/mlir/test/mlir-tblgen/attrdefs.td
@@ -18,16 +18,16 @@
 // 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 {};
 
@@ -66,8 +66,8 @@
 // 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;
@@ -110,8 +110,8 @@
 // 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;
 }
 
diff --git a/mlir/test/mlir-tblgen/typedefs.td b/mlir/test/mlir-tblgen/typedefs.td
--- a/mlir/test/mlir-tblgen/typedefs.td
+++ b/mlir/test/mlir-tblgen/typedefs.td
@@ -19,16 +19,16 @@
 // 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 {};
 
@@ -71,8 +71,7 @@
 // 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;
@@ -91,8 +90,7 @@
 // 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;
 }
 
diff --git a/mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp b/mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp
--- a/mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp
+++ b/mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp
@@ -244,8 +244,7 @@
 /// {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;
 )";
 
@@ -484,7 +483,7 @@
 /// {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) {{
@@ -720,10 +719,11 @@
   // 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) {
@@ -894,11 +894,12 @@
       // 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";
     }
   }
diff --git a/mlir/tools/mlir-tblgen/OpFormatGen.cpp b/mlir/tools/mlir-tblgen/OpFormatGen.cpp
--- a/mlir/tools/mlir-tblgen/OpFormatGen.cpp
+++ b/mlir/tools/mlir-tblgen/OpFormatGen.cpp
@@ -1416,7 +1416,7 @@
     } 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
diff --git a/mlir/unittests/Interfaces/DataLayoutInterfacesTest.cpp b/mlir/unittests/Interfaces/DataLayoutInterfacesTest.cpp
--- a/mlir/unittests/Interfaces/DataLayoutInterfacesTest.cpp
+++ b/mlir/unittests/Interfaces/DataLayoutInterfacesTest.cpp
@@ -197,7 +197,7 @@
     (void)ok;
     assert(ok);
     if (succeeded(parser.parseOptionalGreater()))
-      return CustomDataLayoutSpec::get(parser.getBuilder().getContext(), {});
+      return CustomDataLayoutSpec::get(parser.getContext(), {});
 
     SmallVector<DataLayoutEntryInterface> entries;
     do {
@@ -207,7 +207,7 @@
     } 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 {
@@ -221,7 +221,7 @@
     bool ok = succeeded(parser.parseKeyword("single_query"));
     (void)ok;
     assert(ok);
-    return SingleQueryType::get(parser.getBuilder().getContext());
+    return SingleQueryType::get(parser.getContext());
   }
 };