[Mlir-commits] [mlir] 0a8a590 - [mlir] Fully qualify default generated type/attribute printer and parser

[Markus Böck]

Author: Markus Böck
Date: 2021-11-18T20:24:00+01:00
New Revision: 0a8a5902a694c12ae28233ae21bbf73a6d7204bb

URL: https://github.com/llvm/llvm-project/commit/0a8a5902a694c12ae28233ae21bbf73a6d7204bb
DIFF: https://github.com/llvm/llvm-project/commit/0a8a5902a694c12ae28233ae21bbf73a6d7204bb.diff

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

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 functions from the mlir namespace in the generated C++ code
* Makes sure to emit the printers and parsers inside the same namespace as the Dialect

Differential Revision: https://reviews.llvm.org/D114168

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

Modified: 
    mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

Removed: 
    


################################################################################
diff  --git a/mlir/test/mlir-tblgen/default-type-attr-print-parser.td b/mlir/test/mlir-tblgen/default-type-attr-print-parser.td
new file mode 100644
index 0000000000000..2ec3f65188368
--- /dev/null
+++ b/mlir/test/mlir-tblgen/default-type-attr-print-parser.td
@@ -0,0 +1,76 @@
+// 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

diff  --git a/mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp b/mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp
index f8fe56dc423e9..3ae476123336f 100644
--- a/mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp
+++ b/mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp
@@ -510,7 +510,7 @@ ::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;
@@ -525,7 +525,7 @@ ::mlir::Attribute {0}::parseAttribute(::mlir::DialectAsmParser &parser,
 /// 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;
 }
 )";
@@ -535,13 +535,12 @@ void {0}::printAttribute(::mlir::Attribute attr,
 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 `"
@@ -551,7 +550,7 @@ ::mlir::Type {0}::parseType(::mlir::DialectAsmParser &parser) const {{
 /// 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;
 }
 )";
@@ -1040,17 +1039,22 @@ bool DefGenerator::emitDefs(StringRef selectedDialect) {
          << "::" << def.getCppClassName() << ")\n";
   }
 
-  // Emit the default parser/printer for Attributes if the dialect asked for it.
+  Dialect firstDialect = defs.front().getDialect();
+  // Emit the default parser/printer for Attributes if the dialect asked for
+  // it.
   if (valueType == "Attribute" &&
-      defs.front().getDialect().useDefaultAttributePrinterParser())
+      firstDialect.useDefaultAttributePrinterParser()) {
+    NamespaceEmitter nsEmitter(os, firstDialect);
     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()) {
+    NamespaceEmitter nsEmitter(os, firstDialect);
     os << llvm::formatv(dialectDefaultTypePrinterParserDispatch,
-                        defs.front().getDialect().getCppClassName());
+                        firstDialect.getCppClassName());
+  }
 
   return false;
 }