[mlir] NFC: rename TransformTypeInterface to TransformHandleTypeInterface

[ftynse]

Summary

This makes it more consistent with the recently added
TransformParamTypeInterface.

[springerm]

commit message can be marked [NFC]

[ftynse]

Rebase.

mlir/docs/Dialects/Transform.md

 be made about the order of ops unless specified otherwise by the operation.
 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 operations. They usually apply the respective
 transformation for every mapped op ("batched execution"). Deviations from this
 convention are described in the documentation of Transform IR ops.
 
 The transform IR values have transform IR types, which implement either
-[TransformTypeInterface](Transform.md#transformtypeinterface-transformtypeinterface)
+[TransformHandleTypeInterface](Transform.md#transformhandletypeinterface-transformhandletypeinterface)
 or
 [TransformParamTypeInterface](Transform.md##transformparamtypeinterface-transformparamtypeinterface).
 The former interface verifiers properties of payload IR operations associated
 with the value that are known to the transform dialect, for example, all
 associated payload operations implement a "TileableOp" interface, or have a
 specific "loop" kind. Similarly, the latter interface verifies properties of
 attributes associated with the parameter value. These properties are used to
 statically indicate pre- and post-conditions of a transformation connected to a

 
 The presence of interface implementations is checked at runtime when the
 dialect is loaded to allow for those implementations to be supplied by
 separate dialect extensions if desired.
 
 Similarly to operations, additional types can be injected into the dialect using
 the same extension mechanism. The types must:
 
-  * Implement exactly one of `TransformTypeInterface`,
+  * Implement exactly one of `TransformHandleTypeInterface`,
     `TransformParamTypeInterface`.
 
 ## Side Effects
 
 The Transform dialect relies on MLIR side effect modelling to enable
 optimization of the transform IR. More specifically, it provides several
 side effect resource objects and expects operations to describe their
 effects on these resources.

mlir/include/mlir/Dialect/SCF/TransformOps/SCFTransformOps.td

let description = [{
     (when the affine flag is true) loop for each Payload IR operation
     associated with the operand. Fails if such a loop cannot be found. The list
     of operations associated with the handle contains parent operations in the
     same order as the list associated with the operand, except for operations
     that are parents to more than one input which are only present once.
   }];
 
   let arguments =
-    (ins TransformTypeInterface:$target,
+    (ins TransformHandleTypeInterface:$target,
          DefaultValuedAttr<ConfinedAttr<I64Attr, [IntPositive]>,
                            "1">:$num_loops,
          DefaultValuedAttr<BoolAttr, "false">:$affine);
-  let results = (outs TransformTypeInterface : $parent);
+  let results = (outs TransformHandleTypeInterface : $parent);
 
   let assemblyFormat =
     "$target attr-dict `:` functional-type(operands, results)";
 }
 
 def LoopOutlineOp : Op<Transform_Dialect, "loop.outline",
     [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
      DeclareOpInterfaceMethods<TransformOpInterface>]> {
let description = [{
      have a SymbolTable ancestor (typically true because of the top-level
      module). Returns the handle to the list of outlined functions in the same
      order as the operand handle.
   }];
 
   // Note that despite the name of the transform operation and related utility
   // functions, the actual implementation does not require the operation to be
   // a loop.
-  let arguments = (ins TransformTypeInterface:$target,
+  let arguments = (ins TransformHandleTypeInterface:$target,
                    StrAttr:$func_name);
-  let results = (outs TransformTypeInterface:$transformed);
+  let results = (outs TransformHandleTypeInterface:$transformed);
 
   let assemblyFormat =
     "$target attr-dict `:` functional-type(operands, results)";
 }
 
 def LoopPeelOp : Op<Transform_Dialect, "loop.peel",
     [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
      TransformOpInterface, TransformEachOpTrait]> {
let description = [{
 
      TODO: Return both the peeled loop and the remainder loop.
   }];
 
   let arguments =
       (ins Transform_ScfForOp:$target,
            DefaultValuedAttr<BoolAttr, "false">:$fail_if_already_divisible);
   // TODO: Return both the peeled loop and the remainder loop.
-  let results = (outs TransformTypeInterface:$transformed);
+  let results = (outs TransformHandleTypeInterface:$transformed);
 
   let assemblyFormat =
     "$target attr-dict `:` functional-type(operands, results)";
 
   let extraClassDeclaration = [{
     ::mlir::DiagnosedSilenceableFailure applyToOne(
         ::mlir::scf::ForOp target,
         ::llvm::SmallVector<::mlir::Operation *> &results,
let description = [{
     properly, the transform succeeds. Otherwise the transform silently fails.
     The return handle points to only the subset of successfully produced
     pipelined loops, which can be empty.
   }];
 
   let arguments = (ins Transform_ScfForOp:$target,
                    DefaultValuedAttr<I64Attr, "1">:$iteration_interval,
                    DefaultValuedAttr<I64Attr, "10">:$read_latency);
-  let results = (outs TransformTypeInterface:$transformed);
+  let results = (outs TransformHandleTypeInterface:$transformed);
 
   let assemblyFormat =
     "$target attr-dict `:` functional-type(operands, results)";
 
   let extraClassDeclaration = [{
     ::mlir::DiagnosedSilenceableFailure applyToOne(
         ::mlir::scf::ForOp target,
         ::llvm::SmallVector<::mlir::Operation *> &results,
let description = [{
     the return.  If all the operations referred to by the `target` PDLOperation
     unroll properly, the transform succeeds. Otherwise the transform silently
     fails.
 
     Does not return handles as the operation may result in the loop being
     removed after a full unrolling.
   }];
 
-  let arguments = (ins TransformTypeInterface:$target,
+  let arguments = (ins TransformHandleTypeInterface:$target,
                        ConfinedAttr<I64Attr, [IntPositive]>:$factor);
 
   let assemblyFormat = "$target attr-dict `:` type($target)";
 
   let extraClassDeclaration = [{
     ::mlir::DiagnosedSilenceableFailure applyToOne(
         ::mlir::Operation *target,
         ::llvm::SmallVector<::mlir::Operation *> &results,
         ::mlir::transform::TransformState &state);
   }];
 }
 
 #endif // SCF_TRANSFORM_OPS

mlir/include/mlir/Dialect/Transform/IR/TransformDialect.h

 #ifndef NDEBUG
 namespace detail {
 /// Asserts that the operations provided as template arguments implement the
 /// TransformOpInterface and MemoryEffectsOpInterface. This must be a dynamic
 /// assertion since interface implementations may be registered at runtime.
 void checkImplementsTransformOpInterface(StringRef name, MLIRContext *context);
 
 /// Asserts that the type provided as template argument implements the
-/// TransformTypeInterface. This must be a dynamic assertion since interface
-/// implementations may be registered at runtime.
-void checkImplementsTransformTypeInterface(TypeID typeID, MLIRContext *context);
+/// TransformHandleTypeInterface. This must be a dynamic assertion since
+/// interface implementations may be registered at runtime.
+void checkImplementsTransformHandleTypeInterface(TypeID typeID,
+                                                 MLIRContext *context);
 } // namespace detail
 #endif // NDEBUG
 } // namespace transform
 } // namespace mlir
 
 #include "mlir/Dialect/Transform/IR/TransformDialect.h.inc"
 
 namespace mlir {
protected:
   template <typename... OpTys>
   void registerTransformOps() {
     opInitializers.push_back([](TransformDialect *transformDialect) {
       transformDialect->addOperationsChecked<OpTys...>();
     });
   }
 
   /// Injects the types into the Transform dialect. The types must implement
-  /// the TransformTypeInterface and the implementation must be already
+  /// the TransformHandleTypeInterface and the implementation must be already
   /// available when the type is injected. Furthermore, the types must provide
   /// a `getMnemonic` static method returning an object convertible to
   /// `StringRef` that is unique across all injected types.
   template <typename... TypeTys>
   void registerTypes() {
     opInitializers.push_back([](TransformDialect *transformDialect) {
       transformDialect->addTypesChecked<TypeTys...>();
     });
void TransformDialect::addTypeIfNotRegistered() {
   typePrintingHooks.try_emplace(
       TypeID::get<Type>(), +[](mlir::Type type, AsmPrinter &printer) {
         printer << Type::getMnemonic();
         cast<Type>(type).print(printer);
       });
   addTypes<Type>();
 
 #ifndef NDEBUG
-  detail::checkImplementsTransformTypeInterface(TypeID::get<Type>(),
+  detail::checkImplementsTransformHandleTypeInterface(TypeID::get<Type>(),
                                                       getContext());
 #endif // NDEBUG
 }
 
 /// A wrapper for transform dialect extensions that forces them to be
 /// constructed in the build-only mode.
 template <typename DerivedTy>
 class BuildOnly : public DerivedTy {
 public:

mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.h

private:
   ///   transform.rewrite_and_rename %1 { new_name = "func" }
   ///
   /// is invalid given the transformation "consumes" the handle as expressed
   /// by side effects. Practically, a transformation consuming a handle means
   /// that the associated payload operation may no longer exist.
   ///
   /// Returns failure if the payload does not satisfy the conditions associated
   /// with the type of the handle value. The value is expected to have a type
-  /// implementing TransformTypeInterface.
+  /// implementing TransformHandleTypeInterface.
   LogicalResult setPayloadOps(Value value, ArrayRef<Operation *> targets);
 
   /// Sets the parameters associated with the given transform IR value. Returns
   /// failure if the parameters do not satisfy the conditions associated with
   /// the type of the value. The value is expected to have a type implementing
   /// TransformParamTypeInterface.
   LogicalResult setParams(Value value, ArrayRef<Param> params);
 

 /// TransformOpInterface and the payload IR ops they correspond to.
 class TransformResults {
   friend class TransformState;
 
 public:
   /// Indicates that the result of the transform IR op at the given position
   /// corresponds to the given list of payload IR ops. Each result must be set
   /// by the transformation exactly once. The value must have a type
-  /// implementing TransformTypeInterface.
+  /// implementing TransformHandleTypeInterface.
   void set(OpResult value, ArrayRef<Operation *> ops);
 
   /// Indicates that the result of the transform IR op at the given position
   /// corresponds to the given list of parameters. Each result must be set by
   /// the transformation exactly once. The value must have a type implementing
   /// TransformParamTypeInterface.
   void setParams(OpResult value, ArrayRef<TransformState::Param> params);
 

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

class TransformTypeInterfaceBase<string cppClass, string cppObjectType>
   let extraSharedClassDeclaration = [{
     DiagnosedSilenceableFailure emitSilenceableError(Location loc) const {
       Diagnostic diag(loc, DiagnosticSeverity::Error);
       return DiagnosedSilenceableFailure::silenceableFailure(std::move(diag));
     }
   }];
 }
 
-def TransformTypeInterface
-    : TransformTypeInterfaceBase<"TransformTypeInterface",
+def TransformHandleTypeInterface
+    : TransformTypeInterfaceBase<"TransformHandleTypeInterface",
                                  "::mlir::Operation *"> {
   let description = [{
     Types that can be used for the Transform dialect handle values. Such types
     define the properties of Payload IR operations associated with the handle.
     A user of such a handle can assume that these properties have been verified
     for any Payload IR operation associated with it.
   }];
 }

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

let description = [{
     ^bb0(%arg0: !pdl.operation):
       // Otherwise, the second alternative is tried and it always succeeds by
       // returning the original handle.
       transform.yield %arg0 : !pdl.operation
     }
     ```
   }];
 
-  let arguments = (ins Optional<TransformTypeInterface>:$scope);
-  let results = (outs Variadic<TransformTypeInterface>:$results);
+  let arguments = (ins Optional<TransformHandleTypeInterface>:$scope);
+  let results = (outs Variadic<TransformHandleTypeInterface>:$results);
   let regions = (region VariadicRegion<SizedRegion<1>>:$alternatives);
 
   let assemblyFormat =
     "($scope^ `:` type($scope))? (`->` type($results)^)? "
     "attr-dict-with-keyword regions";
   let hasVerifier = 1;
 }
 
 def CastOp : TransformDialectOp<"cast",
     [TransformOpInterface, TransformEachOpTrait,
      DeclareOpInterfaceMethods<CastOpInterface>,
      DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
-  let arguments = (ins TransformTypeInterface:$input);
-  let results = (outs TransformTypeInterface:$output);
+  let arguments = (ins TransformHandleTypeInterface:$input);
+  let results = (outs TransformHandleTypeInterface:$output);
   let assemblyFormat = "$input attr-dict `:` type($input) `to` type($output)";
 
   let extraClassDeclaration = [{
     ::mlir::DiagnosedSilenceableFailure applyToOne(
       ::mlir::Operation *target,
       ::llvm::SmallVectorImpl<::mlir::Operation *> &results,
       ::mlir::transform::TransformState &state);
   }];
let description = [{
     invalid state, i.e., this operation offers no transformation rollback
     capabilities.
 
     This op generates as many handles as the terminating YieldOp has operands.
     For each result, the payload ops of the corresponding YieldOp operand are
     merged and mapped to the same resulting handle.
   }];
 
-  let arguments = (ins TransformTypeInterface:$target);
-  let results = (outs Variadic<TransformTypeInterface>:$results);
+  let arguments = (ins TransformHandleTypeInterface:$target);
+  let results = (outs Variadic<TransformHandleTypeInterface>:$results);
   let regions = (region SizedRegion<1>:$body);
   let assemblyFormat =
     "$target `:` type($target) (`->` type($results)^)? $body attr-dict";
   let hasVerifier = 1;
 
   let extraClassDeclaration = [{
     /// Allow the dialect prefix to be omitted.
     static StringRef getDefaultDialect() { return "transform"; }
let description = [{
     with the operand have the same parent) for which the ancestor will only be
     listed once for the first time it occurs. For example, given the list
     "(childof(A), childof(B), childof(B), childof(A), childof(B))", the
     resulting list will be just "(A, B)". Note that no other semantic ordering
     is applied, e.g., "B" may itself be a parent of "A". This may have an impact
     on the further transformation applied to the handle produced here.
   }];
 
-  let arguments = (ins TransformTypeInterface:$target);
-  let results = (outs TransformTypeInterface:$parent);
+  let arguments = (ins TransformHandleTypeInterface:$target);
+  let results = (outs TransformHandleTypeInterface:$parent);
   let assemblyFormat =
     "$target attr-dict `:` functional-type(operands, results)";
 }
 
 def GetProducerOfOperand : TransformDialectOp<"get_producer_of_operand",
     [DeclareOpInterfaceMethods<TransformOpInterface>,
      NavigationTransformOpTrait, MemoryEffectsOpInterface]> {
   let summary = "Get handle to the producer of this operation's operand number";
   let description = [{
     The handle defined by this Transform op corresponds to operation that
     produces the SSA value defined by the `target` and `operand_number`
     arguments. If the origin of the SSA value is not an operations (i.e. it is
     a block argument), the transform silently fails.
     The return handle points to only the subset of successfully produced
     computational operations, which can be empty.
   }];
 
-  let arguments = (ins TransformTypeInterface:$target,
+  let arguments = (ins TransformHandleTypeInterface:$target,
                        I64Attr:$operand_number);
-  let results = (outs TransformTypeInterface:$parent);
+  let results = (outs TransformHandleTypeInterface:$parent);
   let assemblyFormat = "$target `[` $operand_number `]` attr-dict `:` "
                        "functional-type(operands, results)";
 }
 
 def MergeHandlesOp : TransformDialectOp<"merge_handles",
     [DeclareOpInterfaceMethods<TransformOpInterface, ["allowsRepeatedHandleOperands"]>,
      DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
      SameOperandsAndResultType]> {
   let summary = "Merges handles into one pointing to the union of payload ops";
   let description = [{
     Creates a new Transform IR handle value that points to the same Payload IR
     operations as the operand handles. The Payload IR operations are listed
     in the same order as they are in the operand handles, grouped by operand
     handle, e.g., all Payload IR operations associated with the first handle
     come first, then all Payload IR operations associated with the second handle
     and so on. If `deduplicate` is set, do not add the given Payload IR
     operation more than once to the final list regardless of it coming from the
     same or different handles. Consumes the operands and produces a new handle.
   }];
 
-  let arguments = (ins Variadic<TransformTypeInterface>:$handles,
+  let arguments = (ins Variadic<TransformHandleTypeInterface>:$handles,
                        UnitAttr:$deduplicate);
-  let results = (outs TransformTypeInterface:$result);
+  let results = (outs TransformHandleTypeInterface:$result);
   let assemblyFormat = "($deduplicate^)? $handles attr-dict `:` type($result)";
   let hasFolder = 1;
 }
 
 def SplitHandlesOp : TransformDialectOp<"split_handles",
     [FunctionalStyleTransformOpTrait,
      DeclareOpInterfaceMethods<TransformOpInterface>,
      DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
   let summary = "Splits handles from a union of payload ops to a list";
   let description = [{
     Creates `num_result_handles` transform IR handles extracted from the
     `handle` operand. The resulting Payload IR operation handles are listed
     in the same order as the operations appear in the source `handle`.
     This is useful for ensuring a statically known number of operations are
     tracked by the source `handle` and to extract them into individual handles
     that can be further manipulated in isolation.
 
     This operation succeeds and returns `num_result_handles` if the statically
     specified `num_result_handles` corresponds to the dynamic number of
     operations contained in the source `handle`. Otherwise it silently fails.
   }];
 
-  let arguments = (ins TransformTypeInterface:$handle,
+  let arguments = (ins TransformHandleTypeInterface:$handle,
                        I64Attr:$num_result_handles);
-  let results = (outs Variadic<TransformTypeInterface>:$results);
+  let results = (outs Variadic<TransformHandleTypeInterface>:$results);
 
   let builders = [
     OpBuilder<(ins "Value":$handle, "int64_t":$numResultHandles)>
   ];
 
   let assemblyFormat = [{
     $handle `in` `[` $num_result_handles `]`
     attr-dict `:` functional-type(operands, results)
let description = [{
     of the matched ops.
 
     The transformation is considered successful regardless of whether some
     Payload IR ops actually matched the pattern and only fails if the pattern
     could not be looked up or compiled.
   }];
 
   let arguments = (ins
-    Arg<TransformTypeInterface, "Payload IR scope to match within">:$root,
+    Arg<TransformHandleTypeInterface, "Payload IR scope to match within">:$root,
     SymbolRefAttr:$pattern_name);
   let results = (outs
-    Res<TransformTypeInterface, "Handle to the matched Payload IR ops">:$matched);
+    Res<TransformHandleTypeInterface, "Handle to the matched Payload IR ops">:$matched);
 
   let assemblyFormat = "$pattern_name `in` $root attr-dict `:` "
                        "functional-type(operands, results)";
 }
 
 def PrintOp : TransformDialectOp<"print",
     [DeclareOpInterfaceMethods<TransformOpInterface>,
      DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
   let summary = "Dump each payload op";
   let description = [{
     This op dumps each payload op that is associated with the `target` operand
     to stderr. It also prints the `name` string attribute. If no target is
     specified, the top-level op is dumped.
 
     This op is useful for printf-style debugging.
   }];
 
-  let arguments = (ins Optional<TransformTypeInterface>:$target,
+  let arguments = (ins Optional<TransformHandleTypeInterface>:$target,
                        OptionalAttr<StrAttr>:$name);
   let results = (outs);
 
   let builders = [
     OpBuilder<(ins CArg<"StringRef", "StringRef()">:$name)>,
     OpBuilder<(ins "Value":$target, CArg<"StringRef", "StringRef()">:$name)>
   ];
 
let description = [{
     an operation that consumes the handle. Handle consumption often indicates
     that the associated payload IR ops are destroyed, so having the same op
     listed more than once will lead to double-free. Single-operand
     MergeHandlesOp may be used to deduplicate the associated list of payload IR
     ops when necessary. Furthermore, a combination of ReplicateOp and
     MergeHandlesOp can be used to construct arbitrary lists with repetitions.
   }];
 
-  let arguments = (ins TransformTypeInterface:$pattern,
-                       Variadic<TransformTypeInterface>:$handles);
-  let results = (outs Variadic<TransformTypeInterface>:$replicated);
+  let arguments = (ins TransformHandleTypeInterface:$pattern,
+                       Variadic<TransformHandleTypeInterface>:$handles);
+  let results = (outs Variadic<TransformHandleTypeInterface>:$replicated);
   let assemblyFormat = "`num` `(` $pattern `)` $handles attr-dict `:` "
                        "type($pattern) `,` type($handles)";
 }
 
 def SequenceOp : TransformDialectOp<"sequence",
     [DeclareOpInterfaceMethods<RegionBranchOpInterface,
         ["getSuccessorEntryOperands", "getSuccessorRegions",
          "getRegionInvocationBounds"]>,
let description = [{
     another sequence.
 
     The body of the sequence terminates with an implicit or explicit
     `transform.yield` op. The operands of the terminator are returned as the
     results of the sequence op.
   }];
 
   let arguments = (ins FailurePropagationMode:$failure_propagation_mode,
-                       Optional<TransformTypeInterface>:$root);
-  let results = (outs Variadic<TransformTypeInterface>:$results);
+                       Optional<TransformHandleTypeInterface>:$root);
+  let results = (outs Variadic<TransformHandleTypeInterface>:$results);
   let regions = (region SizedRegion<1>:$body);
 
   let assemblyFormat =
     "($root^ `:` type($root))? (`->` type($results)^)? `failures` `(` "
     "$failure_propagation_mode `)` attr-dict-with-keyword regions";
 
   let builders = [
     // Build a sequence with a root.
let description = [{
     This op is expected to contain `pdl.pattern` operations and exactly one
     another Transform dialect operation that gets executed with all patterns
     available. This op is a possible top-level Transform IR op, the argument of
     its entry block corresponds to either the root op of the payload IR or the
     ops associated with its operand when provided.
   }];
 
   let arguments = (ins
-    Arg<Optional<TransformTypeInterface>, "Root operation of the Payload IR",
+    Arg<Optional<TransformHandleTypeInterface>, "Root operation of the Payload IR",
         [TransformMappingRead]>:$root);
   let regions = (region SizedRegion<1>:$body);
   let assemblyFormat = "($root^ `:` type($root))? attr-dict-with-keyword regions";
 
   let hasVerifier = 1;
 
   let extraClassDeclaration = [{
     /// Allow the dialect prefix to be omitted.
     static StringRef getDefaultDialect() { return "transform"; }
   }];
 }
 
 def YieldOp : TransformDialectOp<"yield", [Terminator]> {
   let summary = "Yields operation handles from a transform IR region";
   let description = [{
     This terminator operation yields operation handles from regions of the
     transform IR ops back to the containing op. It is not itself associated with
     any transformation on the payload IR and is used for flow purposes only.
   }];
 
   let arguments = (ins
-    Arg<Variadic<TransformTypeInterface>, "Operation handles yielded back to the parent",
+    Arg<Variadic<TransformHandleTypeInterface>, "Operation handles yielded back to the parent",
         [TransformMappingRead]>:$operands);
   let assemblyFormat = "operands attr-dict (`:` type($operands)^)?";
 
   let builders = [
     OpBuilder<(ins), [{
       return build($_builder, $_state, ::mlir::ValueRange());
     }]>
   ];
 }
 
 #endif // MLIR_DIALECT_TRANSFORM_IR_TRANSFORMOPS

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

 //===- TransformTypes.td - Transform dialect types ---------*- tablegen -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_TRANSFORM_IR_TRANSFORMTYPES
 #define MLIR_DIALECT_TRANSFORM_IR_TRANSFORMTYPES
 
 include "mlir/IR/AttrTypeBase.td"
 include "mlir/Dialect/Transform/IR/TransformInterfaces.td"
 include "mlir/Dialect/Transform/IR/TransformDialect.td"
 
 def Transform_AnyOpType : TypeDef<Transform_Dialect, "AnyOp",
-    [DeclareTypeInterfaceMethods<TransformTypeInterface>]> {
+    [DeclareTypeInterfaceMethods<TransformHandleTypeInterface>]> {
   let description = [{
     Transform IR handle that can be associated with a list of arbitrary
     Payload IR operations.
   }];
   let mnemonic = "any_op";
   let assemblyFormat = "";
 }
 
 def Transform_OperationType : TypeDef<Transform_Dialect, "Operation",
-    [DeclareTypeInterfaceMethods<TransformTypeInterface>]> {
+    [DeclareTypeInterfaceMethods<TransformHandleTypeInterface>]> {
   let description = [{
     Transform IR handle that can be associated with a list of Payload IR
     operations with the specified operation name.
   }];
   let mnemonic = "op";
   let parameters = (ins
     StringRefParameter<"Name of the allowed payload operation">:$operation_name
   );

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

assert((opName.hasInterface<TransformOpInterface>() ||
           opName.hasTrait<OpTrait::IsTerminator>()) &&
          "non-terminator ops injected into the transform dialect must "
          "implement TransformOpInterface");
   assert(opName.hasInterface<MemoryEffectOpInterface>() &&
          "ops injected into the transform dialect must implement "
          "MemoryEffectsOpInterface");
 }
 
-void transform::detail::checkImplementsTransformTypeInterface(
+void transform::detail::checkImplementsTransformHandleTypeInterface(
     TypeID typeID, MLIRContext *context) {
   const auto &abstractType = AbstractType::lookup(typeID, context);
   assert(
-      (abstractType.hasInterface(TransformTypeInterface::getInterfaceID()) ||
+      (abstractType.hasInterface(
+           TransformHandleTypeInterface::getInterfaceID()) ||
        abstractType.hasInterface(
            TransformParamTypeInterface::getInterfaceID())) &&
       "expected Transform dialect type to implement one of the two interfaces");
 }
 #endif // NDEBUG
 
 namespace {
-struct PDLOperationTypeTransformTypeInterfaceImpl
-    : public transform::TransformTypeInterface::ExternalModel<
-          PDLOperationTypeTransformTypeInterfaceImpl, pdl::OperationType> {
+struct PDLOperationTypeTransformHandleTypeInterfaceImpl
+    : public transform::TransformHandleTypeInterface::ExternalModel<
+          PDLOperationTypeTransformHandleTypeInterfaceImpl,
+          pdl::OperationType> {
   DiagnosedSilenceableFailure
   checkPayload(Type type, Location loc, ArrayRef<Operation *> payload) const {
     return DiagnosedSilenceableFailure::success();
   }
 };
 } // namespace
 
 void transform::TransformDialect::initialize() {
   // Using the checked versions to enable the same assertions as for the ops
   // from extensions.
   addOperationsChecked<
 #define GET_OP_LIST
 #include "mlir/Dialect/Transform/IR/TransformOps.cpp.inc"
       >();
   initializeTypes();
 
   pdl::OperationType::attachInterface<
-      PDLOperationTypeTransformTypeInterfaceImpl>(*getContext());
+      PDLOperationTypeTransformHandleTypeInterfaceImpl>(*getContext());
 }
 
 void transform::TransformDialect::mergeInPDLMatchHooks(
     llvm::StringMap<PDLConstraintFunction> &&constraintFns) {
   // Steal the constraint functions form the given map.
   for (auto &it : constraintFns)
     pdlMatchHooks.registerConstraintFunction(it.getKey(), std::move(it.second));
 }

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

 LogicalResult
 transform::TransformState::setPayloadOps(Value value,
                                          ArrayRef<Operation *> targets) {
   assert(value != kTopLevelValue &&
          "attempting to reset the transformation root");
   assert(!value.getType().isa<TransformParamTypeInterface>() &&
          "cannot associate payload ops with a value of parameter type");
 
-  auto iface = value.getType().cast<TransformTypeInterface>();
+  auto iface = value.getType().cast<TransformHandleTypeInterface>();
   DiagnosedSilenceableFailure result =
       iface.checkPayload(value.getLoc(), targets);
   if (failed(result.checkAndReport()))
     return failure();
 
   // Setting new payload for the value without cleaning it first is a misuse of
   // the API, assert here.
   SmallVector<Operation *> storedTargets(targets.begin(), targets.end());
LogicalResult transform::TransformState::updatePayloadOps(
   for (Operation *op : association) {
     dropReverseMapping(mappings, op, value);
     if (Operation *updatedOp = callback(op)) {
       updated.push_back(updatedOp);
       mappings.reverse[updatedOp].push_back(value);
     }
   }
 
-  auto iface = value.getType().cast<TransformTypeInterface>();
+  auto iface = value.getType().cast<TransformHandleTypeInterface>();
   DiagnosedSilenceableFailure result =
       iface.checkPayload(value.getLoc(), updated);
   if (failed(result.checkAndReport()))
     return failure();
 
   it->second = updated;
   return success();
 }
if (op->getNumRegions() < 1)
     return op->emitOpError() << "expects at least one region";
 
   Region *bodyRegion = &op->getRegion(0);
   if (!llvm::hasNItems(*bodyRegion, 1))
     return op->emitOpError() << "expects a single-block region";
 
   Block *body = &bodyRegion->front();
   if (body->getNumArguments() != 1 ||
-      !body->getArgumentTypes()[0].isa<TransformTypeInterface>()) {
-    return op->emitOpError() << "expects the entry block to have one argument "
-                                "of type implementing TransformTypeInterface";
+      !body->getArgumentTypes()[0].isa<TransformHandleTypeInterface>()) {
+    return op->emitOpError()
+           << "expects the entry block to have one argument "
+              "of type implementing TransformHandleTypeInterface";
   }
 
   if (auto *parent =
           op->getParentWithTrait<PossibleTopLevelTransformOpTrait>()) {
     if (op->getNumOperands() == 0) {
       InFlightDiagnostic diag =
           op->emitOpError()
           << "expects the root operation to be provided for a nested op";

 //===----------------------------------------------------------------------===//
 
 void transform::detail::getParamProducerTransformOpTraitEffects(
     Operation *op, SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   producesHandle(op->getResults(), effects);
   bool hasPayloadOperands = false;
   for (Value operand : op->getOperands()) {
     onlyReadsHandle(operand, effects);
-    if (operand.getType().isa<TransformTypeInterface>())
+    if (operand.getType().isa<TransformHandleTypeInterface>())
       hasPayloadOperands = true;
   }
   if (hasPayloadOperands)
     onlyReadsPayload(effects);
 }
 
 LogicalResult
 transform::detail::verifyParamProducerTransformOpTrait(Operation *op) {

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

 }
 
 bool transform::CastOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   assert(inputs.size() == 1 && "expected one input");
   assert(outputs.size() == 1 && "expected one output");
   return llvm::all_of(
       std::initializer_list<Type>{inputs.front(), outputs.front()},
       [](Type ty) {
-        return ty.isa<pdl::OperationType, transform::TransformTypeInterface>();
+        return ty
+            .isa<pdl::OperationType, transform::TransformHandleTypeInterface>();
       });
 }
 
 //===----------------------------------------------------------------------===//
 // ForeachOp
 //===----------------------------------------------------------------------===//
 
 DiagnosedSilenceableFailure

 }
 
 LogicalResult transform::ForeachOp::verify() {
   auto yieldOp = getYieldOp();
   if (getNumResults() != yieldOp.getNumOperands())
     return emitOpError() << "expects the same number of results as the "
                             "terminator has operands";
   for (Value v : yieldOp.getOperands())
-    if (!v.getType().isa<TransformTypeInterface>())
-      return yieldOp->emitOpError(
-          "expects operands to have types implementing TransformTypeInterface");
+    if (!v.getType().isa<TransformHandleTypeInterface>())
+      return yieldOp->emitOpError("expects operands to have types implementing "
+                                  "TransformHandleTypeInterface");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // GetClosestIsolatedParentOp
 //===----------------------------------------------------------------------===//
 
 DiagnosedSilenceableFailure transform::GetClosestIsolatedParentOp::apply(

mlir/test/Dialect/Transform/ops-invalid.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics
 
-// expected-error @below {{expects the entry block to have one argument of type implementing TransformTypeInterface}}
+// expected-error @below {{expects the entry block to have one argument of type implementing TransformHandleTypeInterface}}
 transform.sequence failures(propagate) {
 }
 
 // -----
 
 // expected-note @below {{nested in another possible top-level op}}
 transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):
^bb1(%arg1: !pdl.operation):
   ^bb2(%arg2: !pdl.operation):
     // expected-note @below {{terminator}}
     transform.yield
   }
 }
 
 // -----
 
-// expected-error @below {{expects the entry block to have one argument of type implementing TransformTypeInterface}}
+// expected-error @below {{expects the entry block to have one argument of type implementing TransformHandleTypeInterface}}
 transform.alternatives {
 ^bb0:
   transform.yield
 }
 
 // -----
 
 transform.sequence failures(propagate) {

mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.td

 include "mlir/IR/OpBase.td"
 include "mlir/Dialect/Transform/IR/TransformDialect.td"
 include "mlir/Dialect/Transform/IR/TransformEffects.td"
 include "mlir/Dialect/Transform/IR/TransformInterfaces.td"
 include "mlir/Dialect/PDL/IR/PDLTypes.td"
 
 def TestTransformTestDialectHandleType
   : TypeDef<Transform_Dialect, "TestDialectOp",
-      [DeclareTypeInterfaceMethods<TransformTypeInterface>]> {
+      [DeclareTypeInterfaceMethods<TransformHandleTypeInterface>]> {
   let description = [{Handle pointing to an op from the Test dialect.}];
   let mnemonic = "test_dialect_op";
   let assemblyFormat = "";
 }
 
 def TestTransformTestDialectParamType
   : TypeDef<Transform_Dialect, "TestDialectParam",
       [DeclareTypeInterfaceMethods<TransformParamTypeInterface>]> {
def TestConsumeOperandIfMatchesParamOrFail
   let assemblyFormat = "$operand `[` $parameter `]` attr-dict";
   let cppNamespace = "::mlir::test";
 }
 
 def TestPrintRemarkAtOperandOp
   : Op<Transform_Dialect, "test_print_remark_at_operand",
        [DeclareOpInterfaceMethods<TransformOpInterface>]> {
   let arguments = (ins
-    Arg<TransformTypeInterface, "",
+    Arg<TransformHandleTypeInterface, "",
         [TransformMappingRead, PayloadIRRead]>:$operand,
     StrAttr:$message);
   let assemblyFormat =
     "$operand `,` $message attr-dict `:` type($operand)";
   let cppNamespace = "::mlir::test";
 }
 
 def TestAddTestExtensionOp
def TestAddToParamOp
   let assemblyFormat = "($param^ `,`)? $addendum attr-dict";
   let cppNamespace = "::mlir::test";
 }
 
 def TestProduceParamWithNumberOfTestOps
   : Op<Transform_Dialect, "test_produce_param_with_number_of_test_ops",
        [MemoryEffectsOpInterface, ParamProducerTransformOpTrait,
         DeclareOpInterfaceMethods<TransformOpInterface>]> {
-  let arguments = (ins TransformTypeInterface:$handle);
+  let arguments = (ins TransformHandleTypeInterface:$handle);
   let results = (outs TestTransformTestDialectParamType:$result);
   let assemblyFormat = "$handle attr-dict `:` type($handle)";
   let cppNamespace = "::mlir::test";
 }
 
 def TestProduceIntegerParamWithTypeOp
   : Op<Transform_Dialect, "test_produce_integer_param_with_type",
        [MemoryEffectsOpInterface, ParamProducerTransformOpTrait,