[Mlir-commits] [mlir] 97c0506 - [mlir] NFC: rename TransformTypeInterface to TransformHandleTypeInterface
Alex Zinenko
llvmlistbot at llvm.org
Fri Jan 6 04:23:50 PST 2023
Author: Alex Zinenko
Date: 2023-01-06T12:23:33Z
New Revision: 97c05062afdc6be334137c5450b9492af75d2610
URL: https://github.com/llvm/llvm-project/commit/97c05062afdc6be334137c5450b9492af75d2610
DIFF: https://github.com/llvm/llvm-project/commit/97c05062afdc6be334137c5450b9492af75d2610.diff
LOG: [mlir] NFC: rename TransformTypeInterface to TransformHandleTypeInterface
This makes it more consistent with the recently added
TransformParamTypeInterface.
Reviewed By: springerm
Differential Revision: https://reviews.llvm.org/D140977
Added:
Modified:
mlir/docs/Dialects/Transform.md
mlir/include/mlir/Dialect/SCF/TransformOps/SCFTransformOps.td
mlir/include/mlir/Dialect/Transform/IR/TransformDialect.h
mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.h
mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.td
mlir/include/mlir/Dialect/Transform/IR/TransformOps.td
mlir/include/mlir/Dialect/Transform/IR/TransformTypes.td
mlir/lib/Dialect/Transform/IR/TransformDialect.cpp
mlir/lib/Dialect/Transform/IR/TransformInterfaces.cpp
mlir/lib/Dialect/Transform/IR/TransformOps.cpp
mlir/test/Dialect/Transform/ops-invalid.mlir
mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.td
Removed:
################################################################################
diff --git a/mlir/docs/Dialects/Transform.md b/mlir/docs/Dialects/Transform.md
index a74ae5de73d33..eb86bdca5c2a0 100644
--- a/mlir/docs/Dialects/Transform.md
+++ b/mlir/docs/Dialects/Transform.md
@@ -73,7 +73,7 @@ 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
@@ -156,7 +156,7 @@ 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
diff --git a/mlir/include/mlir/Dialect/SCF/TransformOps/SCFTransformOps.td b/mlir/include/mlir/Dialect/SCF/TransformOps/SCFTransformOps.td
index 59d25da1b2d7c..0bdd581bc0083 100644
--- a/mlir/include/mlir/Dialect/SCF/TransformOps/SCFTransformOps.td
+++ b/mlir/include/mlir/Dialect/SCF/TransformOps/SCFTransformOps.td
@@ -32,11 +32,11 @@ def GetParentForOp : Op<Transform_Dialect, "loop.get_parent_for",
}];
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 @@ def LoopOutlineOp : Op<Transform_Dialect, "loop.outline",
// 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 @@ def LoopPeelOp : Op<Transform_Dialect, "loop.peel",
(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 @@ def LoopPipelineOp : Op<Transform_Dialect, "loop.pipeline",
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 @@ def LoopUnrollOp : Op<Transform_Dialect, "loop.unroll",
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
index e386b355e83f9..05533b6a3f2c6 100644
--- a/mlir/include/mlir/Dialect/Transform/IR/TransformDialect.h
+++ b/mlir/include/mlir/Dialect/Transform/IR/TransformDialect.h
@@ -25,9 +25,10 @@ namespace detail {
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 @@ class TransformDialectExtension
}
/// 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 @@ void TransformDialect::addTypeIfNotRegistered() {
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
index bfb6879e5d8b3..4cfc2e44ab96a 100644
--- a/mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.h
+++ b/mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.h
@@ -608,7 +608,7 @@ class TransformState {
///
/// 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 @@ class TransformResults {
/// 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
index 319af25f0c6af..b0b92daa3c855 100644
--- a/mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.td
+++ b/mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.td
@@ -129,8 +129,8 @@ class TransformTypeInterfaceBase<string cppClass, string cppObjectType>
}];
}
-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
index c813a64bd7e2c..b656bce1cc66a 100644
--- a/mlir/include/mlir/Dialect/Transform/IR/TransformOps.td
+++ b/mlir/include/mlir/Dialect/Transform/IR/TransformOps.td
@@ -88,8 +88,8 @@ def AlternativesOp : TransformDialectOp<"alternatives",
```
}];
- 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 @@ 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 = [{
@@ -143,8 +143,8 @@ def ForeachOp : TransformDialectOp<"foreach",
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 @@ def GetClosestIsolatedParentOp : TransformDialectOp<"get_closest_isolated_parent
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 @@ def GetProducerOfOperand : TransformDialectOp<"get_producer_of_operand",
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 @@ def MergeHandlesOp : TransformDialectOp<"merge_handles",
same or
diff erent 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 @@ def SplitHandlesOp : TransformDialectOp<"split_handles",
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 @@ def PDLMatchOp : TransformDialectOp<"pdl_match",
}];
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 @@ def PrintOp : TransformDialectOp<"print",
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 @@ def ReplicateOp : TransformDialectOp<"replicate",
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 @@ def SequenceOp : TransformDialectOp<"sequence",
}];
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 @@ def WithPDLPatternsOp : TransformDialectOp<"with_pdl_patterns",
}];
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 @@ def YieldOp : TransformDialectOp<"yield", [Terminator]> {
}];
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
index b7f39fae002b0..ebaf576451d79 100644
--- 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/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.
@@ -24,7 +24,7 @@ def Transform_AnyOpType : TypeDef<Transform_Dialect, "AnyOp",
}
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
index e7a08996fb03e..fdf3c74808cfd 100644
--- a/mlir/lib/Dialect/Transform/IR/TransformDialect.cpp
+++ b/mlir/lib/Dialect/Transform/IR/TransformDialect.cpp
@@ -35,11 +35,12 @@ void transform::detail::checkImplementsTransformOpInterface(
"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 @@ void transform::detail::checkImplementsTransformTypeInterface(
#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 @@ void transform::TransformDialect::initialize() {
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
index 5a178f31e96e8..46dc2aebdfc9c 100644
--- a/mlir/lib/Dialect/Transform/IR/TransformInterfaces.cpp
+++ b/mlir/lib/Dialect/Transform/IR/TransformInterfaces.cpp
@@ -79,7 +79,7 @@ transform::TransformState::setPayloadOps(Value value,
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 @@ LogicalResult transform::TransformState::updatePayloadOps(
}
}
- 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 @@ transform::detail::verifyPossibleTopLevelTransformOpTrait(Operation *op) {
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 @@ void transform::detail::getParamProducerTransformOpTraitEffects(
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
index 629b1f6a073b1..f7522fa55ca65 100644
--- a/mlir/lib/Dialect/Transform/IR/TransformOps.cpp
+++ b/mlir/lib/Dialect/Transform/IR/TransformOps.cpp
@@ -281,7 +281,8 @@ bool transform::CastOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
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 @@ LogicalResult transform::ForeachOp::verify() {
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
index 369be213d3ac4..ec3f5537cf55a 100644
--- 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 @@ transform.sequence failures(propagate) {
// -----
-// 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
index 59ad0442bfe80..c9740d1a69f4f 100644
--- a/mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.td
+++ b/mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.td
@@ -23,7 +23,7 @@ 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 = "";
@@ -79,7 +79,7 @@ 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 =
@@ -296,7 +296,7 @@ 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";
More information about the Mlir-commits
mailing list