[mlir][PDL] Add a PDL Interpreter Dialect

[rriddle]

Summary

The PDL Interpreter dialect provides a lower level abstraction compared to the PDL dialect, and is targeted towards low level optimization and interpreter code generation. The dialect operations encapsulates low-level pattern match and rewrite "primitives", such as navigating the IR (Operation::getOperand), creating new operations (OpBuilder::create), etc. Many of the operations within this dialect also fuse branching control flow with some form of a predicate comparison operation. This type of fusion reduces the amount of work that an interpreter must do when executing.

An example of this representation is shown below:

mlir
// The following high level PDL pattern:
pdl.pattern : benefit(1) {
  %resultType = pdl.type
  %inputOperand = pdl.input
  %root, %results = pdl.operation "foo.op"(%inputOperand) -> %resultType
  pdl.rewrite(%root) {
    pdl.replace %root with (%inputOperand)
  }
}

// May be represented in the interpreter dialect as follows:
module {
  func @matcher(%arg0: !pdl.operation) {
    pdl_interp.check_operation_name of %arg0 is "foo.op" -> ^bb2, ^bb1
  ^bb1:
    pdl_interp.return
  ^bb2:
    pdl_interp.check_operand_count of %arg0 is 1 -> ^bb3, ^bb1
  ^bb3:
    pdl_interp.check_result_count of %arg0 is 1 -> ^bb4, ^bb1
  ^bb4:
    %0 = pdl_interp.get_operand 0 of %arg0
    pdl_interp.is_not_null %0 : !pdl.value -> ^bb5, ^bb1
  ^bb5:
    %1 = pdl_interp.get_result 0 of %arg0
    pdl_interp.is_not_null %1 : !pdl.value -> ^bb6, ^bb1
  ^bb6:
    pdl_interp.record_match @rewriters::@rewriter(%0, %arg0 : !pdl.value, !pdl.operation) : benefit(1), loc([%arg0]), root("foo.op") -> ^bb1
  }
  module @rewriters {
    func @rewriter(%arg0: !pdl.value, %arg1: !pdl.operation) {
      pdl_interp.replace %arg1 with(%arg0)
      pdl_interp.return
    }
  }
}

Depends On D84578

[rriddle]

Remove unnecessary interfaces

[stephenneuendorffer]

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

25

PDLInterpreter?

mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp

16

pdl_interpreter?

[rriddle]

Rebase

[mehdi_amini]

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

90

name in the description does not match the op name?

101

it isn't clear to me how are the constant parsed? What is the type of 42 for example?

Could you give an example of the "myConstraint" signature / impl?

128

It isn't clear from the description what kind of state the rewrite has access to, maybe explain a bit and refer the reader to pdl_interp.record_match ?

143

"equivalence" isn't super clear: is it more that straight equality?

301

Most of the ops above aren't annotated as "NoSideEffect", should they? Aren't all the "check" in scope for "NoSideEffect"?

534

Can you show the result on the sample? (same for the other get_*)

691

replaced->replace

716

Maybe we can do something else than "return"?
"finish"? "done"? "finalize"?

[rriddle]

Address comments

[rriddle]

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

101

It's an ArrayAttr, 42 is an IntegerAttr which has a default type of i64.

Could you give an example of the "myConstraint" signature / impl?

Waiting for the bytecode before adding signature examples, because they are directly related.

716

Went with finalize.

mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp

16

I considered it, but I don't think spelling it out completely improves the readability as much as it hurts it by making everything longer.

mlir/include/mlir/Dialect/CMakeLists.txt

 add_subdirectory(Affine)
 add_subdirectory(AVX512)
 add_subdirectory(GPU)
 add_subdirectory(Linalg)
 add_subdirectory(LLVMIR)
 add_subdirectory(OpenACC)
 add_subdirectory(OpenMP)
 add_subdirectory(PDL)
+add_subdirectory(PDLInterp)
 add_subdirectory(Quant)
 add_subdirectory(SCF)
 add_subdirectory(Shape)
 add_subdirectory(SPIRV)
 add_subdirectory(StandardOps)
 add_subdirectory(Vector)

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

string description = [{
     // pdl.pattern contains metadata similarly to a `RewritePattern`.
     pdl.pattern : benefit(1) {
       // External input operand values are specified via `pdl.input` operations.
       // Result types are constrainted via `pdl.type` operations.
 
       %resultType = pdl.type
       %inputOperand = pdl.input
       %root, %results = pdl.operation "foo.op"(%inputOperand) -> %resultType
-      pdl.rewrite(%root) {
+      pdl.rewrite %root {
         pdl.replace %root with (%inputOperand)
       }
     }
     ```
 
     The above pattern simply replaces an operation with its first operand. Note
     how the input operation is specified structurally, similarly to how it would
     look in memory. This is a simple example and pdl provides support for many

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

let description = [{
     ```mlir
     // Apply `myConstraint` to the entities defined by `input`, `attr`, and
     // `op`. `42`, `"abc"`, and `i32` are constant parameters passed to the
     // constraint.
     pdl.apply_constraint "myConstraint"[42, "abc", i32](%input, %attr, %op : !pdl.value, !pdl.attribute, !pdl.operation)
     ```
   }];
 
-  let arguments = (ins Variadic<PDL_PositionalValue>:$args,
-                       ArrayAttr:$params,
-                       StrAttr:$name);
-  let assemblyFormat = "$name $params `(` $args `:` type($args) `)` attr-dict";
+  let arguments = (ins StrAttr:$name,
+                       Variadic<PDL_PositionalValue>:$args,
+                       OptionalAttr<ArrayAttr>:$constParams);
+  let assemblyFormat = [{
+    $name ($constParams^)? `(` $args `:` type($args) `)` attr-dict
+  }];
 
   let builders = [
-    OpBuilder<"OpBuilder &builder, OperationState &state, "
-              "ValueRange args, ArrayRef<Attribute> params, "
-              "StringRef name", [{
-      build(builder, state, args, builder.getArrayAttr(params),
-            builder.getStringAttr(name));
+    OpBuilder<"OpBuilder &builder, OperationState &state, StringRef name, "
+              "ValueRange args = {}, ArrayRef<Attribute> params = {}", [{
+      build(builder, state, builder.getStringAttr(name), args,
+            params.empty() ? ArrayAttr() : builder.getArrayAttr(params));
     }]>,
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::AttributeOp
 //===----------------------------------------------------------------------===//
 
let description = [{
 
     Example:
 
     ```mlir
     %ret = pdl.create_native "myNativeFunc"[42, "gt"](%arg0, %arg1) : !pdl.attribute
     ```
   }];
 
-  let arguments = (ins StrAttr:$name, Variadic<PDL_PositionalValue>:$arguments,
-                       ArrayAttr:$constantParams);
+  let arguments = (ins StrAttr:$name,
+                       Variadic<PDL_PositionalValue>:$args,
+                       OptionalAttr<ArrayAttr>:$constParams);
   let results = (outs PDL_PositionalValue:$result);
   let assemblyFormat = [{
-    $name $constantParams (`(` $arguments^ `:` type($arguments) `)`)?
-    `:` type($result) attr-dict
+    $name ($constParams^)? (`(` $args^ `:` type($args) `)`)? `:` type($result)
+    attr-dict
   }];
   let verifier = ?;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::EraseOp
 //===----------------------------------------------------------------------===//
 
let description = [{
     operations correspond to input operations, or those that already existing
     within the MLIR module. Inside of a `pdl.rewrite`, these operations
     correspond to operations that should be created as part of the replacement
     sequence.
 
     `pdl.operation`s are composed of a name, and a set of attribute, operand,
     and result type values, that map to what those that would be on a
     constructed instance of that operation. The results of a `pdl.operation` are
-    a handle to the operation itself, and a handle to each of the operation 
+    a handle to the operation itself, and a handle to each of the operation
     result values.
 
     When used within a matching context, the name of the operation may be
     omitted.
 
     When used within a rewriting context, i.e. when defined within a
     `pdl.rewrite`, all of the result types must be "inferrable". This means that
     the type must be attributable to either a constant type value or the result
def PDL_RewriteOp : PDL_Op<"rewrite", [
   ]> {
   let summary = "Specify the rewrite of a matched pattern";
   let description = [{
     `pdl.rewrite` operations terminate the region of a `pdl.pattern` and specify
     the rewrite of a `pdl.pattern`, on the specified root operation. The
     rewrite is specified either via a string name (`name`) to an external
     rewrite function, or via the region body. The rewrite region, if specified,
     must contain a single block and terminate via the `pdl.rewrite_end`
-    operation.
+    operation. If the rewrite is external, it also takes a set of constant
+    parameters and a set of additional positional values defined within the
+    matcher as arguments.
 
     Example:
 
     ```mlir
     // Specify an external rewrite function:
-    pdl.rewrite "myExternalRewriter"(%root)
+    pdl.rewrite %root with "myExternalRewriter"(%value : !pdl.value)
 
     // Specify the rewrite inline using PDL:
-    pdl.rewrite(%root) {
+    pdl.rewrite %root {
       %op = pdl.operation "foo.op"(%arg0, %arg1)
       pdl.replace %root with %op
     }
     ```
   }];
 
   let arguments = (ins PDL_Operation:$root,
-                       OptionalAttr<StrAttr>:$name);
+                       OptionalAttr<StrAttr>:$name,
+                       Variadic<PDL_PositionalValue>:$externalArgs,
+                       OptionalAttr<ArrayAttr>:$externalConstParams);
   let regions = (region AnyRegion:$body);
 }
 
 def PDL_RewriteEndOp : PDL_Op<"rewrite_end", [Terminator,
                                               HasParent<"pdl::RewriteOp">]> {
   let summary = "Implicit terminator of a `pdl.rewrite` region";
   let description = [{
     `pdl.rewrite_end` operations terminate the region of a `pdl.rewrite`.

mlir/include/mlir/Dialect/PDLInterp/CMakeLists.txt

+add_subdirectory(IR)

mlir/include/mlir/Dialect/PDLInterp/IR/CMakeLists.txt

+add_mlir_dialect(PDLInterpOps pdl_interp)
+add_mlir_doc(PDLInterpOps -gen-op-doc PDLInterpOps Dialects/)

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

+//===- PDLInterp.h - PDL Interpreter 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 declares the interpreter dialect for the PDL pattern descriptor
+// language.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_PDLINTERP_IR_PDLINTERP_H_
+#define MLIR_DIALECT_PDLINTERP_IR_PDLINTERP_H_
+
+#include "mlir/Dialect/PDL/IR/PDL.h"
+#include "mlir/Interfaces/InferTypeOpInterface.h"
+#include "mlir/Interfaces/SideEffectInterfaces.h"
+
+namespace mlir {
+namespace pdl_interp {
+//===----------------------------------------------------------------------===//
+// PDLInterp Dialect
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/PDLInterp/IR/PDLInterpOpsDialect.h.inc"
+
+//===----------------------------------------------------------------------===//
+// PDLInterp Dialect Operations
+//===----------------------------------------------------------------------===//
+
+#define GET_OP_CLASSES
+#include "mlir/Dialect/PDLInterp/IR/PDLInterpOps.h.inc"
+
+} // end namespace pdl_interp
+} // end namespace mlir
+
+#endif // MLIR_DIALECT_PDLINTERP_IR_PDLINTERP_H_

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/Interfaces/SideEffectInterfaces.td"
+
+//===----------------------------------------------------------------------===//
+// PDLInterp Dialect
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_Dialect : Dialect {
+  let summary = "Interpreted pattern execution dialect";
+  let description = [{
+    The PDL Interpreter dialect provides a lower level abstraction compared to
+    the PDL dialect, and is targeted towards low level optimization and
+    interpreter code generation. The dialect operations encapsulates
+    low-level pattern match and rewrite "primitives", such as navigating the
+    IR (Operation::getOperand), creating new operations (OpBuilder::create),
+    etc. Many of the operations within this dialect also fuse branching control
+    flow with some form of a predicate comparison operation. This type of fusion
+    reduces the amount of work that an interpreter must do when executing.
+  }];
+
+  let name = "pdl_interp";
+  let cppNamespace = "mlir::pdl_interp";
+  let dependentDialects = ["pdl::PDLDialect"];
+}
+
+//===----------------------------------------------------------------------===//
+// PDLInterp Operations
+//===----------------------------------------------------------------------===//
+
+// Generic interpreter operation.
+class PDLInterp_Op<string mnemonic, list<OpTrait> traits = []> :
+    Op<PDLInterp_Dialect, mnemonic, traits>;
+
+//===----------------------------------------------------------------------===//
+// PDLInterp_PredicateOp
+
+// Check operations evaluate a predicate on a positional value and then
+// conditionally branch on the result.
+class PDLInterp_PredicateOp<string mnemonic, list<OpTrait> traits = []> :
+    PDLInterp_Op<mnemonic, !listconcat([Terminator], traits)> {
+  let successors = (successor AnySuccessor:$trueDest, AnySuccessor:$falseDest);
+}
+
+//===----------------------------------------------------------------------===//
+// PDLInterp_SwitchOp
+
+// Switch operations evaluate a predicate on a positional value and then
+// conditionally branch on the result.
+class PDLInterp_SwitchOp<string mnemonic, list<OpTrait> traits = []> :
+    PDLInterp_Op<mnemonic, !listconcat([Terminator], traits)> {
+  let successors = (successor AnySuccessor:$defaultDest,
+                              VariadicSuccessor<AnySuccessor>:$cases);
+
+  let verifier = [{
+    // Verify that the number of case destinations matches the number of case
+    // values.
+    size_t numDests = cases().size();
+    size_t numValues = caseValues().size();
+    if (numDests != numValues) {
+      return emitOpError("expected number of cases to match the number of case "
+                         "values, got ")
+          << numDests << " but expected " << numValues;
+    }
+    return success();
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::ApplyConstraintOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_ApplyConstraintOp : PDLInterp_PredicateOp<"apply_constraint"> {
+  let summary = "Apply a constraint to a set of positional values";
+  let description = [{
+    `pdl_interp.apply_constraint` operations apply a generic constraint, that
+    has been registered with the interpreter, with a given set of positional
+    values. The constraint may have any number of constant parameters. On
+    success, this operation branches to the true destination, otherwise the
+    false destination is taken.
+
+    Example:
+
+    ```mlir
+    // Apply `myConstraint` to the entities defined by `input`, `attr`, and
+    // `op`.
+    pdl_interp.apply_constraint "myConstraint"[42, "abc", i32](%input, %attr, %op : !pdl.value, !pdl.attribute, !pdl.operation)
+    ```
+  }];
+
+  let arguments = (ins StrAttr:$name,
+                       Variadic<PDL_PositionalValue>:$args,
+                       OptionalAttr<ArrayAttr>:$constParams);
+  let assemblyFormat = [{
+    $name ($constParams^)? `(` $args `:` type($args) `)` attr-dict `->`
+    successors
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::ApplyRewriteOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_ApplyRewriteOp : PDLInterp_Op<"apply_rewrite"> {
+  let summary = "Invoke and apply an externally registered rewrite method";
+  let description = [{
+    `pdl_interp.apply_rewrite` operations invoke an external rewriter that has
+    been registered with the interpreter to perform the rewrite after a
+    successful match. The rewrite is passed the root operation being matched, a
+    set of additional positional arguments generated within the matcher, and a
+    set of constant parameters.
+
+    Example:
+
+    ```mlir
+    // Rewriter operating solely on the root operation.
+    pdl_interp.apply_rewrite "rewriter" on %root
+
+    // Rewriter operating on the root operation along with additional arguments
+    // from the matcher.
+    pdl_interp.apply_rewrite "rewriter"(%value : !pdl.value) on %root
+
+    // Rewriter operating on the root operation along with additional arguments
+    // and constant parameters.
+    pdl_interp.apply_rewrite "rewriter"[42](%value : !pdl.value) on %root
+    ```
+  }];
+  let arguments = (ins StrAttr:$name,
+                       PDL_Operation:$root,
+                       Variadic<PDL_PositionalValue>:$args,
+                       OptionalAttr<ArrayAttr>:$constParams);
+  let assemblyFormat = [{
+    $name ($constParams^)? (`(` $args^ `:` type($args) `)`)? `on` $root
+    attr-dict
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::AreEqualOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_AreEqualOp
+    : PDLInterp_PredicateOp<"are_equal", [NoSideEffect, SameTypeOperands]> {
+  let summary = "Check if two positional values are equivalent";
+  let description = [{
+    `pdl_interp.are_equal` operations compare two positional values for
+    equality. On success, this operation branches to the true destination,
+    otherwise the false destination is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.are_equal %result1, %result2 : !pdl.value -> ^matchDest, ^failureDest
+    ```
+  }];
+
+  let arguments = (ins PDL_PositionalValue:$lhs,
+                       PDL_PositionalValue:$rhs);
+  let assemblyFormat = "operands `:` type($lhs) attr-dict `->` successors";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::BranchOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_BranchOp : PDLInterp_Op<"branch", [NoSideEffect, Terminator]> {
+  let summary = "General branch operation";
+  let description = [{
+    `pdl_interp.branch` operations expose general branch functionality to the
+    interpreter, and are generally used to branch from one pattern match
+    sequence to another.
+
+    Example:
+
+    ```mlir
+    pdl_interp.branch ^dest
+    ```
+  }];
+
+  let successors = (successor AnySuccessor:$dest);
+  let assemblyFormat = "$dest attr-dict";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::CheckAttributeOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_CheckAttributeOp
+    : PDLInterp_PredicateOp<"check_attribute", [NoSideEffect]> {
+  let summary = "Check the value of an `Attribute`";
+  let description = [{
+    `pdl_interp.check_attribute` operations compare the value of a given
+    attribute with a constant value. On success, this operation branches to the
+    true destination, otherwise the false destination is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.check_attribute %attr is 10 -> ^matchDest, ^failureDest
+    ```
+  }];
+
+  let arguments = (ins PDL_Attribute:$attribute, AnyAttr:$constantValue);
+  let assemblyFormat = [{
+    $attribute `is` $constantValue attr-dict `->` successors
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::CheckOperandCountOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_CheckOperandCountOp
+    : PDLInterp_PredicateOp<"check_operand_count", [NoSideEffect]> {
+  let summary = "Check the number of operands of an `Operation`";
+  let description = [{
+    `pdl_interp.check_operand_count` operations compare the number of operands
+    of a given operation value with a constant. On success, this operation
+    branches to the true destination, otherwise the false destination is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.check_operand_count of %op is 2 -> ^matchDest, ^failureDest
+    ```
+  }];
+
+  let arguments = (ins PDL_Operation:$operation,
+                       Confined<I32Attr, [IntNonNegative]>:$count);
+  let assemblyFormat = "`of` $operation `is` $count attr-dict `->` successors";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::CheckOperationNameOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_CheckOperationNameOp
+    : PDLInterp_PredicateOp<"check_operation_name", [NoSideEffect]> {
+  let summary = "Check the OperationName of an `Operation`";
+  let description = [{
+    `pdl_interp.check_operation_name` operations compare the name of a given
+    operation with a known name. On success, this operation branches to the true
+    destination, otherwise the false destination is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.check_operation_name of %op is "foo.op" -> ^matchDest, ^failureDest
+    ```
+  }];
+
+  let arguments = (ins PDL_Operation:$operation, StrAttr:$name);
+  let assemblyFormat = "`of` $operation `is` $name attr-dict `->` successors";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::CheckResultCountOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_CheckResultCountOp
+    : PDLInterp_PredicateOp<"check_result_count", [NoSideEffect]> {
+  let summary = "Check the number of results of an `Operation`";
+  let description = [{
+    `pdl_interp.check_result_count` operations compare the number of results
+    of a given operation value with a constant. On success, this operation
+    branches to the true destination, otherwise the false destination is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.check_result_count of %op is 0 -> ^matchDest, ^failureDest
+    ```
+  }];
+
+  let arguments = (ins PDL_Operation:$operation,
+                       Confined<I32Attr, [IntNonNegative]>:$count);
+  let assemblyFormat = "`of` $operation `is` $count attr-dict `->` successors";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::CheckTypeOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_CheckTypeOp
+    : PDLInterp_PredicateOp<"check_type", [NoSideEffect]> {
+  let summary = "Compare a type to a known value";
+  let description = [{
+    `pdl_interp.check_type` operations compare a type with a statically known
+    type. On success, this operation branches to the true destination, otherwise
+    the false destination is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.check_type %type is 0 -> ^matchDest, ^failureDest
+    ```
+  }];
+
+  let arguments = (ins PDL_Type:$value, TypeAttr:$type);
+  let assemblyFormat = "$value `is` $type attr-dict `->` successors";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::CreateAttributeOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_CreateAttributeOp
+    : PDLInterp_Op<"create_attribute", [NoSideEffect]> {
+  let summary = "Create an interpreter handle to a constant `Attribute`";
+  let description = [{
+    `pdl_interp.create_attribute` operations generate a handle within the
+    interpreter for a specific constant attribute value.
+
+    Example:
+
+    ```mlir
+    pdl_interp.create_attribute 10 : i64
+    ```
+  }];
+
+  let arguments = (ins AnyAttr:$value);
+  let results = (outs PDL_Attribute:$attribute);
+  let assemblyFormat = "$value attr-dict";
+
+  let builders = [
+    OpBuilder<"OpBuilder &builder, OperationState &state, "
+              "Attribute value", [{
+    build(builder, state, builder.getType<pdl::AttributeType>(), value);
+  }]>];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::CreateNativeOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_CreateNativeOp : PDLInterp_Op<"create_native"> {
+  let summary = "Call a native creation method to construct an `Attribute`, "
+                "`Operation`, `Type`, or `Value`";
+  let description = [{
+    `pdl_interp.create_native` operations invoke a native C++ function, that has
+    been registered externally with the consumer of PDL, to create an
+    `Attribute`, `Operation`, `Type`, or `Value`. The native function must
+    produce a value of the specified return type, and may accept any number of
+    positional arguments and constant attribute parameters.
+
+    Example:
+
+    ```mlir
+    %ret = pdl_interp.create_native "myNativeFunc"[42, "gt"](%arg0, %arg1) : !pdl.attribute
+    ```
+  }];
+
+  let arguments = (ins StrAttr:$name,
+                       Variadic<PDL_PositionalValue>:$args,
+                       OptionalAttr<ArrayAttr>:$constParams);
+  let results = (outs PDL_PositionalValue:$result);
+  let assemblyFormat = [{
+    $name ($constParams^)? (`(` $args^ `:` type($args) `)`)? `:` type($result)
+    attr-dict
+  }];
+  let verifier = ?;
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::CreateOperationOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_CreateOperationOp
+    : PDLInterp_Op<"create_operation", [AttrSizedOperandSegments]> {
+  let summary = "Create an instance of a specific `Operation`";
+  let description = [{
+    `pdl_interp.create_operation` operations create an `Operation` instance with
+    the specified attributes, operands, and result types.
+
+    Example:
+
+    ```mlir
+    // Create an instance of a `foo.op` operation.
+    %op = pdl_interp.create_operation "foo.op"(%arg0) {"attrA" = %attr0} -> %type, %type
+    ```
+  }];
+
+  let arguments = (ins StrAttr:$name,
+                       Variadic<PDL_Value>:$operands,
+                       Variadic<PDL_Attribute>:$attributes,
+                       StrArrayAttr:$attributeNames,
+                       Variadic<PDL_Type>:$types);
+  let results = (outs PDL_Operation:$operation);
+
+  let builders = [
+    OpBuilder<"OpBuilder &builder, OperationState &state, StringRef name, "
+              "ValueRange types, ValueRange operands, ValueRange attributes, "
+              "ArrayAttr attributeNames", [{
+    build(builder, state, builder.getType<pdl::OperationType>(), name,
+          operands, attributes, attributeNames, types);
+  }]>];
+  let parser = [{ return ::parseCreateOperationOp(parser, result); }];
+  let printer = [{ ::print(p, *this); }];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::CreateTypeOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_CreateTypeOp : PDLInterp_Op<"create_type", [NoSideEffect]> {
+  let summary = "Create an interpreter handle to a constant `Type`";
+  let description = [{
+    `pdl_interp.create_type` operations generate a handle within the interpreter
+    for a specific constant type value.
+
+    Example:
+
+    ```mlir
+    pdl_interp.create_type i64
+    ```
+  }];
+
+  let arguments = (ins TypeAttr:$value);
+  let results = (outs PDL_Type:$result);
+  let assemblyFormat = "$value attr-dict";
+
+  let builders = [
+    OpBuilder<"OpBuilder &builder, OperationState &state, TypeAttr type", [{
+      build(builder, state, builder.getType<pdl::TypeType>(), type);
+    }]>
+  ];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::EraseOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_EraseOp : PDLInterp_Op<"erase"> {
+  let summary = "Mark an operation as `erased`";
+  let description = [{
+    `pdl.erase` operations are used to specify that an operation should be
+    marked as erased. The semantics of this operation correspond with the
+    `eraseOp` method on a `PatternRewriter`.
+
+    Example:
+
+    ```mlir
+    pdl_interp.erase %root
+    ```
+  }];
+
+  let arguments = (ins PDL_Operation:$operation);
+  let assemblyFormat = "$operation attr-dict";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::FinalizeOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_FinalizeOp
+    : PDLInterp_Op<"finalize", [NoSideEffect, Terminator]> {
+  let summary = "Finalize a pattern match or rewrite sequence";
+  let description = [{
+    `pdl_interp.finalize` is used to denote the termination of a match or
+    rewrite sequence.
+
+    Example:
+
+    ```mlir
+    pdl_interp.finalize
+    ```
+  }];
+  let assemblyFormat = "attr-dict";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::GetAttributeOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_GetAttributeOp : PDLInterp_Op<"get_attribute", [NoSideEffect]> {
+  let summary = "Get a specified attribute value from an `Operation`";
+  let description = [{
+    `pdl_interp.get_attribute` operations try to get a specific attribute from
+    an operation. If the operation does not have that attribute, a null value is
+    returned.
+
+    Example:
+
+    ```mlir
+    %attr = pdl_interp.get_attribute "attr" of %op
+    ```
+  }];
+
+  let arguments = (ins PDL_Operation:$operation,
+                       StrAttr:$name);
+  let results = (outs PDL_Attribute:$attribute);
+  let assemblyFormat = "$name `of` $operation attr-dict";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::GetAttributeTypeOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_GetAttributeTypeOp
+    : PDLInterp_Op<"get_attribute_type", [NoSideEffect]> {
+  let summary = "Get the result type of a specified `Attribute`";
+  let description = [{
+    `pdl_interp.get_attribute_type` operations get the resulting type of a
+    specific attribute.
+
+    Example:
+
+    ```mlir
+    %type = pdl_interp.get_attribute_type of %attr
+    ```
+  }];
+
+  let arguments = (ins PDL_Attribute:$value);
+  let results = (outs PDL_Type:$result);
+  let assemblyFormat = "`of` $value attr-dict";
+
+  let builders = [
+    OpBuilder<"OpBuilder &builder, OperationState &state, Value value", [{
+      build(builder, state, builder.getType<pdl::TypeType>(), value);
+    }]>
+  ];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::GetDefiningOpOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_GetDefiningOpOp
+    : PDLInterp_Op<"get_defining_op", [NoSideEffect]> {
+  let summary = "Get the defining operation of a `Value`";
+  let description = [{
+    `pdl_interp.get_defining_op` operations try to get the defining operation
+    of a specific value. If the value is not an operation result, null is
+    returned.
+
+    Example:
+
+    ```mlir
+    %op = pdl_interp.get_defining_op of %value
+    ```
+  }];
+
+  let arguments = (ins PDL_Value:$value);
+  let results = (outs PDL_Operation:$operation);
+  let assemblyFormat = "`of` $value attr-dict";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::GetOperandOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_GetOperandOp : PDLInterp_Op<"get_operand", [NoSideEffect]> {
+  let summary = "Get a specified operand from an `Operation`";
+  let description = [{
+    `pdl_interp.get_operand` operations try to get a specific operand from an
+    operation If the operation does not have an operand for the given index, a
+    null value is returned.
+
+    Example:
+
+    ```mlir
+    %operand = pdl_interp.get_operand 1 of %op
+    ```
+  }];
+
+  let arguments = (ins PDL_Operation:$operation,
+                       Confined<I32Attr, [IntNonNegative]>:$index);
+  let results = (outs PDL_Value:$value);
+  let assemblyFormat = "$index `of` $operation attr-dict";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::GetResultOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_GetResultOp : PDLInterp_Op<"get_result", [NoSideEffect]> {
+  let summary = "Get a specified result from an `Operation`";
+  let description = [{
+    `pdl_interp.get_result` operations try to get a specific result from an
+    operation. If the operation does not have a result for the given index, a
+    null value is returned.
+
+    Example:
+
+    ```mlir
+    %result = pdl_interp.get_result 1 of %op
+    ```
+  }];
+
+  let arguments = (ins PDL_Operation:$operation,
+                       Confined<I32Attr, [IntNonNegative]>:$index);
+  let results = (outs PDL_Value:$value);
+  let assemblyFormat = "$index `of` $operation attr-dict";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::GetValueTypeOp
+//===----------------------------------------------------------------------===//
+
+// Get a type from the root operation, held in the rewriter context.
+def PDLInterp_GetValueTypeOp : PDLInterp_Op<"get_value_type", [NoSideEffect]> {
+  let summary = "Get the result type of a specified `Value`";
+  let description = [{
+    `pdl_interp.get_value_type` operations get the resulting type of a specific
+    value.
+
+    Example:
+
+    ```mlir
+    %type = pdl_interp.get_value_type of %value
+    ```
+  }];
+
+  let arguments = (ins PDL_Value:$value);
+  let results = (outs PDL_Type:$result);
+  let assemblyFormat = "`of` $value attr-dict";
+
+  let builders = [
+    OpBuilder<"OpBuilder &builder, OperationState &state, Value value", [{
+      build(builder, state, builder.getType<pdl::TypeType>(), value);
+    }]>
+  ];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::InferredTypeOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_InferredTypeOp : PDLInterp_Op<"inferred_type"> {
+  let summary = "Generate a handle to a Type that is \"inferred\"";
+  let description = [{
+    `pdl_interp.inferred_type` operations generate a handle to a type that
+    should be inferred. This signals to other operations, such as
+    `pdl_interp.create_operation`, that this type should be inferred.
+
+    Example:
+
+    ```mlir
+    pdl_interp.inferred_type
+    ```
+  }];
+  let results = (outs PDL_Type:$type);
+  let assemblyFormat = "attr-dict";
+
+  let builders = [
+    OpBuilder<"OpBuilder &builder, OperationState &state", [{
+      build(builder, state, builder.getType<pdl::TypeType>());
+    }]>,
+  ];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::IsNotNullOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_IsNotNullOp
+    : PDLInterp_PredicateOp<"is_not_null", [NoSideEffect]> {
+  let summary = "Check if a positional value is non-null";
+  let description = [{
+    `pdl_interp.is_not_null` operations check that a positional value exists. On
+    success, this operation branches to the true destination. Otherwise, the
+    false destination is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.is_not_null %value : !pdl.value -> ^matchDest, ^failureDest
+    ```
+  }];
+
+  let arguments = (ins PDL_PositionalValue:$value);
+  let assemblyFormat = "$value `:` type($value) attr-dict `->` successors";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::RecordMatchOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_RecordMatchOp
+    : PDLInterp_Op<"record_match", [AttrSizedOperandSegments, Terminator]> {
+  let summary = "Record the metadata for a successful pattern match";
+  let description = [{
+    `pdl_interp.record_match` operations record a successful pattern match with
+    the interpreter and branch to the next part of the matcher. The metadata
+    recorded by these operations correspond to a specific `pdl.pattern`, as well
+    as what values were used during that match that should be propagated to the
+    rewriter.
+
+    Example:
+
+    ```mlir
+    pdl_interp.record_match @rewriters::myRewriter(%root : !pdl.operation) : benefit(1), loc([%root, %op1]), root("foo.op") -> ^nextDest
+    ```
+  }];
+
+  let arguments = (ins Variadic<PDL_PositionalValue>:$inputs,
+                       Variadic<PDL_Operation>:$matchedOps,
+                       SymbolRefAttr:$rewriter,
+                       OptionalAttr<StrAttr>:$rootKind,
+                       OptionalAttr<StrArrayAttr>:$generatedOps,
+                       Confined<I16Attr, [IntNonNegative]>:$benefit);
+  let successors = (successor AnySuccessor:$dest);
+  let assemblyFormat = [{
+    $rewriter (`(` $inputs^ `:` type($inputs) `)`)? `:`
+    `benefit` `(` $benefit `)` `,`
+    (`generatedOps` `(` $generatedOps^ `)` `,`)?
+    `loc` `(` `[` $matchedOps `]` `)`
+    (`,` `root` `(` $rootKind^ `)`)? attr-dict `->` $dest
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::ReplaceOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_ReplaceOp : PDLInterp_Op<"replace"> {
+  let summary = "Mark an operation as `replace`d";
+  let description = [{
+    `pdl_interp.replaced` operations are used to specify that an operation
+    should be marked as replaced. The semantics of this operation correspond
+    with the `replaceOp` method on a `PatternRewriter`. The set of replacement
+    values must match the number of results specified by the operation.
+
+    Example:
+
+    ```mlir
+    // Replace root node with 2 values:
+    pdl_interp.replace %root with (%val0, %val1)
+    ```
+  }];
+  let arguments = (ins PDL_Operation:$operation,
+                       Variadic<PDL_Value>:$replValues);
+  let assemblyFormat = "$operation `with` `(` $replValues `)` attr-dict";
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::SwitchAttributeOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_SwitchAttributeOp
+    : PDLInterp_SwitchOp<"switch_attribute", [NoSideEffect]> {
+  let summary = "Switch on the value of an `Attribute`";
+  let description = [{
+    `pdl_interp.switch_attribute` operations compare the value of a given
+    attribute with a set of constant attributes. If the value matches one of the
+    provided case values the destination for that case value is taken, otherwise
+    the default destination is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.switch_attribute %attr to [10, true] -> ^10Dest, ^trueDest, ^defaultDest
+    ```
+  }];
+  let arguments = (ins PDL_Attribute:$attribute, ArrayAttr:$caseValues);
+  let assemblyFormat = [{
+    $attribute `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
+  }];
+
+  let builders = [
+    OpBuilder<"OpBuilder &builder, OperationState &state, Value attribute,"
+              "ArrayRef<Attribute> caseValues,"
+              "Block *defaultDest, ArrayRef<Block *> dests", [{
+    build(builder, state, attribute, builder.getArrayAttr(caseValues),
+          defaultDest, dests);
+  }]>];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::SwitchOperandCountOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_SwitchOperandCountOp
+    : PDLInterp_SwitchOp<"switch_operand_count", [NoSideEffect]> {
+  let summary = "Switch on the operand count of an `Operation`";
+  let description = [{
+    `pdl_interp.switch_operand_count` operations compare the operand count of a
+    given operation with a set of potential counts. If the value matches one of
+    the provided case values the destination for that case value is taken,
+    otherwise the default destination is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.switch_operand_count of %op to [10, 2] -> ^10Dest, ^2Dest, ^defaultDest
+    ```
+  }];
+
+  let arguments = (ins PDL_Operation:$operation, I32ElementsAttr:$caseValues);
+  let assemblyFormat = [{
+    `of` $operation `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
+  }];
+
+  let builders = [
+    OpBuilder<"OpBuilder &builder, OperationState &state, Value operation, "
+              "ArrayRef<int32_t> counts, Block *defaultDest, "
+              "ArrayRef<Block *> dests", [{
+    build(builder, state, operation, builder.getI32VectorAttr(counts),
+          defaultDest, dests);
+  }]>];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::SwitchOperationNameOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_SwitchOperationNameOp
+    : PDLInterp_SwitchOp<"switch_operation_name", [NoSideEffect]> {
+  let summary = "Switch on the OperationName of an `Operation`";
+  let description = [{
+    `pdl_interp.switch_operation_name` operations compare the name of a given
+    operation with a set of known names. If the value matches one of the
+    provided case values the destination for that case value is taken, otherwise
+    the default destination is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.switch_operation_name of %op to ["foo.op", "bar.op"] -> ^fooDest, ^barDest, ^defaultDest
+    ```
+  }];
+
+  let arguments = (ins PDL_Operation:$operation,
+                       StrArrayAttr:$caseValues);
+  let assemblyFormat = [{
+    `of` $operation `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
+  }];
+
+  let builders = [
+    OpBuilder<"OpBuilder &builder, OperationState &state, Value operation, "
+              "ArrayRef<OperationName> names, "
+              "Block *defaultDest, ArrayRef<Block *> dests", [{
+      auto stringNames = llvm::to_vector<8>(llvm::map_range(names,
+          [](OperationName name) { return name.getStringRef(); }));
+      build(builder, state, operation, builder.getStrArrayAttr(stringNames),
+            defaultDest, dests);
+    }]>,
+  ];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::SwitchResultCountOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_SwitchResultCountOp
+    : PDLInterp_SwitchOp<"switch_result_count", [NoSideEffect]> {
+  let summary = "Switch on the result count of an `Operation`";
+  let description = [{
+    `pdl_interp.switch_result_count` operations compare the result count of a
+    given operation with a set of potential counts. If the value matches one of
+    the provided case values the destination for that case value is taken,
+    otherwise the default destination is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.switch_result_count of %op to [0, 2] -> ^0Dest, ^2Dest, ^defaultDest
+    ```
+  }];
+
+  let arguments = (ins PDL_Operation:$operation, I32ElementsAttr:$caseValues);
+  let assemblyFormat = [{
+    `of` $operation `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
+  }];
+
+  let builders = [
+    OpBuilder<"OpBuilder &builder, OperationState &state, Value operation, "
+              "ArrayRef<int32_t> counts, Block *defaultDest, "
+              "ArrayRef<Block *> dests", [{
+    build(builder, state, operation, builder.getI32VectorAttr(counts),
+          defaultDest, dests);
+  }]>];
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::SwitchTypeOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_SwitchTypeOp : PDLInterp_SwitchOp<"switch_type", [NoSideEffect]> {
+  let summary = "Switch on a `Type` value";
+  let description = [{
+    `pdl_interp.switch_type` operations compare a type with a set of statically
+    known types. If the value matches one of the provided case values the
+    destination for that case value is taken, otherwise the default destination
+    is taken.
+
+    Example:
+
+    ```mlir
+    pdl_interp.switch_type %type to [i32, i64] -> ^i32Dest, ^i64Dest, ^defaultDest
+    ```
+  }];
+
+  let arguments = (ins PDL_Type:$value, TypeArrayAttr:$caseValues);
+  let assemblyFormat = [{
+    $value `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
+  }];
+
+  let builders = [
+    OpBuilder<"OpBuilder &builder, OperationState &state, Value edge, "
+              "TypeRange types, Block *defaultDest, ArrayRef<Block *> dests", [{
+      build(builder, state, edge, builder.getTypeArrayAttr(types), defaultDest,
+            dests);
+    }]>,
+  ];
+
+  let extraClassDeclaration = [{
+    auto getCaseTypes() { return caseValues().getAsValueRange<TypeAttr>(); }
+  }];
+}
+
+#endif // MLIR_DIALECT_PDLINTERP_IR_PDLINTERPOPS

mlir/include/mlir/IR/Attributes.h

public:
     explicit attr_value_iterator(ArrayAttr::iterator it)
         : llvm::mapped_iterator<ArrayAttr::iterator, AttrTy (*)(Attribute)>(
               it, [](Attribute attr) { return attr.cast<AttrTy>(); }) {}
     AttrTy operator*() const { return (*this->I).template cast<AttrTy>(); }
   };
 
 public:
   template <typename AttrTy>
-  llvm::iterator_range<attr_value_iterator<AttrTy>> getAsRange() {
+  iterator_range<attr_value_iterator<AttrTy>> getAsRange() {
     return llvm::make_range(attr_value_iterator<AttrTy>(begin()),
                             attr_value_iterator<AttrTy>(end()));
   }
-  template <typename AttrTy, typename UnderlyingTy>
-  auto getAsRange() {
+  template <typename AttrTy, typename UnderlyingTy = typename AttrTy::ValueType>
+  auto getAsValueRange() {
     return llvm::map_range(getAsRange<AttrTy>(), [](AttrTy attr) {
       return static_cast<UnderlyingTy>(attr.getValue());
     });
   }
 };
 
 //===----------------------------------------------------------------------===//
 // DictionaryAttr
public:
   template <typename T> iterator_range<T> getValues() const;
 
   /// Return if the given 'index' refers to a valid element in this attribute.
   bool isValidIndex(ArrayRef<uint64_t> index) const;
 
   /// Returns the number of elements held by this attribute.
   int64_t getNumElements() const;
 
+  /// Returns the number of elements held by this attribute.
+  int64_t size() const { return getNumElements(); }
+
   /// Generates a new ElementsAttr by mapping each int value to a new
   /// underlying APInt. The new values can represent either an integer or float.
   /// This ElementsAttr should contain integers.
   ElementsAttr mapValues(Type newElementType,
                          function_ref<APInt(const APInt &)> mapping) const;
 
   /// Generates a new ElementsAttr by mapping each float value to a new
   /// underlying APInt. The new values can represent either an integer or float.

mlir/include/mlir/IR/Builders.h

public:
   ArrayAttr getAffineMapArrayAttr(ArrayRef<AffineMap> values);
   ArrayAttr getBoolArrayAttr(ArrayRef<bool> values);
   ArrayAttr getI32ArrayAttr(ArrayRef<int32_t> values);
   ArrayAttr getI64ArrayAttr(ArrayRef<int64_t> values);
   ArrayAttr getIndexArrayAttr(ArrayRef<int64_t> values);
   ArrayAttr getF32ArrayAttr(ArrayRef<float> values);
   ArrayAttr getF64ArrayAttr(ArrayRef<double> values);
   ArrayAttr getStrArrayAttr(ArrayRef<StringRef> values);
+  ArrayAttr getTypeArrayAttr(TypeRange values);
 
   // Affine expressions and affine maps.
   AffineExpr getAffineDimExpr(unsigned position);
   AffineExpr getAffineSymbolExpr(unsigned position);
   AffineExpr getAffineConstantExpr(int64_t constant);
 
   // Special cases of affine maps and integer sets
   /// Returns a zero result affine map with no dimensions or symbols: () -> ().

mlir/include/mlir/IR/OpImplementation.h

virtual OptionalParseResult parseOptionalAttribute(Attribute &result,
                                                      StringRef attrName,
                                                      NamedAttrList &attrs) = 0;
   OptionalParseResult parseOptionalAttribute(Attribute &result,
                                              StringRef attrName,
                                              NamedAttrList &attrs) {
     return parseOptionalAttribute(result, Type(), attrName, attrs);
   }
 
+  /// Specialized variants of `parseOptionalAttribute` that remove potential
+  /// ambiguities in syntax.
+  virtual OptionalParseResult parseOptionalAttribute(ArrayAttr &result,
+                                                     StringRef attrName,
+                                                     NamedAttrList &attrs) = 0;
+
   /// Parse an arbitrary attribute of a given type and return it in result. This
   /// also adds the attribute to the specified attribute list with the specified
   /// name.
   template <typename AttrType>
   ParseResult parseAttribute(AttrType &result, Type type, StringRef attrName,
                              NamedAttrList &attrs) {
     llvm::SMLoc loc = getCurrentLocation();
 

mlir/include/mlir/InitAllDialects.h

 #include "mlir/Dialect/LLVMIR/LLVMAVX512Dialect.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/LLVMIR/NVVMDialect.h"
 #include "mlir/Dialect/LLVMIR/ROCDLDialect.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/OpenACC/OpenACC.h"
 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
 #include "mlir/Dialect/PDL/IR/PDL.h"
+#include "mlir/Dialect/PDLInterp/IR/PDLInterp.h"
 #include "mlir/Dialect/Quant/QuantOps.h"
 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/Dialect/SDBM/SDBMDialect.h"
 #include "mlir/Dialect/SPIRV/SPIRVDialect.h"
 #include "mlir/Dialect/Shape/IR/Shape.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/IR/Dialect.h"
 
 namespace mlir {
 
 // Add all the MLIR dialects to the provided registry.
 inline void registerAllDialects(DialectRegistry &registry) {
   // clang-format off
   registry.insert<acc::OpenACCDialect,
                   AffineDialect,
                   avx512::AVX512Dialect,
                   gpu::GPUDialect,
                   LLVM::LLVMAVX512Dialect,
                   LLVM::LLVMDialect,
                   linalg::LinalgDialect,
                   scf::SCFDialect,
                   omp::OpenMPDialect,
                   pdl::PDLDialect,
+                  pdl_interp::PDLInterpDialect,
                   quant::QuantizationDialect,
                   spirv::SPIRVDialect,
                   StandardOpsDialect,
                   vector::VectorDialect,
                   NVVM::NVVMDialect,
                   ROCDL::ROCDLDialect,
                   SDBMDialect,
                   shape::ShapeDialect>();

mlir/lib/Dialect/CMakeLists.txt

 add_subdirectory(Affine)
 add_subdirectory(AVX512)
 add_subdirectory(GPU)
 add_subdirectory(Linalg)
 add_subdirectory(LLVMIR)
 add_subdirectory(OpenACC)
 add_subdirectory(OpenMP)
 add_subdirectory(PDL)
+add_subdirectory(PDLInterp)
 add_subdirectory(Quant)
 add_subdirectory(SCF)
 add_subdirectory(SDBM)
 add_subdirectory(Shape)
 add_subdirectory(SPIRV)
 add_subdirectory(StandardOps)
 add_subdirectory(Vector)
 

mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp

static LogicalResult isContraction(Operation *op) {
   if (isa<linalg::BatchMatmulOp, linalg::MatmulOp, linalg::MatvecOp,
           linalg::DotOp>(op))
     return success();
 
   auto genericOp = dyn_cast<linalg::GenericOp>(op);
   if (!genericOp)
     return failure();
 
-  auto mapRange =
-      genericOp.indexing_maps().getAsRange<AffineMapAttr, AffineMap>();
-
+  auto mapRange = genericOp.indexing_maps().getAsValueRange<AffineMapAttr>();
   return success(
       genericOp.getNumInputs() == 2 && genericOp.getNumOutputs() == 1 &&
       llvm::all_of(mapRange,
                    [](AffineMap m) { return m.isProjectedPermutation(); }) &&
       hasMultiplyAddBody(genericOp.region()));
 }
 
 LogicalResult mlir::linalg::vectorizeLinalgOpPrecondition(Operation *op) {

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

static LogicalResult verify(ReplaceOp op) {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::RewriteOp
 //===----------------------------------------------------------------------===//
 
 static ParseResult parseRewriteOp(OpAsmParser &p, OperationState &state) {
-  // If the first token isn't a '(', this is an external rewrite.
-  StringAttr nameAttr;
-  if (failed(p.parseOptionalLParen())) {
-    if (p.parseAttribute(nameAttr, "name", state.attributes) || p.parseLParen())
-      return failure();
-  }
-
   // Parse the root operand.
   OpAsmParser::OperandType rootOperand;
-  if (p.parseOperand(rootOperand) || p.parseRParen() ||
+  if (p.parseOperand(rootOperand) ||
       p.resolveOperand(rootOperand, p.getBuilder().getType<OperationType>(),
                        state.operands))
     return failure();
 
+  // Parse an external rewrite.
+  StringAttr nameAttr;
+  if (succeeded(p.parseOptionalKeyword("with"))) {
+    if (p.parseAttribute(nameAttr, "name", state.attributes))
+      return failure();
+
+    // Parse the optional set of constant parameters.
+    ArrayAttr constantParams;
+    OptionalParseResult constantParamResult = p.parseOptionalAttribute(
+        constantParams, "externalConstParams", state.attributes);
+    if (constantParamResult.hasValue() && failed(*constantParamResult))
+      return failure();
+
+    // Parse the optional additional arguments.
+    if (succeeded(p.parseOptionalLParen())) {
+      SmallVector<OpAsmParser::OperandType, 4> arguments;
+      SmallVector<Type, 4> argumentTypes;
+      llvm::SMLoc argumentLoc = p.getCurrentLocation();
+      if (p.parseOperandList(arguments) ||
+          p.parseColonTypeList(argumentTypes) || p.parseRParen() ||
+          p.resolveOperands(arguments, argumentTypes, argumentLoc,
+                            state.operands))
+        return failure();
+    }
+  }
+
   // If this isn't an external rewrite, parse the region body.
   Region &rewriteRegion = *state.addRegion();
   if (!nameAttr) {
     if (p.parseRegion(rewriteRegion, /*arguments=*/llvm::None,
                       /*argTypes=*/llvm::None))
       return failure();
     RewriteOp::ensureTerminator(rewriteRegion, p.getBuilder(), state.location);
   }
-  return success();
+
+  return p.parseOptionalAttrDictWithKeyword(state.attributes);
 }
 
 static void print(OpAsmPrinter &p, RewriteOp op) {
-  p << "pdl.rewrite";
+  p << "pdl.rewrite " << op.root();
   if (Optional<StringRef> name = op.name()) {
-    p << " \"" << *name << "\"(" << op.root() << ")";
-    return;
-  }
+    p << " with \"" << *name << "\"";
+
+    if (ArrayAttr constantParams = op.externalConstParamsAttr())
+      p << constantParams;
 
-  p << "(" << op.root() << ")";
+    OperandRange externalArgs = op.externalArgs();
+    if (!externalArgs.empty())
+      p << "(" << externalArgs << " : " << externalArgs.getTypes() << ")";
+  } else {
     p.printRegion(op.body(), /*printEntryBlockArgs=*/false,
                   /*printBlockTerminators=*/false);
   }
 
+  p.printOptionalAttrDictWithKeyword(op.getAttrs(),
+                                     {"name", "externalConstParams"});
+}
+
 static LogicalResult verify(RewriteOp op) {
   Region &rewriteRegion = op.body();
-  if (llvm::hasNItemsOrMore(rewriteRegion, 2)) {
+
+  // Handle the case where the rewrite is external.
+  if (op.name()) {
+    if (!rewriteRegion.empty()) {
       return op.emitOpError()
-           << "expected rewrite region when specified to have a single block";
+             << "expected rewrite region to be empty when rewrite is external";
+    }
+    return success();
   }
+
+  // Otherwise, check that the rewrite region only contains a single block.
+  if (rewriteRegion.empty()) {
+    return op.emitOpError() << "expected rewrite region to be non-empty if "
+                               "external name is not specified";
+  }
+
+  // Check that no additional arguments were provided.
+  if (!op.externalArgs().empty()) {
+    return op.emitOpError() << "expected no external arguments when the "
+                               "rewrite is specified inline";
+  }
+  if (op.externalConstParams()) {
+    return op.emitOpError() << "expected no external constant parameters when "
+                               "the rewrite is specified inline";
+  }
+
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::TypeOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(TypeOp op) {

mlir/lib/Dialect/PDLInterp/CMakeLists.txt

+add_subdirectory(IR)

mlir/lib/Dialect/PDLInterp/IR/CMakeLists.txt

+add_mlir_dialect_library(MLIRPDLInterp
+  PDLInterp.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/PDLInterp
+
+  DEPENDS
+  MLIRPDLInterpOpsIncGen
+
+  LINK_LIBS PUBLIC
+  MLIRIR
+  MLIRPDL
+  MLIRInferTypeOpInterface
+  MLIRSideEffectInterfaces
+  )

mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp

+//===- PDLInterp.cpp - PDL Interpreter 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/PDLInterp/IR/PDLInterp.h"
+#include "mlir/Dialect/PDL/IR/PDLTypes.h"
+#include "mlir/IR/DialectImplementation.h"
+#include "mlir/IR/StandardTypes.h"
+
+using namespace mlir;
+using namespace mlir::pdl_interp;
+
+//===----------------------------------------------------------------------===//
+// PDLInterp Dialect
+//===----------------------------------------------------------------------===//
+
+void PDLInterpDialect::initialize() {
+  addOperations<
+#define GET_OP_LIST
+#include "mlir/Dialect/PDLInterp/IR/PDLInterpOps.cpp.inc"
+      >();
+}
+
+//===----------------------------------------------------------------------===//
+// pdl_interp::CreateOperationOp
+//===----------------------------------------------------------------------===//
+
+static ParseResult parseCreateOperationOp(OpAsmParser &p,
+                                          OperationState &state) {
+  if (p.parseOptionalAttrDict(state.attributes))
+    return failure();
+  Builder &builder = p.getBuilder();
+
+  // Parse the operation name.
+  StringAttr opName;
+  if (p.parseAttribute(opName, "name", state.attributes))
+    return failure();
+
+  // Parse the operands.
+  SmallVector<OpAsmParser::OperandType, 4> operands;
+  if (p.parseLParen() || p.parseOperandList(operands) || p.parseRParen() ||
+      p.resolveOperands(operands, builder.getType<pdl::ValueType>(),
+                        state.operands))
+    return failure();
+
+  // Parse the attributes.
+  SmallVector<Attribute, 4> attrNames;
+  if (succeeded(p.parseOptionalLBrace())) {
+    SmallVector<OpAsmParser::OperandType, 4> attrOps;
+    do {
+      StringAttr nameAttr;
+      OpAsmParser::OperandType operand;
+      if (p.parseAttribute(nameAttr) || p.parseEqual() ||
+          p.parseOperand(operand))
+        return failure();
+      attrNames.push_back(nameAttr);
+      attrOps.push_back(operand);
+    } while (succeeded(p.parseOptionalComma()));
+
+    if (p.parseRBrace() ||
+        p.resolveOperands(attrOps, builder.getType<pdl::AttributeType>(),
+                          state.operands))
+      return failure();
+  }
+  state.addAttribute("attributeNames", builder.getArrayAttr(attrNames));
+  state.addTypes(builder.getType<pdl::OperationType>());
+
+  // Parse the result types.
+  SmallVector<OpAsmParser::OperandType, 4> opResultTypes;
+  if (p.parseArrow())
+    return failure();
+  if (succeeded(p.parseOptionalLParen())) {
+    if (p.parseRParen())
+      return failure();
+  } else if (p.parseOperandList(opResultTypes) ||
+             p.resolveOperands(opResultTypes, builder.getType<pdl::TypeType>(),
+                               state.operands)) {
+    return failure();
+  }
+
+  int32_t operandSegmentSizes[] = {static_cast<int32_t>(operands.size()),
+                                   static_cast<int32_t>(attrNames.size()),
+                                   static_cast<int32_t>(opResultTypes.size())};
+  state.addAttribute("operand_segment_sizes",
+                     builder.getI32VectorAttr(operandSegmentSizes));
+  return success();
+}
+
+static void print(OpAsmPrinter &p, CreateOperationOp op) {
+  p << "pdl_interp.create_operation ";
+  p.printOptionalAttrDict(op.getAttrs(),
+                          {"attributeNames", "name", "operand_segment_sizes"});
+  p << '"' << op.name() << "\"(" << op.operands() << ')';
+
+  // Emit the optional attributes.
+  ArrayAttr attrNames = op.attributeNames();
+  if (!attrNames.empty()) {
+    Operation::operand_range attrArgs = op.attributes();
+    p << " {";
+    interleaveComma(llvm::seq<int>(0, attrNames.size()), p,
+                    [&](int i) { p << attrNames[i] << " = " << attrArgs[i]; });
+    p << '}';
+  }
+
+  // Print the result type constraints of the operation.
+  auto types = op.types();
+  if (types.empty())
+    p << " -> ()";
+  else
+    p << " -> " << op.types();
+}
+
+//===----------------------------------------------------------------------===//
+// TableGen Auto-Generated Op and Interface Definitions
+//===----------------------------------------------------------------------===//
+
+#define GET_OP_CLASSES
+#include "mlir/Dialect/PDLInterp/IR/PDLInterpOps.cpp.inc"

mlir/lib/IR/Builders.cpp

 }
 
 ArrayAttr Builder::getStrArrayAttr(ArrayRef<StringRef> values) {
   auto attrs = llvm::to_vector<8>(llvm::map_range(
       values, [this](StringRef v) -> Attribute { return getStringAttr(v); }));
   return getArrayAttr(attrs);
 }
 
+ArrayAttr Builder::getTypeArrayAttr(TypeRange values) {
+  auto attrs = llvm::to_vector<8>(llvm::map_range(
+      values, [](Type v) -> Attribute { return TypeAttr::get(v); }));
+  return getArrayAttr(attrs);
+}
+
 ArrayAttr Builder::getAffineMapArrayAttr(ArrayRef<AffineMap> values) {
   auto attrs = llvm::to_vector<8>(llvm::map_range(
       values, [](AffineMap v) -> Attribute { return AffineMapAttr::get(v); }));
   return getArrayAttr(attrs);
 }
 
 Attribute Builder::getZeroAttr(Type type) {
   if (type.isa<FloatType>())

mlir/lib/Parser/AttributeParser.cpp

default:
     // Parse an optional type attribute.
     Type type;
     OptionalParseResult result = parseOptionalType(type);
     if (result.hasValue() && succeeded(*result))
       attribute = TypeAttr::get(type);
     return result;
   }
 }
+OptionalParseResult Parser::parseOptionalAttribute(ArrayAttr &attribute) {
+  return parseOptionalAttributeWithToken(Token::l_square, attribute);
+}
 
 /// Attribute dictionary.
 ///
 ///   attribute-dict ::= `{` `}`
 ///                    | `{` attribute-entry (`,` attribute-entry)* `}`
 ///   attribute-entry ::= (bare-id | string-literal) `=` attribute-value
 ///
 ParseResult Parser::parseAttributeDict(NamedAttrList &attributes) {

mlir/lib/Parser/Parser.h

public:
   //===--------------------------------------------------------------------===//
 
   /// Parse an arbitrary attribute with an optional type.
   Attribute parseAttribute(Type type = {});
 
   /// Parse an optional attribute with the provided type.
   OptionalParseResult parseOptionalAttribute(Attribute &attribute,
                                              Type type = {});
+  OptionalParseResult parseOptionalAttribute(ArrayAttr &attribute);
+
+  /// Parse an optional attribute that is demarcated by a specific token.
+  template <typename AttributeT>
+  OptionalParseResult parseOptionalAttributeWithToken(Token::Kind kind,
+                                                      AttributeT &attr,
+                                                      Type type = {}) {
+    if (getToken().isNot(kind))
+      return llvm::None;
+
+    if (Attribute parsedAttr = parseAttribute()) {
+      attr = parsedAttr.cast<ArrayAttr>();
+      return success();
+    }
+    return failure();
+  }
 
   /// Parse an attribute dictionary.
   ParseResult parseAttributeDict(NamedAttrList &attributes);
 
   /// Parse an extended attribute.
   Attribute parseExtendedAttr(Type type);
 
   /// Parse a float attribute.

mlir/lib/Parser/Parser.cpp

public:
 
   /// Parse an arbitrary attribute of a given type and return it in result.
   ParseResult parseAttribute(Attribute &result, Type type) override {
     result = parser.parseAttribute(type);
     return success(static_cast<bool>(result));
   }
 
   /// Parse an optional attribute.
-  OptionalParseResult parseOptionalAttribute(Attribute &result, Type type,
-                                             StringRef attrName,
-                                             NamedAttrList &attrs) override {
+  /// Template utilities to simplify specifying multiple derived overloads.
+  template <typename AttrT>
+  OptionalParseResult
+  parseOptionalAttributeAndAddToList(AttrT &result, Type type,
+                                     StringRef attrName, NamedAttrList &attrs) {
     OptionalParseResult parseResult =
         parser.parseOptionalAttribute(result, type);
     if (parseResult.hasValue() && succeeded(*parseResult))
       attrs.push_back(parser.builder.getNamedAttr(attrName, result));
     return parseResult;
   }
+  template <typename AttrT>
+  OptionalParseResult parseOptionalAttributeAndAddToList(AttrT &result,
+                                                         StringRef attrName,
+                                                         NamedAttrList &attrs) {
+    OptionalParseResult parseResult = parser.parseOptionalAttribute(result);
+    if (parseResult.hasValue() && succeeded(*parseResult))
+      attrs.push_back(parser.builder.getNamedAttr(attrName, result));
+    return parseResult;
+  }
+
+  OptionalParseResult parseOptionalAttribute(Attribute &result, Type type,
+                                             StringRef attrName,
+                                             NamedAttrList &attrs) override {
+    return parseOptionalAttributeAndAddToList(result, type, attrName, attrs);
+  }
+  OptionalParseResult parseOptionalAttribute(ArrayAttr &result,
+                                             StringRef attrName,
+                                             NamedAttrList &attrs) override {
+    return parseOptionalAttributeAndAddToList(result, attrName, attrs);
+  }
 
   /// Parse a named dictionary into 'result' if it is present.
   ParseResult parseOptionalAttrDict(NamedAttrList &result) override {
     if (parser.getToken().isNot(Token::l_brace))
       return success();
     return parser.parseAttributeDict(result);
   }
 

mlir/test/Dialect/PDL/invalid.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics
 
 //===----------------------------------------------------------------------===//
 // pdl::ApplyConstraintOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
   %op = pdl.operation "foo.op"
 
   // expected-error@below {{expected at least one argument}}
   "pdl.apply_constraint"() {name = "foo", params = []} : () -> ()
-  pdl.rewrite "rewriter"(%op)
+  pdl.rewrite %op with "rewriter"
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl::AttributeOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
   %type = pdl.type
 
   // expected-error@below {{expected only one of [`type`, `value`] to be set}}
   %attr = pdl.attribute : %type 10
 
   %op, %result = pdl.operation "foo.op" {"attr" = %attr} -> %type
-  pdl.rewrite "rewriter"(%op)
+  pdl.rewrite %op with "rewriter"
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
   %op = pdl.operation "foo.op"
-  pdl.rewrite(%op) {
+  pdl.rewrite %op {
     %type = pdl.type
 
     // expected-error@below {{expected constant value when specified within a `pdl.rewrite`}}
     %attr = pdl.attribute : %type
   }
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
   %op = pdl.operation "foo.op"
-  pdl.rewrite(%op) {
+  pdl.rewrite %op {
     // expected-error@below {{expected constant value when specified within a `pdl.rewrite`}}
     %attr = pdl.attribute
   }
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
   // expected-error@below {{expected a bindable (i.e. `pdl.operation`) user when defined in the matcher body of a `pdl.pattern`}}
   %unused = pdl.attribute
 
   %op = pdl.operation "foo.op"
-  pdl.rewrite "rewriter"(%op)
+  pdl.rewrite %op with "rewriter"
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl::InputOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
   // expected-error@below {{expected a bindable (i.e. `pdl.operation`) user when defined in the matcher body of a `pdl.pattern`}}
   %unused = pdl.input
 
   %op = pdl.operation "foo.op"
-  pdl.rewrite "rewriter"(%op)
+  pdl.rewrite %op with "rewriter"
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl::OperationOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
   %op = pdl.operation "foo.op"
-  pdl.rewrite(%op) {
+  pdl.rewrite %op {
     // expected-error@below {{must have an operation name when nested within a `pdl.rewrite`}}
     %newOp = pdl.operation
   }
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
   // expected-error@below {{expected the same number of attribute values and attribute names, got 1 names and 0 values}}
   %op = "pdl.operation"() {
     attributeNames = ["attr"],
     operand_segment_sizes = dense<0> : vector<3xi32>
   } : () -> (!pdl.operation)
-  pdl.rewrite "rewriter"(%op)
+  pdl.rewrite %op with "rewriter"
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
   %op = pdl.operation "foo.op"()
-  pdl.rewrite (%op) {
+  pdl.rewrite %op {
     %type = pdl.type
 
     // expected-error@below {{op must have inferable or constrained result types when nested within `pdl.rewrite`}}
     // expected-note@below {{result type #0 was not constrained}}
     %newOp, %result = pdl.operation "foo.op" -> %type
   }
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
   // expected-error@below {{expected a bindable (i.e. `pdl.operation` or `pdl.rewrite`) user when defined in the matcher body of a `pdl.pattern`}}
   %unused = pdl.operation "foo.op"
 
   %op = pdl.operation "foo.op"
-  pdl.rewrite "rewriter"(%op)
+  pdl.rewrite %op with "rewriter"
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl::PatternOp
 //===----------------------------------------------------------------------===//
 
 // expected-error@below {{expected body to terminate with `pdl.rewrite`}}
 pdl.pattern : benefit(1) {
   // expected-note@below {{see terminator defined here}}
   return
 }
 
 // -----
 
 // expected-error@below {{expected only `pdl` operations within the pattern body}}
 pdl.pattern : benefit(1) {
   // expected-note@below {{see non-`pdl` operation defined here}}
   "foo.other_op"() : () -> ()
 
   %root = pdl.operation "foo.op"
-  pdl.rewrite "foo"(%root)
+  pdl.rewrite %root with "foo"
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl::ReplaceOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
   %root = pdl.operation "foo.op"
-  pdl.rewrite (%root) {
+  pdl.rewrite %root {
     %type = pdl.type : i32
     %newOp, %newResult = pdl.operation "foo.op" -> %type
 
     // expected-error@below {{to have the same number of results as the replacement operation}}
     pdl.replace %root with %newOp
   }
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
   %type = pdl.type : i32
   %root, %oldResult = pdl.operation "foo.op" -> %type
-  pdl.rewrite (%root) {
+  pdl.rewrite %root {
     %newOp, %newResult = pdl.operation "foo.op" -> %type
 
     // expected-error@below {{expected no replacement values to be provided when the replacement operation is present}}
     "pdl.replace"(%root, %newOp, %newResult) {
       operand_segment_sizes = dense<1> : vector<3xi32>
     } : (!pdl.operation, !pdl.operation, !pdl.value) -> ()
   }
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
   %root = pdl.operation "foo.op"
-  pdl.rewrite (%root) {
+  pdl.rewrite %root {
     %type = pdl.type : i32
     %newOp, %newResult = pdl.operation "foo.op" -> %type
 
     // expected-error@below {{to have the same number of results as the provided replacement values}}
     pdl.replace %root with (%newResult)
   }
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
+// pdl::RewriteOp
+//===----------------------------------------------------------------------===//
+
+pdl.pattern : benefit(1) {
+  %op = pdl.operation "foo.op"
+
+  // expected-error@below {{expected rewrite region to be non-empty if external name is not specified}}
+  "pdl.rewrite"(%op) ({}) : (!pdl.operation) -> ()
+}
+
+// -----
+
+pdl.pattern : benefit(1) {
+  %op = pdl.operation "foo.op"
+
+  // expected-error@below {{expected no external arguments when the rewrite is specified inline}}
+  "pdl.rewrite"(%op, %op) ({
+    ^bb1:
+      pdl.rewrite_end
+  }) : (!pdl.operation, !pdl.operation) -> ()
+}
+
+// -----
+
+pdl.pattern : benefit(1) {
+  %op = pdl.operation "foo.op"
+
+  // expected-error@below {{expected no external constant parameters when the rewrite is specified inline}}
+  "pdl.rewrite"(%op) ({
+    ^bb1:
+      pdl.rewrite_end
+  }) {externalConstParams = []} : (!pdl.operation) -> ()
+}
+
+// -----
+
+pdl.pattern : benefit(1) {
+  %op = pdl.operation "foo.op"
+
+  // expected-error@below {{expected rewrite region to be empty when rewrite is external}}
+  "pdl.rewrite"(%op) ({
+    ^bb1:
+      pdl.rewrite_end
+  }) {name = "foo"} : (!pdl.operation) -> ()
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
 // pdl::TypeOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
   // expected-error@below {{expected a bindable (i.e. `pdl.attribute`, `pdl.input`, or `pdl.operation`) user when defined in the matcher body of a `pdl.pattern`}}
   %unused = pdl.type
 
   %op = pdl.operation "foo.op"
-  pdl.rewrite "rewriter"(%op)
+  pdl.rewrite %op with "rewriter"
 }

mlir/test/Dialect/PDL/ops.mlir

 // RUN: mlir-opt -split-input-file %s | mlir-opt
-// Verify the printed output can be parsed.
-// RUN: mlir-opt %s | mlir-opt
 // Verify the generic form can be parsed.
-// RUN: mlir-opt -mlir-print-op-generic %s | mlir-opt
+// RUN: mlir-opt -split-input-file -mlir-print-op-generic %s | mlir-opt
 
 // -----
 
 pdl.pattern @operations : benefit(1) {
   // Operation with attributes and results.
   %attribute = pdl.attribute
   %type = pdl.type
   %op0, %op0_result = pdl.operation {"attr" = %attribute} -> %type
 
   // Operation with input.
   %input = pdl.input
   %root = pdl.operation(%op0_result, %input)
-  pdl.rewrite "rewriter"(%root)
+  pdl.rewrite %root with "rewriter"
+}
+
+// -----
+
+pdl.pattern @rewrite_with_args : benefit(1) {
+  %input = pdl.input
+  %root = pdl.operation(%input)
+  pdl.rewrite %root with "rewriter"(%input : !pdl.value)
+}
+
+// -----
+
+pdl.pattern @rewrite_with_params : benefit(1) {
+  %root = pdl.operation
+  pdl.rewrite %root with "rewriter"["I am param"]
+}
+
+// -----
+
+pdl.pattern @rewrite_with_args_and_params : benefit(1) {
+  %input = pdl.input
+  %root = pdl.operation(%input)
+  pdl.rewrite %root with "rewriter"["I am param"](%input : !pdl.value)
 }
 
 // -----
 
 // Check that the result type of an operation within a rewrite can be inferred
 // from a pdl.replace.
 pdl.pattern @infer_type_from_operation_replace : benefit(1) {
   %type1 = pdl.type : i32
   %type2 = pdl.type
   %root, %results:2 = pdl.operation -> %type1, %type2
-  pdl.rewrite(%root) {
+  pdl.rewrite %root {
     %type3 = pdl.type
     %newOp, %newResults:2 = pdl.operation "foo.op" -> %type1, %type3
     pdl.replace %root with %newOp
   }
 }
 
 // -----
 
 // Check that the result type of an operation within a rewrite can be inferred
 // from a pdl.replace.
 pdl.pattern @infer_type_from_result_replace : benefit(1) {
   %type1 = pdl.type : i32
   %type2 = pdl.type
   %root, %results:2 = pdl.operation -> %type1, %type2
-  pdl.rewrite(%root) {
+  pdl.rewrite %root {
     %type3 = pdl.type
     %newOp, %newResults:2 = pdl.operation "foo.op" -> %type1, %type3
     pdl.replace %root with (%newResults#0, %newResults#1)
   }
 }
 
 // -----
 
 // Check that the result type of an operation within a rewrite can be inferred
 // from a pdl.replace.
 pdl.pattern @infer_type_from_type_used_in_match : benefit(1) {
   %type1 = pdl.type : i32
   %type2 = pdl.type
   %root, %results:2 = pdl.operation -> %type1, %type2
-  pdl.rewrite(%root) {
+  pdl.rewrite %root {
     %newOp, %newResults:2 = pdl.operation "foo.op" -> %type1, %type2
   }
 }

mlir/test/Dialect/PDLInterp/ops.mlir

+// RUN: mlir-opt -split-input-file %s | mlir-opt
+// Verify the printed output can be parsed.
+// RUN: mlir-opt %s | mlir-opt
+// Verify the generic form can be parsed.
+// RUN: mlir-opt -mlir-print-op-generic %s | mlir-opt
+
+// -----
+
+func @operations(%attribute: !pdl.attribute,
+                 %input: !pdl.value,
+                 %type: !pdl.type) {
+  // attributes, operands, and results
+  %op0 = pdl_interp.create_operation "foo.op"(%input) {"attr" = %attribute} -> %type
+
+  // attributes, and results
+  %op1 = pdl_interp.create_operation "foo.op"() {"attr" = %attribute} -> %type
+
+  // attributes
+  %op2 = pdl_interp.create_operation "foo.op"() {"attr" = %attribute, "attr1" = %attribute} -> ()
+
+  // operands, and results
+  %op3 = pdl_interp.create_operation "foo.op"(%input) -> %type
+
+  pdl_interp.finalize
+}

mlir/tools/mlir-tblgen/OpFormatGen.cpp

 bool LiteralElement::isValidLiteral(StringRef value) {
   if (value.empty())
     return false;
   char front = value.front();
 
   // If there is only one character, this must either be punctuation or a
   // single character bare identifier.
   if (value.size() == 1)
-    return isalpha(front) || StringRef("_:,=<>()[]?").contains(front);
+    return isalpha(front) || StringRef("_:,=<>()[]{}?").contains(front);
 
   // Check the punctuation that are larger than a single character.
   if (value == "->")
     return true;
 
   // Otherwise, this must be an identifier.
   if (!isalpha(front) && front != '_')
     return false;
static void genLiteralParser(StringRef value, OpMethodBody &body) {
   }
   body << (StringRef)llvm::StringSwitch<StringRef>(value)
               .Case("->", "Arrow()")
               .Case(":", "Colon()")
               .Case(",", "Comma()")
               .Case("=", "Equal()")
               .Case("<", "Less()")
               .Case(">", "Greater()")
+              .Case("{", "LBrace()")
+              .Case("}", "RBrace()")
               .Case("(", "LParen()")
               .Case(")", "RParen()")
               .Case("[", "LSquare()")
               .Case("]", "RSquare()")
               .Case("?", "Question()");
 }
 
 /// Generate the storage code required for parsing the given element.