Use base class AsmParser/AsmPrinter in Types and Attribute print/parse method (NFC)

[mehdi_amini]

Summary

This decouples the printing/parsing from the "context" in which the parsing occurs.
This'll allow to invoke these methods directly using an OpAsmParser/OpAsmPrinter.

[rriddle]

possible typo in description: I'll allow

[aartbik]

LGTM sparse

flang/lib/Optimizer/Dialect/FIRType.cpp

bool fir::isa_unknown_size_box(mlir::Type t) {
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // BoxProcType
 //===----------------------------------------------------------------------===//
 
 // `boxproc` `<` return-type `>`
-mlir::Type BoxProcType::parse(mlir::DialectAsmParser &parser) {
+mlir::Type BoxProcType::parse(mlir::AsmParser &parser) {
   mlir::Type ty;
   if (parser.parseLess() || parser.parseType(ty) || parser.parseGreater())
     return {};
   return get(parser.getContext(), ty);
 }
 
 void fir::BoxProcType::print(mlir::DialectAsmPrinter &printer) const {
   printer << "<" << getEleTy() << '>';
return eleTy.isa<BoxType, BoxCharType, BoxProcType, ShapeType, ShapeShiftType,
                    ReferenceType, TypeDescType>();
 }
 
 //===----------------------------------------------------------------------===//
 // BoxType
 //===----------------------------------------------------------------------===//
 
 // `box` `<` type (',' affine-map)? `>`
-mlir::Type fir::BoxType::parse(mlir::DialectAsmParser &parser) {
+mlir::Type fir::BoxType::parse(mlir::AsmParser &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::DialectAsmParser &parser) {
+mlir::Type fir::BoxCharType::parse(mlir::AsmParser &parser) {
   return parseKindSingleton<fir::BoxCharType>(parser);
 }
 
 void fir::BoxCharType::print(mlir::DialectAsmPrinter &printer) const {
   printer << "<" << 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::DialectAsmParser &parser) {
+mlir::Type fir::CharacterType::parse(mlir::AsmParser &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))) {
void fir::CharacterType::print(mlir::DialectAsmPrinter &printer) const {
   }
   printer << '>';
 }
 
 //===----------------------------------------------------------------------===//
 // ComplexType
 //===----------------------------------------------------------------------===//
 
-mlir::Type fir::ComplexType::parse(mlir::DialectAsmParser &parser) {
+mlir::Type fir::ComplexType::parse(mlir::AsmParser &parser) {
   return parseKindSingleton<fir::ComplexType>(parser);
 }
 
 void fir::ComplexType::print(mlir::DialectAsmPrinter &printer) const {
   printer << "<" << getFKind() << '>';
 }
 
 mlir::Type fir::ComplexType::getElementType() const {
   return fir::RealType::get(getContext(), getFKind());
 }
 
 //===----------------------------------------------------------------------===//
 // HeapType
 //===----------------------------------------------------------------------===//
 
 // `heap` `<` type `>`
-mlir::Type fir::HeapType::parse(mlir::DialectAsmParser &parser) {
+mlir::Type fir::HeapType::parse(mlir::AsmParser &parser) {
   return parseTypeSingleton<HeapType>(parser);
 }
 
 void fir::HeapType::print(mlir::DialectAsmPrinter &printer) const {
   printer << "<" << 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::DialectAsmParser &parser) {
+mlir::Type fir::IntegerType::parse(mlir::AsmParser &parser) {
   return parseKindSingleton<fir::IntegerType>(parser);
 }
 
 void fir::IntegerType::print(mlir::DialectAsmPrinter &printer) const {
   printer << "<" << getFKind() << '>';
 }
 
 //===----------------------------------------------------------------------===//
 // LogicalType
 //===----------------------------------------------------------------------===//
 
 // `logical` `<` kind `>`
-mlir::Type fir::LogicalType::parse(mlir::DialectAsmParser &parser) {
+mlir::Type fir::LogicalType::parse(mlir::AsmParser &parser) {
   return parseKindSingleton<fir::LogicalType>(parser);
 }
 
 void fir::LogicalType::print(mlir::DialectAsmPrinter &printer) const {
   printer << "<" << getFKind() << '>';
 }
 
 //===----------------------------------------------------------------------===//
 // PointerType
 //===----------------------------------------------------------------------===//
 
 // `ptr` `<` type `>`
-mlir::Type fir::PointerType::parse(mlir::DialectAsmParser &parser) {
+mlir::Type fir::PointerType::parse(mlir::AsmParser &parser) {
   return parseTypeSingleton<fir::PointerType>(parser);
 }
 
 void fir::PointerType::print(mlir::DialectAsmPrinter &printer) const {
   printer << "<" << 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::DialectAsmParser &parser) {
+mlir::Type fir::RealType::parse(mlir::AsmParser &parser) {
   return parseKindSingleton<fir::RealType>(parser);
 }
 
 void fir::RealType::print(mlir::DialectAsmPrinter &printer) const {
   printer << "<" << 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::DialectAsmParser &parser) {
+mlir::Type fir::RecordType::parse(mlir::AsmParser &parser) {
   llvm::StringRef name;
   if (parser.parseLess() || parser.parseKeyword(&name))
     return {};
   RecordType result = RecordType::get(parser.getContext(), name);
 
   RecordType::TypeList lenParamList;
   if (!parser.parseOptionalLParen()) {
     while (true) {
unsigned fir::RecordType::getFieldIndex(llvm::StringRef ident) {
   return std::numeric_limits<unsigned>::max();
 }
 
 //===----------------------------------------------------------------------===//
 // ReferenceType
 //===----------------------------------------------------------------------===//
 
 // `ref` `<` type `>`
-mlir::Type fir::ReferenceType::parse(mlir::DialectAsmParser &parser) {
+mlir::Type fir::ReferenceType::parse(mlir::AsmParser &parser) {
   return parseTypeSingleton<fir::ReferenceType>(parser);
 }
 
 void fir::ReferenceType::print(mlir::DialectAsmPrinter &printer) const {
   printer << "<" << 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::DialectAsmParser &parser) {
+mlir::Type fir::SequenceType::parse(mlir::AsmParser &parser) {
   if (parser.parseLess())
     return {};
   SequenceType::Shape shape;
   if (parser.parseOptionalStar()) {
     if (parser.parseDimensionList(shape, /*allowDynamic=*/true))
       return {};
   } else if (parser.parseColon()) {
     return {};
return emitError() << "cannot build an array of this element type: "
                        << eleTy << '\n';
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ShapeType
 //===----------------------------------------------------------------------===//
 
-mlir::Type fir::ShapeType::parse(mlir::DialectAsmParser &parser) {
+mlir::Type fir::ShapeType::parse(mlir::AsmParser &parser) {
   return parseRankSingleton<fir::ShapeType>(parser);
 }
 
 void fir::ShapeType::print(mlir::DialectAsmPrinter &printer) const {
   printer << "<" << getImpl()->rank << ">";
 }
 
 //===----------------------------------------------------------------------===//
 // ShapeShiftType
 //===----------------------------------------------------------------------===//
 
-mlir::Type fir::ShapeShiftType::parse(mlir::DialectAsmParser &parser) {
+mlir::Type fir::ShapeShiftType::parse(mlir::AsmParser &parser) {
   return parseRankSingleton<fir::ShapeShiftType>(parser);
 }
 
 void fir::ShapeShiftType::print(mlir::DialectAsmPrinter &printer) const {
   printer << "<" << getRank() << ">";
 }
 
 //===----------------------------------------------------------------------===//
 // ShiftType
 //===----------------------------------------------------------------------===//
 
-mlir::Type fir::ShiftType::parse(mlir::DialectAsmParser &parser) {
+mlir::Type fir::ShiftType::parse(mlir::AsmParser &parser) {
   return parseRankSingleton<fir::ShiftType>(parser);
 }
 
 void fir::ShiftType::print(mlir::DialectAsmPrinter &printer) const {
   printer << "<" << getRank() << ">";
 }
 
 //===----------------------------------------------------------------------===//
 // SliceType
 //===----------------------------------------------------------------------===//
 
 // `slice` `<` rank `>`
-mlir::Type fir::SliceType::parse(mlir::DialectAsmParser &parser) {
+mlir::Type fir::SliceType::parse(mlir::AsmParser &parser) {
   return parseRankSingleton<fir::SliceType>(parser);
 }
 
 void fir::SliceType::print(mlir::DialectAsmPrinter &printer) const {
   printer << "<" << getRank() << '>';
 }
 
 //===----------------------------------------------------------------------===//
 // TypeDescType
 //===----------------------------------------------------------------------===//
 
 // `tdesc` `<` type `>`
-mlir::Type fir::TypeDescType::parse(mlir::DialectAsmParser &parser) {
+mlir::Type fir::TypeDescType::parse(mlir::AsmParser &parser) {
   return parseTypeSingleton<fir::TypeDescType>(parser);
 }
 
 void fir::TypeDescType::print(mlir::DialectAsmPrinter &printer) const {
   printer << "<" << 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::DialectAsmParser &parser) {
+mlir::Type fir::VectorType::parse(mlir::AsmParser &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/Dialect/DLTI/DLTI.h

public:
 
   /// Returns the key of this entry.
   DataLayoutEntryKey getKey() const;
 
   /// Returns the value of this entry.
   Attribute getValue() const;
 
   /// Parses an instance of this attribute.
-  static DataLayoutEntryAttr parse(DialectAsmParser &parser);
+  static DataLayoutEntryAttr parse(AsmParser &parser);
 
   /// Prints this attribute.
-  void print(DialectAsmPrinter &os) const;
+  void print(AsmPrinter &os) const;
 };
 
 //===----------------------------------------------------------------------===//
 // DataLayoutSpecAttr
 //===----------------------------------------------------------------------===//
 
 /// A data layout specification is a list of entries that specify (partial) data
 /// layout information. It is expected to be attached to operations that serve
public:
   /// same key as the newer entries if the entries are compatible. Returns null
   /// if the specifications are not compatible.
   DataLayoutSpecAttr combineWith(ArrayRef<DataLayoutSpecInterface> specs) const;
 
   /// Returns the list of entries.
   DataLayoutEntryListRef getEntries() const;
 
   /// Parses an instance of this attribute.
-  static DataLayoutSpecAttr parse(DialectAsmParser &parser);
+  static DataLayoutSpecAttr parse(AsmParser &parser);
 
   /// Prints this attribute.
-  void print(DialectAsmPrinter &os) const;
+  void print(AsmPrinter &os) const;
 };
 
 } // namespace mlir
 
 #include "mlir/Dialect/DLTI/DLTIDialect.h.inc"
 
 #endif // MLIR_DIALECT_DLTI_DLTI_H

mlir/include/mlir/Dialect/LLVMIR/LLVMTypes.h

 
 namespace llvm {
 class ElementCount;
 class TypeSize;
 } // namespace llvm
 
 namespace mlir {
 
-class DialectAsmParser;
-class DialectAsmPrinter;
+class AsmParser;
+class AsmPrinter;
 
 namespace LLVM {
 class LLVMDialect;
 
 namespace detail {
 struct LLVMFunctionTypeStorage;
 struct LLVMPointerTypeStorage;
 struct LLVMStructTypeStorage;

 // Printing and parsing.
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 /// Parses an LLVM dialect type.
 Type parseType(DialectAsmParser &parser);
 
 /// Prints an LLVM Dialect type.
-void printType(Type type, DialectAsmPrinter &printer);
+void printType(Type type, AsmPrinter &printer);
 } // namespace detail
 
 //===----------------------------------------------------------------------===//
 // Utility functions.
 //===----------------------------------------------------------------------===//
 
 /// Returns `true` if the given type is compatible with the LLVM dialect.
 bool isCompatibleType(Type type);

mlir/include/mlir/Dialect/Vector/VectorOps.h

: public Attribute::AttrBase<CombiningKindAttr, Attribute,
                                  detail::BitmaskEnumStorage> {
 public:
   using Base::Base;
 
   static CombiningKindAttr get(CombiningKind kind, MLIRContext *context);
 
   CombiningKind getKind() const;
 
-  void print(DialectAsmPrinter &p) const;
-  static Attribute parse(DialectAsmParser &parser);
+  void print(AsmPrinter &p) const;
+  static Attribute parse(AsmParser &parser, Type type);
 };
 
 /// Collects patterns to progressively lower vector.broadcast ops on high-D
 /// vectors to low-D vector ops.
 void populateVectorBroadcastLoweringPatterns(RewritePatternSet &patterns);
 
 /// Collects patterns to progressively lower vector mask ops into elementary
 /// selection and insertion ops.

mlir/include/mlir/IR/DialectImplementation.h

 template <typename T, typename = T>
 struct FieldParser;
 
 /// Parse an attribute.
 template <typename AttributeT>
 struct FieldParser<
     AttributeT, std::enable_if_t<std::is_base_of<Attribute, AttributeT>::value,
                                  AttributeT>> {
-  static FailureOr<AttributeT> parse(DialectAsmParser &parser) {
+  static FailureOr<AttributeT> parse(AsmParser &parser) {
     AttributeT value;
     if (parser.parseAttribute(value))
       return failure();
     return value;
   }
 };
 
 /// Parse any integer.
 template <typename IntT>
 struct FieldParser<IntT,
                    std::enable_if_t<std::is_integral<IntT>::value, IntT>> {
-  static FailureOr<IntT> parse(DialectAsmParser &parser) {
+  static FailureOr<IntT> parse(AsmParser &parser) {
     IntT value;
     if (parser.parseInteger(value))
       return failure();
     return value;
   }
 };
 
 /// Parse a string.
 template <>
 struct FieldParser<std::string> {
-  static FailureOr<std::string> parse(DialectAsmParser &parser) {
+  static FailureOr<std::string> parse(AsmParser &parser) {
     std::string value;
     if (parser.parseString(&value))
       return failure();
     return value;
   }
 };
 
 /// Parse any container that supports back insertion as a list.
 template <typename ContainerT>
 struct FieldParser<
     ContainerT, std::enable_if_t<std::is_member_function_pointer<
                                      decltype(&ContainerT::push_back)>::value,
                                  ContainerT>> {
   using ElementT = typename ContainerT::value_type;
-  static FailureOr<ContainerT> parse(DialectAsmParser &parser) {
+  static FailureOr<ContainerT> parse(AsmParser &parser) {
     ContainerT elements;
     auto elementParser = [&]() {
       auto element = FieldParser<ElementT>::parse(parser);
       if (failed(element))
         return failure();
       elements.push_back(element.getValue());
       return success();
     };

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

 
 //===----------------------------------------------------------------------===//
 // TableGen'd type method definitions
 //===----------------------------------------------------------------------===//
 
 #define GET_TYPEDEF_CLASSES
 #include "mlir/Dialect/Async/IR/AsyncOpsTypes.cpp.inc"
 
-void ValueType::print(DialectAsmPrinter &printer) const {
+void ValueType::print(AsmPrinter &printer) const {
   printer << "<";
   printer.printType(getValueType());
   printer << '>';
 }
 
-Type ValueType::parse(mlir::DialectAsmParser &parser) {
+Type ValueType::parse(mlir::AsmParser &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);
 }
 

mlir/lib/Dialect/DLTI/DLTI.cpp

 DataLayoutEntryKey DataLayoutEntryAttr::getKey() const {
   return getImpl()->entryKey;
 }
 
 Attribute DataLayoutEntryAttr::getValue() const { return getImpl()->value; }
 
 /// Parses an attribute with syntax:
 ///   attr ::= `#target.` `dl_entry` `<` (type | quoted-string) `,` attr `>`
-DataLayoutEntryAttr DataLayoutEntryAttr::parse(DialectAsmParser &parser) {
+DataLayoutEntryAttr DataLayoutEntryAttr::parse(AsmParser &parser) {
   if (failed(parser.parseLess()))
     return {};
 
   Type type = nullptr;
   std::string identifier;
   llvm::SMLoc idLoc = parser.getCurrentLocation();
   OptionalParseResult parsedType = parser.parseOptionalType(type);
   if (parsedType.hasValue() && failed(parsedType.getValue()))
DataLayoutEntryAttr DataLayoutEntryAttr::parse(AsmParser &parser) {
   if (failed(parser.parseComma()) || failed(parser.parseAttribute(value)) ||
       failed(parser.parseGreater()))
     return {};
 
   return type ? get(type, value)
               : get(parser.getBuilder().getIdentifier(identifier), value);
 }
 
-void DataLayoutEntryAttr::print(DialectAsmPrinter &os) const {
+void DataLayoutEntryAttr::print(AsmPrinter &os) const {
   os << DataLayoutEntryAttr::kAttrKeyword << "<";
   if (auto type = getKey().dyn_cast<Type>())
     os << type;
   else
     os << "\"" << getKey().get<Identifier>().strref() << "\"";
   os << ", " << getValue() << ">";
 }
 

 DataLayoutEntryListRef DataLayoutSpecAttr::getEntries() const {
   return getImpl()->entries;
 }
 
 /// Parses an attribute with syntax
 ///   attr ::= `#target.` `dl_spec` `<` attr-list? `>`
 ///   attr-list ::= attr
 ///               | attr `,` attr-list
-DataLayoutSpecAttr DataLayoutSpecAttr::parse(DialectAsmParser &parser) {
+DataLayoutSpecAttr DataLayoutSpecAttr::parse(AsmParser &parser) {
   if (failed(parser.parseLess()))
     return {};
 
   // Empty spec.
   if (succeeded(parser.parseOptionalGreater()))
     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.getContext(), entries);
 }
 
-void DataLayoutSpecAttr::print(DialectAsmPrinter &os) const {
+void DataLayoutSpecAttr::print(AsmPrinter &os) const {
   os << DataLayoutSpecAttr::kAttrKeyword << "<";
   llvm::interleaveComma(getEntries(), os);
   os << ">";
 }
 
 //===----------------------------------------------------------------------===//
 // DLTIDialect
 //===----------------------------------------------------------------------===//

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

 
 //===----------------------------------------------------------------------===//
 // EmitC Attributes
 //===----------------------------------------------------------------------===//
 
 #define GET_ATTRDEF_CLASSES
 #include "mlir/Dialect/EmitC/IR/EmitCAttributes.cpp.inc"
 
-Attribute emitc::OpaqueAttr::parse(DialectAsmParser &parser, Type type) {
+Attribute emitc::OpaqueAttr::parse(AsmParser &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();
   }
Attribute EmitCDialect::parseAttribute(DialectAsmParser &parser,
   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 {
+void emitc::OpaqueAttr::print(AsmPrinter &printer) const {
   printer << "<\"";
   llvm::printEscapedString(getValue(), printer.getStream());
   printer << "\">";
 }
 
 //===----------------------------------------------------------------------===//
 // EmitC Types
 //===----------------------------------------------------------------------===//
 
 #define GET_TYPEDEF_CLASSES
 #include "mlir/Dialect/EmitC/IR/EmitCTypes.cpp.inc"
 
-Type emitc::OpaqueType::parse(DialectAsmParser &parser) {
+Type emitc::OpaqueType::parse(AsmParser &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(parser.getContext(), value);
 }
 
-void emitc::OpaqueType::print(DialectAsmPrinter &printer) const {
+void emitc::OpaqueType::print(AsmPrinter &printer) const {
   printer << "<\"";
   llvm::printEscapedString(getValue(), printer.getStream());
   printer << "\">";
 }

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

static constexpr const FastmathFlags fastmathFlagsList[] = {
     FastmathFlags::arcp,
     FastmathFlags::contract,
     FastmathFlags::afn,
     FastmathFlags::reassoc,
     FastmathFlags::fast,
     // clang-format on
 };
 
-void FMFAttr::print(DialectAsmPrinter &printer) const {
+void FMFAttr::print(AsmPrinter &printer) const {
   printer << "<";
   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(DialectAsmParser &parser, Type type) {
+Attribute FMFAttr::parse(AsmParser &parser, Type type) {
   if (failed(parser.parseLess()))
     return {};
 
   FastmathFlags flags = {};
   if (failed(parser.parseOptionalGreater())) {
     do {
       StringRef elemName;
       if (failed(parser.parseKeyword(&elemName)))
if (failed(parser.parseOptionalGreater())) {
 
     if (failed(parser.parseGreater()))
       return {};
   }
 
   return FMFAttr::get(parser.getContext(), flags);
 }
 
-void LinkageAttr::print(DialectAsmPrinter &printer) const {
+void LinkageAttr::print(AsmPrinter &printer) const {
   printer << "<";
   if (static_cast<uint64_t>(getLinkage()) <= getMaxEnumValForLinkage())
     printer << stringifyEnum(getLinkage());
   else
     printer << static_cast<uint64_t>(getLinkage());
   printer << ">";
 }
 
-Attribute LinkageAttr::parse(DialectAsmParser &parser, Type type) {
+Attribute LinkageAttr::parse(AsmParser &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 {};

 
 /// Build the LoopOptions Attribute from a sorted array of individual options.
 LoopOptionsAttr LoopOptionsAttr::get(MLIRContext *context,
                                      LoopOptionsAttrBuilder &optionBuilders) {
   llvm::sort(optionBuilders.options, llvm::less_first());
   return Base::get(context, optionBuilders.options);
 }
 
-void LoopOptionsAttr::print(DialectAsmPrinter &printer) const {
+void LoopOptionsAttr::print(AsmPrinter &printer) const {
   printer << "<";
   llvm::interleaveComma(getOptions(), printer, [&](auto option) {
     printer << stringifyEnum(option.first) << " = ";
     switch (option.first) {
     case LoopOptionCase::disable_licm:
     case LoopOptionCase::disable_unroll:
     case LoopOptionCase::disable_pipeline:
       printer << (option.second ? "true" : "false");
       break;
     case LoopOptionCase::interleave_count:
     case LoopOptionCase::pipeline_initiation_interval:
       printer << option.second;
       break;
     }
   });
   printer << ">";
 }
 
-Attribute LoopOptionsAttr::parse(DialectAsmParser &parser, Type type) {
+Attribute LoopOptionsAttr::parse(AsmParser &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))

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

 
 //===----------------------------------------------------------------------===//
 // Printing.
 //===----------------------------------------------------------------------===//
 
 /// If the given type is compatible with the LLVM dialect, prints it using
 /// internal functions to avoid getting a verbose `!llvm` prefix. Otherwise
 /// prints it as usual.
-static void dispatchPrint(DialectAsmPrinter &printer, Type type) {
+static void dispatchPrint(AsmPrinter &printer, Type type) {
   if (isCompatibleType(type) && !type.isa<IntegerType, FloatType, VectorType>())
     return mlir::LLVM::detail::printType(type, printer);
   printer.printType(type);
 }
 
 /// Returns the keyword to use for the given type.
 static StringRef getTypeKeyword(Type type) {
   return TypeSwitch<Type, StringRef>(type)
return TypeSwitch<Type, StringRef>(type)
       .Case<LLVMStructType>([&](Type) { return "struct"; })
       .Default([](Type) -> StringRef {
         llvm_unreachable("unexpected 'llvm' type kind");
       });
 }
 
 /// Prints a structure type. Keeps track of known struct names to handle self-
 /// or mutually-referring structs without falling into infinite recursion.
-static void printStructType(DialectAsmPrinter &printer, LLVMStructType type) {
+static void printStructType(AsmPrinter &printer, LLVMStructType type) {
   // This keeps track of the names of identified structure types that are
   // currently being printed. Since such types can refer themselves, this
   // tracking is necessary to stop the recursion: the current function may be
-  // called recursively from DialectAsmPrinter::printType after the appropriate
+  // called recursively from AsmPrinter::printType after the appropriate
   // dispatch. We maintain the invariant of this storage being modified
   // exclusively in this function, and at most one name being added per call.
-  // TODO: consider having such functionality inside DialectAsmPrinter.
+  // TODO: consider having such functionality inside AsmPrinter.
   thread_local SetVector<StringRef> knownStructNames;
   unsigned stackSize = knownStructNames.size();
   (void)stackSize;
   auto guard = llvm::make_scope_exit([&]() {
     assert(knownStructNames.size() == stackSize &&
            "malformed identified stack when printing recursive structs");
   });
 
static void printStructType(AsmPrinter &printer, LLVMStructType type) {
   if (type.isIdentified())
     knownStructNames.pop_back();
   printer << ')';
   printer << '>';
 }
 
 /// Prints a type containing a fixed number of elements.
 template <typename TypeTy>
-static void printArrayOrVectorType(DialectAsmPrinter &printer, TypeTy type) {
+static void printArrayOrVectorType(AsmPrinter &printer, TypeTy type) {
   printer << '<' << type.getNumElements() << " x ";
   dispatchPrint(printer, type.getElementType());
   printer << '>';
 }
 
 /// Prints a function type.
-static void printFunctionType(DialectAsmPrinter &printer,
-                              LLVMFunctionType funcType) {
+static void printFunctionType(AsmPrinter &printer, LLVMFunctionType funcType) {
   printer << '<';
   dispatchPrint(printer, funcType.getReturnType());
   printer << " (";
   llvm::interleaveComma(
       funcType.getParams(), printer.getStream(),
       [&printer](Type subtype) { dispatchPrint(printer, subtype); });
   if (funcType.isVarArg()) {
     if (funcType.getNumParams() != 0)
       printer << ", ";
     printer << "...";
   }
   printer << ")>";
 }
 
 /// Prints the given LLVM dialect type recursively. This leverages closedness of
 /// the LLVM dialect type system to avoid printing the dialect prefix
 /// repeatedly. For recursive structures, only prints the name of the structure
 /// when printing a self-reference. Note that this does not apply to sibling
 /// references. For example,
 ///   struct<"a", (ptr<struct<"a">>)>
 ///   struct<"c", (ptr<struct<"b", (ptr<struct<"c">>)>>,
 ///                ptr<struct<"b", (ptr<struct<"c">>)>>)>
 /// note that "b" is printed twice.
-void mlir::LLVM::detail::printType(Type type, DialectAsmPrinter &printer) {
+void mlir::LLVM::detail::printType(Type type, AsmPrinter &printer) {
   if (!type) {
     printer << "<<NULL-TYPE>>";
     return;
   }
 
   printer << getTypeKeyword(type);
 
   if (auto ptrType = type.dyn_cast<LLVMPointerType>()) {
void mlir::LLVM::detail::printType(Type type, AsmPrinter &printer) {
   if (auto funcType = type.dyn_cast<LLVMFunctionType>())
     return printFunctionType(printer, funcType);
 }
 
 //===----------------------------------------------------------------------===//
 // Parsing.
 //===----------------------------------------------------------------------===//
 
-static ParseResult dispatchParse(DialectAsmParser &parser, Type &type);
+static ParseResult dispatchParse(AsmParser &parser, Type &type);
 
 /// Parses an LLVM dialect function type.
 ///   llvm-type :: = `func<` llvm-type `(` llvm-type-list `...`? `)>`
-static LLVMFunctionType parseFunctionType(DialectAsmParser &parser) {
+static LLVMFunctionType parseFunctionType(AsmParser &parser) {
   llvm::SMLoc loc = parser.getCurrentLocation();
   Type returnType;
   if (parser.parseLess() || dispatchParse(parser, returnType) ||
       parser.parseLParen())
     return LLVMFunctionType();
 
   // Function type without arguments.
   if (succeeded(parser.parseOptionalRParen())) {
static LLVMFunctionType parseFunctionType(AsmParser &parser) {
   if (parser.parseOptionalRParen() || parser.parseOptionalGreater())
     return LLVMFunctionType();
   return parser.getChecked<LLVMFunctionType>(loc, returnType, argTypes,
                                              /*isVarArg=*/false);
 }
 
 /// Parses an LLVM dialect pointer type.
 ///   llvm-type ::= `ptr<` llvm-type (`,` integer)? `>`
-static LLVMPointerType parsePointerType(DialectAsmParser &parser) {
+static LLVMPointerType parsePointerType(AsmParser &parser) {
   llvm::SMLoc loc = parser.getCurrentLocation();
   Type elementType;
   if (parser.parseLess() || dispatchParse(parser, elementType))
     return LLVMPointerType();
 
   unsigned addressSpace = 0;
   if (succeeded(parser.parseOptionalComma()) &&
       failed(parser.parseInteger(addressSpace)))
     return LLVMPointerType();
   if (failed(parser.parseGreater()))
     return LLVMPointerType();
   return parser.getChecked<LLVMPointerType>(loc, elementType, addressSpace);
 }
 
 /// Parses an LLVM dialect vector type.
 ///   llvm-type ::= `vec<` `? x`? integer `x` llvm-type `>`
 /// Supports both fixed and scalable vectors.
-static Type parseVectorType(DialectAsmParser &parser) {
+static Type parseVectorType(AsmParser &parser) {
   SmallVector<int64_t, 2> dims;
   llvm::SMLoc dimPos, typePos;
   Type elementType;
   llvm::SMLoc loc = parser.getCurrentLocation();
   if (parser.parseLess() || parser.getCurrentLocation(&dimPos) ||
       parser.parseDimensionList(dims, /*allowDynamic=*/true) ||
       parser.getCurrentLocation(&typePos) ||
       dispatchParse(parser, elementType) || parser.parseGreater())
parser.emitError(typePos)
         << "cannot use !llvm.vec for built-in primitives, use 'vector' instead";
     return Type();
   }
   return parser.getChecked<LLVMFixedVectorType>(loc, elementType, dims[0]);
 }
 
 /// Parses an LLVM dialect array type.
 ///   llvm-type ::= `array<` integer `x` llvm-type `>`
-static LLVMArrayType parseArrayType(DialectAsmParser &parser) {
+static LLVMArrayType parseArrayType(AsmParser &parser) {
   SmallVector<int64_t, 1> dims;
   llvm::SMLoc sizePos;
   Type elementType;
   llvm::SMLoc loc = parser.getCurrentLocation();
   if (parser.parseLess() || parser.getCurrentLocation(&sizePos) ||
       parser.parseDimensionList(dims, /*allowDynamic=*/false) ||
       dispatchParse(parser, elementType) || parser.parseGreater())
     return LLVMArrayType();
 
   if (dims.size() != 1) {
     parser.emitError(sizePos) << "expected ? x <type>";
     return LLVMArrayType();
   }
 
   return parser.getChecked<LLVMArrayType>(loc, elementType, dims[0]);
 }
 
 /// Attempts to set the body of an identified structure type. Reports a parsing
 /// error at `subtypesLoc` in case of failure.
 static LLVMStructType trySetStructBody(LLVMStructType type,
                                        ArrayRef<Type> subtypes, bool isPacked,
-                                       DialectAsmParser &parser,
+                                       AsmParser &parser,
                                        llvm::SMLoc subtypesLoc) {
   for (Type t : subtypes) {
     if (!LLVMStructType::isValidElementType(t)) {
       parser.emitError(subtypesLoc)
           << "invalid LLVM structure element type: " << t;
       return LLVMStructType();
     }
   }
 
   if (succeeded(type.setBody(subtypes, isPacked)))
     return type;
 
   parser.emitError(subtypesLoc)
       << "identified type already used with a different body";
   return LLVMStructType();
 }
 
 /// Parses an LLVM dialect structure type.
 ///   llvm-type ::= `struct<` (string-literal `,`)? `packed`?
 ///                 `(` llvm-type-list `)` `>`
 ///               | `struct<` string-literal `>`
 ///               | `struct<` string-literal `, opaque>`
-static LLVMStructType parseStructType(DialectAsmParser &parser) {
+static LLVMStructType parseStructType(AsmParser &parser) {
   // This keeps track of the names of identified structure types that are
   // currently being parsed. Since such types can refer themselves, this
   // tracking is necessary to stop the recursion: the current function may be
-  // called recursively from DialectAsmParser::parseType after the appropriate
+  // called recursively from AsmParser::parseType after the appropriate
   // dispatch. We maintain the invariant of this storage being modified
   // exclusively in this function, and at most one name being added per call.
-  // TODO: consider having such functionality inside DialectAsmParser.
+  // TODO: consider having such functionality inside AsmParser.
   thread_local SetVector<StringRef> knownStructNames;
   unsigned stackSize = knownStructNames.size();
   (void)stackSize;
   auto guard = llvm::make_scope_exit([&]() {
     assert(knownStructNames.size() == stackSize &&
            "malformed identified stack when parsing recursive structs");
   });
 
auto type = LLVMStructType::getIdentifiedChecked(
       [loc] { return emitError(loc); }, loc.getContext(), name);
   return trySetStructBody(type, subtypes, isPacked, parser, subtypesLoc);
 }
 
 /// Parses a type appearing inside another LLVM dialect-compatible type. This
 /// will try to parse any type in full form (including types with the `!llvm`
 /// prefix), and on failure fall back to parsing the short-hand version of the
 /// LLVM dialect types without the `!llvm` prefix.
-static Type dispatchParse(DialectAsmParser &parser, bool allowAny = true) {
+static Type dispatchParse(AsmParser &parser, bool allowAny = true) {
   llvm::SMLoc keyLoc = parser.getCurrentLocation();
 
   // Try parsing any MLIR type.
   Type type;
   OptionalParseResult result = parser.parseOptionalType(type);
   if (result.hasValue()) {
     if (failed(result.getValue()))
       return nullptr;
return StringSwitch<function_ref<Type()>>(key)
       .Case("struct", [&] { return parseStructType(parser); })
       .Default([&] {
         parser.emitError(keyLoc) << "unknown LLVM type: " << key;
         return Type();
       })();
 }
 
 /// Helper to use in parse lists.
-static ParseResult dispatchParse(DialectAsmParser &parser, Type &type) {
+static ParseResult dispatchParse(AsmParser &parser, Type &type) {
   type = dispatchParse(parser);
   return success(type != nullptr);
 }
 
 /// Parses one of the LLVM dialect types.
 Type mlir::LLVM::detail::parseType(DialectAsmParser &parser) {
   llvm::SMLoc loc = parser.getCurrentLocation();
   Type type = dispatchParse(parser, /*allowAny=*/false);
   if (!type)
     return type;
   if (!isCompatibleType(type)) {
     parser.emitError(loc) << "unexpected type, expected keyword";
     return nullptr;
   }
   return type;
 }

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

 
 void PDLDialect::registerTypes() {
   addTypes<
 #define GET_TYPEDEF_LIST
 #include "mlir/Dialect/PDL/IR/PDLOpsTypes.cpp.inc"
       >();
 }
 
-static Type parsePDLType(DialectAsmParser &parser) {
+static Type parsePDLType(AsmParser &parser) {
   StringRef typeTag;
   if (parser.parseKeyword(&typeTag))
     return Type();
   {
     Type genType;
     auto parseResult = generatedTypeParser(parser, typeTag, genType);
     if (parseResult.hasValue())
       return genType;

 bool PDLType::classof(Type type) {
   return llvm::isa<PDLDialect>(type.getDialect());
 }
 
 //===----------------------------------------------------------------------===//
 // RangeType
 //===----------------------------------------------------------------------===//
 
-Type RangeType::parse(DialectAsmParser &parser) {
+Type RangeType::parse(AsmParser &parser) {
   if (parser.parseLess())
     return Type();
 
   llvm::SMLoc elementLoc = parser.getCurrentLocation();
   Type elementType = parsePDLType(parser);
   if (!elementType || parser.parseGreater())
     return Type();
 
   if (elementType.isa<RangeType>()) {
     parser.emitError(elementLoc)
         << "element of pdl.range cannot be another range, but got"
         << elementType;
     return Type();
   }
   return RangeType::get(elementType);
 }
 
-void RangeType::print(DialectAsmPrinter &printer) const {
+void RangeType::print(AsmPrinter &printer) const {
   printer << "<";
   (void)generatedTypePrinter(getElementType(), printer);
   printer << ">";
 }
 
 LogicalResult RangeType::verify(function_ref<InFlightDiagnostic()> emitError,
                                 Type elementType) {
   if (!elementType.isa<PDLType>() || elementType.isa<RangeType>()) {
     return emitError()
            << "expected element of pdl.range to be one of [!pdl.attribute, "
               "!pdl.operation, !pdl.type, !pdl.value], but got "
            << elementType;
   }
   return success();
 }

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

static bool acceptBitWidth(unsigned bitWidth) {
   case 32:
   case 64:
     return true;
   default:
     return false;
   }
 }
 
-Attribute SparseTensorEncodingAttr::parse(DialectAsmParser &parser, Type type) {
+Attribute SparseTensorEncodingAttr::parse(AsmParser &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") {
       return {};
     }
   }
   // Construct struct-like storage for attribute.
   return parser.getChecked<SparseTensorEncodingAttr>(parser.getContext(), dlt,
                                                      map, ptr, ind);
 }
 
-void SparseTensorEncodingAttr::print(DialectAsmPrinter &printer) const {
+void SparseTensorEncodingAttr::print(AsmPrinter &printer) const {
   // Print the struct-like storage in dictionary fashion.
   printer << "<{ dimLevelType = [ ";
   for (unsigned i = 0, e = getDimLevelType().size(); i < e; i++) {
     switch (getDimLevelType()[i]) {
     case DimLevelType::Dense:
       printer << "\"dense\"";
       break;
     case DimLevelType::Compressed:

mlir/lib/Dialect/Vector/VectorOps.cpp

static constexpr const CombiningKind combiningKindsList[] = {
     CombiningKind::MAXSI,
     CombiningKind::MAXF,
     CombiningKind::AND,
     CombiningKind::OR,
     CombiningKind::XOR,
     // clang-format on
 };
 
-void CombiningKindAttr::print(DialectAsmPrinter &printer) const {
+void CombiningKindAttr::print(AsmPrinter &printer) const {
   printer << "kind<";
   auto kinds = llvm::make_filter_range(combiningKindsList, [&](auto kind) {
     return bitEnumContains(this->getKind(), kind);
   });
   llvm::interleaveComma(kinds, printer,
                         [&](auto kind) { printer << stringifyEnum(kind); });
   printer << ">";
 }
 
-Attribute CombiningKindAttr::parse(DialectAsmParser &parser) {
+Attribute CombiningKindAttr::parse(AsmParser &parser, Type type) {
   if (failed(parser.parseLess()))
     return {};
 
   StringRef elemName;
   if (failed(parser.parseKeyword(&elemName)))
     return {};
 
   auto kind = symbolizeCombiningKind(elemName);

 
 Attribute VectorDialect::parseAttribute(DialectAsmParser &parser,
                                         Type type) const {
   StringRef attrKind;
   if (parser.parseKeyword(&attrKind))
     return {};
 
   if (attrKind == "kind")
-    return CombiningKindAttr::parse(parser);
+    return CombiningKindAttr::parse(parser, {});
 
   parser.emitError(parser.getNameLoc(), "Unknown attribute type: ") << attrKind;
   return {};
 }
 
 void VectorDialect::printAttribute(Attribute attr,
                                    DialectAsmPrinter &os) const {
   if (auto ck = attr.dyn_cast<CombiningKindAttr>())

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

 
 using namespace mlir;
 using namespace test;
 
 //===----------------------------------------------------------------------===//
 // AttrWithSelfTypeParamAttr
 //===----------------------------------------------------------------------===//
 
-Attribute AttrWithSelfTypeParamAttr::parse(DialectAsmParser &parser,
-                                           Type type) {
+Attribute AttrWithSelfTypeParamAttr::parse(AsmParser &parser, Type type) {
   Type selfType;
   if (parser.parseType(selfType))
     return Attribute();
   return get(parser.getContext(), selfType);
 }
 
-void AttrWithSelfTypeParamAttr::print(DialectAsmPrinter &printer) const {
+void AttrWithSelfTypeParamAttr::print(AsmPrinter &printer) const {
   printer << " " << getType();
 }
 
 //===----------------------------------------------------------------------===//
 // AttrWithTypeBuilderAttr
 //===----------------------------------------------------------------------===//
 
-Attribute AttrWithTypeBuilderAttr::parse(DialectAsmParser &parser, Type type) {
+Attribute AttrWithTypeBuilderAttr::parse(AsmParser &parser, Type type) {
   IntegerAttr element;
   if (parser.parseAttribute(element))
     return Attribute();
   return get(parser.getContext(), element);
 }
 
-void AttrWithTypeBuilderAttr::print(DialectAsmPrinter &printer) const {
+void AttrWithTypeBuilderAttr::print(AsmPrinter &printer) const {
   printer << " " << getAttr();
 }
 
 //===----------------------------------------------------------------------===//
 // CompoundAAttr
 //===----------------------------------------------------------------------===//
 
-Attribute CompoundAAttr::parse(DialectAsmParser &parser, Type type) {
+Attribute CompoundAAttr::parse(AsmParser &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(parser.getContext(), widthOfSomething, oneType, arrayOfInts);
 }
 
-void CompoundAAttr::print(DialectAsmPrinter &printer) const {
+void CompoundAAttr::print(AsmPrinter &printer) const {
   printer << "<" << getWidthOfSomething() << ", " << getOneType() << ", [";
   llvm::interleaveComma(getArrayOfInts(), printer);
   printer << "]>";
 }
 
 //===----------------------------------------------------------------------===//
 // CompoundAAttr
 //===----------------------------------------------------------------------===//
 
-Attribute TestI64ElementsAttr::parse(DialectAsmParser &parser, Type type) {
+Attribute TestI64ElementsAttr::parse(AsmParser &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>(
       parser.getContext(), type.cast<ShapedType>(), elements);
 }
 
-void TestI64ElementsAttr::print(DialectAsmPrinter &printer) const {
+void TestI64ElementsAttr::print(AsmPrinter &printer) const {
   printer << "<[";
   llvm::interleaveComma(getElements(), printer);
   printer << "] : " << getType() << ">";
 }
 
 LogicalResult
 TestI64ElementsAttr::verify(function_ref<InFlightDiagnostic()> emitError,
                             ShapedType type, ArrayRef<uint64_t> elements) {
if (four.size() != static_cast<unsigned>(one))
     return emitError() << "expected 'one' to equal 'four.size()'";
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Utility Functions for Generated Attributes
 //===----------------------------------------------------------------------===//
 
-static FailureOr<SmallVector<int>> parseIntArray(DialectAsmParser &parser) {
+static FailureOr<SmallVector<int>> parseIntArray(AsmParser &parser) {
   SmallVector<int> ints;
   if (parser.parseLSquare() || parser.parseCommaSeparatedList([&]() {
         ints.push_back(0);
         return parser.parseInteger(ints.back());
       }) ||
       parser.parseRSquare())
     return failure();
   return ints;
 }
 
-static void printIntArray(DialectAsmPrinter &printer, ArrayRef<int> ints) {
+static void printIntArray(AsmPrinter &printer, ArrayRef<int> ints) {
   printer << '[';
   llvm::interleaveComma(ints, printer);
   printer << ']';
 }
 
 //===----------------------------------------------------------------------===//
 // TestSubElementsAccessAttr
 //===----------------------------------------------------------------------===//
 
-Attribute TestSubElementsAccessAttr::parse(::mlir::DialectAsmParser &parser,
+Attribute TestSubElementsAccessAttr::parse(::mlir::AsmParser &parser,
                                            ::mlir::Type type) {
   Attribute first, second, third;
   if (parser.parseLess() || parser.parseAttribute(first) ||
       parser.parseComma() || parser.parseAttribute(second) ||
       parser.parseComma() || parser.parseAttribute(third) ||
       parser.parseGreater()) {
     return {};
   }
   return get(parser.getContext(), first, second, third);
 }
 
-void TestSubElementsAccessAttr::print(
-    ::mlir::DialectAsmPrinter &printer) const {
+void TestSubElementsAccessAttr::print(::mlir::AsmPrinter &printer) const {
   printer << "<" << getFirst() << ", " << getSecond() << ", " << getThird()
           << ">";
 }
 
 void TestSubElementsAccessAttr::walkImmediateSubElements(
     llvm::function_ref<void(mlir::Attribute)> walkAttrsFn,
     llvm::function_ref<void(mlir::Type)> walkTypesFn) const {
   walkAttrsFn(getFirst());

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

inline llvm::hash_code hash_value(const test::CustomParam &param) {
   return llvm::hash_value(param.value);
 }
 
 } // namespace test
 
 namespace mlir {
 template <>
 struct FieldParser<test::CustomParam> {
-  static FailureOr<test::CustomParam> parse(DialectAsmParser &parser) {
+  static FailureOr<test::CustomParam> parse(AsmParser &parser) {
     auto value = FieldParser<int>::parse(parser);
     if (failed(value))
       return failure();
     return test::CustomParam{value.getValue()};
   }
 };
 } // end namespace mlir
 
-inline mlir::DialectAsmPrinter &operator<<(mlir::DialectAsmPrinter &printer,
-                                           const test::CustomParam &param) {
+inline mlir::AsmPrinter &operator<<(mlir::AsmPrinter &printer,
   return printer << param.value;
 }
 
 #include "TestTypeInterfaces.h.inc"
 
 #define GET_TYPEDEF_CLASSES
 #include "TestTypeDefs.h.inc"
 

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

 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 using namespace mlir;
 using namespace test;
 
 // Custom parser for SignednessSemantics.
 static ParseResult
-parseSignedness(DialectAsmParser &parser,
+parseSignedness(AsmParser &parser,
                 TestIntegerType::SignednessSemantics &result) {
   StringRef signStr;
   auto loc = parser.getCurrentLocation();
   if (parser.parseKeyword(&signStr))
     return failure();
   if (signStr.equals_insensitive("u") || signStr.equals_insensitive("unsigned"))
     result = TestIntegerType::SignednessSemantics::Unsigned;
   else if (signStr.equals_insensitive("s") ||
            signStr.equals_insensitive("signed"))
     result = TestIntegerType::SignednessSemantics::Signed;
   else if (signStr.equals_insensitive("n") ||
            signStr.equals_insensitive("none"))
     result = TestIntegerType::SignednessSemantics::Signless;
   else
     return parser.emitError(loc, "expected signed, unsigned, or none");
   return success();
 }
 
 // Custom printer for SignednessSemantics.
-static void printSignedness(DialectAsmPrinter &printer,
+static void printSignedness(AsmPrinter &printer,
                             const TestIntegerType::SignednessSemantics &ss) {
   switch (ss) {
   case TestIntegerType::SignednessSemantics::Unsigned:
     printer << "unsigned";
     break;
   case TestIntegerType::SignednessSemantics::Signed:
     printer << "signed";
     break;

 static llvm::hash_code test::hash_value(const FieldInfo &fi) { // NOLINT
   return llvm::hash_combine(fi.name, fi.type);
 }
 
 //===----------------------------------------------------------------------===//
 // CompoundAType
 //===----------------------------------------------------------------------===//
 
-Type CompoundAType::parse(DialectAsmParser &parser) {
+Type CompoundAType::parse(AsmParser &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(parser.getContext(), widthOfSomething, oneType, arrayOfInts);
 }
-void CompoundAType::print(DialectAsmPrinter &printer) const {
+void CompoundAType::print(AsmPrinter &printer) const {
   printer << "<" << getWidthOfSomething() << ", " << getOneType() << ", [";
   auto intArray = getArrayOfInts();
   llvm::interleaveComma(intArray, printer);
   printer << "]>";
 }
 
 //===----------------------------------------------------------------------===//
 // TestIntegerType

 void TestType::printTypeC(Location loc) const {
   emitRemark(loc) << *this << " - TestC";
 }
 
 //===----------------------------------------------------------------------===//
 // TestTypeWithLayout
 //===----------------------------------------------------------------------===//
 
-Type TestTypeWithLayoutType::parse(DialectAsmParser &parser) {
+Type TestTypeWithLayoutType::parse(AsmParser &parser) {
   unsigned val;
   if (parser.parseLess() || parser.parseInteger(val) || parser.parseGreater())
     return Type();
   return TestTypeWithLayoutType::get(parser.getContext(), val);
 }
 
-void TestTypeWithLayoutType::print(DialectAsmPrinter &printer) const {
+void TestTypeWithLayoutType::print(AsmPrinter &printer) const {
   printer << "<" << getKey() << ">";
 }
 
 unsigned
 TestTypeWithLayoutType::getTypeSizeInBits(const DataLayout &dataLayout,
                                           DataLayoutEntryListRef params) const {
   return extractKind(params, "size");
 }

 void TestDialect::registerTypes() {
   addTypes<TestRecursiveType,
 #define GET_TYPEDEF_LIST
 #include "TestTypeDefs.cpp.inc"
            >();
   SimpleAType::attachInterface<PtrElementModel>(*getContext());
 }
 
-static Type parseTestType(DialectAsmParser &parser, SetVector<Type> &stack) {
+static Type parseTestType(AsmParser &parser, SetVector<Type> &stack) {
   StringRef typeTag;
   if (failed(parser.parseKeyword(&typeTag)))
     return Type();
 
   {
     Type genType;
     auto parseResult = generatedTypeParser(parser, typeTag, genType);
     if (parseResult.hasValue())
static Type parseTestType(AsmParser &parser, SetVector<Type> &stack) {
   return rec;
 }
 
 Type TestDialect::parseType(DialectAsmParser &parser) const {
   SetVector<Type> stack;
   return parseTestType(parser, stack);
 }
 
-static void printTestType(Type type, DialectAsmPrinter &printer,
+static void printTestType(Type type, AsmPrinter &printer,
                           SetVector<Type> &stack) {
   if (succeeded(generatedTypePrinter(type, printer)))
     return;
 
   auto rec = type.cast<TestRecursiveType>();
   printer << "test_rec<" << rec.getName();
   if (!stack.contains(rec)) {
     printer << ", ";

mlir/test/mlir-tblgen/attr-or-type-format.td

 
 def TypeParamB : TypeParameter<"TestParamD", "a type param D"> {
   let parser = "someFcnCall()";
   let printer = "myPrinter($_self)";
 }
 
 /// Check simple attribute parser and printer are generated correctly.
 
-// ATTR: ::mlir::Attribute TestAAttr::parse(::mlir::DialectAsmParser &parser,
+// ATTR: ::mlir::Attribute TestAAttr::parse(::mlir::AsmParser &parser,
 // ATTR:                                    ::mlir::Type attrType) {
 // ATTR:   FailureOr<IntegerAttr> _result_value;
 // ATTR:   FailureOr<TestParamA> _result_complex;
 // ATTR:   if (parser.parseKeyword("hello"))
 // ATTR:     return {};
 // ATTR:   if (parser.parseEqual())
 // ATTR:     return {};
 // ATTR:   _result_value = ::mlir::FieldParser<IntegerAttr>::parse(parser);
 // ATTR:   if (failed(_result_value))
 // ATTR:     return {};
 // ATTR:   if (parser.parseComma())
 // ATTR:     return {};
 // ATTR:   _result_complex = ::parseAttrParamA(parser, attrType);
 // ATTR:   if (failed(_result_complex))
 // ATTR:     return {};
 // ATTR:   if (parser.parseRParen())
 // ATTR:     return {};
 // ATTR:   return TestAAttr::get(parser.getContext(),
 // ATTR:                         _result_value.getValue(),
 // ATTR:                         _result_complex.getValue());
 // ATTR: }
 
-// ATTR: void TestAAttr::print(::mlir::DialectAsmPrinter &printer) const {
+// ATTR: void TestAAttr::print(::mlir::AsmPrinter &printer) const {
 // ATTR:   printer << ' ' << "hello";
 // ATTR:   printer << ' ' << "=";
 // ATTR:   printer << ' ';
 // ATTR:   printer << getValue();
 // ATTR:   printer << ",";
 // ATTR:   printer << ' ';
 // ATTR:   ::printAttrParamA(printer, getComplex());
 // ATTR:   printer << ")";
 // ATTR: }
 
 def AttrA : TestAttr<"TestA"> {
   let parameters = (ins
       "IntegerAttr":$value,
       AttrParamA:$complex
   );
 
   let mnemonic = "attr_a";
   let assemblyFormat = "`hello` `=` $value `,` $complex `)`";
 }
 
 /// Test simple struct parser and printer are generated correctly.
 
-// ATTR: ::mlir::Attribute TestBAttr::parse(::mlir::DialectAsmParser &parser,
+// ATTR: ::mlir::Attribute TestBAttr::parse(::mlir::AsmParser &parser,
 // ATTR:                                    ::mlir::Type attrType) {
 // ATTR:   bool _seen_v0 = false;
 // ATTR:   bool _seen_v1 = false;
 // ATTR:   for (unsigned _index = 0; _index < 2; ++_index) {
 // ATTR:     StringRef _paramKey;
 // ATTR:     if (parser.parseKeyword(&_paramKey))
 // ATTR:       return {};
 // ATTR:     if (parser.parseEqual())

 // ATTR:     if ((_index != 2 - 1) && parser.parseComma())
 // ATTR:       return {};
 // ATTR:   }
 // ATTR:   return TestBAttr::get(parser.getContext(),
 // ATTR:                         _result_v0.getValue(),
 // ATTR:                         _result_v1.getValue());
 // ATTR: }
 
-// ATTR: void TestBAttr::print(::mlir::DialectAsmPrinter &printer) const {
+// ATTR: void TestBAttr::print(::mlir::AsmPrinter &printer) const {
 // ATTR:   printer << "v0";
 // ATTR:   printer << ' ' << "=";
 // ATTR:   printer << ' ';
 // ATTR:   ::printAttrParamA(printer, getV0());
 // ATTR:   printer << ",";
 // ATTR:   printer << ' ' << "v1";
 // ATTR:   printer << ' ' << "=";
 // ATTR:   printer << ' ';
 // ATTR:   ::printAttrB(printer, getV1());
 // ATTR: }
 
 def AttrB : TestAttr<"TestB"> {
   let parameters = (ins
       AttrParamA:$v0,
       AttrParamB:$v1
   );
 
   let mnemonic = "attr_b";
   let assemblyFormat = "`{` struct($v0, $v1) `}`";
 }
 
 /// Test attribute with capture-all params has correct parser and printer.
 
-// ATTR: ::mlir::Attribute TestFAttr::parse(::mlir::DialectAsmParser &parser,
+// ATTR: ::mlir::Attribute TestFAttr::parse(::mlir::AsmParser &parser,
 // ATTR:                                    ::mlir::Type attrType) {
 // ATTR:   ::mlir::FailureOr<int> _result_v0;
 // ATTR:   ::mlir::FailureOr<int> _result_v1;
 // ATTR:   _result_v0 = ::mlir::FieldParser<int>::parse(parser);
 // ATTR:   if (failed(_result_v0))
 // ATTR:     return {};
 // ATTR:   if (parser.parseComma())
 // ATTR:     return {};
 // ATTR:   _result_v1 = ::mlir::FieldParser<int>::parse(parser);
 // ATTR:   if (failed(_result_v1))
 // ATTR:     return {};
 // ATTR:   return TestFAttr::get(parser.getContext(),
 // ATTR:     _result_v0.getValue(),
 // ATTR:     _result_v1.getValue());
 // ATTR: }
 
-// ATTR: void TestFAttr::print(::mlir::DialectAsmPrinter &printer) const {
+// ATTR: void TestFAttr::print(::mlir::AsmPrinter &printer) const {
 // ATTR:   printer << ' ';
 // ATTR:   printer << getV0();
 // ATTR:   printer << ",";
 // ATTR:   printer << ' ';
 // ATTR:   printer << getV1();
 // ATTR: }
 
 def AttrC : TestAttr<"TestF"> {
   let parameters = (ins "int":$v0, "int":$v1);
 
   let mnemonic = "attr_c";
   let assemblyFormat = "params";
 }
 
 /// Test type parser and printer that mix variables and struct are generated
 /// correctly.
 
-// TYPE: ::mlir::Type TestCType::parse(::mlir::DialectAsmParser &parser) {
+// TYPE: ::mlir::Type TestCType::parse(::mlir::AsmParser &parser) {
 // TYPE:  FailureOr<IntegerAttr> _result_value;
 // TYPE:  FailureOr<TestParamC> _result_complex;
 // TYPE:  if (parser.parseKeyword("foo"))
 // TYPE:    return {};
 // TYPE:  if (parser.parseComma())
 // TYPE:    return {};
 // TYPE:  if (parser.parseColon())
 // TYPE:    return {};

 // TYPE:    }
 // TYPE:    if ((_index != 1 - 1) && parser.parseComma())
 // TYPE:      return {};
 // TYPE:  }
 // TYPE:  if (parser.parseRParen())
 // TYPE:    return {};
 // TYPE:  }
 
-// TYPE: void TestCType::print(::mlir::DialectAsmPrinter &printer) const {
+// TYPE: void TestCType::print(::mlir::AsmPrinter &printer) const {
 // TYPE:   printer << ' ' << "foo";
 // TYPE:   printer << ",";
 // TYPE:   printer << ' ' << ":";
 // TYPE:   printer << ' ' << "bob";
 // TYPE:   printer << ' ' << "bar";
 // TYPE:   printer << ' ';
 // TYPE:   printer << getValue();
 // TYPE:   printer << ' ' << "complex";
def TypeA : TestType<"TestC"> {
 
   let mnemonic = "type_c";
   let assemblyFormat = "`foo` `,` `:` `bob` `bar` $value struct($complex) `)`";
 }
 
 /// Test type parser and printer with mix of variables and struct are generated
 /// correctly.
 
-// TYPE: ::mlir::Type TestDType::parse(::mlir::DialectAsmParser &parser) {
+// TYPE: ::mlir::Type TestDType::parse(::mlir::AsmParser &parser) {
 // TYPE:   _result_v0 = ::parseTypeParamC(parser);
 // TYPE:   if (failed(_result_v0))
 // TYPE:     return {};
 // TYPE:   bool _seen_v1 = false;
 // TYPE:   bool _seen_v2 = false;
 // TYPE:   for (unsigned _index = 0; _index < 2; ++_index) {
 // TYPE:     StringRef _paramKey;
 // TYPE:     if (parser.parseKeyword(&_paramKey))

 // TYPE:     return {};
 // TYPE:   return TestDType::get(parser.getContext(),
 // TYPE:                         _result_v0.getValue(),
 // TYPE:                         _result_v1.getValue(),
 // TYPE:                         _result_v2.getValue(),
 // TYPE:                         _result_v3.getValue());
 // TYPE: }
 
-// TYPE: void TestDType::print(::mlir::DialectAsmPrinter &printer) const {
+// TYPE: void TestDType::print(::mlir::AsmPrinter &printer) const {
 // TYPE:   printer << getV0();
 // TYPE:   myPrinter(getV1());
 // TYPE:   printer << ' ' << "v2";
 // TYPE:   printer << ' ' << "=";
 // TYPE:   printer << ' ';
 // TYPE:   printer << getV2();
 // TYPE:   myPrinter(getV3());
 // TYPE: }
 
 def TypeB : TestType<"TestD"> {
   let parameters = (ins
       TypeParamA:$v0,
       TypeParamB:$v1,
       TypeParamA:$v2,
       TypeParamB:$v3
   );
 
   let mnemonic = "type_d";
   let assemblyFormat = "`<` `foo` `:` $v0 `,` struct($v1, $v2) `,` $v3 `>`";
 }
 
 /// Type test with two struct directives has correctly generated parser and
 /// printer.
 
-// TYPE: ::mlir::Type TestEType::parse(::mlir::DialectAsmParser &parser) {
+// TYPE: ::mlir::Type TestEType::parse(::mlir::AsmParser &parser) {
 // TYPE:   FailureOr<IntegerAttr> _result_v0;
 // TYPE:   FailureOr<IntegerAttr> _result_v1;
 // TYPE:   FailureOr<IntegerAttr> _result_v2;
 // TYPE:   FailureOr<IntegerAttr> _result_v3;
 // TYPE:   bool _seen_v0 = false;
 // TYPE:   bool _seen_v2 = false;
 // TYPE:   for (unsigned _index = 0; _index < 2; ++_index) {
 // TYPE:     StringRef _paramKey;

 // TYPE:   }
 // TYPE:   return TestEType::get(parser.getContext(),
 // TYPE:     _result_v0.getValue(),
 // TYPE:     _result_v1.getValue(),
 // TYPE:     _result_v2.getValue(),
 // TYPE:     _result_v3.getValue());
 // TYPE: }
 
-// TYPE: void TestEType::print(::mlir::DialectAsmPrinter &printer) const {
+// TYPE: void TestEType::print(::mlir::AsmPrinter &printer) const {
 // TYPE:   printer << "v0";
 // TYPE:   printer << ' ' << "=";
 // TYPE:   printer << ' ';
 // TYPE:   printer << getV0();
 // TYPE:   printer << ",";
 // TYPE:   printer << ' ' << "v2";
 // TYPE:   printer << ' ' << "=";
 // TYPE:   printer << ' ';

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(
-// DEF-NEXT: ::mlir::DialectAsmParser &parser,
+// DEF-NEXT: ::mlir::AsmParser &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(parser, type);
 // DEF-NEXT: return ::mlir::success(!!value);
 // DEF-NEXT: }
 // DEF-NEXT: if (mnemonic == ::test::IndexAttr::getMnemonic()) {
 // DEF-NEXT:   value = ::test::IndexAttr::parse(parser, type);

 
 // 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(
-// DECL-SAME: ::mlir::DialectAsmParser &parser, ::mlir::Type type);
-// DECL: void print(::mlir::DialectAsmPrinter &printer) const;
+// DECL-SAME: ::mlir::AsmParser &parser, ::mlir::Type type);
+// DECL: void print(::mlir::AsmPrinter &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 (
 // DEF-NEXT: : ::mlir::AttributeStorage(inner),
let parameters = (
       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(
-// DECL-SAME: ::mlir::DialectAsmParser &parser, ::mlir::Type type);
-// DECL: void print(::mlir::DialectAsmPrinter &printer) const;
+// DECL-SAME: ::mlir::AsmParser &parser, ::mlir::Type type);
+// DECL: void print(::mlir::AsmPrinter &printer) const;
 }
 
 def D_SingleParameterAttr : TestAttr<"SingleParameter"> {
   let parameters = (
     ins
     "int": $num
   );
 // DECL-LABEL: struct SingleParameterAttrStorage;

mlir/test/mlir-tblgen/typedefs.td

 // RUN: mlir-tblgen -gen-typedef-decls -I %S/../../include %s | FileCheck %s --check-prefix=DECL
 // RUN: mlir-tblgen -gen-typedef-defs -I %S/../../include %s | FileCheck %s --check-prefix=DEF
 
 include "mlir/IR/OpBase.td"
 
 // DECL: #ifdef GET_TYPEDEF_CLASSES
 // DECL: #undef GET_TYPEDEF_CLASSES
 
 // DECL: namespace mlir {
-// DECL: class DialectAsmParser;
-// DECL: class DialectAsmPrinter;
+// DECL: class AsmParser;
+// DECL: class AsmPrinter;
 // DECL: } // namespace mlir
 
 // 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(
-// DEF-NEXT: ::mlir::DialectAsmParser &parser,
+// DEF-NEXT: ::mlir::AsmParser &parser,
 // DEF-NEXT: ::llvm::StringRef mnemonic,
 // DEF-NEXT: ::mlir::Type &value) {
 // DEF: if (mnemonic == ::test::CompoundAType::getMnemonic()) {
 // 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(parser);
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::DialectAsmParser &parser);
-// DECL: void print(::mlir::DialectAsmPrinter &printer) const;
+// DECL: static ::mlir::Type parse(::mlir::AsmParser &parser);
+// DECL: void print(::mlir::AsmPrinter &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::DialectAsmParser &parser);
-// DECL: void print(::mlir::DialectAsmPrinter &printer) const;
+// DECL: static ::mlir::Type parse(::mlir::AsmParser &parser);
+// DECL: void print(::mlir::AsmPrinter &printer) const;
 }
 
 def D_SingleParameterType : TestType<"SingleParameter"> {
   let parameters = (
     ins
     "int": $num
   );
 // DECL-LABEL: struct SingleParameterTypeStorage;

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

 //===----------------------------------------------------------------------===//
 // GEN: Declarations
 //===----------------------------------------------------------------------===//
 
 /// Print this above all the other declarations. Contains type declarations used
 /// later on.
 static const char *const typeDefDeclHeader = R"(
 namespace mlir {
+class AsmParser;
 class DialectAsmParser;
+class AsmPrinter;
 class DialectAsmPrinter;
 } // namespace mlir
 )";
 
 /// The code block for the start of a typeDef class declaration -- singleton
 /// case.
 ///
 /// {0}: The name of the def class.

 
 )";
 
 /// 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::DialectAsmParser &parser{1});
-    void print(::mlir::DialectAsmPrinter &printer) const;
+    static ::mlir::{0} parse(::mlir::AsmParser &parser{1});
+    void print(::mlir::AsmPrinter &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;
     static ::mlir::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError{0});

 //===----------------------------------------------------------------------===//
 
 /// 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::DialectAsmParser &parser,
+                                      ::mlir::AsmParser &parser,
                                       ::llvm::StringRef mnemonic{1},
                                       ::mlir::{0} &value) {{
 )";
 
 /// The code block for default attribute parser/printer dispatch boilerplate.
 /// {0}: the dialect fully qualified class name.
 static const char *const dialectDefaultAttrPrinterParserDispatch = R"(
 /// Parse an attribute registered to this dialect.

 }
 )";
 
 /// The code block used to start the auto-generated printer function.
 ///
 /// {0}: The name of the base value type, e.g. Attribute or Type.
 static const char *const defPrinterDispatchStartStr = R"(
 static ::mlir::LogicalResult generated{0}Printer(
-                         ::mlir::{0} def, ::mlir::DialectAsmPrinter &printer) {{
+                         ::mlir::{0} def, ::mlir::AsmPrinter &printer) {{
   return ::llvm::TypeSwitch<::mlir::{0}, ::mlir::LogicalResult>(def)
 )";
 
 /// Beginning of storage class.
 /// {0}: Storage class namespace.
 /// {1}: Storage class c++ name.
 /// {2}: Parameters parameters.
 /// {3}: Parameter initializer string.
if (assemblyFormat) {
     return generateAttrOrTypeFormat(def, os);
   }
 
   // Emit the printer code, if specified.
   if (printerCode) {
     // Both the mnenomic and printerCode must be defined (for parity with
     // parserCode).
     os << "void " << def.getCppClassName()
-       << "::print(::mlir::DialectAsmPrinter &printer) const {\n";
+       << "::print(::mlir::AsmPrinter &printer) const {\n";
     if (printerCode->empty()) {
       // If no code specified, emit error.
       PrintFatalError(def.getLoc(),
                       def.getName() +
                           ": printer (if specified) must have non-empty code");
     }
     FmtContext fmtCtxt = FmtContext().addSubst("_printer", "printer");
     os << tgfmt(*printerCode, &fmtCtxt) << "\n}\n";
   }
 
   // Emit the parser code, if specified.
   if (parserCode) {
     FmtContext fmtCtxt;
     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::DialectAsmParser &parser",
+                        "::mlir::AsmParser &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";
 

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

 //===----------------------------------------------------------------------===//
 // Format Strings
 //===----------------------------------------------------------------------===//
 
 /// Format for defining an attribute parser.
 ///
 /// $0: The attribute C++ class name.
 static const char *const attrParserDefn = R"(
-::mlir::Attribute $0::parse(::mlir::DialectAsmParser &$_parser,
+::mlir::Attribute $0::parse(::mlir::AsmParser &$_parser,
                              ::mlir::Type $_type) {
 )";
 
 /// Format for defining a type parser.
 ///
 /// $0: The type C++ class name.
 static const char *const typeParserDefn = R"(
-::mlir::Type $0::parse(::mlir::DialectAsmParser &$_parser) {
+::mlir::Type $0::parse(::mlir::AsmParser &$_parser) {
 )";
 
 /// Default parser for attribute or type parameters.
 static const char *const defaultParameterParser =
     "::mlir::FieldParser<$0>::parse($_parser)";
 
 /// Default printer for attribute or type parameters.
 static const char *const defaultParameterPrinter = "$_printer << $_self";
 
 /// Print an error when failing to parse an element.
 ///
 /// $0: The parameter C++ class name.
 static const char *const parseErrorStr =
     "$_parser.emitError($_parser.getCurrentLocation(), ";
 
 /// Format for defining an attribute or type printer.
 ///
 /// $0: The attribute or type C++ class name.
 static const char *const attrOrTypePrinterDefn = R"(
-void $0::print(::mlir::DialectAsmPrinter &$_printer) const {
+void $0::print(::mlir::AsmPrinter &$_printer) const {
 )";
 
 /// Loop declaration for struct parser.
 ///
 /// $0: Number of expected parameters.
 static const char *const structParseLoopStart = R"(
   for (unsigned _index = 0; _index < $0; ++_index) {
     StringRef _paramKey;