Change the contract with the type/attribute parsing to let the dispatch handle the mnemonic

[mehdi_amini]

Summary

This breaking change requires to remove printing the mnemonic in the print()
method on Type/Attribute classes.
This makes it consistent with the parsing code which alread handles the
mnemonic outside of the parsing method.

Depends On D113332

[rriddle]

Nice! This is much cleaner.

[aartbik]

Good for the sparse change

mlir/include/mlir/Dialect/ArmSVE/ArmSVE.td

def ScalableVectorType : ArmSVE_Type<"ScalableVector"> {
   }];
 
   let parameters = (ins
     ArrayRefParameter<"int64_t", "Vector shape">:$shape,
     "Type":$elementType
   );
 
   let printer = [{
-    $_printer << "vector<";
+    $_printer << "<";
     for (int64_t dim : getShape())
       $_printer << dim << 'x';
     $_printer << getElementType() << '>';
   }];
 
   let parser = [{
     VectorType vector;
     if ($_parser.parseType(vector))

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 {
-  printer << getMnemonic();
   printer << "<";
   printer.printType(getValueType());
   printer << '>';
 }
 
 Type ValueType::parse(mlir::DialectAsmParser &parser) {
   Type ty;
   if (parser.parseLess() || parser.parseType(ty) || parser.parseGreater()) {

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

 }
 
 void EmitCDialect::printAttribute(Attribute attr, DialectAsmPrinter &os) const {
   if (failed(generatedAttributePrinter(attr, os)))
     llvm_unreachable("unexpected 'EmitC' attribute kind");
 }
 
 void emitc::OpaqueAttr::print(DialectAsmPrinter &printer) const {
-  printer << "opaque<\"";
+  printer << "<\"";
   llvm::printEscapedString(getValue(), printer.getStream());
   printer << "\">";
 }
 
 //===----------------------------------------------------------------------===//
 // EmitC Types
 //===----------------------------------------------------------------------===//
 
if (parser.parseOptionalString(&value) || value.empty()) {
     return Type();
   }
   if (parser.parseGreater())
     return Type();
   return get(parser.getContext(), value);
 }
 
 void emitc::OpaqueType::print(DialectAsmPrinter &printer) const {
-  printer << "opaque<\"";
+  printer << "<\"";
   llvm::printEscapedString(getValue(), printer.getStream());
   printer << "\">";
 }

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

static constexpr const FastmathFlags fastmathFlagsList[] = {
     FastmathFlags::contract,
     FastmathFlags::afn,
     FastmathFlags::reassoc,
     FastmathFlags::fast,
     // clang-format on
 };
 
 void FMFAttr::print(DialectAsmPrinter &printer) const {
-  printer << "fastmath<";
+  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 << ">";
 }
 
if (failed(parser.parseOptionalGreater())) {
     if (failed(parser.parseGreater()))
       return {};
   }
 
   return FMFAttr::get(parser.getContext(), flags);
 }
 
 void LinkageAttr::print(DialectAsmPrinter &printer) const {
-  printer << "linkage<";
+  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) {

 /// 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 {
-  printer << getMnemonic() << "<";
+  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;

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

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 {
-  printer << "range<";
+  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

Attribute SparseTensorEncodingAttr::parse(DialectAsmParser &parser, Type type) {
   }
   // Construct struct-like storage for attribute.
   return parser.getChecked<SparseTensorEncodingAttr>(parser.getContext(), dlt,
                                                      map, ptr, ind);
 }
 
 void SparseTensorEncodingAttr::print(DialectAsmPrinter &printer) const {
   // Print the struct-like storage in dictionary fashion.
-  printer << "encoding<{ dimLevelType = [ ";
+  printer << "<{ dimLevelType = [ ";
   for (unsigned i = 0, e = getDimLevelType().size(); i < e; i++) {
     switch (getDimLevelType()[i]) {
     case DimLevelType::Dense:
       printer << "\"dense\"";
       break;
     case DimLevelType::Compressed:
       printer << "\"compressed\"";
       break;

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

Attribute AttrWithSelfTypeParamAttr::parse(DialectAsmParser &parser,
                                            Type type) {
   Type selfType;
   if (parser.parseType(selfType))
     return Attribute();
   return get(parser.getContext(), selfType);
 }
 
 void AttrWithSelfTypeParamAttr::print(DialectAsmPrinter &printer) const {
-  printer << "attr_with_self_type_param " << getType();
+  printer << " " << getType();
 }
 
 //===----------------------------------------------------------------------===//
 // AttrWithTypeBuilderAttr
 //===----------------------------------------------------------------------===//
 
 Attribute AttrWithTypeBuilderAttr::parse(DialectAsmParser &parser, Type type) {
   IntegerAttr element;
   if (parser.parseAttribute(element))
     return Attribute();
   return get(parser.getContext(), element);
 }
 
 void AttrWithTypeBuilderAttr::print(DialectAsmPrinter &printer) const {
-  printer << "attr_with_type_builder " << getAttr();
+  printer << " " << getAttr();
 }
 
 //===----------------------------------------------------------------------===//
 // CompoundAAttr
 //===----------------------------------------------------------------------===//
 
 Attribute CompoundAAttr::parse(DialectAsmParser &parser, Type type) {
   int widthOfSomething;
Attribute CompoundAAttr::parse(DialectAsmParser &parser, Type type) {
   }
 
   if (parser.parseRSquare() || parser.parseGreater())
     return Attribute();
   return get(parser.getContext(), widthOfSomething, oneType, arrayOfInts);
 }
 
 void CompoundAAttr::print(DialectAsmPrinter &printer) const {
-  printer << "cmpnd_a<" << getWidthOfSomething() << ", " << getOneType()
-          << ", [";
+  printer << "<" << getWidthOfSomething() << ", " << getOneType() << ", [";
   llvm::interleaveComma(getArrayOfInts(), printer);
   printer << "]>";
 }
 
 //===----------------------------------------------------------------------===//
 // CompoundAAttr
 //===----------------------------------------------------------------------===//
 
Attribute TestI64ElementsAttr::parse(DialectAsmParser &parser, Type type) {
 
   if (parser.parseRSquare() || parser.parseGreater())
     return Attribute();
   return parser.getChecked<TestI64ElementsAttr>(
       parser.getContext(), type.cast<ShapedType>(), elements);
 }
 
 void TestI64ElementsAttr::print(DialectAsmPrinter &printer) const {
-  printer << "i64_elements<[";
+  printer << "<[";
   llvm::interleaveComma(getElements(), printer);
   printer << "] : " << getType() << ">";
 }
 
 LogicalResult
 TestI64ElementsAttr::verify(function_ref<InFlightDiagnostic()> emitError,
                             ShapedType type, ArrayRef<uint64_t> elements) {
   if (type.getNumElements() != static_cast<int64_t>(elements.size())) {
if (parser.parseLess() || parser.parseAttribute(first) ||
       parser.parseGreater()) {
     return {};
   }
   return get(parser.getContext(), first, second, third);
 }
 
 void TestSubElementsAccessAttr::print(
     ::mlir::DialectAsmPrinter &printer) const {
-  printer << getMnemonic() << "<" << getFirst() << ", " << getSecond() << ", "
-          << getThird() << ">";
+  printer << "<" << getFirst() << ", " << getSecond() << ", " << getThird()
+          << ">";
 }
 
 void TestSubElementsAccessAttr::walkImmediateSubElements(
     llvm::function_ref<void(mlir::Attribute)> walkAttrsFn,
     llvm::function_ref<void(mlir::Type)> walkTypesFn) const {
   walkAttrsFn(getFirst());
   walkAttrsFn(getSecond());
   walkAttrsFn(getThird());

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

let parameters = (
     ins
     "unsigned":$width,
     // SignednessSemantics is defined below.
     "::test::TestIntegerType::SignednessSemantics":$signedness
   );
 
   // We define the printer inline.
   let printer = [{
-    $_printer << "int<";
+    $_printer << "<";
     printSignedness($_printer, getImpl()->signedness);
     $_printer << ", " << getImpl()->width << ">";
   }];
 
   // Define custom builder methods.
   let builders = [
     TypeBuilder<(ins "unsigned":$width,
                      CArg<"SignednessSemantics", "Signless">:$signedness), [{
let parameters = (
     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 << "struct" << "<";
+    $_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 << ">";
   }];

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

Type CompoundAType::parse(DialectAsmParser &parser) {
   }
 
   if (parser.parseRSquare() || parser.parseGreater())
     return Type();
 
   return get(parser.getContext(), widthOfSomething, oneType, arrayOfInts);
 }
 void CompoundAType::print(DialectAsmPrinter &printer) const {
-  printer << "cmpnd_a<" << getWidthOfSomething() << ", " << getOneType()
-          << ", [";
+  printer << "<" << getWidthOfSomething() << ", " << getOneType() << ", [";
   auto intArray = getArrayOfInts();
   llvm::interleaveComma(intArray, printer);
   printer << "]>";
 }
 
 //===----------------------------------------------------------------------===//
 // TestIntegerType
 //===----------------------------------------------------------------------===//

 Type TestTypeWithLayoutType::parse(DialectAsmParser &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 {
-  printer << "test_type_with_layout<" << getKey() << ">";
+  printer << "<" << getKey() << ">";
 }
 
 unsigned
 TestTypeWithLayoutType::getTypeSizeInBits(const DataLayout &dataLayout,
                                           DataLayoutEntryListRef params) const {
   return extractKind(params, "size");
 }
 

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

for (const AttrOrTypeDef &def : defs) {
     if (!mnemonic)
       continue;
 
     StringRef cppNamespace = def.getDialect().getCppNamespace();
     StringRef cppClassName = def.getCppClassName();
     os << formatv("    .Case<{0}::{1}>([&]({0}::{1} t) {{\n      ",
                   cppNamespace, cppClassName);
 
-    // If the def has no parameters and no printer, just print the mnemonic.
-    if (def.getNumParameters() == 0 && !def.getPrinterCode()) {
-      os << formatv("printer << {0}::{1}::getMnemonic();", cppNamespace,
-                    cppClassName);
-    } else {
+    // If the def has no parameters and no printer, just print the mnemonic.
+    if (def.getNumParameters() != 0 || def.getPrinterCode())
       os << "t.print(printer);";
-    }
     os << "\n      return ::mlir::success();\n    })\n";
   }
   os << llvm::formatv(
       "    .Default([](::mlir::{0}) {{ return ::mlir::failure(); });\n}\n\n",
       valueType);
 }
 
 bool DefGenerator::emitDefs(StringRef selectedDialect) {