[Mlir-commits] [mlir] 46af120 - [mlir] don't hardcode PDL_Operation in TestTransformDialectExtensions

[Alex Zinenko]

Author: Alex Zinenko
Date: 2023-05-22T08:19:49Z
New Revision: 46af120e159c18b5530738ce396a12b545063f3d

URL: https://github.com/llvm/llvm-project/commit/46af120e159c18b5530738ce396a12b545063f3d
DIFF: https://github.com/llvm/llvm-project/commit/46af120e159c18b5530738ce396a12b545063f3d.diff

LOG: [mlir] don't hardcode PDL_Operation in TestTransformDialectExtensions

Update operations in Transform dialect extensions used for testing to
use the more generic `TransformHandleTypeInterface` type constraint
instead of hardcoding `PDL_Operation`. See
https://discourse.llvm.org/t/rfc-type-system-for-the-transform-dialect/65702
for motivation. This is particularly important as these tests are often
used as source of best practices.

Update tests to use `!transform.any_op` instead of `!pdl.operation`.

Depends On D150785

Reviewed By: nicolasvasilache

Differential Revision: https://reviews.llvm.org/D150786

Added: 
    

Modified: 
    mlir/test/Dialect/Transform/check-use-after-free.mlir
    mlir/test/Dialect/Transform/expensive-checks.mlir
    mlir/test/Dialect/Transform/multi-arg-top-level-params.mlir
    mlir/test/Dialect/Transform/ops-invalid.mlir
    mlir/test/Dialect/Transform/ops.mlir
    mlir/test/Dialect/Transform/test-dialect-injection.mlir
    mlir/test/Dialect/Transform/test-interpreter.mlir
    mlir/test/Dialect/Transform/transform-state-extension.mlir
    mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.td

Removed: 
    


################################################################################
diff  --git a/mlir/test/Dialect/Transform/check-use-after-free.mlir b/mlir/test/Dialect/Transform/check-use-after-free.mlir
index e2c0f07032507..742c5dcc78f60 100644
--- a/mlir/test/Dialect/Transform/check-use-after-free.mlir
+++ b/mlir/test/Dialect/Transform/check-use-after-free.mlir
@@ -2,7 +2,7 @@
 
 func.func @use_after_free_branching_control_flow() {
   // expected-note @below {{allocated here}}
-  %0 = transform.test_produce_self_handle_or_forward_operand
+  %0 = transform.test_produce_self_handle_or_forward_operand : () -> !transform.any_op
   transform.test_transform_op_with_regions {
     "transform.test_branching_transform_op_terminator"() : () -> ()
   },
@@ -11,14 +11,14 @@ func.func @use_after_free_branching_control_flow() {
     "transform.test_branching_transform_op_terminator"()[^bb1, ^bb2] : () -> ()
   ^bb1:
     // expected-note @below {{freed here}}
-    transform.test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand"
+    transform.test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand" : !transform.any_op
     "transform.test_branching_transform_op_terminator"()[^bb3] : () -> ()
   ^bb2:
     "transform.test_branching_transform_op_terminator"()[^bb3] : () -> ()
   ^bb3:
     // expected-warning @below {{operand #0 may be used after free}}
-    transform.sequence %0 : !pdl.operation failures(propagate) {
-    ^bb0(%arg0: !pdl.operation):
+    transform.sequence %0 : !transform.any_op failures(propagate) {
+    ^bb0(%arg0: !transform.any_op):
     }
     "transform.test_branching_transform_op_terminator"() : () -> ()
   }
@@ -29,7 +29,7 @@ func.func @use_after_free_branching_control_flow() {
 
 func.func @use_after_free_in_nested_op() {
   // expected-note @below {{allocated here}}
-  %0 = transform.test_produce_self_handle_or_forward_operand
+  %0 = transform.test_produce_self_handle_or_forward_operand : () -> !transform.any_op
   // expected-note @below {{freed here}}
   transform.test_transform_op_with_regions {
     "transform.test_branching_transform_op_terminator"() : () -> ()
@@ -38,7 +38,7 @@ func.func @use_after_free_in_nested_op() {
   ^bb0:
     "transform.test_branching_transform_op_terminator"()[^bb1, ^bb2] : () -> ()
   ^bb1:
-    transform.test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand"
+    transform.test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand" : !transform.any_op
     "transform.test_branching_transform_op_terminator"()[^bb3] : () -> ()
   ^bb2:
     "transform.test_branching_transform_op_terminator"()[^bb3] : () -> ()
@@ -46,8 +46,8 @@ func.func @use_after_free_in_nested_op() {
     "transform.test_branching_transform_op_terminator"() : () -> ()
   }
   // expected-warning @below {{operand #0 may be used after free}}
-  transform.sequence %0 : !pdl.operation failures(propagate) {
-    ^bb0(%arg0: !pdl.operation):
+  transform.sequence %0 : !transform.any_op failures(propagate) {
+    ^bb0(%arg0: !transform.any_op):
   }
   return
 }
@@ -56,29 +56,29 @@ func.func @use_after_free_in_nested_op() {
 
 func.func @use_after_free_recursive_side_effects() {
   transform.sequence failures(propagate) {
-  ^bb0(%arg0: !pdl.operation):
+  ^bb0(%arg0: !transform.any_op):
     // expected-note @below {{allocated here}}
-    %0 = transform.sequence %arg0 : !pdl.operation -> !pdl.operation failures(propagate) attributes { ord = 1 } {
-    ^bb1(%arg1: !pdl.operation):
-      yield %arg1 : !pdl.operation
+    %0 = transform.sequence %arg0 : !transform.any_op -> !transform.any_op failures(propagate) attributes { ord = 1 } {
+    ^bb1(%arg1: !transform.any_op):
+      yield %arg1 : !transform.any_op
     }
-    transform.sequence %0 : !pdl.operation failures(propagate) attributes { ord = 2 } {
-    ^bb2(%arg2: !pdl.operation):
+    transform.sequence %0 : !transform.any_op failures(propagate) attributes { ord = 2 } {
+    ^bb2(%arg2: !transform.any_op):
     }
-    transform.sequence %0 : !pdl.operation failures(propagate) attributes { ord = 3 } {
-    ^bb3(%arg3: !pdl.operation):
+    transform.sequence %0 : !transform.any_op failures(propagate) attributes { ord = 3 } {
+    ^bb3(%arg3: !transform.any_op):
     }
 
     // `transform.sequence` has recursive side effects so it has the same "free"
     // as the child op it contains.
     // expected-note @below {{freed here}}
-    transform.sequence %0 : !pdl.operation failures(propagate) attributes { ord = 4 } {
-    ^bb4(%arg4: !pdl.operation):
-      test_consume_operand_of_op_kind_or_fail %0, "transform.sequence"
+    transform.sequence %0 : !transform.any_op failures(propagate) attributes { ord = 4 } {
+    ^bb4(%arg4: !transform.any_op):
+      test_consume_operand_of_op_kind_or_fail %0, "transform.sequence" : !transform.any_op
     }
     // expected-warning @below {{operand #0 may be used after free}}
-    transform.sequence %0 : !pdl.operation failures(propagate) attributes { ord = 5 } {
-    ^bb3(%arg3: !pdl.operation):
+    transform.sequence %0 : !transform.any_op failures(propagate) attributes { ord = 5 } {
+    ^bb3(%arg3: !transform.any_op):
     }
   }
   return
@@ -88,24 +88,24 @@ func.func @use_after_free_recursive_side_effects() {
 
 func.func @use_after_free() {
   transform.sequence failures(propagate) {
-  ^bb0(%arg0: !pdl.operation):
+  ^bb0(%arg0: !transform.any_op):
     // expected-note @below {{allocated here}}
-    %0 = transform.sequence %arg0 : !pdl.operation -> !pdl.operation failures(propagate) attributes { ord = 1 } {
-    ^bb1(%arg1: !pdl.operation):
-      yield %arg1 : !pdl.operation
+    %0 = transform.sequence %arg0 : !transform.any_op -> !transform.any_op failures(propagate) attributes { ord = 1 } {
+    ^bb1(%arg1: !transform.any_op):
+      yield %arg1 : !transform.any_op
     }
-    transform.sequence %0 : !pdl.operation failures(propagate) attributes { ord = 2 } {
-    ^bb2(%arg2: !pdl.operation):
+    transform.sequence %0 : !transform.any_op failures(propagate) attributes { ord = 2 } {
+    ^bb2(%arg2: !transform.any_op):
     }
-    transform.sequence %0 : !pdl.operation failures(propagate) attributes { ord = 3 } {
-    ^bb3(%arg3: !pdl.operation):
+    transform.sequence %0 : !transform.any_op failures(propagate) attributes { ord = 3 } {
+    ^bb3(%arg3: !transform.any_op):
     }
 
     // expected-note @below {{freed here}}
-    test_consume_operand_of_op_kind_or_fail %0, "transform.sequence"
+    test_consume_operand_of_op_kind_or_fail %0, "transform.sequence" : !transform.any_op
     // expected-warning @below {{operand #0 may be used after free}}
-    transform.sequence %0 : !pdl.operation failures(propagate) attributes { ord = 5 } {
-    ^bb3(%arg3: !pdl.operation):
+    transform.sequence %0 : !transform.any_op failures(propagate) attributes { ord = 5 } {
+    ^bb3(%arg3: !transform.any_op):
     }
   }
   return
@@ -118,7 +118,7 @@ func.func @use_after_free() {
 // be reported as use-after-free.
 func.func @use_after_free_self_cycle() {
   // expected-note @below {{allocated here}}
-  %0 = transform.test_produce_self_handle_or_forward_operand
+  %0 = transform.test_produce_self_handle_or_forward_operand : () -> !transform.any_op
   transform.test_transform_op_with_regions {
     "transform.test_branching_transform_op_terminator"() : () -> ()
   },
@@ -127,12 +127,12 @@ func.func @use_after_free_self_cycle() {
     "transform.test_branching_transform_op_terminator"()[^bb1] : () -> ()
   ^bb1:
     // expected-warning @below {{operand #0 may be used after free}}
-    transform.sequence %0 : !pdl.operation failures(propagate) {
-    ^bb0(%arg0: !pdl.operation):
+    transform.sequence %0 : !transform.any_op failures(propagate) {
+    ^bb0(%arg0: !transform.any_op):
     }
     // expected-warning @below {{operand #0 may be used after free}}
     // expected-note @below {{freed here}}
-    transform.test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand"
+    transform.test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand" : !transform.any_op
     "transform.test_branching_transform_op_terminator"()[^bb1, ^bb2] : () -> ()
   ^bb2:
     "transform.test_branching_transform_op_terminator"() : () -> ()
@@ -147,7 +147,7 @@ func.func @use_after_free_self_cycle() {
 // use-after-free.
 func.func @use_after_free_cycle() {
   // expected-note @below {{allocated here}}
-  %0 = transform.test_produce_self_handle_or_forward_operand
+  %0 = transform.test_produce_self_handle_or_forward_operand : () -> !transform.any_op
   transform.test_transform_op_with_regions {
     "transform.test_branching_transform_op_terminator"() : () -> ()
   },
@@ -157,7 +157,7 @@ func.func @use_after_free_cycle() {
   ^bb1:
     // expected-warning @below {{operand #0 may be used after free}}
     // expected-note @below {{freed here}}
-    transform.test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand"
+    transform.test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand" : !transform.any_op
     "transform.test_branching_transform_op_terminator"()[^bb2, ^bb3] : () -> ()
   ^bb2:
     "transform.test_branching_transform_op_terminator"()[^bb1] : () -> ()
@@ -172,8 +172,8 @@ func.func @use_after_free_cycle() {
 // This should not crash.
 
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation):
-  alternatives %arg0 : !pdl.operation {
-  ^bb0(%arg1: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
+  alternatives %arg0 : !transform.any_op {
+  ^bb0(%arg1: !transform.any_op):
   }
 }

diff  --git a/mlir/test/Dialect/Transform/expensive-checks.mlir b/mlir/test/Dialect/Transform/expensive-checks.mlir
index de5355443edee..3a7a3df97046d 100644
--- a/mlir/test/Dialect/Transform/expensive-checks.mlir
+++ b/mlir/test/Dialect/Transform/expensive-checks.mlir
@@ -7,7 +7,7 @@ func.func @func() {
 }
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   pdl.pattern @return : benefit(1) {
     %0 = operands
     %1 = types
@@ -15,15 +15,15 @@ transform.with_pdl_patterns {
     rewrite %2 with "transform.dialect"
   }
 
-  sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
+  sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb1(%arg1: !transform.any_op):
     // expected-note @below {{handle to invalidated ops}}
-    %0 = pdl_match @return in %arg1 : (!pdl.operation) -> !pdl.operation
-    %1 = get_closest_isolated_parent %0 : (!pdl.operation) -> !pdl.operation
+    %0 = pdl_match @return in %arg1 : (!transform.any_op) -> !transform.any_op
+    %1 = get_closest_isolated_parent %0 : (!transform.any_op) -> !transform.any_op
     // expected-note @below {{invalidated by this transform op that consumes its operand #0}}
-    test_consume_operand %1 : !pdl.operation
+    test_consume_operand %1 : !transform.any_op
     // expected-error @below {{op uses a handle invalidated by a previously executed transform op}}
-    test_print_remark_at_operand %0, "remark" : !pdl.operation
+    test_print_remark_at_operand %0, "remark" : !transform.any_op
   }
 }
 
@@ -36,7 +36,7 @@ func.func @func1() {
 func.func private @func2()
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   pdl.pattern @func : benefit(1) {
     %0 = operands
     %1 = types
@@ -50,14 +50,14 @@ transform.with_pdl_patterns {
     rewrite %2 with "transform.dialect"
   }
 
-  sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
-    %0 = pdl_match @func in %arg1 : (!pdl.operation) -> !pdl.operation
-    %1 = pdl_match @return in %arg1 : (!pdl.operation) -> !pdl.operation
-    %2 = replicate num(%0) %1 : !pdl.operation, !pdl.operation
+  sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb1(%arg1: !transform.any_op):
+    %0 = pdl_match @func in %arg1 : (!transform.any_op) -> !transform.any_op
+    %1 = pdl_match @return in %arg1 : (!transform.any_op) -> !transform.any_op
+    %2 = replicate num(%0) %1 : !transform.any_op, !transform.any_op
     // expected-error @below {{a handle passed as operand #0 and consumed by this operation points to a payload entity more than once}}
-    test_consume_operand %2 : !pdl.operation
-    test_print_remark_at_operand %0, "remark" : !pdl.operation
+    test_consume_operand %2 : !transform.any_op
+    test_print_remark_at_operand %0, "remark" : !transform.any_op
   }
 }
 
@@ -69,14 +69,14 @@ transform.with_pdl_patterns {
 module {
 
   transform.sequence failures(propagate) {
-  ^bb0(%0: !pdl.operation):
-    %1 = transform.test_copy_payload %0
+  ^bb0(%0: !transform.any_op):
+    %1 = transform.test_copy_payload %0 : (!transform.any_op) -> !transform.any_op
     // expected-note @below {{handle to invalidated ops}}
-    %2 = transform.test_copy_payload %0
+    %2 = transform.test_copy_payload %0 : (!transform.any_op) ->!transform.any_op
     // expected-note @below {{invalidated by this transform op that consumes its operand #0}}
-    transform.test_consume_operand %1 : !pdl.operation
+    transform.test_consume_operand %1 : !transform.any_op
     // expected-error @below {{op uses a handle invalidated by a previously executed transform op}}
-    transform.test_consume_operand %2 : !pdl.operation
+    transform.test_consume_operand %2 : !transform.any_op
   }
 }
 
@@ -87,16 +87,16 @@ module {
 module {
 
   transform.sequence failures(propagate) {
-  ^bb0(%0: !pdl.operation):
-    %1 = transform.test_copy_payload %0
+  ^bb0(%0: !transform.any_op):
+    %1 = transform.test_copy_payload %0 : (!transform.any_op) -> !transform.any_op
     // expected-note @below {{handle to invalidated ops}}
-    %2 = transform.test_copy_payload %0
+    %2 = transform.test_copy_payload %0 : (!transform.any_op) -> !transform.any_op
     // Consuming two handles in the same operation is invalid if they point
     // to overlapping sets of payload IR ops.
     //
     // expected-error @below {{op uses a handle invalidated by a previously executed transform op}}
     // expected-note @below {{invalidated by this transform op that consumes its operand #0 and invalidates all handles to payload IR entities}}
-    transform.test_consume_operand %1, %2 : !pdl.operation
+    transform.test_consume_operand %1, %2 : !transform.any_op, !transform.any_op
   }
 }
 
@@ -107,10 +107,10 @@ module {
 module {
 
   transform.sequence failures(propagate) {
-  ^bb0(%0: !pdl.operation):
-    %1 = transform.test_copy_payload %0
-    %2 = transform.test_copy_payload %0
-    transform.merge_handles %1, %2 { deduplicate } : !pdl.operation
+  ^bb0(%0: !transform.any_op):
+    %1 = transform.test_copy_payload %0 : (!transform.any_op) -> !transform.any_op
+    %2 = transform.test_copy_payload %0 : (!transform.any_op) -> !transform.any_op
+    transform.merge_handles %1, %2 { deduplicate } : !transform.any_op
   }
 }
 // -----

diff  --git a/mlir/test/Dialect/Transform/multi-arg-top-level-params.mlir b/mlir/test/Dialect/Transform/multi-arg-top-level-params.mlir
index f5d7f8f595f1d..ab2873ba9dcd1 100644
--- a/mlir/test/Dialect/Transform/multi-arg-top-level-params.mlir
+++ b/mlir/test/Dialect/Transform/multi-arg-top-level-params.mlir
@@ -2,7 +2,7 @@
 // RUN:          --split-input-file --verify-diagnostics
 
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation, %arg1: !transform.param<i64>, %arg2: !transform.param<i64>):
+^bb0(%arg0: !transform.any_op, %arg1: !transform.param<i64>, %arg2: !transform.param<i64>):
   // expected-remark @below {{1 : i64, 2 : i64, 3 : i64}}
   transform.test_print_param %arg1 : !transform.param<i64>
   // expected-remark @below {{42 : i64, 45 : i64}}
@@ -12,7 +12,7 @@ transform.sequence failures(propagate) {
 // -----
 
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation, %arg1: !transform.any_op, %arg2: !transform.param<i64>):
+^bb0(%arg0: !transform.any_op, %arg1: !transform.any_op, %arg2: !transform.param<i64>):
   // expected-error @above {{wrong kind of value provided for top-level operation handle}}
 }
 
@@ -20,5 +20,5 @@ transform.sequence failures(propagate) {
 
 // expected-error @below {{operation expects 3 extra value bindings, but 2 were provided to the interpreter}}
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation, %arg1: !transform.param<i64>, %arg2: !transform.param<i64>, %arg3: !transform.param<i64>):
+^bb0(%arg0: !transform.any_op, %arg1: !transform.param<i64>, %arg2: !transform.param<i64>, %arg3: !transform.param<i64>):
 }

diff  --git a/mlir/test/Dialect/Transform/ops-invalid.mlir b/mlir/test/Dialect/Transform/ops-invalid.mlir
index 988743e93ef5c..74c101f79075a 100644
--- a/mlir/test/Dialect/Transform/ops-invalid.mlir
+++ b/mlir/test/Dialect/Transform/ops-invalid.mlir
@@ -15,10 +15,10 @@ transform.sequence failures(propagate) {
 
 // expected-note @below {{nested in another possible top-level op}}
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   // expected-error @below {{expects operands to be provided for a nested op}}
   transform.sequence failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
+  ^bb1(%arg1: !transform.any_op):
   }
 }
 
@@ -34,7 +34,7 @@ transform.sequence failures(propagate) {
 
 // expected-error @below {{expected children ops to implement TransformOpInterface}}
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   // expected-note @below {{op without interface}}
   arith.constant 42.0 : f32
 }
@@ -42,8 +42,8 @@ transform.sequence failures(propagate) {
 // -----
 
 // expected-error @below {{expects the types of the terminator operands to match the types of the result}}
-%0 = transform.sequence -> !pdl.operation failures(propagate) {
-^bb0(%arg0: !pdl.operation):
+%0 = transform.sequence -> !transform.any_op failures(propagate) {
+^bb0(%arg0: !transform.any_op):
   // expected-note @below {{terminator}}
   transform.yield
 }
@@ -54,7 +54,7 @@ transform.sequence failures(propagate) {
 ^bb0(%arg0: !transform.any_op):
   // expected-error @below {{expects the type of the block argument to match the type of the operand}}
   transform.sequence %arg0: !transform.any_op failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
+  ^bb1(%arg1: !transform.op<"builtin.module">):
     transform.yield
   }
 }
@@ -82,10 +82,10 @@ transform.sequence failures(propagate) {
 
 // expected-note @below {{nested in another possible top-level op}}
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   // expected-error @below {{expects operands to be provided for a nested op}}
   transform.sequence failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
+  ^bb1(%arg1: !transform.any_op):
   }
 }
 
@@ -93,14 +93,14 @@ transform.with_pdl_patterns {
 
 // expected-error @below {{expects only one non-pattern op in its body}}
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   // expected-note @below {{first non-pattern op}}
   transform.sequence failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
+  ^bb1(%arg1: !transform.any_op):
   }
   // expected-note @below {{second non-pattern op}}
   transform.sequence failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
+  ^bb1(%arg1: !transform.any_op):
   }
 }
 
@@ -108,7 +108,7 @@ transform.with_pdl_patterns {
 
 // expected-error @below {{expects only pattern and top-level transform ops in its body}}
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   // expected-note @below {{offending op}}
   "test.something"() : () -> ()
 }
@@ -117,10 +117,10 @@ transform.with_pdl_patterns {
 
 // expected-note @below {{parent operation}}
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
    // expected-error @below {{op cannot be nested}}
-  transform.with_pdl_patterns %arg0 : !pdl.operation {
-  ^bb1(%arg1: !pdl.operation):
+  transform.with_pdl_patterns %arg0 : !transform.any_op {
+  ^bb1(%arg1: !transform.any_op):
   }
 }
 
@@ -128,7 +128,7 @@ transform.with_pdl_patterns {
 
 // expected-error @below {{op expects at least one non-pattern op}}
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   pdl.pattern @some : benefit(1) {
     %0 = pdl.operation "test.foo"
     pdl.rewrite %0 with "transform.dialect"
@@ -138,10 +138,10 @@ transform.with_pdl_patterns {
 // -----
 
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   // expected-error @below {{op expects at least one non-pattern op}}
-  with_pdl_patterns %arg0 : !pdl.operation {
-  ^bb1(%arg1: !pdl.operation):
+  with_pdl_patterns %arg0 : !transform.any_op {
+  ^bb1(%arg1: !transform.any_op):
   }
 }
 
@@ -155,7 +155,7 @@ transform.sequence failures(propagate) {
 
 // expected-error @below {{expects a single-block region}}
 "transform.test_transform_unrestricted_op_no_interface"() ({
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   "test.potential_terminator"() : () -> ()
 ^bb1:
   "test.potential_terminator"() : () -> ()
@@ -164,59 +164,59 @@ transform.sequence failures(propagate) {
 // -----
 
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   // expected-error @below {{result #0 has more than one potential consumer}}
-  %0 = test_produce_self_handle_or_forward_operand
+  %0 = test_produce_self_handle_or_forward_operand : () -> !transform.any_op
   // expected-note @below {{used here as operand #0}}
-  test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand"
+  test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand" : !transform.any_op
   // expected-note @below {{used here as operand #0}}
-  test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand"
+  test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand" : !transform.any_op
 }
 
 // -----
 
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   // expected-error @below {{result #0 has more than one potential consumer}}
-  %0 = test_produce_self_handle_or_forward_operand
+  %0 = test_produce_self_handle_or_forward_operand : () -> !transform.any_op
   // expected-note @below {{used here as operand #0}}
-  test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand"
+  test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand" : !transform.any_op
   // expected-note @below {{used here as operand #0}}
-  transform.sequence %0 : !pdl.operation failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
-    test_consume_operand_of_op_kind_or_fail %arg1, "transform.test_produce_self_handle_or_forward_operand"
+  transform.sequence %0 : !transform.any_op failures(propagate) {
+  ^bb1(%arg1: !transform.any_op):
+    test_consume_operand_of_op_kind_or_fail %arg1, "transform.test_produce_self_handle_or_forward_operand" : !transform.any_op
   }
 }
 
 // -----
 
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   // expected-error @below {{result #0 has more than one potential consumer}}
-  %0 = test_produce_self_handle_or_forward_operand
+  %0 = test_produce_self_handle_or_forward_operand : () -> !transform.any_op
   // expected-note @below {{used here as operand #0}}
-  test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand"
-  transform.sequence %0 : !pdl.operation failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
+  test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand" : !transform.any_op
+  transform.sequence %0 : !transform.any_op failures(propagate) {
+  ^bb1(%arg1: !transform.any_op):
     // expected-note @below {{used here as operand #0}}
-    test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand"
+    test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand" : !transform.any_op
   }
 }
 
 // -----
 
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   // expected-error @below {{result #0 has more than one potential consumer}}
-  %0 = test_produce_self_handle_or_forward_operand
+  %0 = test_produce_self_handle_or_forward_operand : () -> !transform.any_op
   // expected-note @below {{used here as operand #0}}
-  test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand"
+  test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand" : !transform.any_op
   // expected-note @below {{used here as operand #0}}
-  transform.sequence %0 : !pdl.operation failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
-    transform.sequence %arg1 : !pdl.operation failures(propagate) {
-    ^bb2(%arg2: !pdl.operation):
-      test_consume_operand_of_op_kind_or_fail %arg2, "transform.test_produce_self_handle_or_forward_operand"
+  transform.sequence %0 : !transform.any_op failures(propagate) {
+  ^bb1(%arg1: !transform.any_op):
+    transform.sequence %arg1 : !transform.any_op failures(propagate) {
+    ^bb2(%arg2: !transform.any_op):
+      test_consume_operand_of_op_kind_or_fail %arg2, "transform.test_produce_self_handle_or_forward_operand" : !transform.any_op
     }
   }
 }
@@ -224,7 +224,7 @@ transform.sequence failures(propagate) {
 // -----
 
 transform.sequence failures(propagate) {
-^bb1(%arg1: !pdl.operation):
+^bb1(%arg1: !transform.any_op):
   // expected-error @below {{expects at least one region}}
   transform.alternatives
 }
@@ -232,13 +232,13 @@ transform.sequence failures(propagate) {
 // -----
 
 transform.sequence failures(propagate) {
-^bb1(%arg1: !pdl.operation):
+^bb1(%arg1: !transform.any_op):
   // expected-error @below {{expects terminator operands to have the same type as results of the operation}}
-  %2 = transform.alternatives %arg1 : !pdl.operation -> !pdl.operation {
-  ^bb2(%arg2: !pdl.operation):
-    transform.yield %arg2 : !pdl.operation
+  %2 = transform.alternatives %arg1 : !transform.any_op -> !transform.any_op {
+  ^bb2(%arg2: !transform.any_op):
+    transform.yield %arg2 : !transform.any_op
   }, {
-  ^bb2(%arg2: !pdl.operation):
+  ^bb2(%arg2: !transform.any_op):
     // expected-note @below {{terminator}}
     transform.yield
   }
@@ -255,16 +255,16 @@ transform.alternatives {
 // -----
 
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   // expected-error @below {{result #0 has more than one potential consumer}}
-  %0 = test_produce_self_handle_or_forward_operand
+  %0 = test_produce_self_handle_or_forward_operand : () -> !transform.any_op
   // expected-note @below {{used here as operand #0}}
-  transform.foreach %0 : !pdl.operation {
-  ^bb1(%arg1: !pdl.operation):
-    transform.test_consume_operand %arg1 : !pdl.operation
+  transform.foreach %0 : !transform.any_op {
+  ^bb1(%arg1: !transform.any_op):
+    transform.test_consume_operand %arg1 : !transform.any_op
   }
   // expected-note @below {{used here as operand #0}}
-  transform.test_consume_operand %0 : !pdl.operation
+  transform.test_consume_operand %0 : !transform.any_op
 }
 
 // -----

diff  --git a/mlir/test/Dialect/Transform/ops.mlir b/mlir/test/Dialect/Transform/ops.mlir
index 0a2687da2049d..b85df428f5a8d 100644
--- a/mlir/test/Dialect/Transform/ops.mlir
+++ b/mlir/test/Dialect/Transform/ops.mlir
@@ -1,42 +1,42 @@
 // RUN: mlir-opt %s | mlir-opt | FileCheck %s
 
 // CHECK: transform.sequence
-// CHECK: ^{{.+}}(%{{.+}}: !pdl.operation):
+// CHECK: ^{{.+}}(%{{.+}}: !transform.any_op):
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation):
-  // CHECK: sequence %{{.+}} : !pdl.operation
-  // CHECK: ^{{.+}}(%{{.+}}: !pdl.operation):
-  sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
+  // CHECK: sequence %{{.+}} : !transform.any_op
+  // CHECK: ^{{.+}}(%{{.+}}: !transform.any_op):
+  sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb1(%arg1: !transform.any_op):
   }
 }
 
 // CHECK: transform.with_pdl_patterns
-// CHECK: ^{{.+}}(%[[ARG:.+]]: !pdl.operation):
+// CHECK: ^{{.+}}(%[[ARG:.+]]: !transform.any_op):
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
-  // CHECK: sequence %[[ARG]] : !pdl.operation
-  sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
+  // CHECK: sequence %[[ARG]] : !transform.any_op
+  sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb1(%arg1: !transform.any_op):
   }
 }
 
 // Using the same value multiple times without consuming it is fine.
 // CHECK: transform.sequence
-// CHECK: %[[V:.+]] = sequence %{{.*}} : !pdl.operation -> !pdl.operation
+// CHECK: %[[V:.+]] = sequence %{{.*}} : !transform.any_op -> !transform.any_op
 // CHECK: sequence %[[V]]
 // CHECK: sequence %[[V]]
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation):
-  %0 = transform.sequence %arg0 : !pdl.operation -> !pdl.operation failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
-    yield %arg1 : !pdl.operation
+^bb0(%arg0: !transform.any_op):
+  %0 = transform.sequence %arg0 : !transform.any_op -> !transform.any_op failures(propagate) {
+  ^bb1(%arg1: !transform.any_op):
+    yield %arg1 : !transform.any_op
   }
-  transform.sequence %0 : !pdl.operation failures(propagate) {
-  ^bb2(%arg2: !pdl.operation):
+  transform.sequence %0 : !transform.any_op failures(propagate) {
+  ^bb2(%arg2: !transform.any_op):
   }
-  transform.sequence %0 : !pdl.operation failures(propagate) {
-  ^bb3(%arg3: !pdl.operation):
+  transform.sequence %0 : !transform.any_op failures(propagate) {
+  ^bb3(%arg3: !transform.any_op):
   }
 }
 
@@ -70,17 +70,17 @@ transform.sequence failures(propagate) {
 // CHECK: transform.sequence
 // CHECK: foreach
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation):
-  transform.foreach %arg0 : !pdl.operation {
-  ^bb1(%arg1: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
+  transform.foreach %arg0 : !transform.any_op {
+  ^bb1(%arg1: !transform.any_op):
   }
 }
 
 // CHECK: transform.sequence
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation):
-  // CHECK: cast %{{.*}} : !pdl.operation to !transform.any_op
-  %0 = cast %arg0: !pdl.operation to !transform.any_op
+^bb0(%arg0: !transform.any_op):
+  // CHECK: cast %{{.*}} : !transform.any_op to !transform.any_op
+  %0 = cast %arg0: !transform.any_op to !transform.any_op
   // CHECK: cast %{{.*}} : !transform.any_op to !transform.op<"builtin.module">
   %1 = cast %0: !transform.any_op to !transform.op<"builtin.module">
 }
@@ -91,9 +91,9 @@ transform.sequence failures(propagate) {
 // CHECK: print
 // CHECK: print
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation):
-  transform.print %arg0 : !pdl.operation
+^bb0(%arg0: !transform.any_op):
+  transform.print %arg0 : !transform.any_op
   transform.print
-  transform.print %arg0 {name = "test"} : !pdl.operation
+  transform.print %arg0 {name = "test"} : !transform.any_op
   transform.print {name = "test"}
 }

diff  --git a/mlir/test/Dialect/Transform/test-dialect-injection.mlir b/mlir/test/Dialect/Transform/test-dialect-injection.mlir
index 5bbda8e1fe991..400ee8e6c7b8b 100644
--- a/mlir/test/Dialect/Transform/test-dialect-injection.mlir
+++ b/mlir/test/Dialect/Transform/test-dialect-injection.mlir
@@ -7,11 +7,11 @@
 transform.test_transform_op
 
 // CHECK: = transform.test_produce_self_handle_or_forward_operand {foo = "bar"}
-%0 = transform.test_produce_self_handle_or_forward_operand { foo = "bar" }
+%0 = transform.test_produce_self_handle_or_forward_operand { foo = "bar" } : () -> !transform.any_op
 
 // CHECK: transform.test_consume_operand_of_op_kind_or_fail %{{.*}},
-transform.test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand"
+transform.test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand" : !transform.any_op
 
 // Ensure that the extension type is roundtripped correctly.
-// CHECK: transform.cast %{{.*}} : !pdl.operation to !transform.test_dialect_op
-%1 = transform.cast %0: !pdl.operation to !transform.test_dialect_op
+// CHECK: transform.cast %{{.*}} : !transform.any_op to !transform.test_dialect_op
+%1 = transform.cast %0: !transform.any_op to !transform.test_dialect_op

diff  --git a/mlir/test/Dialect/Transform/test-interpreter.mlir b/mlir/test/Dialect/Transform/test-interpreter.mlir
index bb56bcdd239d0..22a06de393e94 100644
--- a/mlir/test/Dialect/Transform/test-interpreter.mlir
+++ b/mlir/test/Dialect/Transform/test-interpreter.mlir
@@ -10,18 +10,18 @@ transform.sequence failures(propagate) {
 
 transform.sequence failures(propagate) {
 ^bb0(%arg0: !transform.any_op):
-  %0 = transform.test_produce_self_handle_or_forward_operand { foo = "bar" }
+  %0 = transform.test_produce_self_handle_or_forward_operand { foo = "bar" } : () -> !transform.any_op
   // expected-remark @below {{succeeded}}
-  transform.test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand"
+  transform.test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand" : !transform.any_op
 }
 
 // -----
 
 transform.sequence failures(propagate) {
 ^bb0(%arg0: !transform.any_op):
-  %0 = transform.test_produce_self_handle_or_forward_operand { foo = "bar" }
+  %0 = transform.test_produce_self_handle_or_forward_operand { foo = "bar" } : () -> !transform.any_op
   // expected-error @below {{expected the operand to be associated a payload op of kind transform.sequence got transform.test_produce_self_handle_or_forward_operand}}
-  transform.test_consume_operand_of_op_kind_or_fail %0, "transform.sequence"
+  transform.test_consume_operand_of_op_kind_or_fail %0, "transform.sequence" : !transform.any_op
 }
 
 // -----
@@ -31,18 +31,18 @@ transform.sequence failures(propagate) {
 // to detect double-consumption.
 transform.sequence failures(propagate) {
 ^bb0(%arg0: !transform.any_op):
-  %0 = transform.test_produce_self_handle_or_forward_operand { foo = "bar" }
-  %1 = transform.test_copy_payload %0
+  %0 = transform.test_produce_self_handle_or_forward_operand { foo = "bar" } : () -> !transform.any_op
+  %1 = transform.test_copy_payload %0 : (!transform.any_op) -> !transform.any_op
   // expected-remark @below {{succeeded}}
-  transform.test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand"
+  transform.test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand" : !transform.any_op
 }
 
 // -----
 
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation):
-  sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb0(%arg1: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
+  sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb0(%arg1: !transform.any_op):
     // expected-remark @below {{applying transformation "a"}}
     test_transform_op "a"
     // expected-remark @below {{applying transformation "b"}}
@@ -59,36 +59,36 @@ transform.sequence failures(propagate) {
 // -----
 
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation):
-  %0 = test_produce_self_handle_or_forward_operand
-  sequence %0 : !pdl.operation failures(propagate) {
-  ^bb0(%arg1: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
+  %0 = test_produce_self_handle_or_forward_operand : () -> !transform.any_op
+  sequence %0 : !transform.any_op failures(propagate) {
+  ^bb0(%arg1: !transform.any_op):
     // expected-remark @below {{succeeded}}
-    test_consume_operand_of_op_kind_or_fail %arg1, "transform.test_produce_self_handle_or_forward_operand"
+    test_consume_operand_of_op_kind_or_fail %arg1, "transform.test_produce_self_handle_or_forward_operand" : !transform.any_op
   }
 }
 
 // -----
 
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation):
-  %0 = sequence %arg0 : !pdl.operation -> !pdl.operation failures(propagate) {
-  ^bb0(%arg1: !pdl.operation):
-    %1 = test_produce_self_handle_or_forward_operand
-    yield %1 : !pdl.operation
+^bb0(%arg0: !transform.any_op):
+  %0 = sequence %arg0 : !transform.any_op -> !transform.any_op failures(propagate) {
+  ^bb0(%arg1: !transform.any_op):
+    %1 = test_produce_self_handle_or_forward_operand : () -> !transform.any_op
+    yield %1 : !transform.any_op
   }
   // expected-remark @below {{succeeded}}
-  test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand"
+  test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand" : !transform.any_op
 }
 
 // -----
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
-  sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb0(%arg1: !pdl.operation):
-    %0 = pdl_match @some in %arg1 : (!pdl.operation) -> !pdl.operation
-    test_print_remark_at_operand %0, "matched" : !pdl.operation
+^bb0(%arg0: !transform.any_op):
+  sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb0(%arg1: !transform.any_op):
+    %0 = pdl_match @some in %arg1 : (!transform.any_op) -> !transform.any_op
+    test_print_remark_at_operand %0, "matched" : !transform.any_op
   }
 
   pdl.pattern @some : benefit(1) {
@@ -124,18 +124,18 @@ func.func @bar() {
 }
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   pdl.pattern @const : benefit(1) {
     %r = pdl.types
     %0 = pdl.operation "arith.constant" -> (%r : !pdl.range<type>)
     pdl.rewrite %0 with "transform.dialect"
   }
 
-  transform.sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
-    %f = pdl_match @const in %arg1 : (!pdl.operation) -> !pdl.operation
-    %m = get_closest_isolated_parent %f : (!pdl.operation) -> !pdl.operation
-    test_print_remark_at_operand %m, "parent function" : !pdl.operation
+  transform.sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb1(%arg1: !transform.any_op):
+    %f = pdl_match @const in %arg1 : (!transform.any_op) -> !transform.any_op
+    %m = get_closest_isolated_parent %f : (!transform.any_op) -> !transform.any_op
+    test_print_remark_at_operand %m, "parent function" : !transform.any_op
   }
 }
 
@@ -147,7 +147,7 @@ func.func @foo() {
 }
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   pdl.pattern @match_func : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
@@ -155,22 +155,22 @@ transform.with_pdl_patterns {
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
+  transform.sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb1(%arg1: !transform.any_op):
     // This is necessary to run the transformation on something other than the
     // top-level module, "alternatives" cannot be run on that.
-    %0 = pdl_match @match_func in %arg1 : (!pdl.operation) -> !pdl.operation
-    transform.alternatives %0 : !pdl.operation {
-    ^bb2(%arg2: !pdl.operation):
-      %1 = transform.test_produce_self_handle_or_forward_operand
+    %0 = pdl_match @match_func in %arg1 : (!transform.any_op) -> !transform.any_op
+    transform.alternatives %0 : !transform.any_op {
+    ^bb2(%arg2: !transform.any_op):
+      %1 = transform.test_produce_self_handle_or_forward_operand : () -> !transform.any_op
       // This operation fails, which triggers the next alternative without
       // reporting the error.
-      transform.test_consume_operand_of_op_kind_or_fail %1, "transform.sequence"
+      transform.test_consume_operand_of_op_kind_or_fail %1, "transform.sequence" : !transform.any_op
     }, {
-    ^bb2(%arg2: !pdl.operation):
-      %1 = transform.test_produce_self_handle_or_forward_operand
+    ^bb2(%arg2: !transform.any_op):
+      %1 = transform.test_produce_self_handle_or_forward_operand : () -> !transform.any_op
       // expected-remark @below {{succeeded}}
-      transform.test_consume_operand_of_op_kind_or_fail %1, "transform.test_produce_self_handle_or_forward_operand"
+      transform.test_consume_operand_of_op_kind_or_fail %1, "transform.test_produce_self_handle_or_forward_operand" : !transform.any_op
     }
   }
 }
@@ -185,7 +185,7 @@ func.func @foo() {
 }
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   pdl.pattern @match_call : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
@@ -193,16 +193,16 @@ transform.with_pdl_patterns {
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
-    %0 = pdl_match @match_call in %arg1 : (!pdl.operation) -> !pdl.operation
-    %1 = get_closest_isolated_parent %0 : (!pdl.operation) -> !pdl.operation
+  transform.sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb1(%arg1: !transform.any_op):
+    %0 = pdl_match @match_call in %arg1 : (!transform.any_op) -> !transform.any_op
+    %1 = get_closest_isolated_parent %0 : (!transform.any_op) -> !transform.any_op
     // expected-error @below {{all alternatives failed}}
-    transform.alternatives %1 : !pdl.operation {
-    ^bb2(%arg2: !pdl.operation):
-      %2 = transform.pdl_match @match_call in %arg2 : (!pdl.operation) -> !pdl.operation
+    transform.alternatives %1 : !transform.any_op {
+    ^bb2(%arg2: !transform.any_op):
+      %2 = transform.pdl_match @match_call in %arg2 : (!transform.any_op) -> !transform.any_op
       // expected-remark @below {{applying}}
-      transform.test_emit_remark_and_erase_operand %2, "applying" {fail_after_erase}
+      transform.test_emit_remark_and_erase_operand %2, "applying" {fail_after_erase} : !transform.any_op
     }
   }
 }
@@ -218,7 +218,7 @@ func.func @foo() {
 }
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   pdl.pattern @match_call : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
@@ -226,25 +226,25 @@ transform.with_pdl_patterns {
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
-    %0 = pdl_match @match_call in %arg1 : (!pdl.operation) -> !pdl.operation
-    %1 = get_closest_isolated_parent %0 : (!pdl.operation) -> !pdl.operation
-    transform.alternatives %1 : !pdl.operation {
-    ^bb2(%arg2: !pdl.operation):
-      %2 = transform.pdl_match @match_call in %arg2 : (!pdl.operation) -> !pdl.operation
+  transform.sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb1(%arg1: !transform.any_op):
+    %0 = pdl_match @match_call in %arg1 : (!transform.any_op) -> !transform.any_op
+    %1 = get_closest_isolated_parent %0 : (!transform.any_op) -> !transform.any_op
+    transform.alternatives %1 : !transform.any_op {
+    ^bb2(%arg2: !transform.any_op):
+      %2 = transform.pdl_match @match_call in %arg2 : (!transform.any_op) -> !transform.any_op
       // expected-remark @below {{applying}}
-      transform.test_emit_remark_and_erase_operand %2, "applying" {fail_after_erase}
+      transform.test_emit_remark_and_erase_operand %2, "applying" {fail_after_erase} : !transform.any_op
     }, {
-    ^bb2(%arg2: !pdl.operation):
-      %2 = transform.pdl_match @match_call in %arg2 : (!pdl.operation) -> !pdl.operation
-      transform.test_print_remark_at_operand %2, "still here" : !pdl.operation
+    ^bb2(%arg2: !transform.any_op):
+      %2 = transform.pdl_match @match_call in %arg2 : (!transform.any_op) -> !transform.any_op
+      transform.test_print_remark_at_operand %2, "still here" : !transform.any_op
       // This alternative succeeds.
     }, {
-    ^bb2(%arg2: !pdl.operation):
+    ^bb2(%arg2: !transform.any_op):
       // This alternative is never run, so we must not have a remark here.
-      %2 = transform.pdl_match @match_call in %arg2 : (!pdl.operation) -> !pdl.operation
-      transform.test_emit_remark_and_erase_operand %2, "should not happen" {fail_after_erase}
+      %2 = transform.pdl_match @match_call in %arg2 : (!transform.any_op) -> !transform.any_op
+      transform.test_emit_remark_and_erase_operand %2, "should not happen" {fail_after_erase} : !transform.any_op
     }
   }
 }
@@ -259,7 +259,7 @@ func.func @erase_call() {
 }
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   pdl.pattern @match_call : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
@@ -267,20 +267,20 @@ transform.with_pdl_patterns {
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
-    %0 = pdl_match @match_call in %arg1 : (!pdl.operation) -> !pdl.operation
-    %1 = get_closest_isolated_parent %0 : (!pdl.operation) -> !pdl.operation
-    transform.alternatives %1 : !pdl.operation {
-    ^bb2(%arg2: !pdl.operation):
-      %2 = transform.pdl_match @match_call in %arg2 : (!pdl.operation) -> !pdl.operation
+  transform.sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb1(%arg1: !transform.any_op):
+    %0 = pdl_match @match_call in %arg1 : (!transform.any_op) -> !transform.any_op
+    %1 = get_closest_isolated_parent %0 : (!transform.any_op) -> !transform.any_op
+    transform.alternatives %1 : !transform.any_op {
+    ^bb2(%arg2: !transform.any_op):
+      %2 = transform.pdl_match @match_call in %arg2 : (!transform.any_op) -> !transform.any_op
       // expected-remark @below {{applying}}
-      transform.test_emit_remark_and_erase_operand %2, "applying" {fail_after_erase}
+      transform.test_emit_remark_and_erase_operand %2, "applying" {fail_after_erase} : !transform.any_op
     }, {
-    ^bb2(%arg2: !pdl.operation):
-      %2 = transform.pdl_match @match_call in %arg2 : (!pdl.operation) -> !pdl.operation
+    ^bb2(%arg2: !transform.any_op):
+      %2 = transform.pdl_match @match_call in %arg2 : (!transform.any_op) -> !transform.any_op
       // expected-remark @below {{applying second time}}
-      transform.test_emit_remark_and_erase_operand %2, "applying second time"
+      transform.test_emit_remark_and_erase_operand %2, "applying second time" : !transform.any_op
     }
   }
 }
@@ -295,7 +295,7 @@ func.func @foo() {
 }
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   pdl.pattern @match_call : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
@@ -303,27 +303,27 @@ transform.with_pdl_patterns {
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
-    %0 = pdl_match @match_call in %arg1 : (!pdl.operation) -> !pdl.operation
-    %1 = get_closest_isolated_parent %0 : (!pdl.operation) -> !pdl.operation
-    %2 = transform.alternatives %1 : !pdl.operation -> !pdl.operation {
-    ^bb2(%arg2: !pdl.operation):
-      %3 = transform.pdl_match @match_call in %arg2 : (!pdl.operation) -> !pdl.operation
+  transform.sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb1(%arg1: !transform.any_op):
+    %0 = pdl_match @match_call in %arg1 : (!transform.any_op) -> !transform.any_op
+    %1 = get_closest_isolated_parent %0 : (!transform.any_op) -> !transform.any_op
+    %2 = transform.alternatives %1 : !transform.any_op -> !transform.any_op {
+    ^bb2(%arg2: !transform.any_op):
+      %3 = transform.pdl_match @match_call in %arg2 : (!transform.any_op) -> !transform.any_op
       // expected-remark @below {{applying}}
-      transform.test_emit_remark_and_erase_operand %3, "applying" {fail_after_erase}
-      %4 = transform.test_produce_self_handle_or_forward_operand %3
-      transform.yield %4 : !pdl.operation
+      transform.test_emit_remark_and_erase_operand %3, "applying" {fail_after_erase} : !transform.any_op
+      %4 = transform.test_produce_self_handle_or_forward_operand %3 : (!transform.any_op) -> !transform.any_op
+      transform.yield %4 : !transform.any_op
     }, {
-    ^bb2(%arg2: !pdl.operation):
-      %4 = transform.test_produce_self_handle_or_forward_operand
-      transform.yield %4 : !pdl.operation
+    ^bb2(%arg2: !transform.any_op):
+      %4 = transform.test_produce_self_handle_or_forward_operand : () -> !transform.any_op
+      transform.yield %4 : !transform.any_op
     }
     // The first alternative failed, so the returned value is taken from the
     // second alternative, associated test_produce_self_handle_or_forward_operand rather
     // than pdl_match.
     // expected-remark @below {{succeeded}}
-    transform.test_consume_operand_of_op_kind_or_fail %2, "transform.test_produce_self_handle_or_forward_operand"
+    transform.test_consume_operand_of_op_kind_or_fail %2, "transform.test_produce_self_handle_or_forward_operand" : !transform.any_op
   }
 }
 
@@ -343,16 +343,16 @@ module {
   }
 
   transform.sequence failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
+  ^bb1(%arg1: !transform.any_op):
     // expected-error @below {{scope must not contain the transforms being applied}}
-    transform.alternatives %arg1 : !pdl.operation {
-    ^bb2(%arg2: !pdl.operation):
-      %0 = transform.test_produce_self_handle_or_forward_operand
-      transform.test_consume_operand_of_op_kind_or_fail %0, "transform.sequence"
+    transform.alternatives %arg1 : !transform.any_op {
+    ^bb2(%arg2: !transform.any_op):
+      %0 = transform.test_produce_self_handle_or_forward_operand : () -> !transform.any_op
+      transform.test_consume_operand_of_op_kind_or_fail %0, "transform.sequence" : !transform.any_op
     }, {
-    ^bb2(%arg2: !pdl.operation):
-      %0 = transform.test_produce_self_handle_or_forward_operand
-      transform.test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand"
+    ^bb2(%arg2: !transform.any_op):
+      %0 = transform.test_produce_self_handle_or_forward_operand : () -> !transform.any_op
+      transform.test_consume_operand_of_op_kind_or_fail %0, "transform.test_produce_self_handle_or_forward_operand" : !transform.any_op
     }
   }
 }
@@ -368,7 +368,7 @@ func.func @foo(%arg0: index, %arg1: index, %arg2: index) {
 }
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   pdl.pattern @match_const : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
@@ -377,13 +377,13 @@ transform.with_pdl_patterns {
   }
 
 
-  sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
-    %0 = transform.pdl_match @match_const in %arg1 : (!pdl.operation) -> !pdl.operation
-    %1 = transform.loop.get_parent_for %0 : (!pdl.operation) -> !pdl.operation
+  sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb1(%arg1: !transform.any_op):
+    %0 = transform.pdl_match @match_const in %arg1 : (!transform.any_op) -> !transform.any_op
+    %1 = transform.loop.get_parent_for %0 : (!transform.any_op) -> !transform.any_op
     // expected-error @below {{only isolated-from-above ops can be alternative scopes}}
-    alternatives %1 : !pdl.operation {
-    ^bb2(%arg2: !pdl.operation):
+    alternatives %1 : !transform.any_op {
+    ^bb2(%arg2: !transform.any_op):
     }
   }
 }
@@ -396,7 +396,7 @@ func.func @foo() {
 }
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   pdl.pattern @some : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
@@ -404,12 +404,12 @@ transform.with_pdl_patterns {
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb0(%arg1: !pdl.operation):
-    %0 = pdl_match @some in %arg1 : (!pdl.operation) -> !pdl.operation
+  transform.sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb0(%arg1: !transform.any_op):
+    %0 = pdl_match @some in %arg1 : (!transform.any_op) -> !transform.any_op
     // expected-error @below {{application of transform.test_wrong_number_of_results expected to produce 3 results (actually produced 1).}}
     // expected-note @below {{if you need variadic results, consider a generic `apply` instead of the specialized `applyToOne`.}}
-    transform.test_wrong_number_of_results %0
+    transform.test_wrong_number_of_results %0 : (!transform.any_op) -> (!transform.any_op, !transform.any_op, !transform.any_op)
   }
 }
 
@@ -423,7 +423,7 @@ func.func @foo() {
 }
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   pdl.pattern @some : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
@@ -431,12 +431,12 @@ transform.with_pdl_patterns {
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb0(%arg1: !pdl.operation):
-    %0 = pdl_match @some in %arg1 : (!pdl.operation) -> !pdl.operation
+  transform.sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb0(%arg1: !transform.any_op):
+    %0 = pdl_match @some in %arg1 : (!transform.any_op) -> !transform.any_op
     // expected-error @below {{application of transform.test_wrong_number_of_multi_results expected to produce 1 results (actually produced 0)}}
     // expected-note @below {{if you need variadic results, consider a generic `apply` instead of the specialized `applyToOne`.}}
-    transform.test_wrong_number_of_multi_results %0
+    transform.test_wrong_number_of_multi_results %0 : (!transform.any_op) -> (!transform.any_op)
   }
 }
 
@@ -450,7 +450,7 @@ func.func @foo() {
 }
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   pdl.pattern @some : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
@@ -458,11 +458,11 @@ transform.with_pdl_patterns {
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb0(%arg1: !pdl.operation):
-    %0 = pdl_match @some in %arg1 : (!pdl.operation) -> !pdl.operation
+  transform.sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb0(%arg1: !transform.any_op):
+    %0 = pdl_match @some in %arg1 : (!transform.any_op) -> !transform.any_op
     // Transform matches 3 ops and produces 2 results.
-    %1:2 = transform.test_correct_number_of_multi_results %0
+    %1:2 = transform.test_correct_number_of_multi_results %0 : (!transform.any_op) -> (!transform.any_op, !transform.any_op)
   }
 }
 
@@ -474,7 +474,7 @@ func.func @foo() {
 }
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   pdl.pattern @some : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
@@ -482,11 +482,11 @@ transform.with_pdl_patterns {
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb0(%arg1: !pdl.operation):
-    %0 = pdl_match @some in %arg1 : (!pdl.operation) -> !pdl.operation
+  transform.sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb0(%arg1: !transform.any_op):
+    %0 = pdl_match @some in %arg1 : (!transform.any_op) -> !transform.any_op
     // Transform fails to match any but still produces 2 results.
-    %1:2 = transform.test_correct_number_of_multi_results %0
+    %1:2 = transform.test_correct_number_of_multi_results %0 : (!transform.any_op) -> (!transform.any_op, !transform.any_op)
   }
 }
 
@@ -500,7 +500,7 @@ func.func @foo() {
 }
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   pdl.pattern @some : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
@@ -508,10 +508,10 @@ transform.with_pdl_patterns {
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb0(%arg1: !pdl.operation):
-    %0 = pdl_match @some in %arg1 : (!pdl.operation) -> !pdl.operation
-    transform.test_mixed_null_and_non_null_results %0
+  transform.sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb0(%arg1: !transform.any_op):
+    %0 = pdl_match @some in %arg1 : (!transform.any_op) -> !transform.any_op
+    transform.test_mixed_null_and_non_null_results %0 : (!transform.any_op) -> (!transform.any_op, !transform.any_op)
   }
 }
 
@@ -530,7 +530,7 @@ func.func @foo(%arg0: index) {
 }
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   pdl.pattern @addi : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
@@ -544,12 +544,12 @@ transform.with_pdl_patterns {
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb0(%arg1: !pdl.operation):
-    %0 = pdl_match @addi in %arg1 : (!pdl.operation) -> !pdl.operation
-    %1 = pdl_match @subi in %arg1 : (!pdl.operation) -> !pdl.operation
-    %2 = merge_handles %0, %1 : !pdl.operation
-    test_print_remark_at_operand %2, "matched" : !pdl.operation
+  transform.sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb0(%arg1: !transform.any_op):
+    %0 = pdl_match @addi in %arg1 : (!transform.any_op) -> !transform.any_op
+    %1 = pdl_match @subi in %arg1 : (!transform.any_op) -> !transform.any_op
+    %2 = merge_handles %0, %1 : !transform.any_op
+    test_print_remark_at_operand %2, "matched" : !transform.any_op
   }
 }
 
@@ -563,7 +563,7 @@ func.func @foo() {
 }
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   pdl.pattern @some : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
@@ -571,11 +571,11 @@ transform.with_pdl_patterns {
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb0(%arg1: !pdl.operation):
-    %0 = pdl_match @some in %arg1 : (!pdl.operation) -> !pdl.operation
+  transform.sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb0(%arg1: !transform.any_op):
+    %0 = pdl_match @some in %arg1 : (!transform.any_op) -> !transform.any_op
     // expected-error @below {{failed to apply}}
-    transform.test_mixed_sucess_and_silenceable %0
+    transform.test_mixed_success_and_silenceable %0 : !transform.any_op
   }
 }
 
@@ -587,7 +587,7 @@ func.func @foo() {
 }
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   pdl.pattern @some : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
@@ -595,12 +595,12 @@ transform.with_pdl_patterns {
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 : !pdl.operation failures(suppress) {
-  ^bb0(%arg1: !pdl.operation):
-    %0 = pdl_match @some in %arg1 : (!pdl.operation) -> !pdl.operation
+  transform.sequence %arg0 : !transform.any_op failures(suppress) {
+  ^bb0(%arg1: !transform.any_op):
+    %0 = pdl_match @some in %arg1 : (!transform.any_op) -> !transform.any_op
     // Not expecting error here because we are suppressing it.
     // expected-remark @below {{foo}}
-    test_emit_remark_and_erase_operand %0, "foo" {fail_after_erase}
+    test_emit_remark_and_erase_operand %0, "foo" {fail_after_erase} : !transform.any_op
   }
 }
 
@@ -612,7 +612,7 @@ func.func @foo() {
 }
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   pdl.pattern @some : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
@@ -620,12 +620,12 @@ transform.with_pdl_patterns {
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb0(%arg1: !pdl.operation):
-    %0 = pdl_match @some in %arg1 : (!pdl.operation) -> !pdl.operation
+  transform.sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb0(%arg1: !transform.any_op):
+    %0 = pdl_match @some in %arg1 : (!transform.any_op) -> !transform.any_op
     // expected-error @below {{silenceable error}}
     // expected-remark @below {{foo}}
-    test_emit_remark_and_erase_operand %0, "foo" {fail_after_erase}
+    test_emit_remark_and_erase_operand %0, "foo" {fail_after_erase} : !transform.any_op
   }
 }
 
@@ -747,10 +747,10 @@ func.func @get_parent_for_op_no_loop(%arg0: index, %arg1: index) {
 }
 
 transform.sequence failures(propagate) {
-^bb1(%arg1: !pdl.operation):
-  %addi = transform.structured.match ops{["arith.addi"]} in %arg1 : (!pdl.operation) -> !pdl.operation
-  %muli = get_producer_of_operand %addi[0] : (!pdl.operation) -> !pdl.operation
-  transform.test_print_remark_at_operand %muli, "found muli" : !pdl.operation
+^bb1(%arg1: !transform.any_op):
+  %addi = transform.structured.match ops{["arith.addi"]} in %arg1 : (!transform.any_op) -> !transform.any_op
+  %muli = get_producer_of_operand %addi[0] : (!transform.any_op) -> !transform.any_op
+  transform.test_print_remark_at_operand %muli, "found muli" : !transform.any_op
 }
 
 // -----
@@ -762,10 +762,10 @@ func.func @get_parent_for_op_no_loop(%arg0: index, %arg1: index) {
 }
 
 transform.sequence failures(propagate) {
-^bb1(%arg1: !pdl.operation):
-  %muli = transform.structured.match ops{["arith.muli"]} in %arg1 : (!pdl.operation) -> !pdl.operation
+^bb1(%arg1: !transform.any_op):
+  %muli = transform.structured.match ops{["arith.muli"]} in %arg1 : (!transform.any_op) -> !transform.any_op
   // expected-error @below {{could not find a producer for operand number: 0 of}}
-  %bbarg = get_producer_of_operand %muli[0] : (!pdl.operation) -> !pdl.operation
+  %bbarg = get_producer_of_operand %muli[0] : (!transform.any_op) -> !transform.any_op
 
 }
 
@@ -779,10 +779,10 @@ func.func @get_consumer(%arg0: index, %arg1: index) {
 }
 
 transform.sequence failures(propagate) {
-^bb1(%arg1: !pdl.operation):
-  %muli = transform.structured.match ops{["arith.muli"]} in %arg1 : (!pdl.operation) -> !pdl.operation
-  %addi = get_consumers_of_result %muli[0] : (!pdl.operation) -> !pdl.operation
-  transform.test_print_remark_at_operand %addi, "found addi" : !pdl.operation
+^bb1(%arg1: !transform.any_op):
+  %muli = transform.structured.match ops{["arith.muli"]} in %arg1 : (!transform.any_op) -> !transform.any_op
+  %addi = get_consumers_of_result %muli[0] : (!transform.any_op) -> !transform.any_op
+  transform.test_print_remark_at_operand %addi, "found addi" : !transform.any_op
 }
 
 // -----
@@ -794,10 +794,10 @@ func.func @get_consumer_fail_1(%arg0: index, %arg1: index) {
 }
 
 transform.sequence failures(propagate) {
-^bb1(%arg1: !pdl.operation):
-  %muli = transform.structured.match ops{["arith.muli"]} in %arg1 : (!pdl.operation) -> !pdl.operation
+^bb1(%arg1: !transform.any_op):
+  %muli = transform.structured.match ops{["arith.muli"]} in %arg1 : (!transform.any_op) -> !transform.any_op
   // expected-error @below {{handle must be mapped to exactly one payload op}}
-  %bbarg = get_consumers_of_result %muli[0] : (!pdl.operation) -> !pdl.operation
+  %bbarg = get_consumers_of_result %muli[0] : (!transform.any_op) -> !transform.any_op
 
 }
 
@@ -809,10 +809,10 @@ func.func @get_consumer_fail_2(%arg0: index, %arg1: index) {
 }
 
 transform.sequence failures(propagate) {
-^bb1(%arg1: !pdl.operation):
-  %muli = transform.structured.match ops{["arith.muli"]} in %arg1 : (!pdl.operation) -> !pdl.operation
+^bb1(%arg1: !transform.any_op):
+  %muli = transform.structured.match ops{["arith.muli"]} in %arg1 : (!transform.any_op) -> !transform.any_op
   // expected-error @below {{result number overflow}}
-  %bbarg = get_consumers_of_result %muli[1] : (!pdl.operation) -> !pdl.operation
+  %bbarg = get_consumers_of_result %muli[1] : (!transform.any_op) -> !transform.any_op
 
 }
 
@@ -923,18 +923,18 @@ transform.with_pdl_patterns {
 "other_dialect.other_op"() : () -> ()
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   pdl.pattern @other : benefit(1) {
     %0 = pdl.operation "other_dialect.other_op"
     pdl.rewrite %0 with "transform.dialect"
   }
 
-  sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
-    %0 = pdl_match @other in %arg1 : (!pdl.operation) -> !pdl.operation
+  sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb1(%arg1: !transform.any_op):
+    %0 = pdl_match @other in %arg1 : (!transform.any_op) -> !transform.any_op
     // expected-error @below {{expected the payload operation to belong to the 'test' dialect}}
-    %2 = transform.cast %0 : !pdl.operation to !transform.test_dialect_op
-    transform.cast %2 : !transform.test_dialect_op to !pdl.operation
+    %2 = transform.cast %0 : !transform.any_op to !transform.test_dialect_op
+    transform.cast %2 : !transform.test_dialect_op to !transform.any_op
   }
 }
 
@@ -944,17 +944,17 @@ transform.with_pdl_patterns {
 "other_dialect.other_op"() : () -> ()
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   pdl.pattern @some : benefit(1) {
     %0 = pdl.operation "test.some_op"
     pdl.rewrite %0 with "transform.dialect"
   }
 
-  sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
-    %0 = pdl_match @some in %arg1 : (!pdl.operation) -> !pdl.operation
-    %2 = transform.cast %0 : !pdl.operation to !transform.op<"test.some_op">
-    transform.cast %2 : !transform.op<"test.some_op"> to !pdl.operation
+  sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb1(%arg1: !transform.any_op):
+    %0 = pdl_match @some in %arg1 : (!transform.any_op) -> !transform.any_op
+    %2 = transform.cast %0 : !transform.any_op to !transform.op<"test.some_op">
+    transform.cast %2 : !transform.op<"test.some_op"> to !transform.any_op
   }
 }
 
@@ -965,36 +965,36 @@ transform.with_pdl_patterns {
 "other_dialect.other_op"() : () -> ()
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   pdl.pattern @other : benefit(1) {
     %0 = pdl.operation "other_dialect.other_op"
     pdl.rewrite %0 with "transform.dialect"
   }
 
-  sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb1(%arg1: !pdl.operation):
-    %0 = pdl_match @other in %arg1 : (!pdl.operation) -> !pdl.operation
+  sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb1(%arg1: !transform.any_op):
+    %0 = pdl_match @other in %arg1 : (!transform.any_op) -> !transform.any_op
     // expected-error @below {{incompatible payload operation name}}
-    %2 = transform.cast %0 : !pdl.operation to !transform.op<"test.some_op">
-    transform.cast %2 : !transform.op<"test.some_op"> to !pdl.operation
+    %2 = transform.cast %0 : !transform.any_op to !transform.op<"test.some_op">
+    transform.cast %2 : !transform.op<"test.some_op"> to !transform.any_op
   }
 }
 
 // -----
 
 transform.with_pdl_patterns {
-^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 : !pdl.operation failures(propagate) {
-  ^bb0(%arg1: !pdl.operation):
-    %0 = pdl_match @some in %arg1 : (!pdl.operation) -> !pdl.operation
+^bb0(%arg0: !transform.any_op):
+  transform.sequence %arg0 : !transform.any_op failures(propagate) {
+  ^bb0(%arg1: !transform.any_op):
+    %0 = pdl_match @some in %arg1 : (!transform.any_op) -> !transform.any_op
     // here, the handles nested under are {%arg0, %arg1, %0}
     // expected-remark @below {{3 handles nested under}}
-    transform.test_report_number_of_tracked_handles_nested_under %arg1
+    transform.test_report_number_of_tracked_handles_nested_under %arg1 : !transform.any_op
     // expected-remark @below {{erased}}
-    transform.test_emit_remark_and_erase_operand %0, "erased"
+    transform.test_emit_remark_and_erase_operand %0, "erased" : !transform.any_op
     // here, the handles nested under are only {%arg0, %arg1}
     // expected-remark @below {{2 handles nested under}}
-    transform.test_report_number_of_tracked_handles_nested_under %arg1
+    transform.test_report_number_of_tracked_handles_nested_under %arg1 : !transform.any_op
   }
 
   pdl.pattern @some : benefit(1) {
@@ -1065,9 +1065,9 @@ transform.sequence failures(propagate) {
 // -----
 
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation):
-  %0 = transform.structured.match ops{["func.func"]} in %arg0 : (!pdl.operation) -> !pdl.operation
-  %1 = transform.test_produce_param_with_number_of_test_ops %0 : !pdl.operation
+^bb0(%arg0: !transform.any_op):
+  %0 = transform.structured.match ops{["func.func"]} in %arg0 : (!transform.any_op) -> !transform.any_op
+  %1 = transform.test_produce_param_with_number_of_test_ops %0 : !transform.any_op
   // expected-remark @below {{1 : i32, 3 : i32}}
   transform.test_print_param %1 : !transform.test_dialect_param
   %2 = transform.test_add_to_param %1, 100

diff  --git a/mlir/test/Dialect/Transform/transform-state-extension.mlir b/mlir/test/Dialect/Transform/transform-state-extension.mlir
index 76cd1acf34493..a26293fbe51ca 100644
--- a/mlir/test/Dialect/Transform/transform-state-extension.mlir
+++ b/mlir/test/Dialect/Transform/transform-state-extension.mlir
@@ -3,15 +3,15 @@
 // expected-note @below {{associated payload op}}
 module {
   transform.sequence failures(propagate) {
-  ^bb0(%arg0: !pdl.operation):
+  ^bb0(%arg0: !transform.any_op):
     // expected-remark @below {{extension absent}}
-    test_check_if_test_extension_present %arg0
+    test_check_if_test_extension_present %arg0 : !transform.any_op
     test_add_test_extension "A"
     // expected-remark @below {{extension present, A}}
-    test_check_if_test_extension_present %arg0
+    test_check_if_test_extension_present %arg0 : !transform.any_op
     test_remove_test_extension
     // expected-remark @below {{extension absent}}
-    test_check_if_test_extension_present %arg0
+    test_check_if_test_extension_present %arg0 : !transform.any_op
   }
 }
 
@@ -20,12 +20,12 @@ module {
 // expected-note @below {{associated payload op}}
 module {
   transform.sequence failures(propagate) {
-  ^bb0(%arg0: !pdl.operation):
+  ^bb0(%arg0: !transform.any_op):
     test_add_test_extension "A"
     test_remove_test_extension
     test_add_test_extension "B"
     // expected-remark @below {{extension present, B}}
-    test_check_if_test_extension_present %arg0
+    test_check_if_test_extension_present %arg0 : !transform.any_op
   }
 }
 
@@ -34,56 +34,56 @@ module {
 // expected-note @below {{associated payload op}}
 module {
   transform.sequence failures(propagate) {
-  ^bb0(%arg0: !pdl.operation):
+  ^bb0(%arg0: !transform.any_op):
     test_add_test_extension "A"
     // expected-remark @below {{extension present, A}}
-    test_check_if_test_extension_present %arg0
+    test_check_if_test_extension_present %arg0 : !transform.any_op
     // expected-note @below {{associated payload op}}
-    test_remap_operand_to_self %arg0
+    test_remap_operand_to_self %arg0 : (!transform.any_op) -> !transform.any_op
     // expected-remark @below {{extension present, A}}
-    test_check_if_test_extension_present %arg0
+    test_check_if_test_extension_present %arg0 : !transform.any_op
   }
 }
 
 // -----
 
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   test_add_test_extension "A"
    // This is okay because we are replacing the top-level module operation
    // (0 results) with this operation that has _more_ (1) results.
-  %dummy = test_remap_operand_to_self %arg0 : !pdl.operation
+  %dummy = test_remap_operand_to_self %arg0 : (!transform.any_op) -> !transform.any_op
 }
 
 // -----
 
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   test_add_test_extension "A"
-  %dummy = test_remap_operand_to_self %arg0 : !pdl.operation
+  %dummy = test_remap_operand_to_self %arg0 : (!transform.any_op) -> !transform.any_op
   // This is still okay. Even though we are replacing the previous
   // operation with (1 result) with this operation that has less (0) results,
   // there is no handle to the result, hence no issue with value handle update.
-  test_remap_operand_to_self %dummy
+  test_remap_operand_to_self %dummy : (!transform.any_op) -> !transform.any_op
 }
 
 // -----
 
 transform.sequence failures(propagate) {
-^bb0(%arg0: !pdl.operation):
+^bb0(%arg0: !transform.any_op):
   test_add_test_extension "A"
   // expected-error @below {{cannot replace an op with another op producing fewer results while tracking handles}}
-  %dummy = test_remap_operand_to_self %arg0 : !pdl.operation
-  %valuehandle = transform.get_result %dummy[0] : (!pdl.operation) -> !transform.any_value
-  test_remap_operand_to_self %dummy
+  %dummy = test_remap_operand_to_self %arg0 : (!transform.any_op) -> !transform.any_op
+  %valuehandle = transform.get_result %dummy[0] : (!transform.any_op) -> !transform.any_value
+  test_remap_operand_to_self %dummy : (!transform.any_op) -> ()
 }
 
 // -----
 
 module {
   transform.sequence failures(suppress) {
-  ^bb0(%arg0: !pdl.operation):
+  ^bb0(%arg0: !transform.any_op):
     // expected-error @below {{TestTransformStateExtension missing}}
-    test_remap_operand_to_self %arg0
+    test_remap_operand_to_self %arg0 : (!transform.any_op) -> !transform.any_op
   }
 }

diff  --git a/mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.td b/mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.td
index 3848ff6b0587c..3e81125e2cda1 100644
--- a/mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.td
+++ b/mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.td
@@ -44,9 +44,10 @@ def TestProduceSelfHandleOrForwardOperandOp
   : Op<Transform_Dialect, "test_produce_self_handle_or_forward_operand",
        [DeclareOpInterfaceMethods<TransformOpInterface>,
         DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
-  let arguments = (ins Optional<PDL_Operation>:$operand);
-  let results = (outs PDL_Operation:$res);
-  let assemblyFormat = "($operand^)? attr-dict";
+  let arguments = (ins Optional<TransformHandleTypeInterface>:$operand);
+  let results = (outs TransformHandleTypeInterface:$res);
+  let assemblyFormat =
+      "($operand^)? attr-dict `:` functional-type($operand, $res)";
   let cppNamespace = "::mlir::test";
 }
 
@@ -100,8 +101,10 @@ def TestConsumeOperand : Op<Transform_Dialect, "test_consume_operand",
       DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
   let arguments = (ins
     Transform_AnyHandleOrParamType:$operand,
-    Optional<PDL_Operation>:$second_operand);
-  let assemblyFormat = "$operand (`,` $second_operand^)? attr-dict `:` type($operand)";
+    Optional<TransformHandleTypeInterface>:$second_operand);
+  let assemblyFormat = 
+      "$operand (`,` $second_operand^)? attr-dict `:` type($operand)"
+      "(`,` type($second_operand)^)?";
   let cppNamespace = "::mlir::test";
 }
 
@@ -110,9 +113,10 @@ def TestConsumeOperandOfOpKindOrFail
        [DeclareOpInterfaceMethods<TransformOpInterface>,
         DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
   let arguments = (ins
-    PDL_Operation:$operand,
+    TransformHandleTypeInterface:$operand,
     StrAttr:$op_kind);
-  let assemblyFormat = "$operand `,` $op_kind attr-dict";
+  let assemblyFormat =
+      "$operand `,` $op_kind attr-dict `:` type($operand)";
   let cppNamespace = "::mlir::test";
 }
 
@@ -166,8 +170,8 @@ def TestCheckIfTestExtensionPresentOp
   : Op<Transform_Dialect, "test_check_if_test_extension_present",
        [DeclareOpInterfaceMethods<TransformOpInterface>,
         DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
-  let arguments = (ins PDL_Operation:$operand);
-  let assemblyFormat = "$operand attr-dict";
+  let arguments = (ins TransformHandleTypeInterface:$operand);
+  let assemblyFormat = "$operand attr-dict `:` type($operand)";
   let cppNamespace = "::mlir::test";
 }
 
@@ -175,9 +179,9 @@ def TestRemapOperandPayloadToSelfOp
   : Op<Transform_Dialect, "test_remap_operand_to_self",
        [DeclareOpInterfaceMethods<TransformOpInterface>,
         DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
-  let arguments = (ins PDL_Operation:$operand);
+  let arguments = (ins TransformHandleTypeInterface:$operand);
   let results = (outs Optional<TransformHandleTypeInterface>:$out);        
-  let assemblyFormat = "$operand attr-dict (`:` type($out)^)?";
+  let assemblyFormat = "$operand attr-dict `:` functional-type($operand, $out)";
   let cppNamespace = "::mlir::test";
 }
 
@@ -221,9 +225,9 @@ def TestEmitRemarkAndEraseOperandOp
     [DeclareOpInterfaceMethods<TransformOpInterface>,
      DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
      FunctionalStyleTransformOpTrait]> {
-  let arguments = (ins PDL_Operation:$target, StrAttr:$remark,
+  let arguments = (ins TransformHandleTypeInterface:$target, StrAttr:$remark,
                    UnitAttr:$fail_after_erase);
-  let assemblyFormat = "$target `,` $remark attr-dict";
+  let assemblyFormat = "$target `,` $remark attr-dict `:` type($target)";
   let cppNamespace = "::mlir::test";
 }
 
@@ -231,11 +235,12 @@ def TestWrongNumberOfResultsOp
   : Op<Transform_Dialect, "test_wrong_number_of_results",
     [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
      TransformEachOpTrait, TransformOpInterface]> {
-  let arguments = (ins PDL_Operation:$target);
-  let results = (outs PDL_Operation:$a,
-                      PDL_Operation:$b,
-                      PDL_Operation:$c);
-  let assemblyFormat = "$target attr-dict";
+  let arguments = (ins TransformHandleTypeInterface:$target);
+  let results = (outs TransformHandleTypeInterface:$a,
+                      TransformHandleTypeInterface:$b,
+                      TransformHandleTypeInterface:$c);
+  let assemblyFormat =
+      "$target attr-dict `:` functional-type(operands, results)";
   let cppNamespace = "::mlir::test";
   let extraClassDeclaration = [{
     ::mlir::DiagnosedSilenceableFailure applyToOne(
@@ -249,9 +254,10 @@ def TestWrongNumberOfMultiResultsOp
   : Op<Transform_Dialect, "test_wrong_number_of_multi_results",
     [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
      TransformEachOpTrait, TransformOpInterface]> {
-  let arguments = (ins PDL_Operation:$target);
-  let results = (outs PDL_Operation:$result);
-  let assemblyFormat = "$target attr-dict";
+  let arguments = (ins TransformHandleTypeInterface:$target);
+  let results = (outs TransformHandleTypeInterface:$result);
+  let assemblyFormat =
+      "$target attr-dict `:` functional-type($target, $result)";
   let cppNamespace = "::mlir::test";
   let extraClassDeclaration = [{
     ::mlir::DiagnosedSilenceableFailure applyToOne(
@@ -265,10 +271,11 @@ def TestCorrectNumberOfMultiResultsOp
   : Op<Transform_Dialect, "test_correct_number_of_multi_results",
     [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
      TransformEachOpTrait, TransformOpInterface]> {
-  let arguments = (ins PDL_Operation:$target);
-  let results = (outs PDL_Operation:$result1,
-                      PDL_Operation:$result2);
-  let assemblyFormat = "$target attr-dict";
+  let arguments = (ins TransformHandleTypeInterface:$target);
+  let results = (outs TransformHandleTypeInterface:$result1,
+                      TransformHandleTypeInterface:$result2);
+  let assemblyFormat =
+      "$target attr-dict `:` functional-type(operands, results)";
   let cppNamespace = "::mlir::test";
   let extraClassDeclaration = [{
     ::mlir::DiagnosedSilenceableFailure applyToOne(
@@ -282,10 +289,11 @@ def TestMixedNullAndNonNullResultsOp
   : Op<Transform_Dialect, "test_mixed_null_and_non_null_results",
     [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
      TransformEachOpTrait, TransformOpInterface]> {
-  let arguments = (ins PDL_Operation:$target);
-  let results = (outs PDL_Operation:$null,
-                      PDL_Operation:$non_null);
-  let assemblyFormat = "$target attr-dict";
+  let arguments = (ins TransformHandleTypeInterface:$target);
+  let results = (outs TransformHandleTypeInterface:$null,
+                      TransformHandleTypeInterface:$non_null);
+  let assemblyFormat =
+      "$target attr-dict `:` functional-type(operands, results)";
   let cppNamespace = "::mlir::test";
   let extraClassDeclaration = [{
     ::mlir::DiagnosedSilenceableFailure applyToOne(
@@ -296,12 +304,12 @@ def TestMixedNullAndNonNullResultsOp
 }
 
 def TestMixedSuccessAndSilenceableOp
-  : Op<Transform_Dialect, "test_mixed_sucess_and_silenceable",
+  : Op<Transform_Dialect, "test_mixed_success_and_silenceable",
     [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
      TransformEachOpTrait, TransformOpInterface]> {
-  let arguments = (ins PDL_Operation:$target);
+  let arguments = (ins TransformHandleTypeInterface:$target);
   let results = (outs);
-  let assemblyFormat = "$target attr-dict";
+  let assemblyFormat = "$target attr-dict `:` type($target)";
   let cppNamespace = "::mlir::test";
   let extraClassDeclaration = [{
     ::mlir::DiagnosedSilenceableFailure applyToOne(
@@ -324,18 +332,19 @@ def TestCopyPayloadOp
   : Op<Transform_Dialect, "test_copy_payload",
        [DeclareOpInterfaceMethods<TransformOpInterface>,
         DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
-  let arguments = (ins PDL_Operation:$handle);
-  let results = (outs PDL_Operation:$copy);
+  let arguments = (ins TransformHandleTypeInterface:$handle);
+  let results = (outs TransformHandleTypeInterface:$copy);
   let cppNamespace = "::mlir::test";
-  let assemblyFormat = "$handle attr-dict";
+  let assemblyFormat =
+      "$handle attr-dict `:` functional-type(operands, results)";
 }
 
 def TestReportNumberOfTrackedHandlesNestedUnder
   : Op<Transform_Dialect, "test_report_number_of_tracked_handles_nested_under",
     [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
      DeclareOpInterfaceMethods<TransformOpInterface>]> {
-  let arguments = (ins PDL_Operation:$target);
-  let assemblyFormat = "$target attr-dict";
+  let arguments = (ins TransformHandleTypeInterface:$target);
+  let assemblyFormat = "$target attr-dict `:` type($target)";
   let cppNamespace = "::mlir::test";
 }