[mlir][pdl] Restructure how results are represented.

[rriddle]

Summary

Up until now, results have been represented as additional results to a pdl.operation. This is fairly clunky, as it mismatches the representation of the rest of the IR constructs(e.g. pdl.operand) and also isn't a viable representation for operations returned by pdl.create_native. This representation also creates much more difficult problems when factoring in support for variadic result groups, optional results, etc. To resolve some of these problems, and simplify adding support for variable length results, this revision extracts the representation for results out of pdl.operation in the form of a new pdl.result operation. This operation returns the result of an operation at a given index, e.g.:

%root = pdl.operation ...
%result = pdl.result 0 of %root

Depends On D95718

[rriddle]

Rebase

[ftynse]

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

382

Nit: mention that the result index is zero-based

[jpienaar]

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

382

And this index is of the underlying Operation, and not the ODS index concept?

389

Perhaps expanding this example to show a multi result operation being matched would make this clearer (so show post the example an example match)

[rriddle]

rebase

[rriddle]

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

382

Yeah. Results are kind of weird/different in comparison to operands, given that operands are inputs into a pdl.operation we don't have to make a distinction between the ODS group and the concrete operand number. For results, we don't necessarily know how the operation was created(e.g. could come from a native rewrite) so there has to be some way for the user to make the distinction. Right now that is by having pdl.result be concrete and pdl.results be group based. My suspicion is that we may come up with something more ergonomic (or at least spelled better) as we use them more.

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

string description = [{
     ```mlir
     // pdl.pattern contains metadata similarly to a `RewritePattern`.
     pdl.pattern : benefit(1) {
       // External input operand values are specified via `pdl.operand` operations.
       // Result types are constrainted via `pdl.type` operations.
 
       %resultType = pdl.type
       %inputOperand = pdl.operand
-      %root, %results = pdl.operation "foo.op"(%inputOperand) -> %resultType
+      %root = pdl.operation "foo.op"(%inputOperand) -> %resultType
       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

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

 // pdl::OperandOp
 //===----------------------------------------------------------------------===//
 
 def PDL_OperandOp : PDL_Op<"operand", [HasParent<"pdl::PatternOp">]> {
   let summary = "Define an 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.operation`). These operations
+    specified within the pattern (e.g. via `pdl.result`). These operations
     define individual input operands of a given operation. A `pdl.operand` may
     partially constrain an input operand by specifying an expected value type
     (via a `pdl.type` operation).
 
     Example:
 
     ```mlir
     // Define an input operand:
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
-    result values.
+    a handle to the operation itself. Handles to the results of the operation
+    can be extracted via `pdl.result`.
 
     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
     `createNative`, or the result type of another operation. If the result type
     value does not meet any of these criteria, the operation must provide the
     `InferTypeOpInterface` to ensure that the result types can be inferred.
 
     Example:
 
     ```mlir
     // Define an instance of a `foo.op` operation.
-    %op, %results:4 = pdl.operation "foo.op"(%arg0, %arg1) {"attrA" = %attr0} -> %type, %type, %type, %type
+    %op = pdl.operation "foo.op"(%arg0, %arg1) {"attrA" = %attr0} -> %type, %type, %type, %type
     ```
   }];
 
   let arguments = (ins OptionalAttr<StrAttr>:$name,
                        Variadic<PDL_Value>:$operands,
                        Variadic<PDL_Attribute>:$attributes,
                        StrArrayAttr:$attributeNames,
                        Variadic<PDL_Type>:$types);
-  let results = (outs PDL_Operation:$op,
-                      Variadic<PDL_Value>:$results);
+  let results = (outs PDL_Operation:$op);
+  let assemblyFormat = [{
+    ($name^)? (`(` $operands^ `)`)?
+    custom<OperationOpAttributes>($attributes, $attributeNames)
+    (`->` $types^)? attr-dict
+  }];
+
   let builders = [
     OpBuilderDAG<(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), [{
       auto nameAttr = name ? StringAttr() : $_builder.getStringAttr(*name);
-      build($_builder, $_state, $_builder.getType<OperationType>(), {}, nameAttr,
+      build($_builder, $_state, $_builder.getType<OperationType>(), nameAttr,
             operandValues, attrValues, $_builder.getStrArrayAttr(attrNames),
             resultTypes);
-      $_state.types.append(resultTypes.size(), $_builder.getType<ValueType>());
     }]>,
   ];
   let extraClassDeclaration = [{
     /// Returns true if the operation type referenced supports result type
     /// inference.
     bool hasTypeInference();
   }];
 }
let description = [{
     Example:
 
     ```mlir
     // Provide a pattern matching "foo.op" that replaces the root with its
     // operand.
     pdl.pattern : benefit(1) {
       %resultType = pdl.type
       %inputOperand = pdl.operand
-      %root, %results = pdl.operation "foo.op"(%inputOperand) -> (%resultType)
+      %root = pdl.operation "foo.op"(%inputOperand) -> (%resultType)
       pdl.rewrite %root {
         pdl.replace %root with (%inputOperand)
       }
     }
     ```
   }];
 
   let arguments = (ins OptionalAttr<StrAttr>:$rootKind,
let arguments = (ins PDL_Operation:$operation,
                        Optional<PDL_Operation>:$replOperation,
                        Variadic<PDL_Value>:$replValues);
   let assemblyFormat = [{
     $operation `with` (`(` $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.
+
+    Example:
+
+    ```mlir
+    // Extract a result:
+    %operation = pdl.operation ...
+    %result = pdl.result 1 of %operation
+    ```
+  }];
+
+  let arguments = (ins PDL_Operation:$parent, I32Attr:$index);
+  let results = (outs PDL_Value:$val);
+  let assemblyFormat = "$index `of` $parent attr-dict";
+  let verifier = ?;
+}
+
+//===----------------------------------------------------------------------===//
 // pdl::RewriteOp
 //===----------------------------------------------------------------------===//
 
 def PDL_RewriteOp : PDL_Op<"rewrite", [
      Terminator, HasParent<"pdl::PatternOp">,
      SingleBlockImplicitTerminator<"pdl::RewriteEndOp">
   ]> {
   let summary = "Specify the rewrite of a matched pattern";

mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp

void generateRewriter(pdl::OperationOp operationOp,
                         DenseMap<Value, Value> &rewriteValues,
                         function_ref<Value(Value)> mapRewriteValue);
   void generateRewriter(pdl::CreateNativeOp createNativeOp,
                         DenseMap<Value, Value> &rewriteValues,
                         function_ref<Value(Value)> mapRewriteValue);
   void generateRewriter(pdl::ReplaceOp replaceOp,
                         DenseMap<Value, Value> &rewriteValues,
                         function_ref<Value(Value)> mapRewriteValue);
+  void generateRewriter(pdl::ResultOp resultOp,
+                        DenseMap<Value, Value> &rewriteValues,
+                        function_ref<Value(Value)> mapRewriteValue);
   void generateRewriter(pdl::TypeOp typeOp,
                         DenseMap<Value, Value> &rewriteValues,
                         function_ref<Value(Value)> mapRewriteValue);
 
   /// Generate the values used for resolving the result types of an operation
   /// created within a dag rewriter region.
   void generateOperationResultTypeRewriter(
       pdl::OperationOp op, SmallVectorImpl<Value> &types,
if (StringAttr rewriteName = rewriter.nameAttr()) {
     builder.create<pdl_interp::ApplyRewriteOp>(
         rewriter.getLoc(), rewriteName, root, args,
         rewriter.externalConstParamsAttr());
   } else {
     // Otherwise this is a dag rewriter defined using PDL operations.
     for (Operation &rewriteOp : *rewriter.getBody()) {
       llvm::TypeSwitch<Operation *>(&rewriteOp)
           .Case<pdl::AttributeOp, pdl::CreateNativeOp, pdl::EraseOp,
-                pdl::OperationOp, pdl::ReplaceOp, pdl::TypeOp>([&](auto op) {
+                pdl::OperationOp, pdl::ReplaceOp, pdl::ResultOp, pdl::TypeOp>(
+              [&](auto op) {
                 this->generateRewriter(op, rewriteValues, mapRewriteValue);
               });
     }
   }
 
   // Update the signature of the rewrite function.
   rewriterFunc.setType(builder.getFunctionType(
       llvm::to_vector<8>(rewriterFunc.front().getArgumentTypes()),
       /*results=*/llvm::None));
 
void PatternLowering::generateRewriter(
 
   // Create the new operation.
   Location loc = operationOp.getLoc();
   Value createdOp = builder.create<pdl_interp::CreateOperationOp>(
       loc, *operationOp.name(), types, operands, attributes,
       operationOp.attributeNames());
   rewriteValues[operationOp.op()] = createdOp;
 
-  // Make all of the new operation results available.
-  OperandRange resultTypes = operationOp.types();
-  for (auto it : llvm::enumerate(operationOp.results())) {
+  // Generate accesses for any results that have their types constrained.
+  for (auto it : llvm::enumerate(operationOp.types())) {
+    Value &type = rewriteValues[it.value()];
+    if (type)
+      continue;
+
     Value getResultVal = builder.create<pdl_interp::GetResultOp>(
         loc, builder.getType<pdl::ValueType>(), createdOp, it.index());
-    rewriteValues[it.value()] = getResultVal;
-
-    // If any of the types have not been resolved, make those available as well.
-    Value &type = rewriteValues[resultTypes[it.index()]];
-    if (!type)
-      type = builder.create<pdl_interp::GetValueTypeOp>(loc, getResultVal);
   }
 }
 
 void PatternLowering::generateRewriter(
     pdl::CreateNativeOp createNativeOp, DenseMap<Value, Value> &rewriteValues,
     function_ref<Value(Value)> mapRewriteValue) {
   SmallVector<Value, 2> arguments;
   for (Value argument : createNativeOp.args())
     arguments.push_back(mapRewriteValue(argument));
   Value result = builder.create<pdl_interp::CreateNativeOp>(
       createNativeOp.getLoc(), createNativeOp.result().getType(),
       createNativeOp.nameAttr(), arguments, createNativeOp.constParamsAttr());
   rewriteValues[createNativeOp] = result;
 }
 
 void PatternLowering::generateRewriter(
     pdl::ReplaceOp replaceOp, DenseMap<Value, Value> &rewriteValues,
     function_ref<Value(Value)> mapRewriteValue) {
+  SmallVector<Value, 4> replOperands;
+
   // If the replacement was another operation, get its results. `pdl` allows
   // for using an operation for simplicitly, but the interpreter isn't as
   // user facing.
-  ValueRange origOperands;
-  if (Value replOp = replaceOp.replOperation())
-    origOperands = cast<pdl::OperationOp>(replOp.getDefiningOp()).results();
-  else
-    origOperands = replaceOp.replValues();
+  if (Value replOp = replaceOp.replOperation()) {
+    pdl::OperationOp op = cast<pdl::OperationOp>(replOp.getDefiningOp());
+    for (unsigned i = 0, e = op.types().size(); i < e; ++i)
+      replOperands.push_back(builder.create<pdl_interp::GetResultOp>(
+          replOp.getLoc(), builder.getType<pdl::ValueType>(),
+          mapRewriteValue(replOp), i));
+  } else {
+    for (Value operand : replaceOp.replValues())
+      replOperands.push_back(mapRewriteValue(operand));
+  }
 
   // If there are no replacement values, just create an erase instead.
-  if (origOperands.empty()) {
+  if (replOperands.empty()) {
     builder.create<pdl_interp::EraseOp>(replaceOp.getLoc(),
                                         mapRewriteValue(replaceOp.operation()));
     return;
   }
 
-  SmallVector<Value, 4> replOperands;
-  for (Value operand : origOperands)
-    replOperands.push_back(mapRewriteValue(operand));
   builder.create<pdl_interp::ReplaceOp>(
       replaceOp.getLoc(), mapRewriteValue(replaceOp.operation()), replOperands);
 }
 
 void PatternLowering::generateRewriter(
+    pdl::ResultOp resultOp, DenseMap<Value, Value> &rewriteValues,
+    function_ref<Value(Value)> mapRewriteValue) {
+  rewriteValues[resultOp] = builder.create<pdl_interp::GetResultOp>(
+      resultOp.getLoc(), builder.getType<pdl::ValueType>(),
+      mapRewriteValue(resultOp.parent()), resultOp.index());
+}
+
+void PatternLowering::generateRewriter(
     pdl::TypeOp typeOp, DenseMap<Value, Value> &rewriteValues,
     function_ref<Value(Value)> mapRewriteValue) {
   // If the type isn't constant, the users (e.g. OperationOp) will resolve this
   // type.
   if (TypeAttr typeAttr = typeOp.typeAttr()) {
     Value newType =
         builder.create<pdl_interp::CreateTypeOp>(typeOp.getLoc(), typeAttr);
     rewriteValues[typeOp] = newType;
void PatternLowering::generateOperationResultTypeRewriter(
 
   // If non-None/non-Null, this is an operation that is replaced by `op`.
   // If Null, there is no full replacement operation for `op`.
   // If None, a replacement operation hasn't been searched for.
   Optional<Operation *> fullReplacedOperation;
   bool hasTypeInference = op.hasTypeInference();
   auto resultTypeValues = op.types();
   types.reserve(resultTypeValues.size());
-  for (auto it : llvm::enumerate(op.results())) {
-    Value result = it.value(), resultType = resultTypeValues[it.index()];
+  for (auto it : llvm::enumerate(resultTypeValues)) {
+    Value resultType = it.value();
 
     // Check for an already translated value.
     if (Value existingRewriteValue = rewriteValues.lookup(resultType)) {
       types.push_back(existingRewriteValue);
       continue;
     }
 
     // Check for an input from the matcher.
for (auto it : llvm::enumerate(resultTypeValues)) {
     // replacement for either the op, or this specific result. Note that this is
     // guaranteed by the verifier of `pdl::OperationOp`.
     Operation *replacedOp = nullptr;
     if (!fullReplacedOperation.hasValue()) {
       for (OpOperand &use : op.op().getUses())
         if ((replacedOp = getReplacedOperationFrom(use)))
           break;
       fullReplacedOperation = replacedOp;
+      assert(fullReplacedOperation &&
+             "expected replaced op to infer a result type from");
     } else {
       replacedOp = fullReplacedOperation.getValue();
     }
-    // Infer from the result, as there was no fully replaced op.
-    if (!replacedOp) {
-      for (OpOperand &use : result.getUses())
-        if ((replacedOp = getReplacedOperationFrom(use)))
-          break;
-      assert(replacedOp && "expected replaced op to infer a result type from");
-    }
 
     auto replOpOp = cast<pdl::OperationOp>(replacedOp);
     types.push_back(mapRewriteValue(replOpOp.types()[it.index()]));
   }
 }
 
 //===----------------------------------------------------------------------===//
 // Conversion Pass

mlir/lib/Conversion/PDLToPDLInterp/Predicate.h

public:
   //===--------------------------------------------------------------------===//
   // Positions
   //===--------------------------------------------------------------------===//
 
   /// Returns the root operation position.
   Position *getRoot() { return OperationPosition::getRoot(uniquer); }
 
   /// Returns the parent position defining the value held by the given operand.
-  Position *getParent(OperandPosition *p) {
+  OperationPosition *getParent(OperandPosition *p) {
     std::vector<unsigned> index = p->getIndex();
     index.push_back(p->getOperandNumber());
     return OperationPosition::get(uniquer, index);
   }
 
   /// Returns an attribute position for an attribute of the given operation.
   Position *getAttribute(OperationPosition *p, StringRef name) {
     return AttributePosition::get(uniquer, p, Identifier::get(name, ctx));

mlir/lib/Conversion/PDLToPDLInterp/PredicateTree.cpp

 //===- PredicateTree.cpp - Predicate tree merging -------------------------===//
 //
 // 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 "PredicateTree.h"
 #include "mlir/Dialect/PDL/IR/PDL.h"
 #include "mlir/Dialect/PDL/IR/PDLTypes.h"
 #include "mlir/Dialect/PDLInterp/IR/PDLInterp.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"
+#include "llvm/ADT/TypeSwitch.h"
 
 using namespace mlir;
 using namespace mlir::pdl_to_pdl_interp;
 
 //===----------------------------------------------------------------------===//
 // Predicate List Building
 //===----------------------------------------------------------------------===//
 
+static void getTreePredicates(std::vector<PositionalPredicate> &predList,
+                              Value val, PredicateBuilder &builder,
+                              DenseMap<Value, Position *> &inputs,
+                              Position *pos);
+
 /// Compares the depths of two positions.
 static bool comparePosDepth(Position *lhs, Position *rhs) {
   return lhs->getIndex().size() < rhs->getIndex().size();
 }
 
-/// Collect the tree predicates anchored at the given value.
 static void getTreePredicates(std::vector<PositionalPredicate> &predList,
                               Value val, PredicateBuilder &builder,
                               DenseMap<Value, Position *> &inputs,
-                              Position *pos) {
-  // Make sure this input value is accessible to the rewrite.
-  auto it = inputs.try_emplace(val, pos);
-
-  // If this is an input value that has been visited in the tree, add a
-  // constraint to ensure that both instances refer to the same value.
-  if (!it.second &&
-      isa<pdl::AttributeOp, pdl::OperandOp, pdl::TypeOp>(val.getDefiningOp())) {
-    auto minMaxPositions = std::minmax(pos, it.first->second, comparePosDepth);
-    predList.emplace_back(minMaxPositions.second,
-                          builder.getEqualTo(minMaxPositions.first));
-    return;
-  }
-
-  // Check for a per-position predicate to apply.
-  switch (pos->getKind()) {
-  case Predicates::AttributePos: {
-    assert(val.getType().isa<pdl::AttributeType>() &&
-           "expected attribute type");
-    pdl::AttributeOp attr = cast<pdl::AttributeOp>(val.getDefiningOp());
-    predList.emplace_back(pos, builder.getIsNotNull());
+                              AttributePosition *pos) {
+  assert(val.getType().isa<pdl::AttributeType>() && "expected attribute type");
 
-    // If the attribute has a type, add a type constraint.
-    if (Value type = attr.type()) {
-      getTreePredicates(predList, type, builder, inputs, builder.getType(pos));
-
-      // Check for a constant value of the attribute.
-    } else if (Optional<Attribute> value = attr.value()) {
-      predList.emplace_back(pos, builder.getAttributeConstraint(*value));
-    }
-    break;
-  }
-  case Predicates::OperandPos: {
-    assert(val.getType().isa<pdl::ValueType>() && "expected value type");
+  // If the attribute has a type or value, add a constraint.
+  if (Value type = attr.type())
+  else if (Attribute value = attr.valueAttr())
+    predList.emplace_back(pos, builder.getAttributeConstraint(value));
+
+static void getTreePredicates(std::vector<PositionalPredicate> &predList,
+                              Value val, PredicateBuilder &builder,
+                              DenseMap<Value, Position *> &inputs,
+                              OperandPosition *pos) {
 
-    // Prevent traversal into a null value.
-    predList.emplace_back(pos, builder.getIsNotNull());
 
-    // If this is a typed operand, add a type constraint.
-    if (auto in = val.getDefiningOp<pdl::OperandOp>()) {
-      if (Value type = in.type()) {
-        getTreePredicates(predList, type, builder, inputs,
-                          builder.getType(pos));
-      }
+    if (Value type = in.type())
+      getTreePredicates(predList, type, builder, inputs, builder.getType(pos));
 
-      // Otherwise, recurse into the parent node.
-    } else if (auto parentOp = val.getDefiningOp<pdl::OperationOp>()) {
-      getTreePredicates(predList, parentOp.op(), builder, inputs,
-                        builder.getParent(cast<OperandPosition>(pos)));
-    }
-    break;
-  }
-  case Predicates::OperationPos: {
-    assert(val.getType().isa<pdl::OperationType>() && "expected operation");
-    pdl::OperationOp op = cast<pdl::OperationOp>(val.getDefiningOp());
-    OperationPosition *opPos = cast<OperationPosition>(pos);
+    // Otherwise, recurse into a result node.
+  } else if (auto resultOp = val.getDefiningOp<pdl::ResultOp>()) {
+    OperationPosition *parentPos = builder.getParent(pos);
+    Position *resultPos = builder.getResult(parentPos, resultOp.index());
+    predList.emplace_back(parentPos, builder.getIsNotNull());
+    predList.emplace_back(resultPos, builder.getEqualTo(pos));
+    getTreePredicates(predList, resultOp.parent(), builder, inputs, parentPos);
+
+static void getTreePredicates(std::vector<PositionalPredicate> &predList,
+                              Value val, PredicateBuilder &builder,
+                              DenseMap<Value, Position *> &inputs,
+                              OperationPosition *pos) {
 
-    // Ensure getDefiningOp returns a non-null operation.
-    if (!opPos->isRoot())
-      predList.emplace_back(pos, builder.getIsNotNull());
 
-    // Check that this is the correct root operation.
-    if (Optional<StringRef> opName = op.name())
-      predList.emplace_back(pos, builder.getOperationName(*opName));
 
-    // Check that the operation has the proper number of operands and results.
-    OperandRange operands = op.operands();
-    ResultRange results = op.results();
-    predList.emplace_back(pos, builder.getOperandCount(operands.size()));
-    predList.emplace_back(pos, builder.getResultCount(results.size()));
+  OperandRange types = op.types();
+  predList.emplace_back(pos, builder.getResultCount(types.size()));
 
-    // Recurse into any attributes, operands, or results.
-    for (auto it : llvm::zip(op.attributeNames(), op.attributes())) {
-      getTreePredicates(
-          predList, std::get<1>(it), builder, inputs,
-          builder.getAttribute(opPos,
-                               std::get<0>(it).cast<StringAttr>().getValue()));
-    }
-    for (auto operandIt : llvm::enumerate(operands))
-      getTreePredicates(predList, operandIt.value(), builder, inputs,
-                        builder.getOperand(opPos, operandIt.index()));
-
-    // Only recurse into results that are not referenced in the source tree.
-    for (auto resultIt : llvm::enumerate(results)) {
-      getTreePredicates(predList, resultIt.value(), builder, inputs,
-                        builder.getResult(opPos, resultIt.index()));
-    }
-    break;
-  }
-  case Predicates::ResultPos: {
-    assert(val.getType().isa<pdl::ValueType>() && "expected value type");
-    pdl::OperationOp parentOp = cast<pdl::OperationOp>(val.getDefiningOp());
+  for (auto operandIt : llvm::enumerate(operands)) {
+  }
+  for (auto &resultIt : llvm::enumerate(types)) {
+    auto *resultPos = builder.getResult(pos, resultIt.index());
+    predList.emplace_back(resultPos, builder.getIsNotNull());
+                      builder.getType(resultPos));
 
-    // Prevent traversing a null value.
-    predList.emplace_back(pos, builder.getIsNotNull());
-
-    // Traverse the type constraint.
-    unsigned resultNo = cast<ResultPosition>(pos)->getResultNumber();
-    getTreePredicates(predList, parentOp.types()[resultNo], builder, inputs,
-                      builder.getType(pos));
-    break;
-  }
-  case Predicates::TypePos: {
-    assert(val.getType().isa<pdl::TypeType>() && "expected value type");
-    pdl::TypeOp typeOp = cast<pdl::TypeOp>(val.getDefiningOp());
+static void getTreePredicates(std::vector<PositionalPredicate> &predList,
+                              Value val, PredicateBuilder &builder,
+                              DenseMap<Value, Position *> &inputs,
+                              TypePosition *pos) {
 
-    // Check for a constraint on a constant type.
-    if (Optional<Type> type = typeOp.type())
-      predList.emplace_back(pos, builder.getTypeConstraint(*type));
-    break;
-  }
-  default:
-    llvm_unreachable("unknown position kind");
+
+/// Collect the tree predicates anchored at the given value.
+static void getTreePredicates(std::vector<PositionalPredicate> &predList,
+                              Value val, PredicateBuilder &builder,
+                              DenseMap<Value, Position *> &inputs,
+                              Position *pos) {
+  // Make sure this input value is accessible to the rewrite.
+  auto it = inputs.try_emplace(val, pos);
+  if (!it.second) {
+    // If this is an input value that has been visited in the tree, add a
+    // constraint to ensure that both instances refer to the same value.
+    if (isa<pdl::AttributeOp, pdl::OperandOp, pdl::OperationOp, pdl::TypeOp>(
+            val.getDefiningOp())) {
+      auto minMaxPositions =
+          std::minmax(pos, it.first->second, comparePosDepth);
+      predList.emplace_back(minMaxPositions.second,
+                            builder.getEqualTo(minMaxPositions.first));
+    }
+    return;
   }
+
+  TypeSwitch<Position *>(pos)
+      .Case<AttributePosition, OperandPosition, OperationPosition,
+            TypePosition>([&](auto *derivedPos) {
+        getTreePredicates(predList, val, builder, inputs, derivedPos);
+      })
+      .Default([](auto *) { llvm_unreachable("unexpected position kind"); });
 }
 
 /// Collect all of the predicates related to constraints within the given
 /// pattern operation.
-static void collectConstraintPredicates(
-    pdl::PatternOp pattern, std::vector<PositionalPredicate> &predList,
-    PredicateBuilder &builder, DenseMap<Value, Position *> &inputs) {
-  for (auto op : pattern.body().getOps<pdl::ApplyConstraintOp>()) {
-    OperandRange arguments = op.args();
-    ArrayAttr parameters = op.constParamsAttr();
+static void getConstraintPredicates(pdl::ApplyConstraintOp op,
+                                    std::vector<PositionalPredicate> &predList,
+                                    PredicateBuilder &builder,
+                                    DenseMap<Value, Position *> &inputs) {
 
-    std::vector<Position *> allPositions;
-    allPositions.reserve(arguments.size());
-    for (Value arg : arguments)
-      allPositions.push_back(inputs.lookup(arg));
 
-    // Push the constraint to the furthest position.
-    Position *pos = *std::max_element(allPositions.begin(), allPositions.end(),
-                                      comparePosDepth);
-    PredicateBuilder::Predicate pred =
-        builder.getConstraint(op.name(), std::move(allPositions), parameters);
-    predList.emplace_back(pos, pred);
-  }
+
+static void getResultPredicates(pdl::ResultOp op,
+                                std::vector<PositionalPredicate> &predList,
+                                PredicateBuilder &builder,
+                                DenseMap<Value, Position *> &inputs) {
+  Position *&resultPos = inputs[op];
+  if (resultPos)
+    return;
+  auto *parentPos = cast<OperationPosition>(inputs.lookup(op.parent()));
+  resultPos = builder.getResult(parentPos, op.index());
+  predList.emplace_back(resultPos, builder.getIsNotNull());
+}
+
+/// Collect all of the predicates that cannot be determined via walking the
+/// tree.
+static void getNonTreePredicates(pdl::PatternOp pattern,
+                                 std::vector<PositionalPredicate> &predList,
+                                 PredicateBuilder &builder,
+                                 DenseMap<Value, Position *> &inputs) {
+  for (Operation &op : pattern.body().getOps()) {
+    if (auto constraintOp = dyn_cast<pdl::ApplyConstraintOp>(&op))
+      getConstraintPredicates(constraintOp, predList, builder, inputs);
+    else if (auto resultOp = dyn_cast<pdl::ResultOp>(&op))
+      getResultPredicates(resultOp, predList, builder, inputs);
+  }
 }
 
 /// Given a pattern operation, build the set of matcher predicates necessary to
 /// match this pattern.
 static void buildPredicateList(pdl::PatternOp pattern,
                                PredicateBuilder &builder,
                                std::vector<PositionalPredicate> &predList,
                                DenseMap<Value, Position *> &valueToPosition) {
   getTreePredicates(predList, pattern.getRewriter().root(), builder,
                     valueToPosition, builder.getRoot());
-  collectConstraintPredicates(pattern, predList, builder, valueToPosition);
+  getNonTreePredicates(pattern, predList, builder, valueToPosition);
 }
 
 //===----------------------------------------------------------------------===//
 // Pattern Predicate Tree Merging
 //===----------------------------------------------------------------------===//
 
 namespace {
 

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

 #include "mlir/Dialect/PDL/IR/PDLOps.cpp.inc"
       >();
   addTypes<
 #define GET_TYPEDEF_LIST
 #include "mlir/Dialect/PDL/IR/PDLOpsTypes.cpp.inc"
       >();
 }
 
+//===----------------------------------------------------------------------===//
+// 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()) {
+    if (user->getBlock() != matcherBlock)
+      continue;
+    if (isa<AttributeOp, OperandOp, OperationOp, RewriteOp>(user))
+      return true;
+    // A result by itself is not binding, it must also be bound.
+    if (isa<ResultOp>(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.
 static LogicalResult
 verifyHasBindingUseInMatcher(Operation *op,
                              StringRef bindableContextStr = "`pdl.operation`") {
   // If the pattern is not a pattern, there is nothing to do.
   if (!isa<PatternOp>(op->getParentOp()))
     return success();
-  Block *matcherBlock = op->getBlock();
-  for (Operation *user : op->getUsers()) {
-    if (user->getBlock() != matcherBlock)
-      continue;
-    if (isa<AttributeOp, OperandOp, OperationOp, RewriteOp>(user))
-      return success();
-  }
+  if (hasBindingUseInMatcher(op, op->getBlock()))
   return op->emitOpError()
          << "expected a bindable (i.e. " << bindableContextStr
          << ") user when defined in the matcher body of a `pdl.pattern`";
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::ApplyConstraintOp
 //===----------------------------------------------------------------------===//

 static LogicalResult verify(OperandOp op) {
   return verifyHasBindingUseInMatcher(op);
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::OperationOp
 //===----------------------------------------------------------------------===//
 
-static ParseResult parseOperationOp(OpAsmParser &p, OperationState &state) {
+static ParseResult parseOperationOpAttributes(
+    OpAsmParser &p, SmallVectorImpl<OpAsmParser::OperandType> &attrOperands,
+    ArrayAttr &attrNamesAttr) {
   Builder &builder = p.getBuilder();
-
-  // Parse the optional operation name.
-  bool startsWithOperands = succeeded(p.parseOptionalLParen());
-  bool startsWithAttributes =
-      !startsWithOperands && succeeded(p.parseOptionalLBrace());
-  bool startsWithOpName = false;
-  if (!startsWithAttributes && !startsWithOperands) {
-    StringAttr opName;
-    OptionalParseResult opNameResult =
-        p.parseOptionalAttribute(opName, "name", state.attributes);
-    startsWithOpName = opNameResult.hasValue();
-    if (startsWithOpName && failed(*opNameResult))
-      return failure();
-  }
-
-  // Parse the operands.
-  SmallVector<OpAsmParser::OperandType, 4> operands;
-  if (startsWithOperands ||
-      (!startsWithAttributes && succeeded(p.parseOptionalLParen()))) {
-    if (p.parseOperandList(operands) || p.parseRParen() ||
-        p.resolveOperands(operands, builder.getType<ValueType>(),
-                          state.operands))
-      return failure();
-  }
-
-  // Parse the attributes.
   SmallVector<Attribute, 4> attrNames;
-  if (startsWithAttributes || succeeded(p.parseOptionalLBrace())) {
-    SmallVector<OpAsmParser::OperandType, 4> attrOps;
+  if (succeeded(p.parseOptionalLBrace())) {
     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);
+      attrOperands.push_back(operand);
     } while (succeeded(p.parseOptionalComma()));
-
-    if (p.parseRBrace() ||
-        p.resolveOperands(attrOps, builder.getType<AttributeType>(),
-                          state.operands))
-      return failure();
-  }
-  state.addAttribute("attributeNames", builder.getArrayAttr(attrNames));
-  state.addTypes(builder.getType<OperationType>());
-
-  // Parse the result types.
-  SmallVector<OpAsmParser::OperandType, 4> opResultTypes;
-  if (succeeded(p.parseOptionalArrow())) {
-    if (p.parseOperandList(opResultTypes) ||
-        p.resolveOperands(opResultTypes, builder.getType<TypeType>(),
-                          state.operands))
+    if (p.parseRBrace())
       return failure();
-    state.types.append(opResultTypes.size(), builder.getType<ValueType>());
   }
-
-  if (p.parseOptionalAttrDict(state.attributes))
-    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));
+  attrNamesAttr = builder.getArrayAttr(attrNames);
   return success();
 }
 
-static void print(OpAsmPrinter &p, OperationOp op) {
-  p << "pdl.operation ";
-  if (Optional<StringRef> name = op.name())
-    p << '"' << *name << '"';
-
-  auto operandValues = op.operands();
-  if (!operandValues.empty())
-    p << '(' << operandValues << ')';
-
-  // 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 << '}';
-  }
+static void printOperationOpAttributes(OpAsmPrinter &p, OperationOp op,
+                                       OperandRange attrArgs,
+                                       ArrayAttr attrNames) {
+  if (attrNames.empty())
+    return;
 
-  // Print the result type constraints of the operation.
-  if (!op.results().empty())
-    p << " -> " << op.types();
-  p.printOptionalAttrDict(op.getAttrs(),
-                          {"attributeNames", "name", "operand_segment_sizes"});
-}
-
 /// Verifies that the result types of this operation, defined within a
 /// `pdl.rewrite`, can be inferred.
 static LogicalResult verifyResultTypesAreInferrable(OperationOp op,
-                                                    ResultRange opResults,
                                                     OperandRange resultTypes) {
   // Functor that returns if the given use can be used to infer a type.
   Block *rewriterBlock = op->getBlock();
   auto canInferTypeFromUse = [&](OpOperand &use) {
     // If the use is within a ReplaceOp and isn't the operation being replaced
     // (i.e. is not the first operand of the replacement), we can infer a type.
     ReplaceOp replOpUser = dyn_cast<ReplaceOp>(use.getOwner());
     if (!replOpUser || use.getOperandNumber() == 0)
       return false;
     // Make sure the replaced operation was defined before this one.
     Operation *replacedOp = replOpUser.operation().getDefiningOp();
     return replacedOp->getBlock() != rewriterBlock ||
            replacedOp->isBeforeInBlock(op);
   };
 
   // Check to see if the uses of the operation itself can be used to infer
   // types.
   if (llvm::any_of(op.op().getUses(), canInferTypeFromUse))
     return success();
 
   // Otherwise, make sure each of the types can be inferred.
-  for (int i : llvm::seq<int>(0, opResults.size())) {
-    Operation *resultTypeOp = resultTypes[i].getDefiningOp();
+  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 `create_native`, it is guaranteed to be
     // usable.
     if (isa<CreateNativeOp>(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))
       continue;
 
-    // Otherwise, check to see if any uses of the result can infer the type.
-    if (llvm::any_of(opResults[i].getUses(), canInferTypeFromUse))
-      continue;
     return op
         .emitOpError("must have inferable or constrained result types when "
                      "nested within `pdl.rewrite`")
         .attachNote()
-        .append("result type #", i, " was not constrained");
+        .append("result type #", it.index(), " was not constrained");
   }
   return success();
 }
 
 static LogicalResult verify(OperationOp op) {
   bool isWithinRewrite = isa<RewriteOp>(op->getParentOp());
   if (isWithinRewrite && !op.name())
     return op.emitOpError("must have an operation name when nested within "
                           "a `pdl.rewrite`");
   ArrayAttr attributeNames = op.attributeNames();
   auto attributeValues = op.attributes();
   if (attributeNames.size() != attributeValues.size()) {
     return op.emitOpError()
            << "expected the same number of attribute values and attribute "
               "names, got "
            << attributeNames.size() << " names and " << attributeValues.size()
            << " values";
   }
 
-  OperandRange resultTypes = op.types();
-  auto opResults = op.results();
-  if (resultTypes.size() != opResults.size()) {
-    return op.emitOpError() << "expected the same number of result values and "
-                               "result type constraints, got "
-                            << opResults.size() << " results and "
-                            << resultTypes.size() << " constraints";
-  }
-
   // If the operation is within a rewrite body and doesn't have type inference,
   // ensure that the result types can be resolved.
   if (isWithinRewrite && !op.hasTypeInference()) {
-    if (failed(verifyResultTypesAreInferrable(op, opResults, resultTypes)))
+    if (failed(verifyResultTypesAreInferrable(op, op.types())))
       return failure();
   }
 
   return verifyHasBindingUseInMatcher(op, "`pdl.operation` or `pdl.rewrite`");
 }
 
 bool OperationOp::hasTypeInference() {
   Optional<StringRef> opName = name();
Optional<StringRef> PatternOp::getRootKind() {
   return rootOp.name();
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::ReplaceOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(ReplaceOp op) {
-  auto sourceOp = cast<OperationOp>(op.operation().getDefiningOp());
-  auto sourceOpResults = sourceOp.results();
-  auto replValues = op.replValues();
-
-  if (Value replOpVal = op.replOperation()) {
-    auto replOp = cast<OperationOp>(replOpVal.getDefiningOp());
-    auto replOpResults = replOp.results();
-    if (sourceOpResults.size() != replOpResults.size()) {
-      return op.emitOpError()
-             << "expected source operation to have the same number of results "
-                "as the replacement operation, replacement operation provided "
-             << replOpResults.size() << " but expected "
-             << sourceOpResults.size();
-    }
-
-    if (!replValues.empty()) {
-      return op.emitOpError() << "expected no replacement values to be provided"
-                                 " when the replacement operation is present";
-    }
-
-    return success();
-  }
-
-  if (sourceOpResults.size() != replValues.size()) {
-    return op.emitOpError()
-           << "expected source operation to have the same number of results "
-              "as the provided replacement values, found "
-           << replValues.size() << " replacement values but expected "
-           << sourceOpResults.size();
-  }
-
+  if (op.replOperation() && !op.replValues().empty())
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::RewriteOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(RewriteOp op) {

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

 
 // -----
 
 // CHECK-LABEL: module @constraints
 module @constraints {
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
   // CHECK-DAG:   %[[INPUT:.*]] = pdl_interp.get_operand 0 of %[[ROOT]]
   // CHECK-DAG:   %[[INPUT1:.*]] = pdl_interp.get_operand 1 of %[[ROOT]]
-  // CHECK:       pdl_interp.apply_constraint "multi_constraint" [true](%[[INPUT]], %[[INPUT1]] : !pdl.value, !pdl.value)
+  // 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
-
-    pdl.apply_constraint "multi_constraint"[true](%input0, %input1 : !pdl.value, !pdl.value)
-
     %root = pdl.operation(%input0, %input1)
+    %result0 = pdl.result 0 of %root
+
+    pdl.apply_constraint "multi_constraint"[true](%input0, %input1, %result0 : !pdl.value, !pdl.value, !pdl.value)
     pdl.rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @inputs
 module @inputs {

 
 // -----
 
 // CHECK-LABEL: module @results
 module @results {
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
   // CHECK:   pdl_interp.check_result_count of %[[ROOT]] is 2
 
-  // Get the input and check the type.
+  // 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
 
-  // Get the second operand and check that it is equal to the first.
-  // CHECK-DAG:  %[[RESULT1:.*]] = pdl_interp.get_result 1 of %[[ROOT]]
-  // CHECK-NOT: pdl_interp.get_value_type of %[[RESULT1]]
+  // 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, %results:2 = pdl.operation -> %type1, %type2
+    %root = pdl.operation -> %type1, %type2
+    pdl.rewrite %root with "rewriter"
+  }
+}
+
+// -----
+
+// CHECK-LABEL: module @results
+module @results_as_operands {
+  // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
+
+  // Get the first result and check it matches the first operand.
+  // CHECK-DAG:   %[[OPERAND_0:.*]] = pdl_interp.get_operand 0 of %[[ROOT]]
+  // CHECK-DAG:   %[[DEF_OP_0:.*]] = pdl_interp.get_defining_op of %[[OPERAND_0]]
+  // CHECK-DAG:   %[[RESULT_0:.*]] = pdl_interp.get_result 0 of %[[DEF_OP_0]]
+  // CHECK-DAG:   pdl_interp.are_equal %[[RESULT_0]], %[[OPERAND_0]]
+
+  // Get the second result and check it matches the second operand.
+  // CHECK-DAG:   %[[OPERAND_1:.*]] = pdl_interp.get_operand 1 of %[[ROOT]]
+  // CHECK-DAG:   %[[DEF_OP_1:.*]] = pdl_interp.get_defining_op of %[[OPERAND_1]]
+  // CHECK-DAG:   %[[RESULT_1:.*]] = pdl_interp.get_result 1 of %[[DEF_OP_1]]
+  // 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
+    %result1 = pdl.result 0 of %inputOp
+    %result2 = pdl.result 1 of %inputOp
+
+    %root = pdl.operation(%result1, %result2)
     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, %result = pdl.operation -> %type
+    %root = pdl.operation -> %type
     pdl.rewrite %root with "rewriter"
   }
   pdl.pattern : benefit(1) {
     %type = pdl.type : i64
-    %root, %result = pdl.operation -> %type
+    %root = pdl.operation -> %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 more 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_constraint "typeConstraint"[](%resultType : !pdl.type)
-    %root, %result = pdl.operation -> %resultType
+    %root = pdl.operation -> %resultType
     pdl.rewrite %root with "rewriter"
   }
 
   pdl.pattern : benefit(1) {
     %resultType = pdl.type
-    %apply, %applyRes = pdl.operation -> %resultType
+    %apply = pdl.operation -> %resultType
     pdl.rewrite %apply with "rewriter"
   }
 }

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

module @operation_operands {
   // 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)
     pdl.rewrite %root {
       %type = pdl.type : i32
-      %newOp, %result = pdl.operation "foo.op"(%operand) -> %type
+      %newOp = pdl.operation "foo.op"(%operand) -> %type
+      %result = pdl.result 0 of %newOp
       %newOp1 = pdl.operation "foo.op2"(%result)
       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)
     pdl.rewrite %root {
       %type = pdl.type : i32
-      %newOp, %result = pdl.operation "foo.op"(%operand) -> %type
+      %newOp = pdl.operation "foo.op"(%operand) -> %type
+      %result = pdl.result 0 of %newOp
       %newOp1 = pdl.operation "foo.op2"(%result)
       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, %results:2 = pdl.operation "foo.op" -> %rootType, %rootType1
+    %root = pdl.operation "foo.op" -> %rootType, %rootType1
     pdl.rewrite %root {
       %newType1 = pdl.type
-      %newOp, %newResults:2 = pdl.operation "foo.op" -> %rootType, %newType1
+      %newOp = pdl.operation "foo.op" -> %rootType, %newType1
       pdl.replace %root with %newOp
     }
   }
 }
 
 // -----
 
-// CHECK-LABEL: module @operation_result_types_infer_from_value_replacement
-module @operation_result_types_infer_from_value_replacement {
-  // CHECK: module @rewriters
-  // CHECK:   func @pdl_generated_rewriter(%[[TYPE:.*]]: !pdl.type
-  // CHECK:     pdl_interp.create_operation "foo.op"() -> %[[TYPE]]
-  pdl.pattern : benefit(1) {
-    %rootType = pdl.type
-    %root, %result = pdl.operation "foo.op" -> %rootType
-    pdl.rewrite %root {
-      %newType = pdl.type
-      %newOp, %newResult = pdl.operation "foo.op" -> %newType
-      pdl.replace %root with (%newResult)
-    }
-  }
-}
-// -----
-
 // 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, %result = pdl.operation "foo.op" -> %type
+    %root = pdl.operation "foo.op" -> %type
     pdl.rewrite %root {
-      %newOp, %newResult = pdl.operation "foo.op" -> %type
+      %newOp = pdl.operation "foo.op" -> %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, %result = pdl.operation "foo.op" -> %type
+    %root = pdl.operation "foo.op" -> %type
     pdl.rewrite %root {
-      %newOp, %newResult = pdl.operation "foo.op" -> %type
+      %newOp = pdl.operation "foo.op" -> %type
+      %newResult = pdl.result 0 of %newOp
       pdl.replace %root with (%newResult)
     }
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @replace_with_no_results

 // CHECK-LABEL: module @create_native
 module @create_native {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[ROOT:.*]]: !pdl.operation)
   // CHECK:     %[[TYPE:.*]] = pdl_interp.create_native "functor" [true](%[[ROOT]] : !pdl.operation) : !pdl.type
   // CHECK:     pdl_interp.create_operation "foo.op"() -> %[[TYPE]]
   pdl.pattern : benefit(1) {
     %type = pdl.type
-    %root, %result = pdl.operation "foo.op" -> %type
+    %root = pdl.operation "foo.op" -> %type
     pdl.rewrite %root {
       %newType = pdl.create_native "functor"[true](%root : !pdl.operation) : !pdl.type
-      %newOp, %newResult = pdl.operation "foo.op" -> %newType
+      %newOp = pdl.operation "foo.op" -> %newType
       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, %result = pdl.operation "foo.op" {"attr" = %attr} -> %type
+  %op = pdl.operation "foo.op" {"attr" = %attr} -> %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 {
     %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
+    %newOp = 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"
pdl.pattern : benefit(1) {
   "foo.other_op"() : () -> ()
 
   %root = pdl.operation "foo.op"
   pdl.rewrite %root with "foo"
 }
 
 // -----
 
-//===----------------------------------------------------------------------===//
-// pdl::ReplaceOp
-//===----------------------------------------------------------------------===//
-
 pdl.pattern : benefit(1) {
-  %root = pdl.operation "foo.op"
-  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
+  %root = pdl.operation "foo.op" -> %type
   pdl.rewrite %root {
-    %newOp, %newResult = pdl.operation "foo.op" -> %type
+    %newOp = pdl.operation "foo.op" -> %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.pattern : benefit(1) {
-  %root = pdl.operation "foo.op"
-  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}}

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, %op0_result = pdl.operation {"attr" = %attribute} -> %type
+  %op0 = pdl.operation {"attr" = %attribute} -> %type
+  %op0_result = pdl.result 0 of %op0
 
   // Operation with input.
   %input = pdl.operand
   %root = pdl.operation(%op0_result, %input)
   pdl.rewrite %root with "rewriter"
 }
 
 // -----

 
 // -----
 
 // 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
+  %root = pdl.operation -> %type1, %type2
   pdl.rewrite %root {
     %type3 = pdl.type
-    %newOp, %newResults:2 = pdl.operation "foo.op" -> %type1, %type3
+    %newOp = 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 {
-    %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
+  %root = pdl.operation -> %type1, %type2
   pdl.rewrite %root {
-    %newOp, %newResults:2 = pdl.operation "foo.op" -> %type1, %type2
+    %newOp = pdl.operation "foo.op" -> %type1, %type2
   }
 }