diff --git a/mlir/docs/Dialects/Transform.md b/mlir/docs/Dialects/Transform.md
--- a/mlir/docs/Dialects/Transform.md
+++ b/mlir/docs/Dialects/Transform.md
@@ -73,7 +73,7 @@
 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
@@ -156,7 +156,7 @@
 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
diff --git a/mlir/include/mlir/Dialect/SCF/TransformOps/SCFTransformOps.td b/mlir/include/mlir/Dialect/SCF/TransformOps/SCFTransformOps.td
--- a/mlir/include/mlir/Dialect/SCF/TransformOps/SCFTransformOps.td
+++ b/mlir/include/mlir/Dialect/SCF/TransformOps/SCFTransformOps.td
@@ -32,11 +32,11 @@
   }];
 
   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)";
@@ -62,9 +62,9 @@
   // 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)";
@@ -101,7 +101,7 @@
       (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)";
@@ -143,7 +143,7 @@
   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)";
@@ -176,7 +176,7 @@
     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)";
diff --git a/mlir/include/mlir/Dialect/Transform/IR/TransformDialect.h b/mlir/include/mlir/Dialect/Transform/IR/TransformDialect.h
--- a/mlir/include/mlir/Dialect/Transform/IR/TransformDialect.h
+++ b/mlir/include/mlir/Dialect/Transform/IR/TransformDialect.h
@@ -25,9 +25,10 @@
 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
@@ -112,7 +113,7 @@
   }
 
   /// 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.
@@ -225,8 +226,8 @@
   addTypes<Type>();
 
 #ifndef NDEBUG
-  detail::checkImplementsTransformTypeInterface(TypeID::get<Type>(),
-                                                getContext());
+  detail::checkImplementsTransformHandleTypeInterface(TypeID::get<Type>(),
+                                                      getContext());
 #endif // NDEBUG
 }
 
diff --git a/mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.h b/mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.h
--- a/mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.h
+++ b/mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.h
@@ -608,7 +608,7 @@
   ///
   /// 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
@@ -686,7 +686,7 @@
   /// 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
diff --git a/mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.td b/mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.td
--- a/mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.td
+++ b/mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.td
@@ -129,8 +129,8 @@
   }];
 }
 
-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
diff --git a/mlir/include/mlir/Dialect/Transform/IR/TransformOps.td b/mlir/include/mlir/Dialect/Transform/IR/TransformOps.td
--- a/mlir/include/mlir/Dialect/Transform/IR/TransformOps.td
+++ b/mlir/include/mlir/Dialect/Transform/IR/TransformOps.td
@@ -88,8 +88,8 @@
     ```
   }];
 
-  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 =
@@ -102,8 +102,8 @@
     [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 = [{
@@ -143,8 +143,8 @@
     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";
@@ -183,8 +183,8 @@
     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)";
 }
@@ -202,9 +202,9 @@
     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)";
 }
@@ -225,9 +225,9 @@
     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;
 }
@@ -250,9 +250,9 @@
     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)>
@@ -286,10 +286,10 @@
   }];
 
   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)";
@@ -307,7 +307,7 @@
     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);
 
@@ -349,9 +349,9 @@
     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)";
 }
@@ -396,8 +396,8 @@
   }];
 
   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 =
@@ -467,7 +467,7 @@
   }];
 
   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";
@@ -489,7 +489,7 @@
   }];
 
   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)^)?";
 
diff --git a/mlir/include/mlir/Dialect/Transform/IR/TransformTypes.td b/mlir/include/mlir/Dialect/Transform/IR/TransformTypes.td
--- a/mlir/include/mlir/Dialect/Transform/IR/TransformTypes.td
+++ b/mlir/include/mlir/Dialect/Transform/IR/TransformTypes.td
@@ -14,7 +14,7 @@
 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.
@@ -24,7 +24,7 @@
 }
 
 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.
diff --git a/mlir/lib/Dialect/Transform/IR/TransformDialect.cpp b/mlir/lib/Dialect/Transform/IR/TransformDialect.cpp
--- a/mlir/lib/Dialect/Transform/IR/TransformDialect.cpp
+++ b/mlir/lib/Dialect/Transform/IR/TransformDialect.cpp
@@ -35,11 +35,12 @@
          "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");
@@ -47,9 +48,10 @@
 #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();
@@ -67,7 +69,7 @@
   initializeTypes();
 
   pdl::OperationType::attachInterface<
-      PDLOperationTypeTransformTypeInterfaceImpl>(*getContext());
+      PDLOperationTypeTransformHandleTypeInterfaceImpl>(*getContext());
 }
 
 void transform::TransformDialect::mergeInPDLMatchHooks(
diff --git a/mlir/lib/Dialect/Transform/IR/TransformInterfaces.cpp b/mlir/lib/Dialect/Transform/IR/TransformInterfaces.cpp
--- a/mlir/lib/Dialect/Transform/IR/TransformInterfaces.cpp
+++ b/mlir/lib/Dialect/Transform/IR/TransformInterfaces.cpp
@@ -79,7 +79,7 @@
   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()))
@@ -155,7 +155,7 @@
     }
   }
 
-  auto iface = value.getType().cast<TransformTypeInterface>();
+  auto iface = value.getType().cast<TransformHandleTypeInterface>();
   DiagnosedSilenceableFailure result =
       iface.checkPayload(value.getLoc(), updated);
   if (failed(result.checkAndReport()))
@@ -439,9 +439,10 @@
 
   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 =
@@ -469,7 +470,7 @@
   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)
diff --git a/mlir/lib/Dialect/Transform/IR/TransformOps.cpp b/mlir/lib/Dialect/Transform/IR/TransformOps.cpp
--- a/mlir/lib/Dialect/Transform/IR/TransformOps.cpp
+++ b/mlir/lib/Dialect/Transform/IR/TransformOps.cpp
@@ -281,7 +281,8 @@
   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>();
       });
 }
 
@@ -370,9 +371,9 @@
     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();
 }
 
diff --git a/mlir/test/Dialect/Transform/ops-invalid.mlir b/mlir/test/Dialect/Transform/ops-invalid.mlir
--- a/mlir/test/Dialect/Transform/ops-invalid.mlir
+++ b/mlir/test/Dialect/Transform/ops-invalid.mlir
@@ -1,6 +1,6 @@
 // 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) {
 }
 
@@ -190,7 +190,7 @@
 
 // -----
 
-// 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
diff --git a/mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.td b/mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.td
--- a/mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.td
+++ b/mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.td
@@ -23,7 +23,7 @@
 
 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 = "";
@@ -79,7 +79,7 @@
   : Op<Transform_Dialect, "test_print_remark_at_operand",
        [DeclareOpInterfaceMethods<TransformOpInterface>]> {
   let arguments = (ins
-    Arg<TransformTypeInterface, "",
+    Arg<TransformHandleTypeInterface, "",
         [TransformMappingRead, PayloadIRRead]>:$operand,
     StrAttr:$message);
   let assemblyFormat =
@@ -296,7 +296,7 @@
   : 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";