[mlir][Toy] Update the tutorial to use tablegen for dialect declarations

[rriddle]

Summary

This was missed when the feature was originally added.

[mehdi_amini]

Thanks!

mlir/docs/Tutorials/Toy/Ch-2.md

213

context.loadDialect?

216–217

This sentence is outdated

mlir/docs/Tutorials/Toy/Ch-7.md

197

I think you should remove expose here?

[jpienaar]

mlir/examples/toy/Ch2/mlir/Dialect.cpp

28

Instead of custom, dialect. This is where dialect types and operations are registered.

mlir/docs/Tutorials/Toy/Ch-2.md

 provide an easy avenue for high-level analysis and transformation.
 
 ```c++
 /// This is the definition of the Toy dialect. A dialect inherits from
 /// mlir::Dialect and registers custom attributes, operations, and types (in its
 /// constructor). It can also override virtual methods to change some general
 /// behavior, which will be demonstrated in later chapters of the tutorial.
 class ToyDialect : public mlir::Dialect {
- public:
   explicit ToyDialect(mlir::MLIRContext *ctx);
 
   /// Provide a utility accessor to the dialect namespace. This is used by
   /// several utilities.
   static llvm::StringRef getDialectNamespace() { return "toy"; }
+
+  /// An initializer called from the constructor of ToyDialect that is used to
+  /// register operations, types, and more within the Toy dialect.
+  void initialize();
 };
 ```
 
-The dialect can now be registered in the global registry:
+This is the C++ definition of a dialect, but MLIR also supports defining
+dialects declaratively via tablegen. Using the declarative specification is much
+cleaner as it removes the need for a large portion of the boilerplate when
+defining a new dialect. In the declarative format, the toy dialect would be
+specified as:
+
+```tablegen
+// Provide a definition of the 'toy' dialect in the ODS framework so that we
+// can define our operations.
+def Toy_Dialect : Dialect {
+  // The namespace of our dialect, this corresponds 1-1 with the string we
+  // provided in `ToyDialect::getDialectNamespace`.
+  let name = "toy";
+
+  // The C++ namespace that the dialect class definition resides in.
+  let cppNamespace = "toy";
+}
+```
+
+To see what this generates, we can run the `mlir-tblgen` command with the
+`gen-dialect-decls` action like so:
+
+```shell
+${build_root}/bin/mlir-tblgen -gen-dialect-decls ${mlir_src_root}/examples/toy/Ch2/include/toy/Ops.td -I ${mlir_src_root}/include/
+```
+
+The dialect can now be loaded into an MLIRContext:
 
 ```c++
-  mlir::registerDialect<ToyDialect>();
+  context.loadDialect<ToyDialect>();
 ```
 
 Any new `MLIRContext` created from now on will contain an instance of the Toy
 dialect and invoke specific hooks for things like parsing attributes and types.
 
 ## Defining Toy Operations
 
 Now that we have a `Toy` dialect, we can start registering operations. This will
 allow for providing semantic information that the rest of the system can hook
 into. Let's walk through the creation of the `toy.constant` operation:
 
 ```mlir
public:
   static void build(mlir::OpBuilder &builder, mlir::OperationState &state,
                     mlir::DenseElementsAttr value);
   /// Build a constant by broadcasting the given 'value'.
   static void build(mlir::OpBuilder &builder, mlir::OperationState &state,
                     double value);
 };
 ```
 
-and we register this operation in the `ToyDialect` constructor:
+and we register this operation in the `ToyDialect` initializer:
 
 ```c++
-ToyDialect::ToyDialect(mlir::MLIRContext *ctx)
-    : mlir::Dialect(getDialectNamespace(), ctx) {
+void ToyDialect::initialize() {
   addOperations<ConstantOp>();
 }
 ```
 
 ### Op vs Operation: Using MLIR Operations
 
 Now that we have defined an operation, we will want to access and
 transform it.  In MLIR, there are two main classes related to

 regarding an operation are specified concisely into a TableGen record, which
 will be expanded into an equivalent `mlir::Op` C++ template specialization at
 compile time. Using the ODS framework is the desired way for defining operations
 in MLIR given the simplicity, conciseness, and general stability in the face of
 C++ API changes.
 
 Lets see how to define the ODS equivalent of our ConstantOp:
 
-The first thing to do is to define a link to the Toy dialect that we defined in
-C++. This is used to link all of the operations that we will define to our
-dialect:
-
-```tablegen
-// Provide a definition of the 'toy' dialect in the ODS framework so that we
-// can define our operations.
-def Toy_Dialect : Dialect {
-  // The namespace of our dialect, this corresponds 1-1 with the string we
-  // provided in `ToyDialect::getDialectNamespace`.
-  let name = "toy";
-
-  // The C++ namespace that the dialect class definition resides in.
-  let cppNamespace = "toy";
-}
-```
-
-Now that we have defined a link to the Toy dialect, we can start defining
-operations. Operations in ODS are defined by inheriting from the `Op` class. To
-simplify our operation definitions, we will define a base class for operations
-in the Toy dialect.
+Operations in ODS are defined by inheriting from the `Op` class. To simplify our
+operation definitions, we will define a base class for operations in the Toy
+dialect.
 
 ```tablegen
 // Base class for toy dialect operations. This operation inherits from the base
 // `Op` class in OpBase.td, and provides:
 //   * The parent dialect of the operation.
 //   * The mnemonic for the operation, or the name without the dialect prefix.
 //   * A list of traits for the operation.
 class Toy_Op<string mnemonic, list<OpTrait> traits = []> :

mlir/docs/Tutorials/Toy/Ch-4.md

struct ToyInlinerInterface : public DialectInlinerInterface {
   }
 };
 ```
 
 We then register our dialect interface directly on the Toy dialect, similarly to
 how we did for operations.
 
 ```c++
-ToyDialect::ToyDialect(mlir::MLIRContext *ctx) : mlir::Dialect("toy", ctx) {
+void ToyDialect::initialize() {
   addInterfaces<ToyInlinerInterface>();
 }
 ```
 
 Next, we need to provide a way for the inliner to know that `toy.generic_call`
 represents a call to a function. MLIR provides an
 [operation interface](../../Interfaces.md#operation-interfaces) that can be used
 to mark an operation as being "call-like". Unlike dialect interfaces, operation

mlir/docs/Tutorials/Toy/Ch-7.md

llvm::ArrayRef<mlir::Type> getElementTypes() {
     return getImpl()->elementTypes;
   }
 
   /// Returns the number of element type held by this struct.
   size_t getNumElementTypes() { return getElementTypes().size(); }
 };
 ```
 
-We register this type in the `ToyDialect` constructor in a similar way to how we
+We register this type in the `ToyDialect` initializer in a similar way to how we
 did with operations:
 
 ```c++
-ToyDialect::ToyDialect(mlir::MLIRContext *ctx)
-    : mlir::Dialect(getDialectNamespace(), ctx) {
+void ToyDialect::initialize() {
   addTypes<StructType>();
 }
 ```
 
 (An important note here is that when registering a type, the definition of the
 storage class must be visible.)
 
 With this we can now use our `StructType` when generating MLIR from Toy. See
 examples/toy/Ch7/mlir/MLIRGen.cpp for more details.
 
+### Exposing to ODS
+
+After defining a new type, we should make the ODS framework aware of our Type so
+that we can use it in the operation definitions and auto-generate utilities
+within the Dialect. A simple example is shown below:
+
+```tablegen
+// Provide a definition for the Toy StructType for use in ODS. This allows for
+// using StructType in a similar way to Tensor or MemRef. We use `DialectType`
+// to demarcate the StructType as belonging to the Toy dialect.
+def Toy_StructType :
+    DialectType<Toy_Dialect, CPred<"$_self.isa<StructType>()">,
+                "Toy struct type">;
+
+// Provide a definition of the types that are used within the Toy dialect.
+def Toy_Type : AnyTypeOf<[F64Tensor, Toy_StructType]>;
+```
+
 ### Parsing and Printing
 
 At this point we can use our `StructType` during MLIR generation and
 transformation, but we can't output or parse `.mlir`. For this we need to add
 support for parsing and printing instances of the `StructType`. This can be done
 by overriding the `parseType` and `printType` methods on the `ToyDialect`.
+Declarations for these methods are automatically provided when the type is
+exposed to ODS as detailed in the previous section.
 
 ```c++
 class ToyDialect : public mlir::Dialect {
 public:
   /// Parse an instance of a type registered to the toy dialect.
   mlir::Type parseType(mlir::DialectAsmParser &parser) const override;
 
   /// Print an instance of a type registered to the toy dialect.

 
 ### Operating on `StructType`
 
 Now that the `struct` type has been defined, and we can round-trip it through
 the IR. The next step is to add support for using it within our operations.
 
 #### Updating Existing Operations
 
-A few of our existing operations will need to be updated to handle `StructType`.
-The first step is to make the ODS framework aware of our Type so that we can use
-it in the operation definitions. A simple example is shown below:
-
-```tablegen
-// Provide a definition for the Toy StructType for use in ODS. This allows for
-// using StructType in a similar way to Tensor or MemRef.
-def Toy_StructType :
-    Type<CPred<"$_self.isa<StructType>()">, "Toy struct type">;
-
-// Provide a definition of the types that are used within the Toy dialect.
-def Toy_Type : AnyTypeOf<[F64Tensor, Toy_StructType]>;
-```
-
-We can then update our operations, e.g. `ReturnOp`, to also accept the
-`Toy_StructType`:
+A few of our existing operations, e.g. `ReturnOp`, will need to be updated to
+handle `Toy_StructType`.
 
 ```tablegen
 def ReturnOp : Toy_Op<"return", [Terminator, HasParent<"FuncOp">]> {
   ...
   let arguments = (ins Variadic<Toy_Type>:$input);
   ...
 }
 ```

mlir/examples/toy/Ch2/include/toy/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Ops.td)
 mlir_tablegen(Ops.h.inc -gen-op-decls)
 mlir_tablegen(Ops.cpp.inc -gen-op-defs)
+mlir_tablegen(Dialect.h.inc -gen-dialect-decls)
 add_public_tablegen_target(ToyCh2OpsIncGen)

mlir/examples/toy/Ch2/include/toy/Dialect.h

 
 #ifndef MLIR_TUTORIAL_TOY_DIALECT_H_
 #define MLIR_TUTORIAL_TOY_DIALECT_H_
 
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
-namespace mlir {
-namespace toy {
-
-/// This is the definition of the Toy dialect. A dialect inherits from
-/// mlir::Dialect and registers custom attributes, operations, and types (in its
-/// constructor). It can also override some general behavior exposed via virtual
-/// methods.
-class ToyDialect : public mlir::Dialect {
-public:
-  explicit ToyDialect(mlir::MLIRContext *ctx);
-
-  /// Provide a utility accessor to the dialect namespace. This is used by
-  /// several utilities for casting between dialects.
-  static llvm::StringRef getDialectNamespace() { return "toy"; }
-};
-
-} // end namespace toy
-} // end namespace mlir
+/// Include the auto-generated header file containing the declaration of the toy
+/// dialect.
+#include "toy/Dialect.h.inc"
 
 /// Include the auto-generated header file containing the declarations of the
 /// toy operations.
 #define GET_OP_CLASSES
 #include "toy/Ops.h.inc"
 
 #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

mlir/examples/toy/Ch2/mlir/Dialect.cpp

 
 using namespace mlir;
 using namespace mlir::toy;
 
 //===----------------------------------------------------------------------===//
 // ToyDialect
 //===----------------------------------------------------------------------===//
 
-/// Dialect creation, the instance will be owned by the context. This is the
-/// point of registration of custom types and operations for the dialect.
-ToyDialect::ToyDialect(mlir::MLIRContext *ctx)
-    : mlir::Dialect(getDialectNamespace(), ctx, TypeID::get<ToyDialect>()) {
+/// Dialect initialization, the instance will be owned by the context. This is
+/// the point of registration of types and operations for the dialect.
+void ToyDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "toy/Ops.cpp.inc"
       >();
 }
 
 //===----------------------------------------------------------------------===//
 // Toy Operations

mlir/examples/toy/Ch3/include/toy/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Ops.td)
 mlir_tablegen(Ops.h.inc -gen-op-decls)
 mlir_tablegen(Ops.cpp.inc -gen-op-defs)
+mlir_tablegen(Dialect.h.inc -gen-dialect-decls)
 add_public_tablegen_target(ToyCh3OpsIncGen)

mlir/examples/toy/Ch3/include/toy/Dialect.h

 
 #ifndef MLIR_TUTORIAL_TOY_DIALECT_H_
 #define MLIR_TUTORIAL_TOY_DIALECT_H_
 
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
-namespace mlir {
-namespace toy {
-
-/// This is the definition of the Toy dialect. A dialect inherits from
-/// mlir::Dialect and registers custom attributes, operations, and types (in its
-/// constructor). It can also override some general behavior exposed via virtual
-/// methods.
-class ToyDialect : public mlir::Dialect {
-public:
-  explicit ToyDialect(mlir::MLIRContext *ctx);
-
-  /// Provide a utility accessor to the dialect namespace. This is used by
-  /// several utilities for casting between dialects.
-  static llvm::StringRef getDialectNamespace() { return "toy"; }
-};
-
-} // end namespace toy
-} // end namespace mlir
+/// Include the auto-generated header file containing the declaration of the toy
+/// dialect.
+#include "toy/Dialect.h.inc"
 
 /// Include the auto-generated header file containing the declarations of the
 /// toy operations.
 #define GET_OP_CLASSES
 #include "toy/Ops.h.inc"
 
 #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

mlir/examples/toy/Ch3/mlir/Dialect.cpp

 
 using namespace mlir;
 using namespace mlir::toy;
 
 //===----------------------------------------------------------------------===//
 // ToyDialect
 //===----------------------------------------------------------------------===//
 
-/// Dialect creation, the instance will be owned by the context. This is the
-/// point of registration of custom types and operations for the dialect.
-ToyDialect::ToyDialect(mlir::MLIRContext *ctx)
-    : mlir::Dialect(getDialectNamespace(), ctx, TypeID::get<ToyDialect>()) {
+/// Dialect initialization, the instance will be owned by the context. This is
+/// the point of registration of types and operations for the dialect.
+void ToyDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "toy/Ops.cpp.inc"
       >();
 }
 
 //===----------------------------------------------------------------------===//
 // Toy Operations

mlir/examples/toy/Ch4/include/toy/CMakeLists.txt

 # Most dialects should use add_mlir_dialect().  See examples/standalone.
 set(LLVM_TARGET_DEFINITIONS Ops.td)
 mlir_tablegen(Ops.h.inc -gen-op-decls)
 mlir_tablegen(Ops.cpp.inc -gen-op-defs)
+mlir_tablegen(Dialect.h.inc -gen-dialect-decls)
 add_public_tablegen_target(ToyCh4OpsIncGen)
 
 # Most dialects should use add_mlir_interfaces().
 set(LLVM_TARGET_DEFINITIONS ShapeInferenceInterface.td)
 mlir_tablegen(ShapeInferenceOpInterfaces.h.inc -gen-op-interface-decls)
 mlir_tablegen(ShapeInferenceOpInterfaces.cpp.inc -gen-op-interface-defs)
 add_public_tablegen_target(ToyCh4ShapeInferenceInterfaceIncGen)

mlir/examples/toy/Ch4/include/toy/Dialect.h

 
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/Interfaces/CastInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "toy/ShapeInferenceInterface.h"
 
-namespace mlir {
-namespace toy {
-
-/// This is the definition of the Toy dialect. A dialect inherits from
-/// mlir::Dialect and registers custom attributes, operations, and types (in its
-/// constructor). It can also override some general behavior exposed via virtual
-/// methods.
-class ToyDialect : public mlir::Dialect {
-public:
-  explicit ToyDialect(mlir::MLIRContext *ctx);
-
-  /// Provide a utility accessor to the dialect namespace. This is used by
-  /// several utilities for casting between dialects.
-  static llvm::StringRef getDialectNamespace() { return "toy"; }
-};
-
-} // end namespace toy
-} // end namespace mlir
+/// Include the auto-generated header file containing the declaration of the toy
+/// dialect.
+#include "toy/Dialect.h.inc"
 
 /// Include the auto-generated header file containing the declarations of the
 /// toy operations.
 #define GET_OP_CLASSES
 #include "toy/Ops.h.inc"
 
 #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

mlir/examples/toy/Ch4/mlir/Dialect.cpp

Operation *materializeCallConversion(OpBuilder &builder, Value input,
     return builder.create<CastOp>(conversionLoc, resultType, input);
   }
 };
 
 //===----------------------------------------------------------------------===//
 // ToyDialect
 //===----------------------------------------------------------------------===//
 
-/// Dialect creation, the instance will be owned by the context. This is the
-/// point of registration of custom types and operations for the dialect.
-ToyDialect::ToyDialect(mlir::MLIRContext *ctx)
-    : mlir::Dialect(getDialectNamespace(), ctx, TypeID::get<ToyDialect>()) {
+/// Dialect initialization, the instance will be owned by the context. This is
+/// the point of registration of types and operations for the dialect.
+void ToyDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "toy/Ops.cpp.inc"
       >();
   addInterfaces<ToyInlinerInterface>();
 }
 
 //===----------------------------------------------------------------------===//

mlir/examples/toy/Ch5/include/toy/CMakeLists.txt

 # Most dialects should use add_mlir_dialect().  See examples/standalone.
 set(LLVM_TARGET_DEFINITIONS Ops.td)
 mlir_tablegen(Ops.h.inc -gen-op-decls)
 mlir_tablegen(Ops.cpp.inc -gen-op-defs)
+mlir_tablegen(Dialect.h.inc -gen-dialect-decls)
 add_public_tablegen_target(ToyCh5OpsIncGen)
 
 # Most dialects should use add_mlir_interfaces().
 set(LLVM_TARGET_DEFINITIONS ShapeInferenceInterface.td)
 mlir_tablegen(ShapeInferenceOpInterfaces.h.inc -gen-op-interface-decls)
 mlir_tablegen(ShapeInferenceOpInterfaces.cpp.inc -gen-op-interface-defs)
 add_public_tablegen_target(ToyCh5ShapeInferenceInterfaceIncGen)

mlir/examples/toy/Ch5/include/toy/Dialect.h

 
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/Interfaces/CastInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "toy/ShapeInferenceInterface.h"
 
-namespace mlir {
-namespace toy {
-
-/// This is the definition of the Toy dialect. A dialect inherits from
-/// mlir::Dialect and registers custom attributes, operations, and types (in its
-/// constructor). It can also override some general behavior exposed via virtual
-/// methods.
-class ToyDialect : public mlir::Dialect {
-public:
-  explicit ToyDialect(mlir::MLIRContext *ctx);
-
-  /// Provide a utility accessor to the dialect namespace. This is used by
-  /// several utilities for casting between dialects.
-  static llvm::StringRef getDialectNamespace() { return "toy"; }
-};
-
-} // end namespace toy
-} // end namespace mlir
+/// Include the auto-generated header file containing the declaration of the toy
+/// dialect.
+#include "toy/Dialect.h.inc"
 
 /// Include the auto-generated header file containing the declarations of the
 /// toy operations.
 #define GET_OP_CLASSES
 #include "toy/Ops.h.inc"
 
 #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

mlir/examples/toy/Ch5/mlir/Dialect.cpp

Operation *materializeCallConversion(OpBuilder &builder, Value input,
     return builder.create<CastOp>(conversionLoc, resultType, input);
   }
 };
 
 //===----------------------------------------------------------------------===//
 // ToyDialect
 //===----------------------------------------------------------------------===//
 
-/// Dialect creation, the instance will be owned by the context. This is the
-/// point of registration of custom types and operations for the dialect.
-ToyDialect::ToyDialect(mlir::MLIRContext *ctx)
-    : mlir::Dialect(getDialectNamespace(), ctx, TypeID::get<ToyDialect>()) {
+/// Dialect initialization, the instance will be owned by the context. This is
+/// the point of registration of types and operations for the dialect.
+void ToyDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "toy/Ops.cpp.inc"
       >();
   addInterfaces<ToyInlinerInterface>();
 }
 
 //===----------------------------------------------------------------------===//

mlir/examples/toy/Ch6/include/toy/CMakeLists.txt

 # Most dialects should use add_mlir_dialect().  See examples/standalone.
 set(LLVM_TARGET_DEFINITIONS Ops.td)
 mlir_tablegen(Ops.h.inc -gen-op-decls)
 mlir_tablegen(Ops.cpp.inc -gen-op-defs)
+mlir_tablegen(Dialect.h.inc -gen-dialect-decls)
 add_public_tablegen_target(ToyCh6OpsIncGen)
 
 # Most dialects should use add_mlir_interfaces().
 set(LLVM_TARGET_DEFINITIONS ShapeInferenceInterface.td)
 mlir_tablegen(ShapeInferenceOpInterfaces.h.inc -gen-op-interface-decls)
 mlir_tablegen(ShapeInferenceOpInterfaces.cpp.inc -gen-op-interface-defs)
 add_public_tablegen_target(ToyCh6ShapeInferenceInterfaceIncGen)

mlir/examples/toy/Ch6/include/toy/Dialect.h

 
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/Interfaces/CastInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "toy/ShapeInferenceInterface.h"
 
-namespace mlir {
-namespace toy {
-
-/// This is the definition of the Toy dialect. A dialect inherits from
-/// mlir::Dialect and registers custom attributes, operations, and types (in its
-/// constructor). It can also override some general behavior exposed via virtual
-/// methods.
-class ToyDialect : public mlir::Dialect {
-public:
-  explicit ToyDialect(mlir::MLIRContext *ctx);
-
-  /// Provide a utility accessor to the dialect namespace. This is used by
-  /// several utilities for casting between dialects.
-  static llvm::StringRef getDialectNamespace() { return "toy"; }
-};
-
-} // end namespace toy
-} // end namespace mlir
+/// Include the auto-generated header file containing the declaration of the toy
+/// dialect.
+#include "toy/Dialect.h.inc"
 
 /// Include the auto-generated header file containing the declarations of the
 /// toy operations.
 #define GET_OP_CLASSES
 #include "toy/Ops.h.inc"
 
 #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

mlir/examples/toy/Ch6/mlir/Dialect.cpp

Operation *materializeCallConversion(OpBuilder &builder, Value input,
     return builder.create<CastOp>(conversionLoc, resultType, input);
   }
 };
 
 //===----------------------------------------------------------------------===//
 // ToyDialect
 //===----------------------------------------------------------------------===//
 
-/// Dialect creation, the instance will be owned by the context. This is the
-/// point of registration of custom types and operations for the dialect.
-ToyDialect::ToyDialect(mlir::MLIRContext *ctx)
-    : mlir::Dialect(getDialectNamespace(), ctx, TypeID::get<ToyDialect>()) {
+/// Dialect initialization, the instance will be owned by the context. This is
+/// the point of registration of types and operations for the dialect.
+void ToyDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "toy/Ops.cpp.inc"
       >();
   addInterfaces<ToyInlinerInterface>();
 }
 
 //===----------------------------------------------------------------------===//

mlir/examples/toy/Ch7/include/toy/CMakeLists.txt

 # Most dialects should use add_mlir_dialect().  See examples/standalone.
 set(LLVM_TARGET_DEFINITIONS Ops.td)
 mlir_tablegen(Ops.h.inc -gen-op-decls)
 mlir_tablegen(Ops.cpp.inc -gen-op-defs)
+mlir_tablegen(Dialect.h.inc -gen-dialect-decls)
 add_public_tablegen_target(ToyCh7OpsIncGen)
 
 # Most dialects should use add_mlir_interfaces().
 set(LLVM_TARGET_DEFINITIONS ShapeInferenceInterface.td)
 mlir_tablegen(ShapeInferenceOpInterfaces.h.inc -gen-op-interface-decls)
 mlir_tablegen(ShapeInferenceOpInterfaces.cpp.inc -gen-op-interface-defs)
 add_public_tablegen_target(ToyCh7ShapeInferenceInterfaceIncGen)

mlir/examples/toy/Ch7/include/toy/Dialect.h

 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "toy/ShapeInferenceInterface.h"
 
 namespace mlir {
 namespace toy {
 namespace detail {
 struct StructTypeStorage;
 } // end namespace detail
-
-/// This is the definition of the Toy dialect. A dialect inherits from
-/// mlir::Dialect and registers custom attributes, operations, and types (in its
-/// constructor). It can also override some general behavior exposed via virtual
-/// methods.
-class ToyDialect : public mlir::Dialect {
-public:
-  explicit ToyDialect(mlir::MLIRContext *ctx);
-
-  /// A hook used to materialize constant values with the given type.
-  Operation *materializeConstant(OpBuilder &builder, Attribute value, Type type,
-                                 Location loc) override;
-
-  /// Parse an instance of a type registered to the toy dialect.
-  mlir::Type parseType(mlir::DialectAsmParser &parser) const override;
-
-  /// Print an instance of a type registered to the toy dialect.
-  void printType(mlir::Type type,
-                 mlir::DialectAsmPrinter &printer) const override;
-
-  /// Provide a utility accessor to the dialect namespace. This is used by
-  /// several utilities for casting between dialects.
-  static llvm::StringRef getDialectNamespace() { return "toy"; }
-};
-
 } // end namespace toy
 } // end namespace mlir
 
+/// Include the auto-generated header file containing the declaration of the toy
+/// dialect.
+#include "toy/Dialect.h.inc"
+
 //===----------------------------------------------------------------------===//
 // Toy Operations
 //===----------------------------------------------------------------------===//
 
 /// Include the auto-generated header file containing the declarations of the
 /// toy operations.
 #define GET_OP_CLASSES
 #include "toy/Ops.h.inc"

mlir/examples/toy/Ch7/include/toy/Ops.td

 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "toy/ShapeInferenceInterface.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
   let name = "toy";
   let cppNamespace = "::mlir::toy";
+
+  // We set this bit to generate a declaration of the `materializeConstant`
+  // method so that we can materialize constants for our toy operations.
+  let hasConstantMaterializer = 1;
 }
 
 // Base class for toy dialect operations. This operation inherits from the base
 // `Op` class in OpBase.td, and provides:
 //   * The parent dialect of the operation.
 //   * The mnemonic for the operation, or the name without the dialect prefix.
 //   * A list of traits for the operation.
 class Toy_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<Toy_Dialect, mnemonic, traits>;
 
 // Provide a definition for the Toy StructType for use in ODS. This allows for
-// using StructType in a similar way to Tensor or MemRef.
+// using StructType in a similar way to Tensor or MemRef. We use `DialectType`
+// to demarcate the StructType as belonging to the Toy dialect.
 def Toy_StructType :
-    Type<CPred<"$_self.isa<StructType>()">, "Toy struct type">;
+    DialectType<Toy_Dialect, CPred<"$_self.isa<StructType>()">,
+                "Toy struct type">;
 
 // Provide a definition of the types that are used within the Toy dialect.
 def Toy_Type : AnyTypeOf<[F64Tensor, Toy_StructType]>;
 
 //===----------------------------------------------------------------------===//
 // Toy Operations
 //===----------------------------------------------------------------------===//
 

mlir/examples/toy/Ch7/mlir/Dialect.cpp

 
 #define GET_OP_CLASSES
 #include "toy/Ops.cpp.inc"
 
 //===----------------------------------------------------------------------===//
 // ToyDialect
 //===----------------------------------------------------------------------===//
 
-/// Dialect creation, the instance will be owned by the context. This is the
-/// point of registration of custom types and operations for the dialect.
-ToyDialect::ToyDialect(mlir::MLIRContext *ctx)
-    : mlir::Dialect(getDialectNamespace(), ctx, TypeID::get<ToyDialect>()) {
+/// Dialect initialization, the instance will be owned by the context. This is
+/// the point of registration of types and operations for the dialect.
+void ToyDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "toy/Ops.cpp.inc"
       >();
   addInterfaces<ToyInlinerInterface>();
   addTypes<StructType>();
 }