[mlir][PDL] Add support for variadic operands and results in PDL

[rriddle]

Summary

This revision extends the PDL dialect to add support for variadic operands and results, with ranges of these values represented via the recently added !pdl.range type. To support this extension, three new operations have been added that closely match the single variant:

• pdl.operands : Define a range of input operands.
• pdl.results : Extract a range of results from an operation.
• pdl.types :Define a handle to a range of types.

Support for these in the pdl interpreter dialect and byte code will be added in followup revisions.

Depends On D95720

[rriddle]

Rebase

[ftynse]

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

537

a groups -> groups

[jpienaar]

Nice, thanks

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

236

Is result the only other mechanism? The description here is a bit opaque, makes me wonder what other cases there are

249

Use different name here to avoid conflict?

[rriddle]

rebase

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

let arguments = (ins StrAttr:$name,
                        Variadic<PDL_AnyType>:$args,
                        OptionalAttr<ArrayAttr>:$constParams);
   let assemblyFormat = [{
     $name ($constParams^)? `(` $args `:` type($args) `)` attr-dict
   }];
 
   let builders = [
     OpBuilder<(ins "StringRef":$name, CArg<"ValueRange", "{}">:$args,
                    CArg<"ArrayRef<Attribute>", "{}">:$params), [{
       build($_builder, $_state, $_builder.getStringAttr(name), args,
             params.empty() ? ArrayAttr() : $_builder.getArrayAttr(params));
     }]>,
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::ApplyNativeRewriteOp

 // pdl::OperandOp
 //===----------------------------------------------------------------------===//
 
 def PDL_OperandOp : PDL_Op<"operand", [HasParent<"pdl::PatternOp">]> {
   let summary = "Define an external input operand in a pattern";
   let description = [{
     `pdl.operand` operations capture external operand edges into an operation
     node that originate from operations or block arguments not otherwise
-    specified within the pattern (e.g. via `pdl.result`). These operations
-    define individual operands of a given operation. A `pdl.operand` may
-    partially constrain an operand by specifying an expected value type
+    specified within the pattern (i.e. via `pdl.result` or `pdl.results`). These
+    operations define individual operands of a given operation. A `pdl.operand`
+    may partially constrain an operand by specifying an expected value type
     (via a `pdl.type` operation).
 
     Example:
 
     ```mlir
     // Define an external operand:
     %operand = pdl.operand
 
def PDL_OperandOp : PDL_Op<"operand", [HasParent<"pdl::PatternOp">]> {
   let builders = [
     OpBuilder<(ins), [{
       build($_builder, $_state, $_builder.getType<ValueType>(), Value());
     }]>,
   ];
 }
 
 //===----------------------------------------------------------------------===//
+// pdl::OperandsOp
+//===----------------------------------------------------------------------===//
+
+def PDL_OperandsOp : PDL_Op<"operands", [HasParent<"pdl::PatternOp">]> {
+  let summary = "Define a range of input operands in a pattern";
+  let description = [{
+    `pdl.operands` operations capture external operand range edges into an
+    operation node that originate from operations or block arguments not
+    otherwise specified within the pattern (i.e. via `pdl.result` or
+    `pdl.results`). These operations define groups of input operands into a
+    given operation. A `pdl.operands` may partially constrain a set of input
+    operands by specifying expected value types (via `pdl.types` operations).
+
+    Example:
+
+    ```mlir
+    // Define a range of input operands:
+    %operands = pdl.operands
+
+    // Define a range of input operands with expected types:
+    %types = pdl.types : [i32, i64, i32]
+    %typed_operands = pdl.operands : %types
+    ```
+  }];
+
+  let arguments = (ins Optional<PDL_RangeOf<PDL_Type>>:$type);
+  let results = (outs PDL_RangeOf<PDL_Value>:$val);
+  let assemblyFormat = "(`:` $type^)? attr-dict";
+
+  let builders = [
+    OpBuilder<(ins), [{
+      build($_builder, $_state, RangeType::get($_builder.getType<ValueType>()),
+            Value());
+    }]>,
+  ];
+}
+
+//===----------------------------------------------------------------------===//
 // pdl::OperationOp
 //===----------------------------------------------------------------------===//
 
 def PDL_OperationOp
     : PDL_Op<"operation", [AttrSizedOperandSegments, NoSideEffect]> {
   let summary = "Define an operation within a pattern";
   let description = [{
     `pdl.operation` operations define operation nodes within a pattern. Within
     a match sequence, i.e. when directly nested within a `pdl.pattern`, these
     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. Handles to the results of the operation
     can be extracted via `pdl.result`.
 
+    Example:
+
+    ```mlir
+    // Define an instance of a `foo.op` operation.
+    %op = pdl.operation "foo.op"(%arg0, %arg1 : !pdl.value, !pdl.value)
+      {"attrA" = %attr0} -> (%type, %type : !pdl.type, !pdl.type)
+    ```
+
     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 "inferable". This means that
     the type must be attributable to either a constant type value or the result
     type of another entity, such as an attribute, the result of a
     `apply_native_rewrite`, or the result type of another operation. If the
     result type value does not meet any of these criteria, the operation must
     override the `InferTypeOpInterface` to ensure that the result types can be
     inferred.
 
-    Example:
+    The operands of the operation are interpreted in the following ways:
+
+    1) A single !pdl.range<value>:
+
+    In this case, the single range is treated as all of the operands of the
+    operation.
 
     ```mlir
-    // Define an instance of a `foo.op` operation.
-    %op = pdl.operation "foo.op"(%arg0, %arg1) {"attrA" = %attr0} -> %type, %type, %type, %type
+    // Define an instance with single range of operands.
+    %op = pdl.operation "std.return"(%allArgs : !pdl.range<value>)
+    ```
+
+    2) A variadic number of either !pdl.value or !pdl.range<value>:
+
+    In this case, the inputs are expected to correspond with the operand groups
+    defined on the operation in ODS.
+
+    ```tablgen
+    // Given the following operation definition in ODS:
+    def MyIndirectCallOp {
+      let results = (outs FunctionType:$call, Variadic<AnyType>:$args);
+    }
+    ```
+
+    ```mlir
+    // We can match the operands as so:
+    %op = pdl.operation "my.indirect_call"(%call, %args : !pdl.value, !pdl.range<value>)
+    ```
+
+    The results of the operation are interpreted in the following ways:
+
+    1) A single !pdl.range<type>:
+
+    In this case, the single range is treated as all of the result types of the
+    operation.
+
+    ```mlir
+    // Define an instance with single range of types.
+    %allResultTypes = pdl.types
+    %op = pdl.operation "unrealized_conversion_cast" -> (%allResultTypes : !pdl.types)
+    ```
+
+    2) A variadic number of either !pdl.type or !pdl.range<type>:
+
+    In this case, the inputs are expected to correspond with the result groups
+    defined on the operation in ODS.
+
+    ```tablgen
+    // Given the following operation definition in ODS:
+    def MyOp {
+      let results = (outs SomeType:$result, Variadic<SomeType>:$otherResults);
+    }
+    ```
+
+    ```mlir
+    // We can match the results as so:
+    %result = pdl.type
+    %otherResults = pdl.types
+    %op = pdl.operation "foo.op" -> (%result, %otherResults : !pdl.type, !pdl.range<type>)
     ```
   }];
 
   let arguments = (ins OptionalAttr<StrAttr>:$name,
-                       Variadic<PDL_Value>:$operands,
+                       Variadic<PDL_InstOrRangeOf<PDL_Value>>:$operands,
                        Variadic<PDL_Attribute>:$attributes,
                        StrArrayAttr:$attributeNames,
-                       Variadic<PDL_Type>:$types);
+                       Variadic<PDL_InstOrRangeOf<PDL_Type>>:$types);
   let results = (outs PDL_Operation:$op);
   let assemblyFormat = [{
-    ($name^)? (`(` $operands^ `)`)?
+    ($name^)? (`(` $operands^ `:` type($operands) `)`)?
     custom<OperationOpAttributes>($attributes, $attributeNames)
-    (`->` $types^)? attr-dict
+    (`->` `(` $types^ `:` type($types) `)`)? attr-dict
   }];
 
   let builders = [
     OpBuilder<(ins CArg<"Optional<StringRef>", "llvm::None">:$name,
       CArg<"ValueRange", "llvm::None">:$operandValues,
       CArg<"ArrayRef<StringRef>", "llvm::None">:$attrNames,
       CArg<"ValueRange", "llvm::None">:$attrValues,
       CArg<"ValueRange", "llvm::None">:$resultTypes), [{
* a single `Operation` (`replOperation` should be populated)
       - The operation will be replaced with the results of this operation.
     * a set of `Value`s (`replValues` should be populated)
       - The operation will be replaced with these values.
 
     Example:
 
     ```mlir
     // Replace root node with 2 values:
-    pdl.replace %root with (%val0, %val1)
+    pdl.replace %root with (%val0, %val1 : !pdl.value, !pdl.value)
+
+    // Replace root node with a range of values:
+    pdl.replace %root with (%vals : !pdl.range<value>)
 
     // Replace root with another operation:
     pdl.replace %root with %otherOp
     ```
   }];
   let arguments = (ins PDL_Operation:$operation,
                        Optional<PDL_Operation>:$replOperation,
-                       Variadic<PDL_Value>:$replValues);
+                       Variadic<PDL_InstOrRangeOf<PDL_Value>>:$replValues);
   let assemblyFormat = [{
-    $operation `with` (`(` $replValues^ `)`)? ($replOperation^)? attr-dict
+    $operation `with` (`(` $replValues^ `:` type($replValues) `)`)?
+    ($replOperation^)? attr-dict
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::ResultOp
 //===----------------------------------------------------------------------===//
 
 def PDL_ResultOp : PDL_Op<"result"> {
   let summary = "Extract a result from an operation";
   let description = [{
     `pdl.result` operations extract result edges from an operation node within
     a pattern or rewrite region. The provided index is zero-based, and
     represents the concrete result to extract, i.e. this is not the result index
     as defined by the ODS definition of the operation.
 
     Example:
 
     ```mlir
     // Extract a result:
     %operation = pdl.operation ...
-    %result = pdl.result 1 of %operation
+    %pdl_result = pdl.result 1 of %operation
 
     // Imagine the following IR being matched:
     %result_0, %result_1 = foo.op ...
 
     // If the example pattern snippet above were matching against `foo.op` in
-    // the IR snippted, `%result` would correspond to `%result_1`.
+    // the IR snippet, `%pdl_result` would correspond to `%result_1`.
     ```
   }];
 
   let arguments = (ins PDL_Operation:$parent, I32Attr:$index);
   let results = (outs PDL_Value:$val);
   let assemblyFormat = "$index `of` $parent attr-dict";
   let verifier = ?;
 }
 
 //===----------------------------------------------------------------------===//
+// pdl::ResultsOp
+//===----------------------------------------------------------------------===//
+
+def PDL_ResultsOp : PDL_Op<"results"> {
+  let summary = "Extract a result group from an operation";
+  let description = [{
+    `pdl.results` operations extract a result group from an operation within a
+    pattern or rewrite region. If an index is provided, this operation extracts
+    a result group as defined by the ODS definition of the operation. In this
+    case the result of this operation may be either a single `pdl.value` or
+    a `pdl.range<value>`, depending on the constraint of the result in ODS. If
+    no index is provided, this operation extracts the full result range of the
+    operation.
+
+    Example:
+
+    ```mlir
+    // Extract all of the results of an operation:
+    %operation = pdl.operation ...
+    %results = pdl.results of %operation
+
+    // Extract the results in the first result group of an operation, which is
+    // variadic:
+    %operation = pdl.operation ...
+    %results = pdl.results 0 of %operation -> !pdl.range<value>
+
+    // Extract the results in the second result group of an operation, which is
+    // not variadic:
+    %operation = pdl.operation ...
+    %results = pdl.results 1 of %operation -> !pdl.value
+    ```
+  }];
+
+  let arguments = (ins PDL_Operation:$parent, OptionalAttr<I32Attr>:$index);
+  let results = (outs PDL_InstOrRangeOf<PDL_Value>:$val);
+  let assemblyFormat = [{
+    ($index^)? `of` $parent custom<ResultsValueType>(ref($index), type($val))
+    attr-dict
+  }];
+}
+
+//===----------------------------------------------------------------------===//
 // pdl::RewriteOp
 //===----------------------------------------------------------------------===//
 
 def PDL_RewriteOp : PDL_Op<"rewrite", [
      Terminator, HasParent<"pdl::PatternOp">,
      SingleBlockImplicitTerminator<"pdl::RewriteEndOp">
   ]> {
   let summary = "Specify the rewrite of a matched pattern";

 
 //===----------------------------------------------------------------------===//
 // pdl::TypeOp
 //===----------------------------------------------------------------------===//
 
 def PDL_TypeOp : PDL_Op<"type"> {
   let summary = "Define a type handle within a pattern";
   let description = [{
-    `pdl.type` operations capture result type constraints of an `Attributes`,
+    `pdl.type` operations capture result type constraints of `Attributes`,
     `Values`, and `Operations`. Instances of this operation define, and
     partially constrain, results types of a given entity. A `pdl.type` may
     partially constrain the result by specifying a constant `Type`.
 
     Example:
 
     ```mlir
     // Define a type:
-    %attr = pdl.type
+    %type = pdl.type
 
     // Define a type with a constant value:
-    %attr = pdl.type : i32
+    %type = pdl.type : i32
     ```
   }];
 
   let arguments = (ins OptionalAttr<TypeAttr>:$type);
   let results = (outs PDL_Type:$result);
   let assemblyFormat = "attr-dict (`:` $type^)?";
+}
 
-  let builders = [
-    OpBuilder<(ins CArg<"Type", "Type()">:$ty), [{
-      build($_builder, $_state, $_builder.getType<AttributeType>(),
-            ty ? TypeAttr::get(ty) : TypeAttr());
-    }]>,
-  ];
+//===----------------------------------------------------------------------===//
+// pdl::TypesOp
+//===----------------------------------------------------------------------===//
+
+def PDL_TypesOp : PDL_Op<"types"> {
+  let summary = "Define a range of type handles within a pattern";
+  let description = [{
+    `pdl.types` operations capture result type constraints of `Value`s, and
+    `Operation`s. Instances of this operation define results types of a given
+    entity. A `pdl.types` may partially constrain the results by specifying
+    an array of `Type`s.
+
+    Example:
+
+    ```mlir
+    // Define a range of types:
+    %types = pdl.types
+
+    // Define a range of types with a range of constant values:
+    %types = pdl.types : [i32, i64, i32]
+    ```
+  }];
+
+  let arguments = (ins OptionalAttr<TypeArrayAttr>:$types);
+  let results = (outs PDL_RangeOf<PDL_Type>:$result);
+  let assemblyFormat = "attr-dict (`:` $types^)?";
 }
 
 #endif // MLIR_DIALECT_PDL_IR_PDLOPS

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

 //===----------------------------------------------------------------------===//
 // Additional Type Constraints
 //===----------------------------------------------------------------------===//
 
 def PDL_AnyType : Type<
   CPred<"$_self.isa<::mlir::pdl::PDLType>()">, "pdl type",
         "::mlir::pdl::PDLType">;
 
+// A range of positional values of one of the provided types.
+class PDL_RangeOf<Type positionalType> :
+  ContainerType<AnyTypeOf<[positionalType]>, PDL_Range.predicate,
+                "$_self.cast<::mlir::pdl::RangeType>().getElementType()",
+                "range", "::mlir::pdl::RangeType">,
+    BuildableType<"::mlir::pdl::RangeType::get(" # positionalType.builderCall #
+                  ")">;
+
+// Either a positional value or a range of positional values for a given type.
+class PDL_InstOrRangeOf<Type positionalType> :
+    AnyTypeOf<[positionalType, PDL_RangeOf<positionalType>],
+              "single element or range of " # positionalType.summary,
+              "::mlir::pdl::PDLType">;
+
 #endif // MLIR_DIALECT_PDL_IR_PDLTYPES

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

 
 //===----------------------------------------------------------------------===//
 // PDL Operations
 //===----------------------------------------------------------------------===//
 
 /// Returns true if the given operation is used by a "binding" pdl operation
 /// within the main matcher body of a `pdl.pattern`.
 static bool hasBindingUseInMatcher(Operation *op, Block *matcherBlock) {
-  for (Operation *user : op->getUsers()) {
+  for (OpOperand &use : op->getUses()) {
+    Operation *user = use.getOwner();
     if (user->getBlock() != matcherBlock)
       continue;
-    if (isa<AttributeOp, OperandOp, OperationOp, RewriteOp>(user))
+    if (isa<AttributeOp, OperandOp, OperandsOp, OperationOp>(user))
+      return true;
+    // Only the first operand of RewriteOp may be bound to, i.e. the root
+    // operation of the pattern.
+    if (isa<RewriteOp>(user) && use.getOperandNumber() == 0)
       return true;
     // A result by itself is not binding, it must also be bound.
-    if (isa<ResultOp>(user) && hasBindingUseInMatcher(user, matcherBlock))
+    if (isa<ResultOp, ResultsOp>(user) &&
+        hasBindingUseInMatcher(user, matcherBlock))
       return true;
   }
   return false;
 }
 
 /// Returns success if the given operation is used by a "binding" pdl operation
 /// within the main matcher body of a `pdl.pattern`. On failure, emits an error
 /// with the given context message.

 // pdl::OperandOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(OperandOp op) {
   return verifyHasBindingUseInMatcher(op);
 }
 
 //===----------------------------------------------------------------------===//
+// pdl::OperandsOp
+//===----------------------------------------------------------------------===//
+
+static LogicalResult verify(OperandsOp op) {
+  return verifyHasBindingUseInMatcher(op);
+}
+
+//===----------------------------------------------------------------------===//
 // pdl::OperationOp
 //===----------------------------------------------------------------------===//
 
 static ParseResult parseOperationOpAttributes(
     OpAsmParser &p, SmallVectorImpl<OpAsmParser::OperandType> &attrOperands,
     ArrayAttr &attrNamesAttr) {
   Builder &builder = p.getBuilder();
   SmallVector<Attribute, 4> attrNames;
for (auto it : llvm::enumerate(resultTypes)) {
     Operation *resultTypeOp = it.value().getDefiningOp();
     assert(resultTypeOp && "expected valid result type operation");
 
     // If the op was defined by a `apply_native_rewrite`, it is guaranteed to be
     // usable.
     if (isa<ApplyNativeRewriteOp>(resultTypeOp))
       continue;
 
-    // If the type is already constrained, there is nothing to do.
-    TypeOp typeOp = cast<TypeOp>(resultTypeOp);
-    if (typeOp.type())
-      continue;
-
     // If the type operation was defined in the matcher and constrains the
     // result of an input operation, it can be used.
     auto constrainsInputOp = [rewriterBlock](Operation *user) {
       return user->getBlock() != rewriterBlock && isa<OperationOp>(user);
     };
-    if (llvm::any_of(typeOp.getResult().getUsers(), constrainsInputOp))
+    if (TypeOp typeOp = dyn_cast<TypeOp>(resultTypeOp)) {
+      if (typeOp.type() || llvm::any_of(typeOp->getUsers(), constrainsInputOp))
+        continue;
+    } else if (TypesOp typeOp = dyn_cast<TypesOp>(resultTypeOp)) {
+      if (typeOp.types() || llvm::any_of(typeOp->getUsers(), constrainsInputOp))
         continue;
+    }
 
     return op
         .emitOpError("must have inferable or constrained result types when "
                      "nested within `pdl.rewrite`")
         .attachNote()
         .append("result type #", it.index(), " was not constrained");
   }
   return success();

 static LogicalResult verify(ReplaceOp op) {
   if (op.replOperation() && !op.replValues().empty())
     return op.emitOpError() << "expected no replacement values to be provided"
                                " when the replacement operation is present";
   return success();
 }
 
 //===----------------------------------------------------------------------===//
+// pdl::ResultsOp
+//===----------------------------------------------------------------------===//
+
+static ParseResult parseResultsValueType(OpAsmParser &p, IntegerAttr index,
+                                         Type &resultType) {
+  if (!index) {
+    resultType = RangeType::get(p.getBuilder().getType<ValueType>());
+    return success();
+  }
+  if (p.parseArrow() || p.parseType(resultType))
+    return failure();
+  return success();
+}
+
+static void printResultsValueType(OpAsmPrinter &p, ResultsOp op,
+                                  IntegerAttr index, Type resultType) {
+  if (index)
+    p << " -> " << resultType;
+}
+
+static LogicalResult verify(ResultsOp op) {
+  if (!op.index() && op.getType().isa<pdl::ValueType>()) {
+    return op.emitOpError() << "expected `pdl.range<value>` result type when "
+                               "no index is specified, but got: "
+                            << op.getType();
+  }
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
 // pdl::RewriteOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(RewriteOp op) {
   Region &rewriteRegion = op.body();
 
   // Handle the case where the rewrite is external.
   if (op.name()) {

 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(TypeOp op) {
   return verifyHasBindingUseInMatcher(
       op, "`pdl.attribute`, `pdl.operand`, or `pdl.operation`");
 }
 
 //===----------------------------------------------------------------------===//
+// pdl::TypesOp
+//===----------------------------------------------------------------------===//
+
+static LogicalResult verify(TypesOp op) {
+  return verifyHasBindingUseInMatcher(op, "`pdl.operands`, or `pdl.operation`");
+}
+
+//===----------------------------------------------------------------------===//
 // TableGen'd op method definitions
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/PDL/IR/PDLOps.cpp.inc"

mlir/test/Conversion/PDLToPDLInterp/pdl-to-pdl-interp-matcher.mlir

module @simple {
   // CHECK:   pdl_interp.record_match @rewriters::@pdl_generated_rewriter
   // CHECK-SAME: benefit(1), loc([%[[ROOT]]]), root("foo.op") -> ^bb1
 
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[REWRITE_ROOT:.*]]: !pdl.operation)
   // CHECK:     pdl_interp.apply_rewrite "rewriter"(%[[REWRITE_ROOT]]
   // CHECK:     pdl_interp.finalize
   pdl.pattern : benefit(1) {
-    %root = pdl.operation "foo.op"()
+    %root = pdl.operation "foo.op"
     pdl.rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @attributes
 module @attributes {
module @constraints {
   // CHECK-DAG:   %[[INPUT:.*]] = pdl_interp.get_operand 0 of %[[ROOT]]
   // CHECK-DAG:   %[[INPUT1:.*]] = pdl_interp.get_operand 1 of %[[ROOT]]
   // CHECK-DAG:   %[[RESULT:.*]] = pdl_interp.get_result 0 of %[[ROOT]]
   // CHECK:       pdl_interp.apply_constraint "multi_constraint" [true](%[[INPUT]], %[[INPUT1]], %[[RESULT]]
 
   pdl.pattern : benefit(1) {
     %input0 = pdl.operand
     %input1 = pdl.operand
-    %root = pdl.operation(%input0, %input1)
+    %root = pdl.operation(%input0, %input1 : !pdl.value, !pdl.value)
     %result0 = pdl.result 0 of %root
 
     pdl.apply_native_constraint "multi_constraint"[true](%input0, %input1, %result0 : !pdl.value, !pdl.value, !pdl.value)
     pdl.rewrite %root with "rewriter"
   }
 }
 
 // -----
module @inputs {
   // CHECK-DAG:   pdl_interp.check_type %[[INPUT_TYPE]] is i64
 
   // Get the second operand and check that it is equal to the first.
   // CHECK-DAG:  %[[INPUT1:.*]] = pdl_interp.get_operand 1 of %[[ROOT]]
   // CHECK-DAG:  pdl_interp.are_equal %[[INPUT]], %[[INPUT1]] : !pdl.value
   pdl.pattern : benefit(1) {
     %type = pdl.type : i64
     %input = pdl.operand : %type
-    %root = pdl.operation(%input, %input)
+    %root = pdl.operation(%input, %input : !pdl.value, !pdl.value)
     pdl.rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @results
 module @results {
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
   // CHECK:   pdl_interp.check_result_count of %[[ROOT]] is 2
 
   // Get the result and check the type.
   // CHECK-DAG:   %[[RESULT:.*]] = pdl_interp.get_result 0 of %[[ROOT]]
   // CHECK-DAG:   pdl_interp.is_not_null %[[RESULT]] : !pdl.value
   // CHECK-DAG:   %[[RESULT_TYPE:.*]] = pdl_interp.get_value_type of %[[RESULT]]
   // CHECK-DAG:   pdl_interp.check_type %[[RESULT_TYPE]] is i32
 
   // The second result doesn't have any constraints, so we don't generate an
   // access for it.
   // CHECK-NOT:   pdl_interp.get_result 1 of %[[ROOT]]
   pdl.pattern : benefit(1) {
     %type1 = pdl.type : i32
     %type2 = pdl.type
-    %root = pdl.operation -> %type1, %type2
+    %root = pdl.operation -> (%type1, %type2 : !pdl.type, !pdl.type)
     pdl.rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @results_as_operands
 module @results_as_operands {
module @results_as_operands {
   // CHECK-DAG:   pdl_interp.are_equal %[[RESULT_1]], %[[OPERAND_1]]
 
   // Check that the parent operation of both results is the same.
   // CHECK-DAG:   pdl_interp.are_equal %[[DEF_OP_0]], %[[DEF_OP_1]]
 
   pdl.pattern : benefit(1) {
     %type1 = pdl.type : i32
     %type2 = pdl.type
-    %inputOp = pdl.operation -> %type1, %type2
+    %inputOp = pdl.operation -> (%type1, %type2 : !pdl.type, !pdl.type)
     %result1 = pdl.result 0 of %inputOp
     %result2 = pdl.result 1 of %inputOp
 
-    %root = pdl.operation(%result1, %result2)
+    %root = pdl.operation(%result1, %result2 : !pdl.value, !pdl.value)
     pdl.rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @switch_result_types
 module @switch_result_types {
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
   // CHECK:   %[[RESULT:.*]] = pdl_interp.get_result 0 of %[[ROOT]]
   // CHECK:   %[[RESULT_TYPE:.*]] = pdl_interp.get_value_type of %[[RESULT]]
   // CHECK:   pdl_interp.switch_type %[[RESULT_TYPE]] to [i32, i64]
   pdl.pattern : benefit(1) {
     %type = pdl.type : i32
-    %root = pdl.operation -> %type
+    %root = pdl.operation -> (%type : !pdl.type)
     pdl.rewrite %root with "rewriter"
   }
   pdl.pattern : benefit(1) {
     %type = pdl.type : i64
-    %root = pdl.operation -> %type
+    %root = pdl.operation -> (%type : !pdl.type)
     pdl.rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @predicate_ordering
 module @predicate_ordering  {
   // Check that the result is checked for null first, before applying the
   // constraint. The null check is prevalent in both patterns, so should be
   // prioritized first.
 
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
   // CHECK:   %[[RESULT:.*]] = pdl_interp.get_result 0 of %[[ROOT]]
   // CHECK-NEXT: pdl_interp.is_not_null %[[RESULT]]
   // CHECK:   %[[RESULT_TYPE:.*]] = pdl_interp.get_value_type of %[[RESULT]]
   // CHECK: pdl_interp.apply_constraint "typeConstraint" [](%[[RESULT_TYPE]]
 
   pdl.pattern : benefit(1) {
     %resultType = pdl.type
     pdl.apply_native_constraint "typeConstraint"[](%resultType : !pdl.type)
-    %root = pdl.operation -> %resultType
+    %root = pdl.operation -> (%resultType : !pdl.type)
     pdl.rewrite %root with "rewriter"
   }
 
   pdl.pattern : benefit(1) {
     %resultType = pdl.type
-    %apply = pdl.operation -> %resultType
+    %apply = pdl.operation -> (%resultType : !pdl.type)
     pdl.rewrite %apply with "rewriter"
   }
 }

mlir/test/Conversion/PDLToPDLInterp/pdl-to-pdl-interp-rewriter.mlir

 // RUN: mlir-opt -split-input-file -convert-pdl-to-pdl-interp %s | FileCheck %s
 
 // -----
 
 // CHECK-LABEL: module @external
 module @external {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[ROOT:.*]]: !pdl.operation, %[[INPUT:.*]]: !pdl.value)
   // CHECK:     pdl_interp.apply_rewrite "rewriter" [true](%[[ROOT]], %[[INPUT]] : !pdl.operation, !pdl.value)
   pdl.pattern : benefit(1) {
     %input = pdl.operand
-    %root = pdl.operation "foo.op"(%input)
+    %root = pdl.operation "foo.op"(%input : !pdl.value)
     pdl.rewrite %root with "rewriter"[true](%input : !pdl.value)
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @erase
 module @erase {

 module @operation_operands {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[OPERAND:.*]]: !pdl.value, %[[ROOT:.*]]: !pdl.operation)
   // CHECK:     %[[NEWOP:.*]] = pdl_interp.create_operation "foo.op"(%[[OPERAND]])
   // CHECK:     %[[OPERAND1:.*]] = pdl_interp.get_result 0 of %[[NEWOP]]
   // CHECK:     pdl_interp.create_operation "foo.op2"(%[[OPERAND1]])
   pdl.pattern : benefit(1) {
     %operand = pdl.operand
-    %root = pdl.operation "foo.op"(%operand)
+    %root = pdl.operation "foo.op"(%operand : !pdl.value)
     pdl.rewrite %root {
       %type = pdl.type : i32
-      %newOp = pdl.operation "foo.op"(%operand) -> %type
+      %newOp = pdl.operation "foo.op"(%operand : !pdl.value) -> (%type : !pdl.type)
       %result = pdl.result 0 of %newOp
-      %newOp1 = pdl.operation "foo.op2"(%result)
+      %newOp1 = pdl.operation "foo.op2"(%result : !pdl.value)
       pdl.erase %root
     }
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @operation_operands
 module @operation_operands {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[OPERAND:.*]]: !pdl.value, %[[ROOT:.*]]: !pdl.operation)
   // CHECK:     %[[NEWOP:.*]] = pdl_interp.create_operation "foo.op"(%[[OPERAND]])
   // CHECK:     %[[OPERAND1:.*]] = pdl_interp.get_result 0 of %[[NEWOP]]
   // CHECK:     pdl_interp.create_operation "foo.op2"(%[[OPERAND1]])
   pdl.pattern : benefit(1) {
     %operand = pdl.operand
-    %root = pdl.operation "foo.op"(%operand)
+    %root = pdl.operation "foo.op"(%operand : !pdl.value)
     pdl.rewrite %root {
       %type = pdl.type : i32
-      %newOp = pdl.operation "foo.op"(%operand) -> %type
+      %newOp = pdl.operation "foo.op"(%operand : !pdl.value) -> (%type : !pdl.type)
       %result = pdl.result 0 of %newOp
-      %newOp1 = pdl.operation "foo.op2"(%result)
+      %newOp1 = pdl.operation "foo.op2"(%result : !pdl.value)
       pdl.erase %root
     }
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @operation_result_types
 module @operation_result_types {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[TYPE:.*]]: !pdl.type, %[[TYPE1:.*]]: !pdl.type
   // CHECK:     pdl_interp.create_operation "foo.op"() -> %[[TYPE]], %[[TYPE1]]
   pdl.pattern : benefit(1) {
     %rootType = pdl.type
     %rootType1 = pdl.type
-    %root = pdl.operation "foo.op" -> %rootType, %rootType1
+    %root = pdl.operation "foo.op" -> (%rootType, %rootType1 : !pdl.type, !pdl.type)
     pdl.rewrite %root {
       %newType1 = pdl.type
-      %newOp = pdl.operation "foo.op" -> %rootType, %newType1
+      %newOp = pdl.operation "foo.op" -> (%rootType, %newType1 : !pdl.type, !pdl.type)
       pdl.replace %root with %newOp
     }
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @replace_with_op
 module @replace_with_op {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[ROOT:.*]]: !pdl.operation)
   // CHECK:     %[[NEWOP:.*]] = pdl_interp.create_operation
   // CHECK:     %[[OP_RESULT:.*]] = pdl_interp.get_result 0 of %[[NEWOP]]
   // CHECK:     pdl_interp.replace %[[ROOT]] with(%[[OP_RESULT]])
   pdl.pattern : benefit(1) {
     %type = pdl.type : i32
-    %root = pdl.operation "foo.op" -> %type
+    %root = pdl.operation "foo.op" -> (%type : !pdl.type)
     pdl.rewrite %root {
-      %newOp = pdl.operation "foo.op" -> %type
+      %newOp = pdl.operation "foo.op" -> (%type : !pdl.type)
       pdl.replace %root with %newOp
     }
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @replace_with_values
 module @replace_with_values {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[ROOT:.*]]: !pdl.operation)
   // CHECK:     %[[NEWOP:.*]] = pdl_interp.create_operation
   // CHECK:     %[[OP_RESULT:.*]] = pdl_interp.get_result 0 of %[[NEWOP]]
   // CHECK:     pdl_interp.replace %[[ROOT]] with(%[[OP_RESULT]])
   pdl.pattern : benefit(1) {
     %type = pdl.type : i32
-    %root = pdl.operation "foo.op" -> %type
+    %root = pdl.operation "foo.op" -> (%type : !pdl.type)
     pdl.rewrite %root {
-      %newOp = pdl.operation "foo.op" -> %type
+      %newOp = pdl.operation "foo.op" -> (%type : !pdl.type)
       %newResult = pdl.result 0 of %newOp
-      pdl.replace %root with (%newResult)
+      pdl.replace %root with (%newResult : !pdl.value)
     }
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @replace_with_no_results
 module @replace_with_no_results {

 // CHECK-LABEL: module @apply_native_rewrite
 module @apply_native_rewrite {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[ROOT:.*]]: !pdl.operation)
   // CHECK:     %[[TYPE:.*]] = pdl_interp.apply_rewrite "functor" [true](%[[ROOT]] : !pdl.operation) : !pdl.type
   // CHECK:     pdl_interp.create_operation "foo.op"() -> %[[TYPE]]
   pdl.pattern : benefit(1) {
     %type = pdl.type
-    %root = pdl.operation "foo.op" -> %type
+    %root = pdl.operation "foo.op" -> (%type : !pdl.type)
     pdl.rewrite %root {
       %newType = pdl.apply_native_rewrite "functor"[true](%root : !pdl.operation) : !pdl.type
-      %newOp = pdl.operation "foo.op" -> %newType
+      %newOp = pdl.operation "foo.op" -> (%newType : !pdl.type)
       pdl.replace %root with %newOp
     }
   }
 }

mlir/test/Dialect/PDL/invalid.mlir

 //===----------------------------------------------------------------------===//
 
 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 = pdl.operation "foo.op" {"attr" = %attr} -> %type
+  %op = pdl.operation "foo.op" {"attr" = %attr} -> (%type : !pdl.type)
   pdl.rewrite %op with "rewriter"
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
   %op = pdl.operation "foo.op"
   pdl.rewrite %op {
pdl.pattern : benefit(1) {
 
   %op = pdl.operation "foo.op"
   pdl.rewrite %op with "rewriter"
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
+// pdl::OperandsOp
+//===----------------------------------------------------------------------===//
+
+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.operands
+
+  %op = pdl.operation "foo.op"
+  pdl.rewrite %op with "rewriter"
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
 // pdl::OperationOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
   %op = pdl.operation "foo.op"
   pdl.rewrite %op {
     // expected-error@below {{must have an operation name when nested within a `pdl.rewrite`}}
     %newOp = pdl.operation
%op = "pdl.operation"() {
     operand_segment_sizes = dense<0> : vector<3xi32>
   } : () -> (!pdl.operation)
   pdl.rewrite %op with "rewriter"
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
-  %op = pdl.operation "foo.op"()
+  %op = pdl.operation "foo.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 = pdl.operation "foo.op" -> %type
+    %newOp = pdl.operation "foo.op" -> (%type : !pdl.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"
pdl.pattern : benefit(1) {
   %root = pdl.operation "foo.op"
   pdl.rewrite %root with "foo"
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
   %type = pdl.type : i32
-  %root = pdl.operation "foo.op" -> %type
+  %root = pdl.operation "foo.op" -> (%type : !pdl.type)
   pdl.rewrite %root {
-    %newOp = pdl.operation "foo.op" -> %type
+    %newOp = pdl.operation "foo.op" -> (%type : !pdl.type)
     %newResult = pdl.result 0 of %newOp
 
     // 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::ResultsOp
+//===----------------------------------------------------------------------===//
+
+pdl.pattern : benefit(1) {
+  %root = pdl.operation "foo.op"
+  // expected-error@below {{expected `pdl.range<value>` result type when no index is specified, but got: '!pdl.value'}}
+  %results = "pdl.results"(%root) : (!pdl.operation) -> !pdl.value
+  pdl.rewrite %root with "rewriter"
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
 // 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) {
   // expected-error@below {{expected a bindable (i.e. `pdl.attribute`, `pdl.operand`, or `pdl.operation`) user when defined in the matcher body of a `pdl.pattern`}}
   %unused = pdl.type
 
   %op = pdl.operation "foo.op"
   pdl.rewrite %op with "rewriter"
 }
+
+// -----
+
+//===----------------------------------------------------------------------===//
+// pdl::TypesOp
+//===----------------------------------------------------------------------===//
+
+pdl.pattern : benefit(1) {
+  // expected-error@below {{expected a bindable (i.e. `pdl.operands`, or `pdl.operation`) user when defined in the matcher body of a `pdl.pattern`}}
+  %unused = pdl.types
+
+  %op = pdl.operation "foo.op"
+  pdl.rewrite %op with "rewriter"
+}

mlir/test/Dialect/PDL/ops.mlir

 // RUN: mlir-opt -split-input-file %s | mlir-opt
 // Verify the generic form can be parsed.
 // 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 = pdl.operation {"attr" = %attribute} -> %type
+  %op0 = pdl.operation {"attr" = %attribute} -> (%type : !pdl.type)
   %op0_result = pdl.result 0 of %op0
 
   // Operation with input.
   %input = pdl.operand
-  %root = pdl.operation(%op0_result, %input)
+  %root = pdl.operation(%op0_result, %input : !pdl.value, !pdl.value)
   pdl.rewrite %root with "rewriter"
 }
 
 // -----
 
 pdl.pattern @rewrite_with_args : benefit(1) {
   %input = pdl.operand
-  %root = pdl.operation(%input)
+  %root = pdl.operation(%input : !pdl.value)
   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.operand
-  %root = pdl.operation(%input)
+  %root = pdl.operation(%input : !pdl.value)
   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 = pdl.operation -> %type1, %type2
+  %root = pdl.operation -> (%type1, %type2 : !pdl.type, !pdl.type)
   pdl.rewrite %root {
     %type3 = pdl.type
-    %newOp = pdl.operation "foo.op" -> %type1, %type3
+    %newOp = pdl.operation "foo.op" -> (%type1, %type3 : !pdl.type, !pdl.type)
     pdl.replace %root with %newOp
   }
 }
 
 // -----
 
 // Check that the result type of an operation within a rewrite can be inferred
-// from a pdl.replace.
+// from types used within the match block.
 pdl.pattern @infer_type_from_type_used_in_match : benefit(1) {
   %type1 = pdl.type : i32
   %type2 = pdl.type
-  %root = pdl.operation -> %type1, %type2
+  %root = pdl.operation -> (%type1, %type2 : !pdl.type, !pdl.type)
+  pdl.rewrite %root {
+    %newOp = pdl.operation "foo.op" -> (%type1, %type2 : !pdl.type, !pdl.type)
+  }
+}
+
+// -----
+
+// Check that the result type of an operation within a rewrite can be inferred
+// from types used within the match block.
+pdl.pattern @infer_type_from_type_used_in_match : benefit(1) {
+  %types = pdl.types
+  %root = pdl.operation -> (%types : !pdl.range<type>)
   pdl.rewrite %root {
-    %newOp = pdl.operation "foo.op" -> %type1, %type2
+    %otherTypes = pdl.types : [i32, i64]
+    %newOp = pdl.operation "foo.op" -> (%types, %otherTypes : !pdl.range<type>, !pdl.range<type>)
   }
 }