[mlir] Refactor how parser/printers are specified for AttrDef/TypeDef

[rriddle]

Summary

There is currently an awkwardly complex set of rules for how a
parser/printer is generated for AttrDef/TypeDef. It can change depending on if a
mnemonic was specified, if there are parameters, if using the assemblyFormat, if
individual parser/printer code blocks were specified, etc. This commit refactors
this to make what the attribute/type wants more explicit, and to better align
with how formats are specified for operations.

Firstly, the parser/printer code blocks are removed in favor of a
hasCustomAssemblyFormat bit field. This aligns with the operation format
specification (and is nice to remove code blocks from ODS).

This commit also adds a requirement to explicitly set assemblyFormat or
hasCustomAssemblyFormat when the mnemonic is set and the attr/type
has no parameters. This removes the weird implicit matrix of behavior,
and also encourages the author to make a conscious choice of either C++
or declarative format instead of implicitly opting them into the C++
format (we should be pushing towards declarative when possible).

Depends on D120011

[mehdi_amini]

mlir/test/lib/Dialect/Test/TestTypeDefs.td

123

You could have used the "extraClassDefinitions" to provide it as an example of inline definition, but it may not have been the intent here anyway

[rriddle]

mlir/test/lib/Dialect/Test/TestTypeDefs.td

123

Yeah, I've been strongly leaning towards just removing code out of tablegen unless we really need it.

flang/include/flang/Optimizer/Dialect/FIRTypes.td

let description = [{
     The type of a pair that describes a CHARACTER variable. Specifically, a
     CHARACTER consists of a reference to a buffer (the string value) and a LEN
     type parameter (the runtime length of the buffer).
   }];
 
   let parameters = (ins "KindTy":$kind);
 
   let genAccessors = 1;
+  let hasCustomAssemblyFormat = 1;
 
   let extraClassDeclaration = [{
     using KindTy = unsigned;
 
     // a !fir.boxchar<k> always wraps a !fir.char<k, ?>
     CharacterType getElementType(mlir::MLIRContext *context) const;
 
     CharacterType getEleTy() const;
   }];
 }
 
 def fir_BoxProcType : FIR_Type<"BoxProc", "boxproc"> {
   let summary = "";
 
   let description = [{
     The type of a pair that describes a PROCEDURE reference. Pointers to
     internal procedures must carry an additional reference to the host's
     variables that are referenced.
   }];
 
   let parameters = (ins "mlir::Type":$eleTy);
 
   let genVerifyDecl = 1;
+  let hasCustomAssemblyFormat = 1;
 }
 
 def fir_BoxType : FIR_Type<"Box", "box"> {
   let summary = "The type of a Fortran descriptor";
 
   let description = [{
     Descriptors are tuples of information that describe an entity being passed
     from a calling context. This information might include (but is not limited
def fir_BoxType : FIR_Type<"Box", "box"> {
   ];
 
   let extraClassDeclaration = [{
     mlir::Type getElementType() const { return getEleTy(); }
     mlir::AffineMapAttr getLayoutMap() const { return getMap(); }
   }];
 
   let genVerifyDecl = 1;
+  let hasCustomAssemblyFormat = 1;
 }
 
 def fir_CharacterType : FIR_Type<"Character", "char"> {
   let summary = "FIR character type";
 
   let description = [{
     Model of the Fortran CHARACTER intrinsic type, including the KIND type
     parameter. The model optionally includes a LEN type parameter. A
     CharacterType is thus the type of both a single character value and a
     character with a LEN parameter.
   }];
 
   let parameters = (ins "KindTy":$FKind, "CharacterType::LenType":$len);
+  let hasCustomAssemblyFormat = 1;
 
   let extraClassDeclaration = [{
     using KindTy = unsigned;
     using LenType = std::int64_t;
 
     /// Return unknown length Character type. e.g., CHARACTER(LEN=n).
     static CharacterType getUnknownLen(mlir::MLIRContext *ctxt, KindTy kind) {
       return get(ctxt, kind, unknownLen());
def fir_ComplexType : FIR_Type<"Complex", "complex"> {
 
   let description = [{
     Model of a Fortran COMPLEX intrinsic type, including the KIND type
     parameter. COMPLEX is a floating point type with a real and imaginary
     member.
   }];
 
   let parameters = (ins "KindTy":$fKind);
+  let hasCustomAssemblyFormat = 1;
 
   let extraClassDeclaration = [{
     using KindTy = unsigned;
 
     mlir::Type getElementType() const;
   }];
 }
 
let description = [{
     may be allocated on the heap at runtime. These pointers are explicitly
     distinguished to disallow the composition of multiple levels of
     indirection. For example, an ALLOCATABLE POINTER is invalid.
   }];
 
   let parameters = (ins "mlir::Type":$eleTy);
 
   let genVerifyDecl = 1;
+  let hasCustomAssemblyFormat = 1;
 
   let skipDefaultBuilders = 1;
 
   let builders = [
     TypeBuilderWithInferredContext<(ins "mlir::Type":$elementType), [{
       assert(singleIndirectionLevel(elementType) && "invalid element type");
       return Base::get(elementType.getContext(), elementType);
     }]>,
   ];
 }
 
 def fir_IntegerType : FIR_Type<"Integer", "int"> {
   let summary = "FIR integer type";
 
   let description = [{
     Model of a Fortran INTEGER intrinsic type, including the KIND type
     parameter.
   }];
 
   let parameters = (ins "KindTy":$fKind);
+  let hasCustomAssemblyFormat = 1;
 
   let extraClassDeclaration = [{
     using KindTy = unsigned;
   }];
 }
 
 def fir_LenType : FIR_Type<"Len", "len"> {
   let summary = "A LEN parameter (in a RecordType) argument's type";
def fir_LogicalType : FIR_Type<"Logical", "logical"> {
   let summary = "FIR logical type";
 
   let description = [{
     Model of a Fortran LOGICAL intrinsic type, including the KIND type
     parameter.
   }];
 
   let parameters = (ins "KindTy":$fKind);
+  let hasCustomAssemblyFormat = 1;
 
   let extraClassDeclaration = [{
     using KindTy = unsigned;
   }];
 }
 
 def fir_LLVMPointerType : FIR_Type<"LLVMPointer", "llvm_ptr"> {
   let summary = "Like LLVM pointer type";
let description = [{
     The type of entities with the POINTER attribute.  These pointers are
     explicitly distinguished to disallow the composition of multiple levels of
     indirection. For example, an ALLOCATABLE POINTER is invalid.
   }];
 
   let parameters = (ins "mlir::Type":$eleTy);
 
   let genVerifyDecl = 1;
+  let hasCustomAssemblyFormat = 1;
 
   let skipDefaultBuilders = 1;
 
   let builders = [
     TypeBuilderWithInferredContext<(ins "mlir::Type":$elementType), [{
       assert(singleIndirectionLevel(elementType) && "invalid element type");
       return Base::get(elementType.getContext(), elementType);
     }]>,
   ];
 
   let extraClassDeclaration = [{
     mlir::Type getElementType() const { return getEleTy(); }
   }];
 }
 
 def fir_RealType : FIR_Type<"Real", "real"> {
   let summary = "FIR real type";
 
   let description = [{
     Model of a Fortran REAL (and DOUBLE PRECISION) intrinsic type, including the
     KIND type parameter.
   }];
 
   let parameters = (ins "KindTy":$fKind);
+  let hasCustomAssemblyFormat = 1;
 
   let extraClassDeclaration = [{
     using KindTy = unsigned;
   }];
 
   let genVerifyDecl = 1;
 }
 
 def fir_RecordType : FIR_Type<"Record", "type"> {
   let summary = "FIR derived type";
 
   let description = [{
     Model of Fortran's derived type, TYPE. The name of the TYPE includes any
     KIND type parameters. The record includes runtime slots for LEN type
     parameters and for data components.
   }];
 
   let parameters = (ins StringRefParameter<"name">:$name);
 
   let genVerifyDecl = 1;
   let genStorageClass = 0;
+  let hasCustomAssemblyFormat = 1;
 
   let extraClassDeclaration = [{
     using TypePair = std::pair<std::string, mlir::Type>;
     using TypeList = std::vector<TypePair>;
     TypeList getTypeList() const;
     TypeList getLenParamList() const;
 
     mlir::Type getType(llvm::StringRef ident);
let builders = [
     }]>,
   ];
 
   let extraClassDeclaration = [{
     mlir::Type getElementType() const { return getEleTy(); }
   }];
 
   let genVerifyDecl = 1;
+  let hasCustomAssemblyFormat = 1;
 }
 
 def fir_ShapeType : FIR_Type<"Shape", "shape"> {
   let summary = "shape of a multidimensional array object";
 
   let description = [{
     Type of a vector of runtime values that define the shape of a
     multidimensional array object. The vector is the extents of each array
     dimension. The rank of a ShapeType must be at least 1.
   }];
 
   let parameters = (ins "unsigned":$rank);
+  let hasCustomAssemblyFormat = 1;
 }
 
 def fir_ShapeShiftType : FIR_Type<"ShapeShift", "shapeshift"> {
   let summary = "shape and origin of a multidimensional array object";
 
   let description = [{
     Type of a vector of runtime values that define the shape and the origin of a
     multidimensional array object. The vector is of pairs, origin offset and
     extent, of each array dimension. The rank of a ShapeShiftType must be at
     least 1.
   }];
 
   let parameters = (ins "unsigned":$rank);
+  let hasCustomAssemblyFormat = 1;
 }
 
 def fir_ShiftType : FIR_Type<"Shift", "shift"> {
   let summary = "lower bounds of a multidimensional array object";
 
   let description = [{
     Type of a vector of runtime values that define the lower bounds of a
     multidimensional array object. The vector is the lower bounds of each array
     dimension. The rank of a ShiftType must be at least 1.
   }];
 
   let parameters = (ins "unsigned":$rank);
+  let hasCustomAssemblyFormat = 1;
 
   let extraClassDeclaration = [{
     using KindTy = unsigned;
 
     // a !fir.boxchar<k> always wraps a !fir.char<k, ?>
     CharacterType getElementType(mlir::MLIRContext *context) const;
 
     CharacterType getEleTy() const;
def fir_SequenceType : FIR_Type<"Sequence", "array"> {
 
   let parameters = (ins
     ArrayRefParameter<"int64_t", "Sequence shape">:$shape,
     "mlir::Type":$eleTy,
     "mlir::AffineMapAttr":$layoutMap
   );
 
   let genVerifyDecl = 1;
+  let hasCustomAssemblyFormat = 1;
 
   let builders = [
     TypeBuilderWithInferredContext<(ins
         "llvm::ArrayRef<int64_t>":$shape,
         "mlir::Type":$eleTy), [{
       return get(eleTy.getContext(), shape, eleTy, {});
     }]>,
     TypeBuilderWithInferredContext<(ins
def fir_SliceType : FIR_Type<"Slice", "slice"> {
 
   let description = [{
     Type of a vector that represents an array slice operation on an array.
     Fortran slices are triples of lower bound, upper bound, and stride. The rank
     of a SliceType must be at least 1.
   }];
 
   let parameters = (ins "unsigned":$rank);
+  let hasCustomAssemblyFormat = 1;
 }
 
 def fir_TypeDescType : FIR_Type<"TypeDesc", "tdesc"> {
   let summary = "FIR Type descriptor type";
 
   let description = [{
     The type of a type descriptor object. The runtime may generate type
     descriptor objects to determine the type of an entity at runtime, etc.
   }];
 
   let parameters = (ins "mlir::Type":$ofTy);
 
   let genVerifyDecl = 1;
+  let hasCustomAssemblyFormat = 1;
 
   let skipDefaultBuilders = 1;
 
   let builders = [
     TypeBuilderWithInferredContext<(ins "mlir::Type":$elementType), [{
       return Base::get(elementType.getContext(), elementType);
     }]>,
   ];
 }
 
 def fir_VectorType : FIR_Type<"Vector", "vector"> {
   let summary = "FIR vector type";
 
   let description = [{
     Replacement for the builtin vector type.
     The FIR vector type is always rank one. It's size is always a constant.
     A vector's element type must be real or integer.
   }];
 
   let parameters = (ins "uint64_t":$len, "mlir::Type":$eleTy);
 
   let genVerifyDecl = 1;
+  let hasCustomAssemblyFormat = 1;
 
   let extraClassDeclaration = [{
     static bool isValidElementType(mlir::Type t);
   }];
 
   let skipDefaultBuilders = 1;
 
   let builders = [

mlir/include/mlir/Dialect/Async/IR/AsyncTypes.td

def Async_ValueType : Async_Type<"Value", "value"> {
   }];
 
   let parameters = (ins "Type":$valueType);
   let builders = [
     TypeBuilderWithInferredContext<(ins "Type":$valueType), [{
       return $_get(valueType.getContext(), valueType);
     }]>
   ];
+  let hasCustomAssemblyFormat = 1;
   let skipDefaultBuilders = 1;
 }
 
 def Async_GroupType : Async_Type<"Group", "group"> {
   let summary = "async group type";
   let description = [{
     `async.group` represent a set of async tokens or values and allows to
     execute async operations on all of them together (e.g. wait for the

mlir/include/mlir/Dialect/EmitC/IR/EmitCAttributes.td

let description = [{
     ```mlir
     #emitc.opaque<"">
     #emitc.opaque<"NULL">
     #emitc.opaque<"nullptr">
     ```
   }];
 
   let parameters = (ins StringRefParameter<"the opaque value">:$value);
+  
+  let hasCustomAssemblyFormat = 1;
 }
 
 #endif // MLIR_DIALECT_EMITC_IR_EMITCATTRIBUTES

mlir/include/mlir/Dialect/EmitC/IR/EmitCTypes.td

let description = [{
     ```mlir
     !emitc.opaque<"int">
     !emitc.opaque<"mytype">
     !emitc.opaque<"std::vector<std::string>">
     ```
   }];
 
   let parameters = (ins StringRefParameter<"the opaque value">:$value);
+  let hasCustomAssemblyFormat = 1;
 }
 
 def EmitC_PointerType : EmitC_Type<"Pointer", "ptr"> {
   let summary = "EmitC pointer type";
 
   let description = [{
     A pointer data type.
 

mlir/include/mlir/Dialect/LLVMIR/LLVMAttrDefs.td

 // The "FastMath" flags associated with floating point LLVM instructions.
 def FastmathFlagsAttr : LLVM_Attr<"FMF"> {
   let mnemonic = "fastmath";
 
   // List of type parameters.
   let parameters = (ins
     "FastmathFlags":$flags
   );
+  let hasCustomAssemblyFormat = 1;
 }
 
 // Attribute definition for the LLVM Linkage enum.
 def LinkageAttr : LLVM_Attr<"Linkage"> {
   let mnemonic = "linkage";
   let parameters = (ins
     "linkage::Linkage":$linkage
   );
+  let hasCustomAssemblyFormat = 1;
 }
 
 def LoopOptionsAttr : LLVM_Attr<"LoopOptions"> {
   let mnemonic = "loopopts";
 
   let description = [{
     This attributes encapsulates "loop options". It is means to decorate
     branches that are "latches" (loop backedges) and maps to the `!llvm.loop`
let extraClassDeclaration = [{
     Optional<int64_t> interleaveCount();
   }];
 
   let builders = [
     /// Build the LoopOptions Attribute from a sorted array of individual options.
     AttrBuilder<(ins "ArrayRef<std::pair<LoopOptionCase, int64_t>>":$sortedOptions)>,
     AttrBuilder<(ins "LoopOptionsAttrBuilder &":$optionBuilders)>
   ];
+  let hasCustomAssemblyFormat = 1;
   let skipDefaultBuilders = 1;
 }
 
 #endif // LLVMIR_ATTRDEFS

mlir/include/mlir/Dialect/PDL/IR/PDLTypes.td

def PDL_Range : PDL_Type<"Range", "range"> {
   let parameters = (ins "Type":$elementType);
 
   let builders = [
     TypeBuilderWithInferredContext<(ins "Type":$elementType), [{
       return $_get(elementType.getContext(), elementType);
     }]>,
   ];
   let genVerifyDecl = 1;
+  let hasCustomAssemblyFormat = 1;
   let skipDefaultBuilders = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::TypeType
 //===----------------------------------------------------------------------===//
 
 def PDL_Type : PDL_Type<"Type", "type"> {

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorAttrDefs.td

let parameters = (
     // the memory footprint of overhead storage, as long as the width
     // suffices to define the total required range (viz. the maximum
     // value of each tensor index over all dimensions). The choices are `8`,
     // `16`, `32`, `64`, or `0` for a native width.
     "unsigned":$indexBitWidth
   );
 
   let genVerifyDecl = 1;
+  let hasCustomAssemblyFormat = 1;
 
   let extraClassDeclaration = [{
     // Dimension level types that define sparse tensors:
     //   Dense      - dimension is dense, every entry is stored
     //   Compressed - dimension is sparse, only nonzeros are stored
     //   Singleton  - dimension contains single coordinate, no siblings
     enum class DimLevelType {
       Dense, Compressed, Singleton
     };
   }];
 }
 
 #endif // SPARSETENSOR_ATTRDEFS

mlir/include/mlir/IR/AttrTypeBase.td

class AttrOrTypeDef<string valueType, string name, list<Trait> defTraits,
   // Note that builders should only be provided when a def has parameters.
   list<AttrOrTypeBuilder> builders = ?;
 
   // The list of traits attached to this def.
   list<Trait> traits = defTraits;
 
   // Use the lowercased name as the keyword for parsing/printing. Specify only
   // if you want tblgen to generate declarations and/or definitions of
-  // the printer/parser.
+  // the printer/parser. If specified and the Attribute or Type contains
+  // parameters, `assemblyFormat` or `hasCustomAssemblyFormat` must also be
+  // specified.
   string mnemonic = ?;
 
-  // If 'mnemonic' specified,
-  //   If null, generate just the declarations.
-  //   If a non-empty code block, just use that code as the definition code.
-  //   Error if an empty code block.
-  code printer = ?;
-  code parser = ?;
-
   // Custom assembly format. Requires 'mnemonic' to be specified. Cannot be
-  // specified at the same time as either 'printer' or 'parser'. The generated
+  // specified at the same time as 'hasCustomAssemblyFormat'. The generated
   // printer requires 'genAccessors' to be true.
   string assemblyFormat = ?;
+  /// This field indicates that the attribute or type has a custom assembly format
+  /// implemented in C++. When set to `1` a `parse` and `print` method are generated
+  /// on the generated class. The attribute or type should implement these methods to
+  /// support the custom format.
+  bit hasCustomAssemblyFormat = 0;
 
   // If set, generate accessors for each parameter.
   bit genAccessors = 1;
 
   // Avoid generating default get/getChecked functions. Custom get methods must
   // be provided.
   bit skipDefaultBuilders = 0;
 

mlir/include/mlir/TableGen/AttrOrTypeDef.h

public:
 
   /// Return the number of parameters
   unsigned getNumParameters() const;
 
   /// Return the keyword/mnemonic to use in the printer/parser methods if we are
   /// supposed to auto-generate them.
   Optional<StringRef> getMnemonic() const;
 
-  /// Returns the code to use as the types printer method. If not specified,
-  /// return a non-value. Otherwise, return the contents of that code block.
-  Optional<StringRef> getPrinterCode() const;
-
-  /// Returns the code to use as the parser method. If not specified, returns
-  /// None. Otherwise, returns the contents of that code block.
-  Optional<StringRef> getParserCode() const;
+  /// Returns if the attribute or type has a custom assembly format implemented
+  /// in C++. Corresponds to the `hasCustomAssemblyFormat` field.
+  bool hasCustomAssemblyFormat() const;
 
   /// Returns the custom assembly format, if one was specified.
   Optional<StringRef> getAssemblyFormat() const;
 
-  /// An attribute or type with parameters needs a parser.
-  bool needsParserPrinter() const { return getNumParameters() != 0; }
-
-  /// Returns true if this attribute or type has a generated parser.
-  bool hasGeneratedParser() const {
-    return getParserCode() || getAssemblyFormat();
-  }
-
-  /// Returns true if this attribute or type has a generated printer.
-  bool hasGeneratedPrinter() const {
-    return getPrinterCode() || getAssemblyFormat();
-  }
-
   /// Returns true if the accessors based on the parameters should be generated.
   bool genAccessors() const;
 
   /// Return true if we need to generate the verify declaration and getChecked
   /// method.
   bool genVerifyDecl() const;
 
   /// Returns the def's extra class declaration code.

mlir/lib/TableGen/AttrOrTypeDef.cpp

for (auto *traitInit : *traitList)
         traits.push_back(Trait::create(traitInit));
   }
 
   // Populate the parameters.
   if (auto *parametersDag = def->getValueAsDag("parameters")) {
     for (unsigned i = 0, e = parametersDag->getNumArgs(); i < e; ++i)
       parameters.push_back(AttrOrTypeParameter(parametersDag, i));
   }
+
+  // Verify the use of the mnemonic field.
+  bool hasCppFormat = hasCustomAssemblyFormat();
+  bool hasDeclarativeFormat = getAssemblyFormat().hasValue();
+  if (getMnemonic()) {
+    if (hasCppFormat && hasDeclarativeFormat) {
+      PrintFatalError(getLoc(), "cannot specify both 'assemblyFormat' "
+                                "and 'hasCustomAssemblyFormat'");
+    }
+    if (!parameters.empty() && !hasCppFormat && !hasDeclarativeFormat) {
+      PrintFatalError(getLoc(),
+                      "must specify either 'assemblyFormat' or "
+                      "'hasCustomAssemblyFormat' when 'mnemonic' is set");
+    }
+  } else if (hasCppFormat || hasDeclarativeFormat) {
+    PrintFatalError(getLoc(),
+                    "'assemblyFormat' or 'hasCustomAssemblyFormat' can only be "
+                    "used when 'mnemonic' is set");
+  }
+  // Assembly format requires accessors to be generated.
+  if (hasDeclarativeFormat && !genAccessors()) {
+    PrintFatalError(getLoc(),
+                    "'assemblyFormat' requires 'genAccessors' to be true");
+  }
 }
 
 Dialect AttrOrTypeDef::getDialect() const {
   auto *dialect = dyn_cast<llvm::DefInit>(def->getValue("dialect")->getValue());
   return Dialect(dialect ? dialect->getDef() : nullptr);
 }
 
 StringRef AttrOrTypeDef::getName() const { return def->getName(); }
unsigned AttrOrTypeDef::getNumParameters() const {
   auto *parametersDag = def->getValueAsDag("parameters");
   return parametersDag ? parametersDag->getNumArgs() : 0;
 }
 
 Optional<StringRef> AttrOrTypeDef::getMnemonic() const {
   return def->getValueAsOptionalString("mnemonic");
 }
 
-Optional<StringRef> AttrOrTypeDef::getPrinterCode() const {
-  return def->getValueAsOptionalString("printer");
-}
-
-Optional<StringRef> AttrOrTypeDef::getParserCode() const {
-  return def->getValueAsOptionalString("parser");
+bool AttrOrTypeDef::hasCustomAssemblyFormat() const {
+  return def->getValueAsBit("hasCustomAssemblyFormat");
 }
 
 Optional<StringRef> AttrOrTypeDef::getAssemblyFormat() const {
   return def->getValueAsOptionalString("assemblyFormat");
 }
 
 bool AttrOrTypeDef::genAccessors() const {
   return def->getValueAsBit("genAccessors");

mlir/test/lib/Dialect/Test/TestAttrDefs.td

let parameters = (
     "::mlir::Type":$oneType,
     // This is special syntax since ArrayRefs require allocation in the
     // constructor.
     ArrayRefParameter<
       "int", // The parameter C++ type.
       "An example of an array of ints" // Parameter description.
       >: $arrayOfInts
   );
+  let hasCustomAssemblyFormat = 1;
 }
 def CompoundAttrNested : Test_Attr<"CompoundAttrNested"> {
   let mnemonic = "cmpnd_nested";
   let parameters = (ins CompoundAttrA : $nested );
   let assemblyFormat = "`<` `nested` `=` $nested `>`";
 }
 
 // An attribute testing AttributeSelfTypeParameter.
 def AttrWithSelfTypeParam : Test_Attr<"AttrWithSelfTypeParam"> {
   let mnemonic = "attr_with_self_type_param";
   let parameters = (ins AttributeSelfTypeParameter<"">:$type);
+  let hasCustomAssemblyFormat = 1;
 }
 
 // An attribute testing AttributeSelfTypeParameter.
 def AttrWithTypeBuilder : Test_Attr<"AttrWithTypeBuilder"> {
   let mnemonic = "attr_with_type_builder";
   let parameters = (ins "::mlir::IntegerAttr":$attr);
   let typeBuilder = "$_attr.getType()";
+  let hasCustomAssemblyFormat = 1;
 }
 
 def TestAttrTrait : NativeAttrTrait<"TestAttrTrait">;
 
 // The definition of a singleton attribute that has a trait.
 def AttrWithTrait : Test_Attr<"AttrWithTrait", [TestAttrTrait]> {
   let mnemonic = "attr_with_trait";
-  let parameters = (ins );
 }
 
 // Test support for ElementsAttrInterface.
 def TestI64ElementsAttr : Test_Attr<"TestI64Elements", [
     ElementsAttrInterface
   ]> {
   let mnemonic = "i64_elements";
   let parameters = (ins
let extraClassDeclaration = [{
     // * APInt
     auto value_begin_impl(OverloadToken<llvm::APInt>) const {
       return llvm::map_range(getElements(), [=](uint64_t value) {
         return llvm::APInt(/*numBits=*/64, value);
       }).begin();
     }
   }];
   let genVerifyDecl = 1;
+  let hasCustomAssemblyFormat = 1;
 }
 
 def TestSubElementsAccessAttr : Test_Attr<"TestSubElementsAccess", [
     DeclareAttrInterfaceMethods<SubElementAttrInterface,
         ["replaceImmediateSubAttribute"]>
   ]> {
 
   let mnemonic = "sub_elements_access";
 
   let parameters = (ins
     "::mlir::Attribute":$first,
     "::mlir::Attribute":$second,
     "::mlir::Attribute":$third
   );
+  let hasCustomAssemblyFormat = 1;
 }
 
 // A more complex parameterized attribute with multiple level of nesting.
 def CompoundNestedInner : Test_Attr<"CompoundNestedInner"> {
   let mnemonic = "cmpnd_nested_inner";
   // List of type parameters.
   let parameters = (
     ins

mlir/test/lib/Dialect/Test/TestTypeDefs.td

ArrayRefParameter<
       "int", // The parameter C++ type.
       "An example of an array of ints" // Parameter description.
     >:$arrayOfInts
   );
 
   let extraClassDeclaration = [{
     struct SomeCppStruct {};
   }];
+  let hasCustomAssemblyFormat = 1;
 }
 
 // A more complex and nested parameterized type.
 def CompoundNestedInnerType : Test_Type<"CompoundNestedInner"> {
   let mnemonic = "cmpnd_inner";
   // List of type parameters.
   let parameters = (
     ins
def IntegerType : Test_Type<"TestInteger"> {
   let genVerifyDecl = 1;
   let parameters = (
     ins
     "unsigned":$width,
     // SignednessSemantics is defined below.
     "::test::TestIntegerType::SignednessSemantics":$signedness
   );
 
-  // We define the printer inline.
-  let printer = [{
-    $_printer << "<";
-    printSignedness($_printer, getImpl()->signedness);
-    $_printer << ", " << getImpl()->width << ">";
-  }];
+  // Indicate we use a custom format.
+  let hasCustomAssemblyFormat = 1;
 
   // Define custom builder methods.
   let builders = [
     TypeBuilder<(ins "unsigned":$width,
                      CArg<"SignednessSemantics", "Signless">:$signedness), [{
       return $_get($_ctxt, width, signedness);
     }]>
   ];
   let skipDefaultBuilders = 1;
 
-  // The parser is defined here also.
-  let parser = [{
-    if ($_parser.parseLess()) return Type();
-    SignednessSemantics signedness;
-    if (parseSignedness($_parser, signedness)) return Type();
-    if ($_parser.parseComma()) return Type();
-    int width;
-    if ($_parser.parseInteger(width)) return Type();
-    if ($_parser.parseGreater()) return Type();
-    Location loc = $_parser.getEncodedSourceLoc($_parser.getNameLoc());
-    return getChecked(loc, loc.getContext(), width, signedness);
-  }];
-
   // Any extra code one wants in the type's class declaration.
   let extraClassDeclaration = [{
     /// Signedness semantics.
     enum SignednessSemantics {
       Signless, /// No signedness semantics
       Signed,   /// Signed integer
       Unsigned, /// Unsigned integer
     };
class FieldInfo_Type<string name> : Test_Type<name> {
   let parameters = (
     ins
     // An ArrayRef of something which requires allocation in the storage
     // constructor.
     ArrayRefOfSelfAllocationParameter<
       "::test::FieldInfo", // FieldInfo is defined/declared in TestTypes.h.
       "Models struct fields">: $fields
   );
-
-  // Prints the type in this format:
-  //   struct<[{field1Name, field1Type}, {field2Name, field2Type}]
-  let printer = [{
-    $_printer << "<";
-    for (size_t i=0, e = getImpl()->fields.size(); i < e; i++) {
-      const auto& field = getImpl()->fields[i];
-      $_printer << "{" << field.name << "," << field.type << "}";
-      if (i < getImpl()->fields.size() - 1)
-          $_printer << ",";
-    }
-    $_printer << ">";
-  }];
-
-  // Parses the above format
-  let parser = [{
-    llvm::SmallVector<FieldInfo, 4> parameters;
-    if ($_parser.parseLess()) return Type();
-    while (mlir::succeeded($_parser.parseOptionalLBrace())) {
-      llvm::StringRef name;
-      if ($_parser.parseKeyword(&name)) return Type();
-      if ($_parser.parseComma()) return Type();
-      Type type;
-      if ($_parser.parseType(type)) return Type();
-      if ($_parser.parseRBrace()) return Type();
-      parameters.push_back(FieldInfo {name, type});
-      if ($_parser.parseOptionalComma()) break;
-    }
-    if ($_parser.parseGreater()) return Type();
-    return get($_ctxt, parameters);
-  }];
+  let hasCustomAssemblyFormat = 1;
 }
 
 def StructType : FieldInfo_Type<"Struct"> {
     let mnemonic = "struct";
 }
 
 def TestType : Test_Type<"Test", [
   DeclareTypeInterfaceMethods<TestTypeInterface>
::mlir::LogicalResult verifyEntries(::mlir::DataLayoutEntryListRef params,
                                 ::mlir::Location loc) const;
 
   private:
     unsigned extractKind(::mlir::DataLayoutEntryListRef params,
                          ::llvm::StringRef expectedKind) const;
 
   public:
   }];
+  let hasCustomAssemblyFormat = 1;
 }
 
 def TestMemRefElementType : Test_Type<"TestMemRefElementType",
                                       [MemRefElementTypeInterface]> {
   let mnemonic = "memref_element";
 }
 
 def TestTypeTrait : NativeTypeTrait<"TestTypeTrait">;

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

 }
 
 // FieldInfo is used as part of a parameter, so a hash will be computed.
 static llvm::hash_code test::hash_value(const FieldInfo &fi) { // NOLINT
   return llvm::hash_combine(fi.name, fi.type);
 }
 
 //===----------------------------------------------------------------------===//
+// Tablegen Generated Definitions
+//===----------------------------------------------------------------------===//
+
+#define GET_TYPEDEF_CLASSES
+#include "TestTypeDefs.cpp.inc"
+
+//===----------------------------------------------------------------------===//
 // CompoundAType
 //===----------------------------------------------------------------------===//
 
 Type CompoundAType::parse(AsmParser &parser) {
   int widthOfSomething;
   Type oneType;
   SmallVector<int, 4> arrayOfInts;
   if (parser.parseLess() || parser.parseInteger(widthOfSomething) ||

 TestIntegerType::verify(function_ref<InFlightDiagnostic()> emitError,
                         unsigned width,
                         TestIntegerType::SignednessSemantics ss) {
   if (width > 8)
     return failure();
   return success();
 }
 
+Type TestIntegerType::parse(AsmParser &parser) {
+  SignednessSemantics signedness;
+  int width;
+  if (parser.parseLess() || parseSignedness(parser, signedness) ||
+      parser.parseComma() || parser.parseInteger(width) ||
+      parser.parseGreater())
+    return Type();
+  Location loc = parser.getEncodedSourceLoc(parser.getNameLoc());
+  return getChecked(loc, loc.getContext(), width, signedness);
+}
+
+void TestIntegerType::print(AsmPrinter &p) const {
+  p << "<";
+  printSignedness(p, getSignedness());
+  p << ", " << getWidth() << ">";
+}
+
+//===----------------------------------------------------------------------===//
+// TestStructType
+//===----------------------------------------------------------------------===//
+
+Type StructType::parse(AsmParser &p) {
+  SmallVector<FieldInfo, 4> parameters;
+  if (p.parseLess())
+    return Type();
+  while (succeeded(p.parseOptionalLBrace())) {
+    Type type;
+    StringRef name;
+    if (p.parseKeyword(&name) || p.parseComma() || p.parseType(type) ||
+        p.parseRBrace())
+      return Type();
+    parameters.push_back(FieldInfo{name, type});
+    if (p.parseOptionalComma())
+      break;
+  }
+  if (p.parseGreater())
+    return Type();
+  return get(p.getContext(), parameters);
+}
+
+void StructType::print(AsmPrinter &p) const {
+  p << "<";
+  llvm::interleaveComma(getFields(), p, [&](const FieldInfo &field) {
+    p << "{" << field.name << "," << field.type << "}";
+  });
+  p << ">";
+}
+
 //===----------------------------------------------------------------------===//
 // TestType
 //===----------------------------------------------------------------------===//
 
 void TestType::printTypeC(Location loc) const {
   emitRemark(loc) << *this << " - TestC";
 }
 
for (DataLayoutEntryInterface entry : params) {
     StringRef kind = pair.front().cast<StringAttr>().getValue();
     if (kind == expectedKind)
       return pair.back().cast<IntegerAttr>().getValue().getZExtValue();
   }
   return 1;
 }
 
 //===----------------------------------------------------------------------===//
-// Tablegen Generated Definitions
-//===----------------------------------------------------------------------===//
-
-#define GET_TYPEDEF_CLASSES
-#include "TestTypeDefs.cpp.inc"
-
-//===----------------------------------------------------------------------===//
 // TestDialect
 //===----------------------------------------------------------------------===//
 
 namespace {
 
 struct PtrElementModel
     : public LLVM::PointerElementTypeInterface::ExternalModel<PtrElementModel,
                                                               SimpleAType> {};

mlir/test/mlir-tblgen/attrdefs.td

let parameters = (
       "int":$widthOfSomething,
       "::test::SimpleTypeA": $exampleTdType,
       APFloatParameter<"">: $apFloat,
       ArrayRefParameter<"int", "Matrix dimensions">:$dims,
       AttributeSelfTypeParameter<"">:$inner
   );
 
   let genVerifyDecl = 1;
+  let hasCustomAssemblyFormat = 1;
 
 // DECL-LABEL: class CompoundAAttr : public ::mlir::Attribute
 // DECL: static CompoundAAttr getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, int widthOfSomething, ::test::SimpleTypeA exampleTdType, ::llvm::APFloat apFloat, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
 // DECL: static ::mlir::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, int widthOfSomething, ::test::SimpleTypeA exampleTdType, ::llvm::APFloat apFloat, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
 // DECL: static constexpr ::llvm::StringLiteral getMnemonic() {
 // DECL:   return {"cmpnd_a"};
 // DECL: }
 // DECL: static ::mlir::Attribute parse(

 
 def C_IndexAttr : TestAttr<"Index"> {
     let mnemonic = "index";
 
     let parameters = (
       ins
       StringRefParameter<"Label for index">:$label
     );
+  let hasCustomAssemblyFormat = 1;
 
 // DECL-LABEL: class IndexAttr : public ::mlir::Attribute
 // DECL: static constexpr ::llvm::StringLiteral getMnemonic() {
 // DECL:   return {"index"};
 // DECL: }
 // DECL: static ::mlir::Attribute parse(
 // DECL-SAME: ::mlir::AsmParser &odsParser, ::mlir::Type odsType);
 // DECL: void print(::mlir::AsmPrinter &odsPrinter) const;

 // DECL-SAME:  detail::SingleParameterAttrStorage
 }
 
 // An attribute testing AttributeSelfTypeParameter.
 def E_AttrWithTypeBuilder : TestAttr<"AttrWithTypeBuilder"> {
   let mnemonic = "attr_with_type_builder";
   let parameters = (ins "::mlir::IntegerAttr":$attr);
   let typeBuilder = "$_attr.getType()";
+  let hasCustomAssemblyFormat = 1;
 }
 
 // DEF-LABEL: struct AttrWithTypeBuilderAttrStorage
 // DEF: AttrWithTypeBuilderAttrStorage(::mlir::IntegerAttr attr)
 // DEF-SAME: : ::mlir::AttributeStorage(attr.getType()), attr(attr)
 
 def F_ParamWithAccessorTypeAttr : TestAttr<"ParamWithAccessorType"> {
   let parameters = (ins AttrParameter<"std::string", "", "StringRef">:$param);
 }
 
 // DECL-LABEL: class ParamWithAccessorTypeAttr
 // DECL: StringRef getParam()
 // DEF: ParamWithAccessorTypeAttrStorage
 // DEF: ParamWithAccessorTypeAttrStorage(std::string param)
 // DEF: StringRef ParamWithAccessorTypeAttr::getParam()

mlir/test/mlir-tblgen/testdialect-typedefs.mlir

 // CHECK-SAME: !test.cmpnd_nested_outer_qual<i !test.cmpnd_inner<42 <1, !test.smpla, [5, 6]>>>
 func private @compoundNestedQual(%arg0: !test.cmpnd_nested_outer_qual<i !test.cmpnd_inner<42 <1, !test.smpla, [5, 6]>>>) -> ()
 
 // CHECK: @testInt(%arg0: !test.int<signed, 8>, %arg1: !test.int<unsigned, 2>, %arg2: !test.int<none, 1>)
 func @testInt(%A : !test.int<s, 8>, %B : !test.int<unsigned, 2>, %C : !test.int<n, 1>) {
   return
 }
 
-// CHECK: @structTest(%arg0: !test.struct<{field1,!test.smpla},{field2,!test.int<none, 3>}>)
+// CHECK: @structTest(%arg0: !test.struct<{field1,!test.smpla}, {field2,!test.int<none, 3>}>)
 func @structTest (%A : !test.struct< {field1, !test.smpla}, {field2, !test.int<none, 3>} > ) {
   return
 }

mlir/test/mlir-tblgen/typedefs.td

 // DEF-NEXT: }
 // DEF-NEXT: if (mnemonic == ::test::IndexType::getMnemonic()) {
 // DEF-NEXT:   value = ::test::IndexType::parse(parser);
 // DEF-NEXT:   return ::mlir::success(!!value);
 // DEF: return {};
 
 def Test_Dialect: Dialect {
 // DECL-NOT: TestDialect
-    let name = "TestDialect";
-    let cppNamespace = "::test";
 }
 
 class TestType<string name> : TypeDef<Test_Dialect, name> { }
 
 def A_SimpleTypeA : TestType<"SimpleA"> {
 // DECL: class SimpleAType : public ::mlir::Type
 }
 
 def RTLValueType : Type<CPred<"isRTLValueType($_self)">, "Type"> {
   string cppType = "::mlir::Type";
 }
 
 // A more complex parameterized type
 def B_CompoundTypeA : TestType<"CompoundA"> {
   let summary = "A more complex parameterized type";
   let description = "This type is to test a reasonably complex type";
   let mnemonic = "cmpnd_a";
-  let parameters = (
-      ins
-      "int":$widthOfSomething,
-      "::test::SimpleTypeA": $exampleTdType,
-      "SomeCppStruct": $exampleCppType,
-      ArrayRefParameter<"int", "Matrix dimensions">:$dims,
-      RTLValueType:$inner
+  let parameters = (ins
   );
 
   let genVerifyDecl = 1;
+  let hasCustomAssemblyFormat = 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 {"cmpnd_a"};
 // DECL: }
 // DECL: static ::mlir::Type parse(::mlir::AsmParser &odsParser);
 // DECL: void print(::mlir::AsmPrinter &odsPrinter) 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
-    );
+  let parameters = (ins
+  let hasCustomAssemblyFormat = 1;
 
 // DECL-LABEL: class IndexType : public ::mlir::Type
 // DECL: static constexpr ::llvm::StringLiteral getMnemonic() {
 // DECL:   return {"index"};
 // DECL: }
 // DECL: static ::mlir::Type parse(::mlir::AsmParser &odsParser);
 // DECL: void print(::mlir::AsmPrinter &odsPrinter) const;
 }
 
 def D_SingleParameterType : TestType<"SingleParameter"> {
-  let parameters = (
-    ins
+  let parameters = (ins
     "int": $num
   );
 // DECL-LABEL: struct SingleParameterTypeStorage;
 // DECL-LABEL: class SingleParameterType
 // DECL-SAME:  detail::SingleParameterTypeStorage
 }
 
 def E_IntegerType : TestType<"Integer"> {
-    let mnemonic = "int";
-    let genVerifyDecl = 1;
-    let parameters = (
-        ins
-        "SignednessSemantics":$signedness,
-        TypeParameter<"unsigned", "Bitwidth of integer">:$width
-    );
+  let hasCustomAssemblyFormat = 1;
+  let parameters = (ins
 
 // DECL-LABEL: IntegerType : public ::mlir::Type
 
-    let extraClassDeclaration = [{
   /// Signedness semantics.
   enum SignednessSemantics {
     Signless, /// No signedness semantics
     Signed,   /// Signed integer
     Unsigned, /// Unsigned integer
   };
 
   /// This extra function is necessary since it doesn't include signedness
   static IntegerType getChecked(unsigned width, Location location);
 
   /// Return true if this is a signless integer type.
   bool isSignless() const { return getSignedness() == Signless; }
   /// Return true if this is a signed integer type.
   bool isSigned() const { return getSignedness() == Signed; }
   /// Return true if this is an unsigned integer type.
   bool isUnsigned() const { return getSignedness() == Unsigned; }
-    }];
 
 // DECL: /// Signedness semantics.
 // DECL-NEXT: enum SignednessSemantics {
 // DECL-NEXT:   Signless, /// No signedness semantics
 // DECL-NEXT:   Signed,   /// Signed integer
 // DECL-NEXT:   Unsigned, /// Unsigned integer
 // DECL-NEXT: };
 // DECL: /// This extra function is necessary since it doesn't include signedness

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

private:
   /// Emit the checked builder `Attribute::getChecked`
   void emitCheckedBuilder();
   /// Emit a custom builder.
   void emitCustomBuilder(const AttrOrTypeBuilder &builder);
   /// Emit a checked custom builder.
   void emitCheckedCustomBuilder(const AttrOrTypeBuilder &builder);
 
   //===--------------------------------------------------------------------===//
-  // Parser and Printer Emission
-  void emitParserPrinterBody(MethodBody &parser, MethodBody &printer);
-
-  //===--------------------------------------------------------------------===//
   // Interface Method Emission
 
   /// Emit methods for a trait.
   void emitTraitMethods(const InterfaceTrait &trait);
   /// Emit a trait method.
   void emitTraitMethod(const InterfaceMethod &method);
 
   //===--------------------------------------------------------------------===//
defCls.declareStaticMethod(
       getBuilderParams({{"::llvm::function_ref<::mlir::InFlightDiagnostic()>",
                          "emitError"}}));
 }
 
 void DefGen::emitParserPrinter() {
   auto *mnemonic = defCls.addStaticMethod<Method::Constexpr>(
       "::llvm::StringLiteral", "getMnemonic");
   mnemonic->body().indent() << strfmt("return {\"{0}\"};", *def.getMnemonic());
+
   // Declare the parser and printer, if needed.
-  if (!def.needsParserPrinter() && !def.hasGeneratedParser() &&
-      !def.hasGeneratedPrinter())
+  bool hasAssemblyFormat = def.getAssemblyFormat().hasValue();
+  if (!def.hasCustomAssemblyFormat() && !hasAssemblyFormat)
     return;
 
   // Declare the parser.
   SmallVector<MethodParameter> parserParams;
   parserParams.emplace_back("::mlir::AsmParser &", "odsParser");
   if (isa<AttrDef>(&def))
     parserParams.emplace_back("::mlir::Type", "odsType");
-  auto *parser = defCls.addMethod(
-      strfmt("::mlir::{0}", valueType), "parse",
-      def.hasGeneratedParser() ? Method::Static : Method::StaticDeclaration,
+  auto *parser = defCls.addMethod(strfmt("::mlir::{0}", valueType), "parse",
+                                  hasAssemblyFormat ? Method::Static
+                                                    : Method::StaticDeclaration,
                                   std::move(parserParams));
   // Declare the printer.
-  auto props =
-      def.hasGeneratedPrinter() ? Method::Const : Method::ConstDeclaration;
+  auto props = hasAssemblyFormat ? Method::Const : Method::ConstDeclaration;
   Method *printer =
       defCls.addMethod("void", "print", props,
                        MethodParameter("::mlir::AsmPrinter &", "odsPrinter"));
-  // Emit the bodies.
-  emitParserPrinterBody(parser->body(), printer->body());
+  // Emit the bodies if we are using the declarative format.
+  if (hasAssemblyFormat)
+    return generateAttrOrTypeFormat(def, parser->body(), printer->body());
 }
 
 void DefGen::emitAccessors() {
   for (auto &param : params) {
     Method *m = defCls.addMethod(
         param.getCppAccessorType(), getParameterAccessorName(param.getName()),
         def.genStorageClass() ? Method::Const : Method::ConstDeclaration);
     // Generate accessor definitions only if we also generate the storage
if (!builder.hasInferredContextParameter())
     ctx.addSubst("_ctxt", "context");
   std::string bodyStr = replaceInStr(builder.getBody()->str(), "$_get(",
                                      "Base::getChecked(emitError, ");
   bodyStr = tgfmt(bodyStr, &ctx);
   m->body().indent().getStream().printReindented(bodyStr);
 }
 
 //===----------------------------------------------------------------------===//
-// Parser and Printer Emission
-
-void DefGen::emitParserPrinterBody(MethodBody &parser, MethodBody &printer) {
-  Optional<StringRef> parserCode = def.getParserCode();
-  Optional<StringRef> printerCode = def.getPrinterCode();
-  Optional<StringRef> asmFormat = def.getAssemblyFormat();
-  // Verify the parser-printer specification first.
-  if (asmFormat && (parserCode || printerCode)) {
-    PrintFatalError(def.getLoc(),
-                    def.getName() + ": assembly format cannot be specified at "
-                                    "the same time as printer or parser code");
-  }
-  // Specified code cannot be empty.
-  if (parserCode && parserCode->empty())
-    PrintFatalError(def.getLoc(), def.getName() + ": parser cannot be empty");
-  if (printerCode && printerCode->empty())
-    PrintFatalError(def.getLoc(), def.getName() + ": printer cannot be empty");
-  // Assembly format requires accessors to be generated.
-  if (asmFormat && !def.genAccessors()) {
-    PrintFatalError(def.getLoc(),
-                    def.getName() +
-                        ": the generated printer from 'assemblyFormat' "
-                        "requires 'genAccessors' to be true");
-  }
-
-  // Generate the parser and printer bodies.
-  if (asmFormat)
-    return generateAttrOrTypeFormat(def, parser, printer);
-
-  FmtContext ctx = FmtContext({{"_parser", "odsParser"},
-                               {"_printer", "odsPrinter"},
-                               {"_type", "odsType"}});
-  if (parserCode) {
-    ctx.addSubst("_ctxt", "odsParser.getContext()");
-    parser.indent().getStream().printReindented(tgfmt(*parserCode, &ctx).str());
-  }
-  if (printerCode) {
-    ctx.addSubst("_ctxt", "odsPrinter.getContext()");
-    printer.indent().getStream().printReindented(
-        tgfmt(*printerCode, &ctx).str());
-  }
-}
-
-//===----------------------------------------------------------------------===//
 // Interface Method Emission
 
 void DefGen::emitTraitMethods(const InterfaceTrait &trait) {
   // Get the set of methods that should always be declared.
   auto alwaysDeclaredMethods = trait.getAlwaysDeclaredMethods();
   StringSet<> alwaysDeclared;
   alwaysDeclared.insert(alwaysDeclaredMethods.begin(),
                         alwaysDeclaredMethods.end());
)";
   const char *const printValue = R"(    .Case<{0}>([&](auto t) {{
       printer << {0}::getMnemonic();{1}
       return ::mlir::success();
     })
 )";
   for (auto &def : defs) {
     if (!def.getMnemonic())
       continue;
+    bool hasParserPrinterDecl =
+        def.hasCustomAssemblyFormat() || def.getAssemblyFormat();
     std::string defClass = strfmt(
         "{0}::{1}", def.getDialect().getCppNamespace(), def.getCppClassName());
+
     // If the def has no parameters or parser code, invoke a normal `get`.
     std::string parseOrGet =
-        def.needsParserPrinter() || def.hasGeneratedParser()
+        hasParserPrinterDecl
             ? strfmt("parse(parser{0})", isAttrGenerator ? ", type" : "")
             : "get(parser.getContext())";
     parse.body() << llvm::formatv(getValueForMnemonic, defClass, parseOrGet);
 
     // If the def has no parameters and no printer, just print the mnemonic.
     StringRef printDef = "";
-    if (def.needsParserPrinter() || def.hasGeneratedPrinter())
+    if (hasParserPrinterDecl)
       printDef = "\nt.print(printer);";
     printer.body() << llvm::formatv(printValue, defClass, printDef);
   }
   parse.body() << "  return {};";
   printer.body() << "    .Default([](auto) { return ::mlir::failure(); });";
 
   raw_indented_ostream indentedOs(os);
   parse.writeDeclTo(indentedOs);

mlir/tools/mlir-tblgen/OpDocGen.cpp

 static void emitAttrOrTypeDefDoc(const AttrOrTypeDef &def, raw_ostream &os) {
   os << llvm::formatv("### {0}\n", def.getCppClassName());
 
   // Emit the summary if present.
   if (def.hasSummary())
     os << "\n" << def.getSummary() << "\n";
 
   // Emit the syntax if present.
-  if (def.getMnemonic() && def.getPrinterCode() == StringRef() &&
-      def.getParserCode() == StringRef())
+  if (def.getMnemonic() && !def.hasCustomAssemblyFormat())
     emitAttrOrTypeDefAssemblyFormat(def, os);
 
   // Emit the description if present.
   if (def.hasDescription()) {
     os << "\n";
     mlir::tblgen::emitDescription(def.getDescription(), os);
   }