[mlir] Fully qualify default generated type/attribute printer and parser

[zero9178]

Summary

This patch makes it possible to use the newly added useDefaultAttributePrinterParser and useDefaultTypePrinterParser dialect options without any using namespace declarations. Two things had to be done to make this possible:

• Fully qualify any type usages or function from the mlir namespace in the generated C++ code
• Makes sure to emit the printers and parsers inside the same namespace as the Dialect

[rriddle]

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

1043

valueType == "Attribute" || valueType == "Type"

When is the not true?

1044–1046

Instead of duplicating checks, why not just sink this into both of the if statements below?

[zero9178]

Addressed review comments

[zero9178]

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

1043

I think my original thought was in case valueType does ever get another possible value. Unlikely now that I think about it so happy to remove that check. Sinking the NamespaceEmitter as you suggested makes this redundant either way.

[rriddle]

Thanks for the fix!

mlir/test/mlir-tblgen/default-type-attr-print-parser.td

+// RUN: mlir-tblgen -gen-attrdef-defs -I %S/../../include %s | FileCheck %s --check-prefix=ATTR
+// RUN: mlir-tblgen -gen-typedef-defs -I %S/../../include %s | FileCheck %s --check-prefix=TYPE
+
+include "mlir/IR/OpBase.td"
+
+/// Test that attribute and type printers and parsers are correctly generated.
+def Test_Dialect : Dialect {
+  let name = "TestDialect";
+  let cppNamespace = "::test";
+
+  let useDefaultAttributePrinterParser = 1;
+
+  let useDefaultTypePrinterParser = 1;
+}
+
+class TestAttr<string name> : AttrDef<Test_Dialect, name>;
+class TestType<string name> : TypeDef<Test_Dialect, name>;
+
+def AttrA : TestAttr<"AttrA"> {
+  let mnemonic = "attr_a";
+}
+
+// ATTR: namespace test {
+
+// ATTR: ::mlir::Attribute TestDialect::parseAttribute(::mlir::DialectAsmParser &parser,
+// ATTR:                                               ::mlir::Type type) const {
+// ATTR:   ::llvm::SMLoc typeLoc = parser.getCurrentLocation();
+// ATTR:   ::llvm::StringRef attrTag;
+// ATTR:   if (::mlir::failed(parser.parseKeyword(&attrTag)))
+// ATTR:     return {};
+// ATTR:   {
+// ATTR:     ::mlir::Attribute attr;
+// ATTR:     auto parseResult = generatedAttributeParser(parser, attrTag, type, attr);
+// ATTR:     if (parseResult.hasValue())
+// ATTR:       return attr;
+// ATTR:   }
+// ATTR:   parser.emitError(typeLoc) << "unknown attribute `"
+// ATTR:       << attrTag << "` in dialect `" << getNamespace() << "`";
+// ATTR:   return {}
+// ATTR: }
+
+// ATTR: void TestDialect::printAttribute(::mlir::Attribute attr,
+// ATTR:                          ::mlir::DialectAsmPrinter &printer) const {
+// ATTR:   if (::mlir::succeeded(generatedAttributePrinter(attr, printer)))
+// ATTR:     return;
+// ATTR: }
+
+// ATTR: } // namespace test
+
+def TypeA : TestType<"TypeA"> {
+  let mnemonic = "type_a";
+}
+
+// TYPE: namespace test {
+
+// TYPE: ::mlir::Type TestDialect::parseType(::mlir::DialectAsmParser &parser) const {
+// TYPE:   ::llvm::SMLoc typeLoc = parser.getCurrentLocation();
+// TYPE:   ::llvm::StringRef mnemonic;
+// TYPE:   if (parser.parseKeyword(&mnemonic))
+// TYPE:     return ::mlir::Type();
+// TYPE:   ::mlir::Type genType;
+// TYPE:   auto parseResult = generatedTypeParser(parser, mnemonic, genType);
+// TYPE:   if (parseResult.hasValue())
+// TYPE:     return genType;
+// TYPE:   parser.emitError(typeLoc) << "unknown  type `"
+// TYPE:       << mnemonic << "` in dialect `" << getNamespace() << "`";
+// TYPE:   return {};
+// TYPE: }
+
+// TYPE: void TestDialect::printType(::mlir::Type type,
+// TYPE:                     ::mlir::DialectAsmPrinter &printer) const {
+// TYPE:   if (::mlir::succeeded(generatedTypePrinter(type, printer)))
+// TYPE:     return;
+// TYPE: }
+
+// TYPE: } // namespace test

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

 /// 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.
 ::mlir::Attribute {0}::parseAttribute(::mlir::DialectAsmParser &parser,
                                       ::mlir::Type type) const {{
   ::llvm::SMLoc typeLoc = parser.getCurrentLocation();
   ::llvm::StringRef attrTag;
-  if (failed(parser.parseKeyword(&attrTag)))
+  if (::mlir::failed(parser.parseKeyword(&attrTag)))
     return {{};
   {{
     ::mlir::Attribute attr;
     auto parseResult = generatedAttributeParser(parser, attrTag, type, attr);
     if (parseResult.hasValue())
       return attr;
   }
   parser.emitError(typeLoc) << "unknown  attribute `"
       << attrTag << "` in dialect `" << getNamespace() << "`";
   return {{};
 }
 /// Print an attribute registered to this dialect.
 void {0}::printAttribute(::mlir::Attribute attr,
                          ::mlir::DialectAsmPrinter &printer) const {{
-  if (succeeded(generatedAttributePrinter(attr, printer)))
+  if (::mlir::succeeded(generatedAttributePrinter(attr, printer)))
     return;
 }
 )";
 
 /// The code block for default type parser/printer dispatch boilerplate.
 /// {0}: the dialect fully qualified class name.
 static const char *const dialectDefaultTypePrinterParserDispatch = R"(
 /// Parse a type registered to this dialect.
 ::mlir::Type {0}::parseType(::mlir::DialectAsmParser &parser) const {{
-  llvm::SMLoc typeLoc = parser.getCurrentLocation();
-  StringRef mnemonic;
+  ::llvm::SMLoc typeLoc = parser.getCurrentLocation();
+  ::llvm::StringRef mnemonic;
   if (parser.parseKeyword(&mnemonic))
-    return Type();
-  Type genType;
-  OptionalParseResult parseResult =
-      generatedTypeParser(parser, mnemonic, genType);
+    return ::mlir::Type();
+  ::mlir::Type genType;
+  auto parseResult = generatedTypeParser(parser, mnemonic, genType);
   if (parseResult.hasValue())
     return genType;
   parser.emitError(typeLoc) << "unknown  type `"
       << mnemonic << "` in dialect `" << getNamespace() << "`";
   return {{};
 }
 /// Print a type registered to this dialect.
 void {0}::printType(::mlir::Type type,
                     ::mlir::DialectAsmPrinter &printer) const {{
-  if (succeeded(generatedTypePrinter(type, printer)))
+  if (::mlir::succeeded(generatedTypePrinter(type, printer)))
     return;
 }
 )";
 
 /// 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"(
bool DefGenerator::emitDefs(StringRef selectedDialect) {
   for (const AttrOrTypeDef &def : defs) {
     emitDefDef(def);
     // Emit the TypeID explicit specializations to have a single symbol def.
     if (!def.getDialect().getCppNamespace().empty())
       os << "DEFINE_EXPLICIT_TYPE_ID(" << def.getDialect().getCppNamespace()
          << "::" << def.getCppClassName() << ")\n";
   }
 
-  // Emit the default parser/printer for Attributes if the dialect asked for it.
+  Dialect firstDialect = defs.front().getDialect();
+  if ((valueType == "Attribute" || valueType == "Type") &&
+      (firstDialect.useDefaultAttributePrinterParser() ||
+       firstDialect.useDefaultTypePrinterParser())) {
+    NamespaceEmitter nsEmitter(os, firstDialect);
+
+    // Emit the default parser/printer for Attributes if the dialect asked for
+    // it.
     if (valueType == "Attribute" &&
-      defs.front().getDialect().useDefaultAttributePrinterParser())
+        firstDialect.useDefaultAttributePrinterParser())
       os << llvm::formatv(dialectDefaultAttrPrinterParserDispatch,
-                        defs.front().getDialect().getCppClassName());
+                          firstDialect.getCppClassName());
 
     // Emit the default parser/printer for Types if the dialect asked for it.
-  if (valueType == "Type" &&
-      defs.front().getDialect().useDefaultTypePrinterParser())
+    if (valueType == "Type" && firstDialect.useDefaultTypePrinterParser())
       os << llvm::formatv(dialectDefaultTypePrinterParserDispatch,
-                        defs.front().getDialect().getCppClassName());
+                          firstDialect.getCppClassName());
+  }
 
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // GEN: Registration hooks
 //===----------------------------------------------------------------------===//