[mlir][PDL] Use ODS for defining PDL types

[rriddle]

Summary

This removes the need to define these classes and their parser/printers in C++.

Depends On D94133

[mehdi_amini]

mlir/lib/TableGen/Type.cpp

72

This seems orthogonal to PDL, can you split it out?

[rriddle]

Rebase

[rriddle]

Rebase

[rriddle]

Rebase

[antiagainst]

Looks neat! :)

mlir/include/mlir/Dialect/PDL/IR/PDL.h

 //===- PDL.h - Pattern Descriptor Language Dialect --------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the dialect for the Pattern Descriptor Language.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_PDL_IR_PDL_H_
 #define MLIR_DIALECT_PDL_IR_PDL_H_
 
-#include "mlir/IR/Builders.h"
 #include "mlir/IR/Dialect.h"
-#include "mlir/IR/OpImplementation.h"
-#include "mlir/IR/SymbolTable.h"
-#include "mlir/Interfaces/SideEffectInterfaces.h"
 
 //===----------------------------------------------------------------------===//
 // PDL Dialect
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/PDL/IR/PDLOpsDialect.h.inc"
 
-//===----------------------------------------------------------------------===//
-// PDL Dialect Operations
-//===----------------------------------------------------------------------===//
-
-#define GET_OP_CLASSES
-#include "mlir/Dialect/PDL/IR/PDLOps.h.inc"
-
-
 #endif // MLIR_DIALECT_PDL_IR_PDL_H_

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

-//===- PDLBase.td - PDL base definitions -------------------*- tablegen -*-===//
+//===- PDLDialect.td - PDL dialect definition --------------*- tablegen -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// Defines base support for MLIR PDL operations.
+// Defines the MLIR PDL dialect.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_PDL_IR_PDLBASE
-#define MLIR_DIALECT_PDL_IR_PDLBASE
+#ifndef MLIR_DIALECT_PDL_IR_PDLDIALECT
+#define MLIR_DIALECT_PDL_IR_PDLDIALECT
 
 include "mlir/IR/OpBase.td"
 
 //===----------------------------------------------------------------------===//
 // PDL Dialect
 //===----------------------------------------------------------------------===//
 
 def PDL_Dialect : Dialect {
string description = [{
     other features such as applying external constraints or external generator
     methods. These features and more are detailed below.
   }];
 
   let name = "pdl";
   let cppNamespace = "::mlir::pdl";
 }
 
-//===----------------------------------------------------------------------===//
-// PDL Types
-//===----------------------------------------------------------------------===//
-
-class PDL_Handle<string underlying> :
-    DialectType<PDL_Dialect, CPred<"$_self.isa<" # underlying # ">()">,
-                underlying>,
-    BuildableType<"$_builder.getType<" # underlying # ">()">;
-
-// Handle for `mlir::Attribute`.
-def PDL_Attribute : PDL_Handle<"mlir::pdl::AttributeType">;
-
-// Handle for `mlir::Operation*`.
-def PDL_Operation : PDL_Handle<"mlir::pdl::OperationType">;
-
-// Handle for `mlir::Type`.
-def PDL_Type : PDL_Handle<"mlir::pdl::TypeType">;
-
-// Handle for `mlir::Value`.
-def PDL_Value : PDL_Handle<"mlir::pdl::ValueType">;
-
-// A positional value is a location on a pattern DAG, which may be an operation,
-// an attribute, or an operand/result.
-def PDL_PositionalValue :
-    AnyTypeOf<[PDL_Attribute, PDL_Operation, PDL_Type, PDL_Value],
-              "Positional Value">;
-
-#endif // MLIR_DIALECT_PDL_IR_PDLBASE
+#endif // MLIR_DIALECT_PDL_IR_PDLDIALECT

mlir/include/mlir/Dialect/PDL/IR/PDLOps.h

-//===- PDL.h - Pattern Descriptor Language Dialect --------------*- C++ -*-===//
+//===- PDLOps.h - Pattern Descriptor Language Operations --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// This file defines the dialect for the Pattern Descriptor Language.
+// This file defines the operations for the Pattern Descriptor Language dialect.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_PDL_IR_PDL_H_
-#define MLIR_DIALECT_PDL_IR_PDL_H_
+#ifndef MLIR_DIALECT_PDL_IR_PDLOPS_H_
+#define MLIR_DIALECT_PDL_IR_PDLOPS_H_
 
+#include "mlir/Dialect/PDL/IR/PDLTypes.h"
 #include "mlir/IR/Builders.h"
-#include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
 //===----------------------------------------------------------------------===//
-// PDL Dialect
-//===----------------------------------------------------------------------===//
-
-#include "mlir/Dialect/PDL/IR/PDLOpsDialect.h.inc"
-
-//===----------------------------------------------------------------------===//
 // PDL Dialect Operations
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/PDL/IR/PDLOps.h.inc"
 
-
-#endif // MLIR_DIALECT_PDL_IR_PDL_H_
+#endif // MLIR_DIALECT_PDL_IR_PDLOPS_H_

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

 //===- PDLOps.td - Pattern descriptor operations -----------*- tablegen -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the Pattern Descriptor Language dialect operations.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_PDL_IR_PDLOPS
 #define MLIR_DIALECT_PDL_IR_PDLOPS
 
-include "mlir/Dialect/PDL/IR/PDLBase.td"
+include "mlir/Dialect/PDL/IR/PDLTypes.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/IR/SymbolInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // PDL Ops
 //===----------------------------------------------------------------------===//
 
 class PDL_Op<string mnemonic, list<OpTrait> traits = []>

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

-//===- PDL.h - Pattern Descriptor Language Types ----------------*- C++ -*-===//
+//===- PDLTypes.h - Pattern Descriptor Language Types -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the types for the Pattern Descriptor Language dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_PDL_IR_PDLTYPES_H_
 #define MLIR_DIALECT_PDL_IR_PDLTYPES_H_
 
 #include "mlir/IR/Types.h"
 
-namespace mlir {
-namespace pdl {
 //===----------------------------------------------------------------------===//
 // PDL Dialect Types
 //===----------------------------------------------------------------------===//
 
-/// This type represents a handle to an `mlir::Attribute`.
-struct AttributeType : public Type::TypeBase<AttributeType, Type, TypeStorage> {
-  using Base::Base;
-};
-
-/// This type represents a handle to an `mlir::Operation*`.
-struct OperationType : public Type::TypeBase<OperationType, Type, TypeStorage> {
-  using Base::Base;
-};
-
-/// This type represents a handle to an `mlir::Type`.
-struct TypeType : public Type::TypeBase<TypeType, Type, TypeStorage> {
-  using Base::Base;
-};
-
-/// This type represents a handle to an `mlir::Value`.
-struct ValueType : public Type::TypeBase<ValueType, Type, TypeStorage> {
-  using Base::Base;
-};
-
-} // end namespace pdl
-} // end namespace mlir
+#define GET_TYPEDEF_CLASSES
+#include "mlir/Dialect/PDL/IR/PDLTypes.h.inc"
 
 #endif // MLIR_DIALECT_PDL_IR_PDLTYPES_H_

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

+//===- PDLTypes.td - Pattern descriptor types --------------*- tablegen -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the Pattern Descriptor Language dialect types.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_PDL_IR_PDLTYPES
+#define MLIR_DIALECT_PDL_IR_PDLTYPES
+
+include "mlir/Dialect/PDL/IR/PDLDialect.td"
+
+//===----------------------------------------------------------------------===//
+// PDL Types
+//===----------------------------------------------------------------------===//
+
+class PDL_Type<string name, string typeMnemonic> : TypeDef<PDL_Dialect, name> {
+  let mnemonic = typeMnemonic;
+}
+
+//===----------------------------------------------------------------------===//
+// pdl::AttributeType
+//===----------------------------------------------------------------------===//
+
+def PDL_Attribute : PDL_Type<"Attribute", "attribute"> {
+  let summary = "PDL handle to an `mlir::Attribute`";
+  let description = [{
+    This type represents a handle to an instance of an `mlir::Attribute`, bound
+    to a value that is usable within a PDL pattern or rewrite.
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl::OperationType
+//===----------------------------------------------------------------------===//
+
+def PDL_Operation : PDL_Type<"Operation", "operation"> {
+  let summary = "PDL handle to an `mlir::Operation *`";
+  let description = [{
+    This type represents a handle to an instance of an `mlir::Operation *`,
+    bound to a value that is usable within a PDL pattern or rewrite.
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl::TypeType
+//===----------------------------------------------------------------------===//
+
+def PDL_Type : PDL_Type<"Type", "type"> {
+  let summary = "PDL handle to an `mlir::Type`";
+  let description = [{
+    This type represents a handle to an instance of an `mlir::Type`, bound to a
+    value that is usable within a PDL pattern or rewrite.
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl::ValueType
+//===----------------------------------------------------------------------===//
+
+def PDL_Value : PDL_Type<"Value", "value"> {
+  let summary = "PDL handle for an `mlir::Value`";
+  let description = [{
+    This type represents a handle to an instance of an `mlir::Value`, bound to a
+    value that is usable within a PDL pattern or rewrite.
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// Additional Type Constraints
+//===----------------------------------------------------------------------===//
+
+// A positional value is a location on a pattern DAG, which may be an attribute,
+// operation, or operand/result.
+def PDL_PositionalValue :
+    AnyTypeOf<[PDL_Attribute, PDL_Operation, PDL_Type, PDL_Value],
+              "Positional Value">;
+
+#endif // MLIR_DIALECT_PDL_IR_PDLTYPES

mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterp.h

 // language.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_PDLINTERP_IR_PDLINTERP_H_
 #define MLIR_DIALECT_PDLINTERP_IR_PDLINTERP_H_
 
 #include "mlir/Dialect/PDL/IR/PDL.h"
+#include "mlir/Dialect/PDL/IR/PDLTypes.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
 //===----------------------------------------------------------------------===//
 // PDLInterp Dialect
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/PDLInterp/IR/PDLInterpOpsDialect.h.inc"

mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td

 //===- PDLInterpOps.td - Pattern Interpreter Dialect -------*- tablegen -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the PDL interpreter dialect ops.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_PDLINTERP_IR_PDLINTERPOPS
 #define MLIR_DIALECT_PDLINTERP_IR_PDLINTERPOPS
 
-include "mlir/Dialect/PDL/IR/PDLBase.td"
+include "mlir/Dialect/PDL/IR/PDLTypes.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // PDLInterp Dialect
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_Dialect : Dialect {
   let summary = "Interpreted pattern execution dialect";

mlir/include/mlir/IR/OpBase.td

 
 // Any type from the given list
 class AnyTypeOf<list<Type> allowedTypes, string summary = "",
                 string cppClassName = "::mlir::Type"> : Type<
     // Satisfy any of the allowed type's condition
     Or<!foreach(allowedtype, allowedTypes, allowedtype.predicate)>,
     !if(!eq(summary, ""),
         !interleave(!foreach(t, allowedTypes, t.summary), " or "),
-        summary)>;
+        summary),
+    cppClassName>;
 
 // Integer types.
 
 // Any integer type irrespective of its width and signedness semantics.
 def AnyInteger : Type<CPred<"$_self.isa<::mlir::IntegerType>()">, "integer",
                       "::mlir::IntegerType">;
 
 // Any integer type (regardless of signedness semantics) of a specific width.

mlir/include/mlir/TableGen/Type.h

public:
   // variadic or optional.
   bool isVariableLength() const { return isOptional() || isVariadic(); }
 
   // Returns the builder call for this constraint if this is a buildable type,
   // returns None otherwise.
   Optional<StringRef> getBuilderCall() const;
 
   // Return the C++ class name for this type (which may just be ::mlir::Type).
-  StringRef getCPPClassName() const;
+  std::string getCPPClassName() const;
 };
 
 // Wrapper class with helper methods for accessing Types defined in TableGen.
 class Type : public TypeConstraint {
 public:
   explicit Type(const llvm::Record *record);
 
   // Returns the description of the type.

mlir/lib/Conversion/PDLToPDLInterp/PredicateTree.h

 // the general control flow within a pattern match.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_LIB_CONVERSION_PDLTOPDLINTERP_PREDICATETREE_H_
 #define MLIR_LIB_CONVERSION_PDLTOPDLINTERP_PREDICATETREE_H_
 
 #include "Predicate.h"
-#include "mlir/Dialect/PDL/IR/PDL.h"
+#include "mlir/Dialect/PDL/IR/PDLOps.h"
 #include "llvm/ADT/MapVector.h"
 
 namespace mlir {
 class ModuleOp;
 
 namespace pdl_to_pdl_interp {
 
 class MatcherNode;

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

 //===- PDL.cpp - Pattern Descriptor Language Dialect ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/PDL/IR/PDL.h"
+#include "mlir/Dialect/PDL/IR/PDLOps.h"
 #include "mlir/Dialect/PDL/IR/PDLTypes.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"
 #include "llvm/ADT/StringSwitch.h"
 
 using namespace mlir;
 using namespace mlir::pdl;

mlir/lib/Rewrite/FrozenRewritePatternList.cpp

 //===- FrozenRewritePatternList.cpp - Frozen Pattern List -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Rewrite/FrozenRewritePatternList.h"
 #include "ByteCode.h"
 #include "mlir/Conversion/PDLToPDLInterp/PDLToPDLInterp.h"
-#include "mlir/Dialect/PDL/IR/PDL.h"
+#include "mlir/Dialect/PDL/IR/PDLOps.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 
 using namespace mlir;
 
 static LogicalResult convertPDLToPDLInterp(ModuleOp pdlModule) {
   // Skip the conversion if the module doesn't contain pdl.

mlir/lib/TableGen/Type.cpp

 //===- Type.cpp - Type class ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Type wrapper to simplify using TableGen Record defining a MLIR Type.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/TableGen/Type.h"
+#include "mlir/TableGen/Dialect.h"
+#include "llvm/ADT/Twine.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace mlir;
 using namespace mlir::tblgen;
 
 TypeConstraint::TypeConstraint(const llvm::Record *record)
     : Constraint(Constraint::CK_Type, record) {
return TypeSwitch<llvm::Init *, Optional<StringRef>>(builderCall->getValue())
       .Case<llvm::StringInit>([&](auto *init) {
         StringRef value = init->getValue();
         return value.empty() ? Optional<StringRef>() : value;
       })
       .Default([](auto *) { return llvm::None; });
 }
 
 // Return the C++ class name for this type (which may just be ::mlir::Type).
-StringRef TypeConstraint::getCPPClassName() const {
-  return def->getValueAsString("cppClassName");
+std::string TypeConstraint::getCPPClassName() const {
+  StringRef className = def->getValueAsString("cppClassName");
+
+  // If the class name is already namespace resolved, use it.
+  if (className.contains("::"))
+    return className.str();
+
+  // Otherwise, check to see if there is a namespace from a dialect to prepend.
+  if (const llvm::RecordVal *value = def->getValue("dialect")) {
+    Dialect dialect(cast<const llvm::DefInit>(value->getValue())->getDef());
+    return (dialect.getCppNamespace() + "::" + className).str();
+  }
+  return className.str();
 }
 
 Type::Type(const llvm::Record *record) : TypeConstraint(record) {}
 
 StringRef Type::getDescription() const {
   return def->getValueAsString("description");
 }
 
 Dialect Type::getDialect() const {
   return Dialect(def->getValueAsDef("dialect"));
 }