[mlir] Use PDLL instead of TableGen DRR in the toy tutorial

[rriddle]

Summary

TableGen DRR is on its way out, and moving forward we want to
push new users towards PDLL instead.

mlir/docs/PatternRewriter.md

 ```
 
 ### Construction
 
 Constructing a RewritePattern should be performed by using the static
 `RewritePattern::create<T>` utility method. This method ensures that the pattern
 is properly initialized and prepared for insertion into a `RewritePatternSet`.
 
+## Defining Patterns with PDLL
+
+In addition to the C++ pattern definitions detailed in the
+[section above](#defining-patterns), MLIR also provides a custom language for
+defining patterns declaratively via PDLL. PDLL is a language built from the
+ground up for supporting MLIR pattern rewrites, with a focus on expressability
+and developer tooling. See the main [PDLL documentation](PDLL.md) for details
+on defining patterns this way.
+
 ## Pattern Rewriter
 
 A `PatternRewriter` is a special class that allows for a pattern to communicate
 with the driver of pattern application. As noted above, *all* IR mutations,
 including creations, are required to be performed via the `PatternRewriter`
 class. This is required because the underlying pattern driver may have state
 that would be invalidated when a mutation takes place. Examples of some of the
 more prevalent `PatternRewriter` API is shown below, please refer to the

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

 
 We divide compiler transformations into two categories: local and global. In
 this chapter, we focus on how to leverage the Toy Dialect and its high-level
 semantics to perform local pattern-match transformations that would be difficult
 in LLVM. For this, we use MLIR's
 [Generic DAG Rewriter](../../PatternRewriter.md).
 
 There are two methods that can be used to implement pattern-match
-transformations: 1. Imperative, C++ pattern-match and rewrite 2. Declarative,
-rule-based pattern-match and rewrite using table-driven
-[Declarative Rewrite Rules](../../DeclarativeRewrites.md) (DRR). Note that the
-use of DRR requires that the operations be defined using ODS, as described in
-[Chapter 2](Ch-2.md).
+transformations:
+
+1. Imperatively: C++ pattern-match and rewrite
+1. Declaratively: Pattern-match and rewrite using [PDLL](../../PDLL.md).
 
 ## Optimize Transpose using C++ style pattern-match and rewrite
 
 Let's start with a simple pattern and try to eliminate a sequence of two
 transposes that cancel out: `transpose(transpose(X)) -> X`. Here is the
 corresponding Toy example:
 
 ```toy
struct SimplifyRedundantTranspose : public mlir::OpRewritePattern<TransposeOp> {
   }
 };
 ```
 
 The implementation of this rewriter is in `ToyCombine.cpp`. The
 [canonicalization pass](../../Canonicalization.md) applies transformations
 defined by operations in a greedy, iterative manner. To ensure that the
 canonicalization pass applies our new transform, we set
-[hasCanonicalizer = 1](../../OpDefinitions.md/#hascanonicalizer) and register the
-pattern with the canonicalization framework.
+[hasCanonicalizer = 1](../../OpDefinitions.md/#hascanonicalizer) and register
+the pattern with the canonicalization framework.
 
 ```c++
 // Register our patterns for rewrite by the Canonicalization framework.
 void TransposeOp::getCanonicalizationPatterns(
     RewritePatternSet &results, MLIRContext *context) {
   results.add<SimplifyRedundantTranspose>(context);
 }
 ```
 
 We also need to update our main file, `toyc.cpp`, to add an optimization
 pipeline. In MLIR, the optimizations are run through a `PassManager` in a
 similar way to LLVM:
 
 ```c++
   mlir::PassManager pm(module.getContext());
   pm.addNestedPass<mlir::toy::FuncOp>(mlir::createCanonicalizerPass());
 ```
 
-Finally, we can run `toyc-ch3 test/Examples/Toy/Ch3/transpose_transpose.toy 
--emit=mlir -opt` and observe our pattern in action:
+Finally, we can run
+`toyc-ch3 test/Examples/Toy/Ch3/transpose_transpose.toy -emit=mlir -opt` and
+observe our pattern in action:
 
 ```mlir
 toy.func @transpose_transpose(%arg0: tensor<*xf64>) -> tensor<*xf64> {
   %0 = toy.transpose(%arg0 : tensor<*xf64>) to tensor<*xf64>
   toy.return %arg0 : tensor<*xf64>
 }
 ```
 

 ```mlir
 toy.func @transpose_transpose(%arg0: tensor<*xf64>) -> tensor<*xf64> {
   toy.return %arg0 : tensor<*xf64>
 }
 ```
 
 Perfect! No `transpose` operation is left - the code is optimal.
 
-In the next section, we use DRR for pattern match optimizations associated with
+In the next section, we use PDLL for pattern match optimizations associated with
 the Reshape op.
 
-## Optimize Reshapes using DRR
-
-Declarative, rule-based pattern-match and rewrite (DRR) is an operation
-DAG-based declarative rewriter that provides a table-based syntax for
-pattern-match and rewrite rules:
+## Optimize Reshapes using PDLL
 
-```tablegen
-class Pattern<
-    dag sourcePattern, list<dag> resultPatterns,
-    list<dag> additionalConstraints = [],
-    dag benefitsAdded = (addBenefit 0)>;
-```
+PDLL provides a declarative language with which to define our pattern rewrites,
+with a syntax designed to mimic the IR we want to transform. A redundant reshape
+optimization similar to SimplifyRedundantTranspose can be expressed more simply
+using PDLL as follows:
 
-A redundant reshape optimization similar to SimplifyRedundantTranspose can be
-expressed more simply using DRR as follows:
+```pdll
+#include "toy/Ops.td"
 
-```tablegen
 // Reshape(Reshape(x)) = Reshape(x)
-def ReshapeReshapeOptPattern : Pat<(ReshapeOp(ReshapeOp $arg)),
-                                   (ReshapeOp $arg)>;
+Pattern ReshapeReshapeOptPattern {
+  replace op<toy.reshape>(op<toy.reshape>(arg: Value))
+    with op<toy.reshape>(arg);
+}
 ```
 
-The automatically generated C++ code corresponding to each of the DRR patterns
-can be found under `path/to/BUILD/tools/mlir/examples/toy/Ch3/ToyCombine.inc`.
+There are a few pieces to unpack here, let's walk through them. Firstly, at the
+top of the pattern we include our Toy operation definitions. This isn't strictly
+necessary, but it gives PDLL access to our ODS operations, interfaces, and more.
+This allows for more powerful error handling, tooling, and more.
+
+For the pattern itself, each `op<toy.reshape>` represents an
+["Operation Expression"](../../PDLL.md#operation-expression), which is what we
+use to describe the IR we are matching and to define what operations we want to
+create. The structure of these expressions matches nearly 1-1 with the generic
+format of our toy operations, with a little bit of sugar on top. The
+`arg: Value` represents an
+[inline variable definition](../../PDLL.md#inline-variable-definition) of a
+Value, which in this case is an unknown input operand to the inner reshape.
 
-DRR also provides a method for adding argument constraints when the
-transformation is conditional on some properties of the arguments and results.
-An example is a transformation that eliminates reshapes when they are redundant,
-i.e. when the input and output shapes are identical.
+The structure of the pattern is a bit more clear if we outline each step into
+separate variables:
 
-```tablegen
-def TypesAreIdentical : Constraint<CPred<"$0.getType() == $1.getType()">>;
-def RedundantReshapeOptPattern : Pat<
-  (ReshapeOp:$res $arg), (replaceWithValue $arg),
-  [(TypesAreIdentical $res, $arg)]>;
+```pdll
+// Reshape(Reshape(x)) = Reshape(x)
+Pattern ReshapeReshapeOptPattern {
+  let arg: Value;
+  let innerReshape = op<toy.reshape>(arg);
+  let reshape = op<toy.reshape>(innerReshape);
+  replace reshape with op<toy.reshape>(arg);
+}
 ```
 
-Some optimizations may require additional transformations on instruction
-arguments. This is achieved using NativeCodeCall, which allows for more complex
-transformations either by calling into a C++ helper function or by using inline
-C++. An example of such an optimization is FoldConstantReshape, where we
-optimize Reshape of a constant value by reshaping the constant in place and
-eliminating the reshape operation.
+Let's compare that to the .mlir form of what we want to match:
 
-```tablegen
-def ReshapeConstant : NativeCodeCall<"$0.reshape(($1.getType()).cast<ShapedType>())">;
-def FoldConstantReshapeOptPattern : Pat<
-  (ReshapeOp:$res (ConstantOp $arg)),
-  (ConstantOp (ReshapeConstant $arg, $res))>;
+```mlir
+// arg is some value defined elsewhere, we don't care where it comes from
+// for this pattern.
+%arg = ...
+%innerReshape = "toy.reshape"(%arg) : (tensor<...>) -> (tensor<...>)
+%reshape = "toy.reshape"(%innerReshape) : (tensor<...>) -> (tensor<...>)
+```
+
+You can likely see now that our pattern in PDLL is mostly just a sugared version
+of the exact IR that we want to match.
+
+With our PDLL pattern defined, we can generate some corresponding C++ code that
+we can use within our toy code. The automatically generated C++ code
+corresponding to each of the PDLL patterns can be found under
+`path/to/BUILD/tools/mlir/examples/toy/Ch3/ToyCombine.inc`.
+
+Outside of our simple pattern above, PDLL provides many more power capabilities
+layered on top. For example below is a transformation that eliminates reshapes
+when they are redundant, i.e. when the input and output shapes are identical.
+
+```pdll
+Pattern RedundantReshapeOptPattern {
+  replace op<toy.reshape>(arg: Value<type: Type>) -> (type)
+    with arg;
+}
 ```
 
+Each use of a variable within the match portion of the PDLL pattern is
+constrained to be equal, thus in the above pattern we constrain the input and
+result type to be the same `type`.
+
+Each pattern above has been written using pure PDLL, but some optimizations may
+require more complex logic that PDLL can't natively support. In these cases, we
+can define custom constraints and rewrites that call into a C++ helper function
+or by inline C++. An example of such an optimization is FoldConstantReshape,
+where we optimize Reshape of a constant value by reshaping the constant in place
+and eliminating the reshape operation.
+
+```pdll
+Rewrite ReshapeConstant(attr: F64ElementsAttr, type: F64Tensor) -> Attr [{
+  return attr.reshape(type);
+}];
+Pattern FoldConstantReshapeOptPattern {
+  replace op<toy.reshape>(op<toy.constant> {value = cstValue: Attr}) -> (result: Type)
+    with op<toy.constant> {value = ReshapeConstant(cstValue, result)};
+}
+```
+
+In the above, we define a new rewrite function that contains a bit of inline C++
+to reshape the attribute value of the input constant. When defining the
+arguments to the rewrite, we use the exact same constraints as we do in ODS to
+allow for the inline C++ code to interact with the same C++ types that our
+operations do.
+
 We demonstrate these reshape optimizations using the following
 trivial_reshape.toy program:
 
 ```c++
 def main() {
   var a<2,1> = [1, 2];
   var b<2,1> = a;
   var c<2,1> = b;
toy.func @main() {
     %2 = toy.reshape(%1 : tensor<2x1xf64>) to tensor<2x1xf64>
     %3 = toy.reshape(%2 : tensor<2x1xf64>) to tensor<2x1xf64>
     toy.print %3 : tensor<2x1xf64>
     toy.return
   }
 }
 ```
 
-We can try to run `toyc-ch3 test/Examples/Toy/Ch3/trivial_reshape.toy -emit=mlir 
--opt` and observe our pattern in action:
+We can try to run
+`toyc-ch3 test/Examples/Toy/Ch3/trivial_reshape.toy -emit=mlir -opt` and observe
+our pattern in action:
 
 ```mlir
 module {
   toy.func @main() {
     %0 = toy.constant dense<[[1.000000e+00], [2.000000e+00]]> : tensor<2x1xf64>
     toy.print %0 : tensor<2x1xf64>
     toy.return
   }
 }
 ```
 
 As expected, no reshape operations remain after canonicalization.
 
-Further details on the declarative rewrite method can be found at
-[Table-driven Declarative Rewrite Rule (DRR)](../../DeclarativeRewrites.md).
+See the main documentation of [PDLL](../../PDLL.md) for much more information on
+what it can do. Also checkout the
+[PDLL language server](../../Tools/MLIRLSP.md#pdll-lsp-language-server--mlir-pdll-lsp-server),
+which paired with an IDE like
+[VSCode](https://marketplace.visualstudio.com/items?itemName=llvm-vs-code-extensions.vscode-mlir),
+gives you many modern programming language features when interacting with PDLL;
+such as code completion, go-to-definition, and more.
 
 In this chapter, we saw how to use certain core transformations through always
 available hooks. In the [next chapter](Ch-4.md), we will see how to use generic
 solutions that scale better through Interfaces.

mlir/examples/toy/Ch3/CMakeLists.txt

 # For a better template to copy, see examples/standalone
 include_directories(include)
 add_subdirectory(include)
 
 set(LLVM_LINK_COMPONENTS
   Support
   )
 
-set(LLVM_TARGET_DEFINITIONS mlir/ToyCombine.td)
-mlir_tablegen(ToyCombine.inc -gen-rewriters)
-add_public_tablegen_target(ToyCh3CombineIncGen)
+add_mlir_pdll_library(ToyCh3CombineIncGen
+  mlir/ToyCombine.pdll
+  ToyCombine.inc
+)
 
 add_toy_chapter(toyc-ch3
   toyc.cpp
   parser/AST.cpp
   mlir/MLIRGen.cpp
   mlir/Dialect.cpp
   mlir/ToyCombine.cpp
 

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

 include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.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";
+  let dependentDialects = ["pdl::PDLDialect", "pdl_interp::PDLInterpDialect"];
 }
 
 // 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<Trait> traits = []> :

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

 //===- Dialect.cpp - Toy IR Dialect registration in MLIR ------------------===//
 //
 // 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 implements the dialect for the Toy IR: custom type parsing and
 // operation verification.
 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/Dialect.h"
 
+#include "mlir/Dialect/PDL/IR/PDL.h"
+#include "mlir/Dialect/PDLInterp/IR/PDLInterp.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/FunctionImplementation.h"
 #include "mlir/IR/OpImplementation.h"
 
 using namespace mlir;
 using namespace mlir::toy;
 

mlir/examples/toy/Ch3/mlir/ToyCombine.cpp

 //===- ToyCombine.cpp - Toy High Level Optimizer --------------------------===//
 //
 // 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 implements a set of simple combiners for optimizing operations in
 // the Toy dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/PatternMatch.h"
+#include "mlir/Parser/Parser.h"
 #include "toy/Dialect.h"
 #include <numeric>
 using namespace mlir;
 using namespace toy;
 
 namespace {
 /// Include the patterns defined in the Declarative Rewrite framework.
 #include "ToyCombine.inc"

mlir/examples/toy/Ch3/mlir/ToyCombine.pdll

-//===- ToyCombine.td - Pattern Match Optimizations for Toy -*- tablegen -*-===//
+//===- ToyCombine.pdll - Pattern Match Optimizations for Toy ----*- pdll -*-===//
 //
 // 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 language-specific pattern match optimizations for Toy using
-// Declarative Rewrite Rules (DRR) specified using TableGen records.
+// This file defins language-specific pattern match optimizations for Toy using
+// PDLL.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef TOY_COMBINE
-#define TOY_COMBINE
-
-include "mlir/IR/PatternBase.td"
-include "toy/Ops.td"
-
-/// Note: The DRR definition used for defining patterns is shown below:
-///
-/// class Pattern<
-///    dag sourcePattern, list<dag> resultPatterns,
-///    list<dag> additionalConstraints = [],
-///    dag benefitsAdded = (addBenefit 0)
-/// >;
+#include "toy/Ops.td"
 
 //===----------------------------------------------------------------------===//
 // Basic Pattern-Match and Rewrite
 //===----------------------------------------------------------------------===//
 
 // Reshape(Reshape(x)) = Reshape(x)
-def ReshapeReshapeOptPattern : Pat<(ReshapeOp(ReshapeOp $arg)),
-                                   (ReshapeOp $arg)>;
+Pattern ReshapeReshapeOptPattern {
+  replace op<toy.reshape>(op<toy.reshape>(arg: Value))
+    with op<toy.reshape>(arg);
+}
 
 //===----------------------------------------------------------------------===//
 // Pattern-Match and Rewrite using Native Code Call
 //===----------------------------------------------------------------------===//
 
 // Native Code Calls may be used for more complex transformations using inline
 // C++ and C++ helper functions.
 
 // Reshape(Constant(x)) = x'
-def ReshapeConstant :
-  NativeCodeCall<"$0.reshape(($1.getType()).cast<ShapedType>())">;
-def FoldConstantReshapeOptPattern : Pat<
-  (ReshapeOp:$res (ConstantOp $arg)),
-  (ConstantOp (ReshapeConstant $arg, $res))>;
+Rewrite ReshapeConstant(attr: F64ElementsAttr, type: F64Tensor) -> Attr [{
+  return attr.reshape(type);
+}];
+Pattern FoldConstantReshapeOptPattern {
+  replace op<toy.reshape>(op<toy.constant> {value = cst: Attr}) -> (res: Type)
+    with op<toy.constant> {value = ReshapeConstant(cst, res)};
+}
 
 //===----------------------------------------------------------------------===//
 // Pattern-Match and Rewrite with Constraints
 //===----------------------------------------------------------------------===//
 
-// DRR allows for constraint checking when the transformation is conditional
-// on operand properties.
-
 // Reshape(x) = x, where input and output shapes are identical
-def TypesAreIdentical : Constraint<CPred<"$0.getType() == $1.getType()">>;
-def RedundantReshapeOptPattern : Pat<
-  (ReshapeOp:$res $arg), (replaceWithValue $arg),
-  [(TypesAreIdentical $res, $arg)]>;
-
-#endif // TOY_COMBINE
+Pattern RedundantReshapeOptPattern {
+  replace op<toy.reshape>(arg: Value<type: Type>) -> (type)
+    with arg;
+}

mlir/examples/toy/Ch4/CMakeLists.txt

 # For a better template to copy, see examples/standalone
 include_directories(include)
 add_subdirectory(include)
 
 set(LLVM_LINK_COMPONENTS
   Support
   )
 
-set(LLVM_TARGET_DEFINITIONS mlir/ToyCombine.td)
-mlir_tablegen(ToyCombine.inc -gen-rewriters)
-add_public_tablegen_target(ToyCh4CombineIncGen)
+add_mlir_pdll_library(ToyCh4CombineIncGen
+  mlir/ToyCombine.pdll
+  ToyCombine.inc
+)
 
 add_toy_chapter(toyc-ch4
   toyc.cpp
   parser/AST.cpp
   mlir/MLIRGen.cpp
   mlir/Dialect.cpp
   mlir/ShapeInferencePass.cpp
   mlir/ToyCombine.cpp

mlir/examples/toy/Ch4/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";
+  let dependentDialects = ["pdl::PDLDialect", "pdl_interp::PDLInterpDialect"];
 }
 
 // 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<Trait> traits = []> :

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

 //===- Dialect.cpp - Toy IR Dialect registration in MLIR ------------------===//
 //
 // 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 implements the dialect for the Toy IR: custom type parsing and
 // operation verification.
 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/Dialect.h"
 
+#include "mlir/Dialect/PDL/IR/PDL.h"
+#include "mlir/Dialect/PDLInterp/IR/PDLInterp.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/FunctionImplementation.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Transforms/InliningUtils.h"
 
 using namespace mlir;
 using namespace mlir::toy;

mlir/examples/toy/Ch4/mlir/ToyCombine.cpp

 //===- ToyCombine.cpp - Toy High Level Optimizer --------------------------===//
 //
 // 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 implements a set of simple combiners for optimizing operations in
 // the Toy dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/PatternMatch.h"
+#include "mlir/Parser/Parser.h"
 #include "toy/Dialect.h"
 #include <numeric>
 using namespace mlir;
 using namespace toy;
 
 namespace {
 /// Include the patterns defined in the Declarative Rewrite framework.
 #include "ToyCombine.inc"

mlir/examples/toy/Ch4/mlir/ToyCombine.pdll

-//===- ToyCombine.td - Pattern Match Optimizations for Toy -*- tablegen -*-===//
+//===- ToyCombine.pdll - Pattern Match Optimizations for Toy ----*- pdll -*-===//
 //
 // 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 language-specific pattern match optimizations for Toy using
-// Declarative Rewrite Rules (DRR) specified using TableGen records.
+// This file defins language-specific pattern match optimizations for Toy using
+// PDLL.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef TOY_COMBINE
-#define TOY_COMBINE
-
-include "mlir/IR/PatternBase.td"
-include "toy/Ops.td"
-
-/// Note: The DRR definition used for defining patterns is shown below:
-///
-/// class Pattern<
-///    dag sourcePattern, list<dag> resultPatterns,
-///    list<dag> additionalConstraints = [],
-///    dag benefitsAdded = (addBenefit 0)
-/// >;
+#include "toy/Ops.td"
 
 //===----------------------------------------------------------------------===//
 // Basic Pattern-Match and Rewrite
 //===----------------------------------------------------------------------===//
 
 // Reshape(Reshape(x)) = Reshape(x)
-def ReshapeReshapeOptPattern : Pat<(ReshapeOp(ReshapeOp $arg)),
-                                   (ReshapeOp $arg)>;
+Pattern ReshapeReshapeOptPattern {
+  replace op<toy.reshape>(op<toy.reshape>(arg: Value))
+    with op<toy.reshape>(arg);
+}
 
 //===----------------------------------------------------------------------===//
 // Pattern-Match and Rewrite using Native Code Call
 //===----------------------------------------------------------------------===//
 
 // Native Code Calls may be used for more complex transformations using inline
 // C++ and C++ helper functions.
 
 // Reshape(Constant(x)) = x'
-def ReshapeConstant :
-  NativeCodeCall<"$0.reshape(($1.getType()).cast<ShapedType>())">;
-def FoldConstantReshapeOptPattern : Pat<
-  (ReshapeOp:$res (ConstantOp $arg)),
-  (ConstantOp (ReshapeConstant $arg, $res))>;
+Rewrite ReshapeConstant(attr: F64ElementsAttr, type: F64Tensor) -> Attr [{
+  return attr.reshape(type);
+}];
+Pattern FoldConstantReshapeOptPattern {
+  replace op<toy.reshape>(op<toy.constant> {value = cst: Attr}) -> (res: Type)
+    with op<toy.constant> {value = ReshapeConstant(cst, res)};
+}
 
 //===----------------------------------------------------------------------===//
 // Pattern-Match and Rewrite with Constraints
 //===----------------------------------------------------------------------===//
 
-// DRR allows for constraint checking when the transformation is conditional
-// on operand properties.
-
 // Reshape(x) = x, where input and output shapes are identical
-def TypesAreIdentical : Constraint<CPred<"$0.getType() == $1.getType()">>;
-def RedundantReshapeOptPattern : Pat<
-  (ReshapeOp:$res $arg), (replaceWithValue $arg),
-  [(TypesAreIdentical $res, $arg)]>;
-
-#endif // TOY_COMBINE
+Pattern RedundantReshapeOptPattern {
+  replace op<toy.reshape>(arg: Value<type: Type>) -> (type)
+    with arg;
+}

mlir/examples/toy/Ch5/CMakeLists.txt

 # For a better template to copy, see examples/standalone
 include_directories(include)
 add_subdirectory(include)
 
 set(LLVM_LINK_COMPONENTS
   Support
   )
 
-set(LLVM_TARGET_DEFINITIONS mlir/ToyCombine.td)
-mlir_tablegen(ToyCombine.inc -gen-rewriters)
-add_public_tablegen_target(ToyCh5CombineIncGen)
+add_mlir_pdll_library(ToyCh5CombineIncGen
+  mlir/ToyCombine.pdll
+  ToyCombine.inc
+)
 
 add_toy_chapter(toyc-ch5
   toyc.cpp
   parser/AST.cpp
   mlir/MLIRGen.cpp
   mlir/Dialect.cpp
   mlir/LowerToAffineLoops.cpp
   mlir/ShapeInferencePass.cpp

mlir/examples/toy/Ch5/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";
+  let dependentDialects = ["pdl::PDLDialect", "pdl_interp::PDLInterpDialect"];
 }
 
 // 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<Trait> traits = []> :

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

 //===- Dialect.cpp - Toy IR Dialect registration in MLIR ------------------===//
 //
 // 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 implements the dialect for the Toy IR: custom type parsing and
 // operation verification.
 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/Dialect.h"
 
+#include "mlir/Dialect/PDL/IR/PDL.h"
+#include "mlir/Dialect/PDLInterp/IR/PDLInterp.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/FunctionImplementation.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Transforms/InliningUtils.h"
 
 using namespace mlir;
 using namespace mlir::toy;

mlir/examples/toy/Ch5/mlir/ToyCombine.cpp

 //===- ToyCombine.cpp - Toy High Level Optimizer --------------------------===//
 //
 // 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 implements a set of simple combiners for optimizing operations in
 // the Toy dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/PatternMatch.h"
+#include "mlir/Parser/Parser.h"
 #include "toy/Dialect.h"
 #include <numeric>
 using namespace mlir;
 using namespace toy;
 
 namespace {
 /// Include the patterns defined in the Declarative Rewrite framework.
 #include "ToyCombine.inc"

mlir/examples/toy/Ch5/mlir/ToyCombine.pdll

-//===- ToyCombine.td - Pattern Match Optimizations for Toy -*- tablegen -*-===//
+//===- ToyCombine.pdll - Pattern Match Optimizations for Toy ----*- pdll -*-===//
 //
 // 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 language-specific pattern match optimizations for Toy using
-// Declarative Rewrite Rules (DRR) specified using TableGen records.
+// This file defins language-specific pattern match optimizations for Toy using
+// PDLL.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef TOY_COMBINE
-#define TOY_COMBINE
-
-include "mlir/IR/PatternBase.td"
-include "toy/Ops.td"
-
-/// Note: The DRR definition used for defining patterns is shown below:
-///
-/// class Pattern<
-///    dag sourcePattern, list<dag> resultPatterns,
-///    list<dag> additionalConstraints = [],
-///    dag benefitsAdded = (addBenefit 0)
-/// >;
+#include "toy/Ops.td"
 
 //===----------------------------------------------------------------------===//
 // Basic Pattern-Match and Rewrite
 //===----------------------------------------------------------------------===//
 
 // Reshape(Reshape(x)) = Reshape(x)
-def ReshapeReshapeOptPattern : Pat<(ReshapeOp(ReshapeOp $arg)),
-                                   (ReshapeOp $arg)>;
+Pattern ReshapeReshapeOptPattern {
+  replace op<toy.reshape>(op<toy.reshape>(arg: Value))
+    with op<toy.reshape>(arg);
+}
 
 //===----------------------------------------------------------------------===//
 // Pattern-Match and Rewrite using Native Code Call
 //===----------------------------------------------------------------------===//
 
 // Native Code Calls may be used for more complex transformations using inline
 // C++ and C++ helper functions.
 
 // Reshape(Constant(x)) = x'
-def ReshapeConstant :
-  NativeCodeCall<"$0.reshape(($1.getType()).cast<ShapedType>())">;
-def FoldConstantReshapeOptPattern : Pat<
-  (ReshapeOp:$res (ConstantOp $arg)),
-  (ConstantOp (ReshapeConstant $arg, $res))>;
+Rewrite ReshapeConstant(attr: F64ElementsAttr, type: F64Tensor) -> Attr [{
+  return attr.reshape(type);
+}];
+Pattern FoldConstantReshapeOptPattern {
+  replace op<toy.reshape>(op<toy.constant> {value = cst: Attr}) -> (res: Type)
+    with op<toy.constant> {value = ReshapeConstant(cst, res)};
+}
 
 //===----------------------------------------------------------------------===//
 // Pattern-Match and Rewrite with Constraints
 //===----------------------------------------------------------------------===//
 
-// DRR allows for constraint checking when the transformation is conditional
-// on operand properties.
-
 // Reshape(x) = x, where input and output shapes are identical
-def TypesAreIdentical : Constraint<CPred<"$0.getType() == $1.getType()">>;
-def RedundantReshapeOptPattern : Pat<
-  (ReshapeOp:$res $arg), (replaceWithValue $arg),
-  [(TypesAreIdentical $res, $arg)]>;
-
-#endif // TOY_COMBINE
+Pattern RedundantReshapeOptPattern {
+  replace op<toy.reshape>(arg: Value<type: Type>) -> (type)
+    with arg;
+}

mlir/examples/toy/Ch6/CMakeLists.txt

 # For a better template to copy, see examples/standalone
 include_directories(include)
 add_subdirectory(include)
 
 set(LLVM_LINK_COMPONENTS
   Core
   Support
   nativecodegen
   OrcJIT
   )
 
-set(LLVM_TARGET_DEFINITIONS mlir/ToyCombine.td)
-mlir_tablegen(ToyCombine.inc -gen-rewriters)
-add_public_tablegen_target(ToyCh6CombineIncGen)
+add_mlir_pdll_library(ToyCh6CombineIncGen
+  mlir/ToyCombine.pdll
+  ToyCombine.inc
+)
 
 add_toy_chapter(toyc-ch6
   toyc.cpp
   parser/AST.cpp
   mlir/MLIRGen.cpp
   mlir/Dialect.cpp
   mlir/LowerToAffineLoops.cpp
   mlir/LowerToLLVM.cpp

mlir/examples/toy/Ch6/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";
+  let dependentDialects = ["pdl::PDLDialect", "pdl_interp::PDLInterpDialect"];
 }
 
 // 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<Trait> traits = []> :

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

 //===- Dialect.cpp - Toy IR Dialect registration in MLIR ------------------===//
 //
 // 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 implements the dialect for the Toy IR: custom type parsing and
 // operation verification.
 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/Dialect.h"
 
+#include "mlir/Dialect/PDL/IR/PDL.h"
+#include "mlir/Dialect/PDLInterp/IR/PDLInterp.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/FunctionImplementation.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Transforms/InliningUtils.h"
 
 using namespace mlir;
 using namespace mlir::toy;

mlir/examples/toy/Ch6/mlir/ToyCombine.cpp

 //===- ToyCombine.cpp - Toy High Level Optimizer --------------------------===//
 //
 // 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 implements a set of simple combiners for optimizing operations in
 // the Toy dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/PatternMatch.h"
+#include "mlir/Parser/Parser.h"
 #include "toy/Dialect.h"
 #include <numeric>
 using namespace mlir;
 using namespace toy;
 
 namespace {
 /// Include the patterns defined in the Declarative Rewrite framework.
 #include "ToyCombine.inc"

mlir/examples/toy/Ch6/mlir/ToyCombine.pdll

-//===- ToyCombine.td - Pattern Match Optimizations for Toy -*- tablegen -*-===//
+//===- ToyCombine.pdll - Pattern Match Optimizations for Toy ----*- pdll -*-===//
 //
 // 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 language-specific pattern match optimizations for Toy using
-// Declarative Rewrite Rules (DRR) specified using TableGen records.
+// This file defins language-specific pattern match optimizations for Toy using
+// PDLL.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef TOY_COMBINE
-#define TOY_COMBINE
-
-include "mlir/IR/PatternBase.td"
-include "toy/Ops.td"
-
-/// Note: The DRR definition used for defining patterns is shown below:
-///
-/// class Pattern<
-///    dag sourcePattern, list<dag> resultPatterns,
-///    list<dag> additionalConstraints = [],
-///    dag benefitsAdded = (addBenefit 0)
-/// >;
+#include "toy/Ops.td"
 
 //===----------------------------------------------------------------------===//
 // Basic Pattern-Match and Rewrite
 //===----------------------------------------------------------------------===//
 
 // Reshape(Reshape(x)) = Reshape(x)
-def ReshapeReshapeOptPattern : Pat<(ReshapeOp(ReshapeOp $arg)),
-                                   (ReshapeOp $arg)>;
+Pattern ReshapeReshapeOptPattern {
+  replace op<toy.reshape>(op<toy.reshape>(arg: Value))
+    with op<toy.reshape>(arg);
+}
 
 //===----------------------------------------------------------------------===//
 // Pattern-Match and Rewrite using Native Code Call
 //===----------------------------------------------------------------------===//
 
 // Native Code Calls may be used for more complex transformations using inline
 // C++ and C++ helper functions.
 
 // Reshape(Constant(x)) = x'
-def ReshapeConstant :
-  NativeCodeCall<"$0.reshape(($1.getType()).cast<ShapedType>())">;
-def FoldConstantReshapeOptPattern : Pat<
-  (ReshapeOp:$res (ConstantOp $arg)),
-  (ConstantOp (ReshapeConstant $arg, $res))>;
+Rewrite ReshapeConstant(attr: F64ElementsAttr, type: F64Tensor) -> Attr [{
+  return attr.reshape(type);
+}];
+Pattern FoldConstantReshapeOptPattern {
+  replace op<toy.reshape>(op<toy.constant> {value = cst: Attr}) -> (res: Type)
+    with op<toy.constant> {value = ReshapeConstant(cst, res)};
+}
 
 //===----------------------------------------------------------------------===//
 // Pattern-Match and Rewrite with Constraints
 //===----------------------------------------------------------------------===//
 
-// DRR allows for constraint checking when the transformation is conditional
-// on operand properties.
-
 // Reshape(x) = x, where input and output shapes are identical
-def TypesAreIdentical : Constraint<CPred<"$0.getType() == $1.getType()">>;
-def RedundantReshapeOptPattern : Pat<
-  (ReshapeOp:$res $arg), (replaceWithValue $arg),
-  [(TypesAreIdentical $res, $arg)]>;
-
-#endif // TOY_COMBINE
+Pattern RedundantReshapeOptPattern {
+  replace op<toy.reshape>(arg: Value<type: Type>) -> (type)
+    with arg;
+}

mlir/examples/toy/Ch7/CMakeLists.txt

 # For a better template to copy, see examples/standalone
 include_directories(include)
 add_subdirectory(include)
 
 set(LLVM_LINK_COMPONENTS
   Core
   Support
   nativecodegen
   OrcJIT
   )
 
-set(LLVM_TARGET_DEFINITIONS mlir/ToyCombine.td)
-mlir_tablegen(ToyCombine.inc -gen-rewriters)
-add_public_tablegen_target(ToyCh7CombineIncGen)
+add_mlir_pdll_library(ToyCh7CombineIncGen
+  mlir/ToyCombine.pdll
+  ToyCombine.inc
+)
 
 add_toy_chapter(toyc-ch7
   toyc.cpp
   parser/AST.cpp
   mlir/MLIRGen.cpp
   mlir/Dialect.cpp
   mlir/LowerToAffineLoops.cpp
   mlir/LowerToLLVM.cpp

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";
+  let dependentDialects = ["pdl::PDLDialect", "pdl_interp::PDLInterpDialect"];
 
   // 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;
 
   // We set this bit to generate the declarations for the dialect's type parsing
   // and printing hooks.
   let useDefaultTypePrinterParser = 1;

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

 //===- Dialect.cpp - Toy IR Dialect registration in MLIR ------------------===//
 //
 // 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 implements the dialect for the Toy IR: custom type parsing and
 // operation verification.
 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/Dialect.h"
 
+#include "mlir/Dialect/PDL/IR/PDL.h"
+#include "mlir/Dialect/PDLInterp/IR/PDLInterp.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/FunctionImplementation.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Transforms/InliningUtils.h"
 
 using namespace mlir;

mlir/examples/toy/Ch7/mlir/ToyCombine.cpp

 //===- ToyCombine.cpp - Toy High Level Optimizer --------------------------===//
 //
 // 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 implements a set of simple combiners for optimizing operations in
 // the Toy dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/PatternMatch.h"
+#include "mlir/Parser/Parser.h"
 #include "toy/Dialect.h"
 #include <numeric>
 using namespace mlir;
 using namespace toy;
 
 namespace {
 /// Include the patterns defined in the Declarative Rewrite framework.
 #include "ToyCombine.inc"

mlir/examples/toy/Ch7/mlir/ToyCombine.pdll

-//===- ToyCombine.td - Pattern Match Optimizations for Toy -*- tablegen -*-===//
+//===- ToyCombine.pdll - Pattern Match Optimizations for Toy ----*- pdll -*-===//
 //
 // 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 language-specific pattern match optimizations for Toy using
-// Declarative Rewrite Rules (DRR) specified using TableGen records.
+// This file defins language-specific pattern match optimizations for Toy using
+// PDLL.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef TOY_COMBINE
-#define TOY_COMBINE
-
-include "mlir/IR/PatternBase.td"
-include "toy/Ops.td"
-
-/// Note: The DRR definition used for defining patterns is shown below:
-///
-/// class Pattern<
-///    dag sourcePattern, list<dag> resultPatterns,
-///    list<dag> additionalConstraints = [],
-///    dag benefitsAdded = (addBenefit 0)
-/// >;
+#include "toy/Ops.td"
 
 //===----------------------------------------------------------------------===//
 // Basic Pattern-Match and Rewrite
 //===----------------------------------------------------------------------===//
 
 // Reshape(Reshape(x)) = Reshape(x)
-def ReshapeReshapeOptPattern : Pat<(ReshapeOp(ReshapeOp $arg)),
-                                   (ReshapeOp $arg)>;
+Pattern ReshapeReshapeOptPattern {
+  replace op<toy.reshape>(op<toy.reshape>(arg: Value))
+    with op<toy.reshape>(arg);
+}
 
 //===----------------------------------------------------------------------===//
 // Pattern-Match and Rewrite using Native Code Call
 //===----------------------------------------------------------------------===//
 
 // Native Code Calls may be used for more complex transformations using inline
 // C++ and C++ helper functions.
 
 // Reshape(Constant(x)) = x'
-def ReshapeConstant :
-  NativeCodeCall<"$0.reshape(($1.getType()).cast<ShapedType>())">;
-def FoldConstantReshapeOptPattern : Pat<
-  (ReshapeOp:$res (ConstantOp $arg)),
-  (ConstantOp (ReshapeConstant $arg, $res))>;
+Rewrite ReshapeConstant(attr: F64ElementsAttr, type: F64Tensor) -> Attr [{
+  return attr.reshape(type);
+}];
+Pattern FoldConstantReshapeOptPattern {
+  replace op<toy.reshape>(op<toy.constant> {value = cst: Attr}) -> (res: Type)
+    with op<toy.constant> {value = ReshapeConstant(cst, res)};
+}
 
 //===----------------------------------------------------------------------===//
 // Pattern-Match and Rewrite with Constraints
 //===----------------------------------------------------------------------===//
 
-// DRR allows for constraint checking when the transformation is conditional
-// on operand properties.
-
 // Reshape(x) = x, where input and output shapes are identical
-def TypesAreIdentical : Constraint<CPred<"$0.getType() == $1.getType()">>;
-def RedundantReshapeOptPattern : Pat<
-  (ReshapeOp:$res $arg), (replaceWithValue $arg),
-  [(TypesAreIdentical $res, $arg)]>;
-
-#endif // TOY_COMBINE
+Pattern RedundantReshapeOptPattern {
+  replace op<toy.reshape>(arg: Value<type: Type>) -> (type)
+    with arg;
+}

mlir/examples/toy/Ch7/mlir/ToyCombine.td

-//===- ToyCombine.td - Pattern Match Optimizations for Toy -*- 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 language-specific pattern match optimizations for Toy using
-// Declarative Rewrite Rules (DRR) specified using TableGen records.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef TOY_COMBINE
-#define TOY_COMBINE
-
-include "mlir/IR/PatternBase.td"
-include "toy/Ops.td"
-
-/// Note: The DRR definition used for defining patterns is shown below:
-///
-/// class Pattern<
-///    dag sourcePattern, list<dag> resultPatterns,
-///    list<dag> additionalConstraints = [],
-///    dag benefitsAdded = (addBenefit 0)
-/// >;
-
-//===----------------------------------------------------------------------===//
-// Basic Pattern-Match and Rewrite
-//===----------------------------------------------------------------------===//
-
-// Reshape(Reshape(x)) = Reshape(x)
-def ReshapeReshapeOptPattern : Pat<(ReshapeOp(ReshapeOp $arg)),
-                                   (ReshapeOp $arg)>;
-
-//===----------------------------------------------------------------------===//
-// Pattern-Match and Rewrite using Native Code Call
-//===----------------------------------------------------------------------===//
-
-// Native Code Calls may be used for more complex transformations using inline
-// C++ and C++ helper functions.
-
-// Reshape(Constant(x)) = x'
-def ReshapeConstant :
-  NativeCodeCall<"$0.reshape(($1.getType()).cast<ShapedType>())">;
-def FoldConstantReshapeOptPattern : Pat<
-  (ReshapeOp:$res (ConstantOp $arg)),
-  (ConstantOp (ReshapeConstant $arg, $res))>;
-
-//===----------------------------------------------------------------------===//
-// Pattern-Match and Rewrite with Constraints
-//===----------------------------------------------------------------------===//
-
-// DRR allows for constraint checking when the transformation is conditional
-// on operand properties.
-
-// Reshape(x) = x, where input and output shapes are identical
-def TypesAreIdentical : Constraint<CPred<"$0.getType() == $1.getType()">>;
-def RedundantReshapeOptPattern : Pat<
-  (ReshapeOp:$res $arg), (replaceWithValue $arg),
-  [(TypesAreIdentical $res, $arg)]>;
-
-#endif // TOY_COMBINE

mlir/include/mlir/IR/PatternMatch.h

 //===- PatternMatch.h - PatternMatcher classes -------==---------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_PATTERNMATCH_H
 #define MLIR_IR_PATTERNMATCH_H
 
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "llvm/ADT/FunctionExtras.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/TypeName.h"
 
 namespace mlir {
 
 class PatternRewriter;
 
 //===----------------------------------------------------------------------===//
 // PatternBenefit class