[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/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. Note that it is discouraged to mix attribute based transform
+    control with parameter based control.
+  }];
+  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