[mlir][pdl][NFC] Rename InputOp to OperandOp

[rriddle]

Summary

This better matches the actual IR concept that is being modeled, and is consistent with how the rest of PDL is structured.

Depends On D95717

[jpienaar]

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

172

Lucky that no move was required to keep it alphatized :)

176

Is there a non-input operand tin PDL too?

[rriddle]

Rebase

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

176

input here should probably be external, as that is the property that input was poorly trying to convey.

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

string description = [{
     and `!pdl.type` directly mapping to `mlir::Attribute`, `mlir::Operation*`,
     and `mlir::Value` respectively.
 
     An example pattern is shown below:
 
     ```mlir
     // pdl.pattern contains metadata similarly to a `RewritePattern`.
     pdl.pattern : benefit(1) {
-      // External input operand values are specified via `pdl.input` operations.
+      // External input operand values are specified via `pdl.operand` operations.
       // Result types are constrainted via `pdl.type` operations.
 
       %resultType = pdl.type
-      %inputOperand = pdl.input
+      %inputOperand = pdl.operand
       %root, %results = 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

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

let description = [{
     ```
   }];
   let arguments = (ins PDL_Operation:$operation);
   let assemblyFormat = "$operation attr-dict";
   let verifier = ?;
 }
 
 //===----------------------------------------------------------------------===//
-// pdl::InputOp
+// pdl::OperandOp
 //===----------------------------------------------------------------------===//
 
-def PDL_InputOp : PDL_Op<"input", [HasParent<"pdl::PatternOp">]> {
-  let summary = "Define an input value in a pattern";
+def PDL_OperandOp : PDL_Op<"operand", [HasParent<"pdl::PatternOp">]> {
+  let summary = "Define an external input operand in a pattern";
   let description = [{
-    `pdl.input` operations capture external operand edges into an operation
+    `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
-    define, and partially constrain, input operands of a given operation.
-    A `pdl.input` may partially constrain an input operand by specifying an
-    expected value type (via a `pdl.type` operation).
+    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 input operand:
-    %operand = pdl.input
+    // Define an external operand:
+    %operand = pdl.operand
 
-    // Define an input operand with an expected type:
+    // Define an external operand with an expected type:
     %type = pdl.type : i32
-    %attr = pdl.input : %type
+    %operand = pdl.operand : %type
     ```
   }];
 
   let arguments = (ins Optional<PDL_Type>:$type);
   let results = (outs PDL_Value:$val);
   let assemblyFormat = "(`:` $type^)? attr-dict";
 
   let builders = [
let description = [{
     metadata on a `RewritePattern`, such as the benefit. The match section of
     the pattern is specified within the region body, with the rewrite provided
     by a terminating `pdl.rewrite`.
 
     Example:
 
     ```mlir
     // Provide a pattern matching "foo.op" that replaces the root with its
-    // input.
+    // operand.
     pdl.pattern : benefit(1) {
       %resultType = pdl.type
-      %inputOperand = pdl.input
+      %inputOperand = pdl.operand
       %root, %results = pdl.operation "foo.op"(%inputOperand) -> (%resultType)
       pdl.rewrite %root {
         pdl.replace %root with (%inputOperand)
       }
     }
     ```
   }];
 

mlir/lib/Conversion/PDLToPDLInterp/PredicateTree.cpp

static void getTreePredicates(std::vector<PositionalPredicate> &predList,
                               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::InputOp, pdl::TypeOp>(val.getDefiningOp())) {
+      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: {
     break;
   }
   case Predicates::OperandPos: {
     assert(val.getType().isa<pdl::ValueType>() && "expected value type");
 
     // Prevent traversal into a null value.
     predList.emplace_back(pos, builder.getIsNotNull());
 
-    // If this is a typed input, add a type constraint.
-    if (auto in = val.getDefiningOp<pdl::InputOp>()) {
+    // 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));
       }
 
       // Otherwise, recurse into the parent node.
     } else if (auto parentOp = val.getDefiningOp<pdl::OperationOp>()) {
       getTreePredicates(predList, parentOp.op(), builder, inputs,

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

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, InputOp, OperationOp, RewriteOp>(user))
+    if (isa<AttributeOp, OperandOp, OperationOp, RewriteOp>(user))
       return success();
   }
   return op->emitOpError()
          << "expected a bindable (i.e. " << bindableContextStr
          << ") user when defined in the matcher body of a `pdl.pattern`";
 }
 
 //===----------------------------------------------------------------------===//
if (!attrValue && isa<RewriteOp>(op->getParentOp()))
     return op.emitOpError("expected constant value when specified within a "
                           "`pdl.rewrite`");
   if (attrValue && attrType)
     return op.emitOpError("expected only one of [`type`, `value`] to be set");
   return verifyHasBindingUseInMatcher(op);
 }
 
 //===----------------------------------------------------------------------===//
-// pdl::InputOp
+// pdl::OperandOp
 //===----------------------------------------------------------------------===//
 
-static LogicalResult verify(InputOp op) {
+static LogicalResult verify(OperandOp op) {
   return verifyHasBindingUseInMatcher(op);
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::OperationOp
 //===----------------------------------------------------------------------===//
 
 static ParseResult parseOperationOp(OpAsmParser &p, OperationState &state) {

 }
 
 //===----------------------------------------------------------------------===//
 // pdl::TypeOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(TypeOp op) {
   return verifyHasBindingUseInMatcher(
-      op, "`pdl.attribute`, `pdl.input`, or `pdl.operation`");
+      op, "`pdl.attribute`, `pdl.operand`, 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

 // 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)
 
   pdl.pattern : benefit(1) {
-    %input0 = pdl.input
-    %input1 = pdl.input
+    %input0 = pdl.operand
+    %input1 = pdl.operand
 
     pdl.apply_constraint "multi_constraint"[true](%input0, %input1 : !pdl.value, !pdl.value)
 
     %root = pdl.operation(%input0, %input1)
     pdl.rewrite %root with "rewriter"
   }
 }
 
module @inputs {
   // CHECK-DAG:   %[[INPUT_TYPE:.*]] = pdl_interp.get_value_type of %[[INPUT]]
   // 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.input : %type
+    %input = pdl.operand : %type
     %root = pdl.operation(%input, %input)
     pdl.rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @results

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](%[[INPUT]] : !pdl.value) on %[[ROOT]]
   pdl.pattern : benefit(1) {
-    %input = pdl.input
+    %input = pdl.operand
     %root = pdl.operation "foo.op"(%input)
     pdl.rewrite %root with "rewriter"[true](%input : !pdl.value)
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @erase

 // 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.input
+    %operand = pdl.operand
     %root = pdl.operation "foo.op"(%operand)
     pdl.rewrite %root {
       %type = pdl.type : i32
       %newOp, %result = pdl.operation "foo.op"(%operand) -> %type
       %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.input
+    %operand = pdl.operand
     %root = pdl.operation "foo.op"(%operand)
     pdl.rewrite %root {
       %type = pdl.type : i32
       %newOp, %result = pdl.operation "foo.op"(%operand) -> %type
       %newOp1 = pdl.operation "foo.op2"(%result)
       pdl.erase %root
     }
   }

mlir/test/Dialect/PDL/invalid.mlir

pdl.pattern : benefit(1) {
 
   %op = pdl.operation "foo.op"
   pdl.rewrite %op with "rewriter"
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// pdl::InputOp
+// pdl::OperandOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
   // expected-error@below {{expected a bindable (i.e. `pdl.operation`) user when defined in the matcher body of a `pdl.pattern`}}
-  %unused = pdl.input
+  %unused = pdl.operand
 
   %op = pdl.operation "foo.op"
   pdl.rewrite %op with "rewriter"
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//

 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl::TypeOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
-  // expected-error@below {{expected a bindable (i.e. `pdl.attribute`, `pdl.input`, or `pdl.operation`) user when defined in the matcher body of a `pdl.pattern`}}
+  // 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"
 }

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
 
   // Operation with input.
-  %input = pdl.input
+  %input = pdl.operand
   %root = pdl.operation(%op0_result, %input)
   pdl.rewrite %root with "rewriter"
 }
 
 // -----
 
 pdl.pattern @rewrite_with_args : benefit(1) {
-  %input = pdl.input
+  %input = pdl.operand
   %root = pdl.operation(%input)
   pdl.rewrite %root with "rewriter"(%input : !pdl.value)
 }
 
 // -----
 
 pdl.pattern @rewrite_with_params : benefit(1) {
   %root = pdl.operation
   pdl.rewrite %root with "rewriter"["I am param"]
 }
 
 // -----
 
 pdl.pattern @rewrite_with_args_and_params : benefit(1) {
-  %input = pdl.input
+  %input = pdl.operand
   %root = pdl.operation(%input)
   pdl.rewrite %root with "rewriter"["I am param"](%input : !pdl.value)
 }
 
 // -----
 
 // Check that the result type of an operation within a rewrite can be inferred
 // from a pdl.replace.