IRDL-to-C++

mlir/include/mlir/Dialect/IRDL/IR/IRDLOps.td

@@ -91,6 +91,7 @@ def IRDL_TypeOp : IRDL_Op<"type",
   let regions = (region SizedRegion<1>:$body);
   let assemblyFormat =
     "$sym_name attr-dict-with-keyword custom<SingleBlockRegion>($body)";
+  let hasVerifier = 1;
 }
 
 def IRDL_AttributeOp : IRDL_Op<"attribute",
@@ -126,6 +127,8 @@ def IRDL_AttributeOp : IRDL_Op<"attribute",
   let regions = (region SizedRegion<1>:$body);
   let assemblyFormat =
     "$sym_name attr-dict-with-keyword custom<SingleBlockRegion>($body)";
+
+  let hasVerifier = 1;
 }
 
 def IRDL_ParametersOp : IRDL_Op<"parameters",
@@ -202,6 +205,7 @@ def IRDL_OperationOp : IRDL_Op<"operation",
   let assemblyFormat =
     "$sym_name attr-dict-with-keyword custom<SingleBlockRegion>($body)";
   let hasRegionVerifier = true;
+  let hasVerifier = 1;
 }
 
 def IRDL_OperandsOp : IRDL_Op<"operands", [HasParent<"OperationOp">]> {

mlir/include/mlir/Target/IRDLToCpp/IRDLToCpp.h

@@ -29,8 +29,9 @@ namespace irdl {
 ///
 ///  // This define generates code for the dialect's class definitions
 ///  #define GEN_DIALECT_DEF
-LogicalResult translateIRDLDialectToCpp(llvm::ArrayRef<irdl::DialectOp> dialect,
-                                        raw_ostream &output);
+LogicalResult
+translateIRDLDialectToCpp(llvm::ArrayRef<irdl::DialectOp> dialects,
+                          raw_ostream &output);
 
 } // namespace irdl
 } // namespace mlir

mlir/lib/Dialect/IRDL/IR/IRDL.cpp

@@ -74,13 +74,62 @@ static void printSingleBlockRegion(OpAsmPrinter &p, Operation *op,
   if (!region.getBlocks().front().empty())
     p.printRegion(region);
 }
+static llvm::LogicalResult isSnakeCase(llvm::StringRef in, mlir::Operation *loc,
+                                       const Twine &label) {
+  if (in.empty())
+    return loc->emitError("name of ") << label << " is empty";
+
+  bool allowUnderscore = false;
+  for (auto &elem : in) {
+    if (elem == '_') {
+      if (!allowUnderscore)
+        return loc->emitError("name of ")
+               << label << " should not contain leading or double underscores";
+    } else {
+      if (!isalnum(elem))
+        return loc->emitError("name of ")
+               << label
+               << " must contain only lowercase letters, digits and "
+                  "underscores";
+
+      if (llvm::isUpper(elem))
+        return loc->emitError("name of ")
+               << label << " should not contain uppercase letters";
+    }
+
+    allowUnderscore = elem != '_';
+  }
+
+  return success();
+}
 
 LogicalResult DialectOp::verify() {
   if (!Dialect::isValidNamespace(getName()))
     return emitOpError("invalid dialect name");
+  if (failed(isSnakeCase(getSymName(), getOperation(), "dialect")))
+    return failure();
+
   return success();
 }
 
+LogicalResult OperationOp::verify() {
+  return isSnakeCase(getSymName(), getOperation(), "operation");
+}
+
+LogicalResult TypeOp::verify() {
+  auto symName = getSymName();
+  if (symName.front() == '!')
+    symName = symName.substr(1);
+  return isSnakeCase(symName, getOperation(), "type");
+}
+
+LogicalResult AttributeOp::verify() {
+  auto symName = getSymName();
+  if (symName.front() == '#')
+    symName = symName.substr(1);
+  return isSnakeCase(symName, getOperation(), "attribute");
+}
+
 LogicalResult OperationOp::verifyRegions() {
   // Stores pairs of value kinds and the list of names of values of this kind in
   // the operation.
@@ -133,18 +182,11 @@ static LogicalResult verifyNames(Operation *op, StringRef kindName,
   DenseMap<StringRef, size_t> nameMap;
   for (auto [i, name] : llvm::enumerate(names)) {
     StringRef nameRef = llvm::cast<StringAttr>(name).getValue();
-    if (nameRef.empty())
-      return op->emitOpError()
-             << "name of " << kindName << " #" << i << " is empty";
-    if (!llvm::isAlpha(nameRef[0]) && nameRef[0] != '_')
-      return op->emitOpError()
-             << "name of " << kindName << " #" << i
-             << " must start with either a letter or an underscore";
-    if (llvm::any_of(nameRef,
-                     [](char c) { return !llvm::isAlnum(c) && c != '_'; }))
-      return op->emitOpError()
-             << "name of " << kindName << " #" << i
-             << " must contain only letters, digits and underscores";
+    auto verifyNameRef =
+        isSnakeCase(nameRef, op, Twine(kindName) + " #" + Twine(i));
+    if (failed(verifyNameRef))
+      return verifyNameRef;
+
     if (nameMap.contains(nameRef))
       return op->emitOpError() << "name of " << kindName << " #" << i
                                << " is a duplicate of the name of " << kindName

mlir/lib/Target/IRDLToCpp/IRDLToCpp.cpp

@@ -13,6 +13,7 @@
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/raw_ostream.h"
 
@@ -60,6 +61,35 @@ static std::string joinNameList(llvm::ArrayRef<std::string> names) {
   return nameArray;
 }
 
+static llvm::LogicalResult isSnakeCase(llvm::StringRef in,
+                                       mlir::Operation *loc) {
+  bool allowUnderscore = false;
+  for (auto &elem : in) {
+    if (elem == '_') {
+      if (!allowUnderscore)
+        return loc->emitError(
+            llvm::formatv("Error in symbol name `{}`: No leading or double "
+                          "underscores allowed.",
+                          in));
+    } else {
+      if (!isalnum(elem))
+        return loc->emitError(
+            llvm::formatv("Error in symbol name `{}`: Only numbers and "
+                          "lower-case characters allowed.",
+                          in));
+
+      if (llvm::isUpper(elem))
+        return loc->emitError(llvm::formatv(
+            "Error in symbol name `{}`: Upper-case characters are not allowed.",
+            in));
+    }
+
+    allowUnderscore = elem != '_';
+  }
+
+  return success();
+}
+
 static std::string snakeToCamel(llvm::StringRef in, bool capitalize = false) {
   std::string output;
   output.reserve(in.size());
@@ -472,31 +502,69 @@ void {0}::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState,
 }
 
 static LogicalResult verifySupported(irdl::DialectOp dialect) {
-  for (auto operation : dialect.getOps<irdl::OperationOp>()) {
-    // scan operands of operation
-    for (auto operands : operation.getOps<irdl::OperandsOp>()) {
-      for (auto operand : operands.getOperands()) {
-        if (!llvm::isa<irdl::AnyOp>(operand.getDefiningOp())) {
-          return operands.emitError(
-              "IRDL C++ translation only supports irdl.any "
-              "constraint for types");
-        }
-      }
-    }
-
-    // scan results of operation
-    for (auto results : operation.getOps<irdl::ResultsOp>()) {
-      for (auto operand : results.getOperands()) {
-        if (!llvm::isa<irdl::AnyOp>(operand.getDefiningOp())) {
-          return results.emitError(
-              "IRDL C++ translation only supports irdl.any "
-              "constraint for types");
-        }
-      }
-    }
-  }
+  if (failed(isSnakeCase(dialect.getSymName(), dialect)))
+    return failure();
 
-  return success();
+  LogicalResult res = success();
+  dialect.walk([&](mlir::Operation *op) {
+    res =
+        llvm::TypeSwitch<Operation *, LogicalResult>(op)
+            .Case<irdl::AttributeOp>([](irdl::AttributeOp op) -> LogicalResult {
+              return op.emitError(
+                  "IRDL C++ translation does not yet support attributes.");
+            })
+            .Case<irdl::AttributesOp>(
+                [](irdl::AttributesOp op) -> LogicalResult {
+                  return op.emitError(
+                      "IRDL C++ translation does not yet support attributes.");
+                })
+            .Case<irdl::AnyOfOp>([](irdl::AnyOfOp op) -> LogicalResult {
+              return op.emitError("IRDL C++ translation only supports irdl.any "
+                                  "constraint for types");
+            })
+            .Case<irdl::AllOfOp>([](irdl::AllOfOp op) -> LogicalResult {
+              return op.emitError("IRDL C++ translation only supports irdl.any "
+                                  "constraint for types");
+            })
+            .Case<irdl::BaseOp>([](irdl::BaseOp op) -> LogicalResult {
+              return op.emitError(
+                  "IRDL C++ translation does not yet support base types.");
+            })
+            .Case<irdl::ParametersOp>([](irdl::ParametersOp op)
+                                          -> LogicalResult {
+              return op.emitError(
+                  "IRDL C++ translation does not yet support type parameters.");
+            })
+            .Case<irdl::ParametricOp>(
+                [](irdl::ParametricOp op) -> LogicalResult {
+                  return op.emitError("IRDL C++ translation does not yet "
+                                      "support parametric operations.");
+                })
+            .Case<irdl::RegionOp>([](irdl::RegionOp op) -> LogicalResult {
+              return op.emitError(
+                  "IRDL C++ translation does not yet support regions.");
+            })
+            .Case<irdl::RegionsOp>([](irdl::RegionsOp op) -> LogicalResult {
+              return op.emitError(
+                  "IRDL C++ translation does not yet support regions.");
+            })
+            .Case<irdl::IsOp>([](irdl::IsOp op) -> LogicalResult {
+              return op.emitError("IRDL C++ translation only supports irdl.any "
+                                  "constraint for types");
+            })
+            .Case<irdl::CPredOp>([](irdl::CPredOp op) -> LogicalResult {
+              return op.emitError("IRDL C++ translation only supports irdl.any "
+                                  "constraint for types");
+            })
+            .Default(success());
+
+    if (failed(res))
+      return WalkResult::interrupt();
+
+    return WalkResult::advance();
+  });
+
+  return res;
 }
 
 LogicalResult
@@ -511,26 +579,11 @@ irdl::translateIRDLDialectToCpp(llvm::ArrayRef<irdl::DialectOp> dialects,
   for (auto dialect : dialects) {
     StringRef dialectName = dialect.getSymName();
 
-    // TODO: deal with no more constraints than the verifier allows.
-    if (dialectName.size() < 1) {
-      result =
-          dialect->emitError("dialect name must be more than one character");
-      continue;
-    }
-    if (!llvm::isAlpha(dialectName[0])) {
-      result = dialect->emitError("dialect name must start with a letter");
-      continue;
-    }
-    if (!llvm::all_of(dialectName,
-                      [](char c) { return llvm::isAlnum(c) || c == '_'; })) {
-      result = dialect->emitError(
-          "dialect name must only contain letters, numbers or underscores");
+    if (failed(verifySupported(dialect))) {
+      result = failure();
       continue;
     }
 
-    if (failed(verifySupported(dialect)))
-      result = failure();
-
     llvm::SmallVector<llvm::SmallString<8>> namespaceAbsolutePath{{"mlir"},
                                                                   dialectName};
     std::string namespaceOpen;

mlir/lib/Target/IRDLToCpp/Templates/PerOperationDecl.txt

@@ -1,4 +1,8 @@
 R"(
+//===----------------------------------------------------------------------===//
+// __NAMESPACE_PATH__::__OP_CPP_NAME__ declarations
+//===----------------------------------------------------------------------===//
+
 __NAMESPACE_OPEN__
 
 namespace detail {

mlir/test/Dialect/IRDL/invalid.irdl.mlir

@@ -25,7 +25,7 @@ irdl.dialect @testd {
 irdl.dialect @testd {
   irdl.type @type {
     %0 = irdl.any
-    // expected-error@+1 {{name of parameter #0 must contain only letters, digits and underscores}}
+    // expected-error@+1 {{name of parameter #0 must contain only lowercase letters, digits and underscores}}
     irdl.parameters(test$test: %0)
   }
 }
@@ -35,7 +35,7 @@ irdl.dialect @testd {
 irdl.dialect @testd {
   irdl.operation @op {
     %0 = irdl.any
-    // expected-error@+1 {{name of result #0 must contain only letters, digits and underscores}}
+    // expected-error@+1 {{name of result #0 must contain only lowercase letters, digits and underscores}}
     irdl.results(test$test: %0)
   }
 }
@@ -45,7 +45,7 @@ irdl.dialect @testd {
 irdl.dialect @testd {
   irdl.operation @op {
     %0 = irdl.any
-    // expected-error@+1 {{name of operand #0 must contain only letters, digits and underscores}}
+    // expected-error@+1 {{name of operand #0 must contain only lowercase letters, digits and underscores}}
     irdl.operands(test$test: %0)
   }
 }

mlir/test/Dialect/IRDL/regions-ops.irdl.mlir

@@ -1,6 +1,6 @@
 // RUN: mlir-opt %s -verify-diagnostics -split-input-file
 
-irdl.dialect @testRegionOpNegativeNumber {
+irdl.dialect @test_region_op_negative_number {
     irdl.operation @op {
         // expected-error @below {{'irdl.region' op the number of blocks is expected to be >= 1 but got -42}}
         %r1 = irdl.region with size -42
@@ -9,7 +9,7 @@ irdl.dialect @testRegionOpNegativeNumber {
 
 // -----
 
-irdl.dialect @testRegionsOpMissingName {
+irdl.dialect @test_regions_op_missing_name {
     irdl.operation @op {
         %r1 = irdl.region
         // expected-error @below {{expected valid keyword}}
@@ -19,17 +19,17 @@ irdl.dialect @testRegionsOpMissingName {
 
 // -----
 
-irdl.dialect @testRegionsOpWrongName {
+irdl.dialect @test_regions_op_wrong_name {
     irdl.operation @op {
         %r1 = irdl.region
-        // expected-error @below {{name of region #0 must contain only letters, digits and underscores}}
+        // expected-error @below {{name of region #0 must contain only lowercase letters, digits and underscores}}
         irdl.regions(test$test: %r1)
     }
 }
 
 // -----
 
-irdl.dialect @testRegionsDuplicateName {
+irdl.dialect @test_regions_duplicate_name {
     irdl.operation @op {
         %r1 = irdl.region
         // expected-error @below {{name of region #2 is a duplicate of the name of region #0}}
@@ -39,7 +39,7 @@ irdl.dialect @testRegionsDuplicateName {
 
 // -----
 
-irdl.dialect @testRegionsOpWrongOperation {
+irdl.dialect @test_regions_op_wrong_operation {
     irdl.operation @op {
         // expected-note @below {{prior use here}}
         %r1 = irdl.any

mlir/test/lib/Dialect/TestIRDLToCpp/test.testd.mlir

@@ -1,5 +1,5 @@
 // RUN: mlir-opt %s | FileCheck %s
+// CHECK: module {
 module {
-  // CHECK: %[[v0:[^ ]*]] = "test_irdl_to_cpp.bar"() : () -> !test_irdl_to_cpp.foo
   %0 = "test_irdl_to_cpp.bar"() : () -> !test_irdl_to_cpp.foo
 }