[mlir][Transform] Add transform.any_param type

[qedawkins]

Summary

Introduces a generic parameter type intended for transform dialect use
cases that uses/manipulates the underlying attribute (e.g. op
annotation). Includes a disclaimer that mixing parameter based and
attribute based control is discouraged.

[qedawkins]

mlir/include/mlir/Dialect/Transform/IR/TransformTypes.td

63

Is there a better place in the dialect documentation to put this disclaimer? I could not find an obvious place to put it.

[ftynse]

mlir/include/mlir/Dialect/Transform/IR/TransformTypes.td

63

In docs/Dialect/Transform.md, there must be a sentence describing what parameters are. That would be a good place. Probably turning it into a full paragraph with an example of what we understand by "parameter-based control".

[qedawkins]

Add docs explaining parameter control

[qedawkins]

mlir/include/mlir/Dialect/Transform/IR/TransformTypes.td

63

I added a section above. Please confirm that what I wrote there matches your thinking and/or the example makes sense.

[ftynse]

Let's go with this, I can always rephrase later.

mlir/docs/Dialects/Transform.md

 Similarly, a value handle such as `%3` may be associated with a set of payload
 IR values. Transform dialect operations may take as operands and produce an
 arbitrary combination of values representing handles and parameters. Most
 Transform IR ops support operand values that are mapped to multiple payload
 objects. They usually apply the respective transformation for every mapped
 object ("batched execution"). Deviations from this convention are described in
 the documentation of Transform IR ops.
 
+Parameters, such as `%1` in the above example, have two logical roles in
+transform IR. In parameter based control, they carry the values needed to
+execute the explicit control defined by the transforms, for example:
+
+```mlir
+%0 = transform.match.structured.rank %linalg_op_handle : !transform.param<index>
+%1 = transform.param.constant 3 : i32 -> !transform.param<index>
+transform.execute_if_cmpi eq %0, %1 : !transform.param<index>, !transform.param<index>
+// Some nested body of transform ops
+```
+
+Alternatively, parameters can associate with the payload IR where the specific
+value at execution time has no bearing on the execution of the transform IR. In
+other words, parameters can either associate with the transform IR or the
+payload IR.  Note that it is generally discouraged to use parameters containing
+arbitrary attributes within transform control. Parameter based control should
+try to be explicitly typed when possible.
+
 The transform IR values have transform IR types, which should implement exactly one of:
 
   * [TransformHandleTypeInterface](Transform.md#transformhandletypeinterface-transformhandletypeinterface),
 
   * [TransformValueHandleTypeInterface](Transform.md#transformvaluehandletypeinterface-transformvaluehandletypeinterface),
 
   * [TransformParamTypeInterface](Transform.md##transformparamtypeinterface-transformparamtypeinterface).
 

mlir/include/mlir/Dialect/Transform/IR/TransformTypes.td

def Transform_OperationType : TypeDef<Transform_Dialect, "Operation",
   }];
   let mnemonic = "op";
   let parameters = (ins
     StringRefParameter<"Name of the allowed payload operation">:$operation_name
   );
   let assemblyFormat = "`<` $operation_name `>`";
 }
 
+def Transform_AnyParamType : TypeDef<Transform_Dialect, "AnyParam",
+    [DeclareTypeInterfaceMethods<TransformParamTypeInterface>]> {
+  let description = [{
+    Transform IR value that can be associated with a list of parameters
+    of any type.
+  }];
+  let mnemonic = "any_param";
+  let assemblyFormat = "";
+}
+
 def Transform_ParamType : TypeDef<Transform_Dialect, "Param",
     [DeclareTypeInterfaceMethods<TransformParamTypeInterface>]> {
   let description = [{
     Transform IR value that can be associated with the list of parameters
     of the given type. Types are currently limited to integers, but may be
     extended in the future to other types values of which can be contained
     in attributes.
   }];

mlir/lib/Dialect/Transform/IR/TransformTypes.cpp

if (opName != op->getName()) {
       return diag;
     }
   }
 
   return DiagnosedSilenceableFailure::success();
 }
 
 //===----------------------------------------------------------------------===//
+// transform::AnyParamType
+//===----------------------------------------------------------------------===//
+
+DiagnosedSilenceableFailure
+transform::AnyParamType::checkPayload(Location loc,
+                                      ArrayRef<Attribute> payload) const {
+  return DiagnosedSilenceableFailure::success();
+}
+
+//===----------------------------------------------------------------------===//
 // transform::ParamType
 //===----------------------------------------------------------------------===//
 
 LogicalResult
 transform::ParamType::verify(function_ref<InFlightDiagnostic()> emitError,
                              Type type) {
   IntegerType intType = llvm::dyn_cast<IntegerType>(type);
   if (!intType || intType.getWidth() > 64)

mlir/test/Dialect/Transform/ops.mlir

 
 // CHECK: transform.sequence
 // CHECK: transform.structured.tile %0{{\[}}[2], 4, 8]
 transform.sequence failures(propagate) {
 ^bb0(%arg1: !transform.any_op):
   %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op
   transform.structured.tile %0 [[2], 4, 8] : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op, !transform.any_op)
 }
+
+// CHECK: transform.sequence
+// CHECK: transform.param.constant "example_string
+transform.sequence failures(propagate) {
+^bb0(%arg1: !transform.any_op):
+  transform.param.constant "example_string" -> !transform.any_param
+}

mlir/test/Dialect/Transform/test-interpreter.mlir

^bb1(%arg0: !transform.any_op):
   %8 = transform.merge_handles %2, %2, %3, %4 : !transform.any_value
   // expected-remark @below {{4}}
   test_print_number_of_associated_payload_ir_values %8 : !transform.any_value
 }
 // -----
 
 // CHECK-LABEL: func @test_annotation()
 //  CHECK-NEXT:   "test.annotate_me"()
+//  CHECK-SAME:                        any_attr = "example"
 //  CHECK-SAME:                        broadcast_attr = 2 : i64
 //  CHECK-SAME:                        new_attr = 1 : i32
 //  CHECK-SAME:                        unit_attr
 //  CHECK-NEXT:   "test.annotate_me"()
+//  CHECK-SAME:                        any_attr = "example"
 //  CHECK-SAME:                        broadcast_attr = 2 : i64
 //  CHECK-SAME:                        existing_attr = "test"
 //  CHECK-SAME:                        new_attr = 1 : i32
 //  CHECK-SAME:                        unit_attr
 //  CHECK-NEXT:   "test.annotate_me"()
+//  CHECK-SAME:                        any_attr = "example"
 //  CHECK-SAME:                        broadcast_attr = 2 : i64
 //  CHECK-SAME:                        new_attr = 1 : i32
 //  CHECK-SAME:                        unit_attr
 func.func @test_annotation() {
   %0 = "test.annotate_me"() : () -> (i1)
   %1 = "test.annotate_me"() {existing_attr = "test"} : () -> (i1)
   %2 = "test.annotate_me"() {new_attr = 0} : () -> (i1)
 }
 
 transform.sequence failures(propagate) {
 ^bb1(%arg0: !transform.any_op):
   %0 = transform.structured.match ops{["test.annotate_me"]} in %arg0 : (!transform.any_op) -> !transform.any_op
   %1 = transform.test_produce_param_with_number_of_test_ops %0 : !transform.any_op
   transform.annotate %0 "new_attr" = %1 : !transform.any_op, !transform.test_dialect_param
 
   %2 = transform.param.constant 2 -> !transform.param<i64>
   transform.annotate %0 "broadcast_attr" = %2 : !transform.any_op, !transform.param<i64>
   transform.annotate %0 "unit_attr" : !transform.any_op
+
+  %3 = transform.param.constant "example" -> !transform.any_param
+  transform.annotate %0 "any_attr" = %3 : !transform.any_op, !transform.any_param
 }
 
 // -----
 
 func.func @notify_payload_op_replaced(%arg0: index, %arg1: index) {
   %0 = arith.muli %arg0, %arg1 {original} : index
   // expected-remark @below{{updated handle}}
   %1 = arith.muli %arg0, %arg1 {replacement} : index