xref: /llvm-project/mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.td (revision 6634d44e5e6079e19efe54c2de35e2e63108b085) 
1//===- TestTransformDialectExtension.td --------------------*- tablegen -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file declares the operations that are injected into the Transform
10// dialect through the extension mechanism, as a test.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef MLIR_TESTTRANSFORMDIALECTEXTENSION_TD
15#define MLIR_TESTTRANSFORMDIALECTEXTENSION_TD
16
17include "mlir/Interfaces/SideEffectInterfaces.td"
18include "mlir/IR/AttrTypeBase.td"
19include "mlir/IR/OpBase.td"
20include "mlir/Dialect/Transform/Interfaces/MatchInterfaces.td"
21include "mlir/Dialect/Transform/IR/TransformDialect.td"
22include "mlir/Dialect/Transform/Interfaces/TransformInterfaces.td"
23include "mlir/Dialect/PDL/IR/PDLTypes.td"
24
25def TestTransformTestDialectHandleType
26  : TypeDef<Transform_Dialect, "TestDialectOp",
27      [DeclareTypeInterfaceMethods<TransformHandleTypeInterface>]> {
28  let description = [{Handle pointing to an op from the Test dialect.}];
29  let mnemonic = "test_dialect_op";
30  let assemblyFormat = "";
31}
32
33def TestTransformTestDialectParamType
34  : TypeDef<Transform_Dialect, "TestDialectParam",
35      [DeclareTypeInterfaceMethods<TransformParamTypeInterface>]> {
36  let description = [{
37    Parameter associated with an i32 attribute for testing purposes.
38  }];
39  let mnemonic = "test_dialect_param";
40  let assemblyFormat = "";
41}
42
43def TestProduceSelfHandleOrForwardOperandOp
44  : Op<Transform_Dialect, "test_produce_self_handle_or_forward_operand",
45       [DeclareOpInterfaceMethods<TransformOpInterface>,
46        DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
47  let arguments = (ins Optional<TransformHandleTypeInterface>:$operand);
48  let results = (outs TransformHandleTypeInterface:$res);
49  let assemblyFormat =
50      "($operand^)? attr-dict `:` functional-type($operand, $res)";
51  let cppNamespace = "::mlir::test";
52}
53
54def TestProduceValueHandleToSelfOperand
55  : Op<Transform_Dialect, "test_produce_value_handle_to_self_operand",
56       [DeclareOpInterfaceMethods<TransformOpInterface>,
57        DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
58  let arguments = (ins TransformHandleTypeInterface:$in);
59  let results = (outs TransformValueHandleTypeInterface:$out);
60  let assemblyFormat = "$in attr-dict `:` functional-type(operands, results)";
61  let cppNamespace = "::mlir::test";
62}
63
64def TestProduceValueHandleToResult
65  : Op<Transform_Dialect, "test_produce_value_handle_to_result",
66       [TransformEachOpTrait, TransformOpInterface,
67        DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
68  let arguments = (ins TransformHandleTypeInterface:$in,
69                       I64Attr:$number);
70  let results = (outs TransformValueHandleTypeInterface:$out);
71  let assemblyFormat = "$in `,` $number attr-dict `:` functional-type(operands, results)";
72  let cppNamespace = "::mlir::test";
73  let extraClassDeclaration = [{
74    ::mlir::DiagnosedSilenceableFailure applyToOne(
75        ::mlir::transform::TransformRewriter &rewriter,
76        ::mlir::Operation *target,
77        ::mlir::transform::ApplyToEachResultList &results,
78        ::mlir::transform::TransformState &state);
79  }];
80}
81
82def TestProduceValueHandleToArgumentOfParentBlock
83  : Op<Transform_Dialect, "test_produce_value_handle_to_argument_of_parent_block",
84       [TransformEachOpTrait, TransformOpInterface,
85        DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
86  let arguments = (ins TransformHandleTypeInterface:$in,
87                       I64Attr:$number);
88  let results = (outs TransformValueHandleTypeInterface:$out);
89  let assemblyFormat = "$in `,` $number attr-dict `:` functional-type(operands, results)";
90  let cppNamespace = "::mlir::test";
91  let extraClassDeclaration = [{
92    ::mlir::DiagnosedSilenceableFailure applyToOne(
93        ::mlir::transform::TransformRewriter &rewriter,
94        ::mlir::Operation *target,
95        ::mlir::transform::ApplyToEachResultList &results,
96        ::mlir::transform::TransformState &state);
97  }];
98}
99
100def TestConsumeOperand : Op<Transform_Dialect, "test_consume_operand",
101     [DeclareOpInterfaceMethods<TransformOpInterface, ["allowsRepeatedHandleOperands"]>,
102      DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
103  let arguments = (ins
104    Transform_AnyHandleOrParamType:$operand,
105    Optional<TransformHandleTypeInterface>:$second_operand,
106    UnitAttr:$allow_repeated_handles);
107  let assemblyFormat =
108      "$operand (`,` $second_operand^)? attr-dict `:` type($operand)"
109      "(`,` type($second_operand)^)?";
110  let cppNamespace = "::mlir::test";
111}
112
113def TestConsumeOperandEach : Op<Transform_Dialect, "test_consume_operand_each",
114     [TransformOpInterface, TransformEachOpTrait,
115      MemoryEffectsOpInterface, FunctionalStyleTransformOpTrait]> {
116  let arguments = (ins TransformHandleTypeInterface:$target);
117  let assemblyFormat = "$target attr-dict `:` type($target)";
118  let cppNamespace = "::mlir::test";
119  let extraClassDeclaration = [{
120    ::mlir::DiagnosedSilenceableFailure applyToOne(
121        ::mlir::transform::TransformRewriter &rewriter,
122        ::mlir::Operation *target,
123        ::mlir::transform::ApplyToEachResultList &results,
124        ::mlir::transform::TransformState &state) {
125      return ::mlir::DiagnosedSilenceableFailure::success();
126    }
127  }];
128}
129
130def TestConsumeOperandOfOpKindOrFail
131  : Op<Transform_Dialect, "test_consume_operand_of_op_kind_or_fail",
132       [DeclareOpInterfaceMethods<TransformOpInterface>,
133        DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
134  let arguments = (ins
135    TransformHandleTypeInterface:$operand,
136    StrAttr:$op_kind);
137  let assemblyFormat =
138      "$operand `,` $op_kind attr-dict `:` type($operand)";
139  let cppNamespace = "::mlir::test";
140}
141
142def TestSucceedIfOperandOfOpKind
143  : Op<Transform_Dialect, "test_succeed_if_operand_of_op_kind",
144       [MatchOpInterface,
145        SingleOpMatcher,
146        DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
147  let arguments = (ins
148    TransformHandleTypeInterface:$operand_handle,
149    StrAttr:$op_kind);
150  let assemblyFormat =
151      "$operand_handle `,` $op_kind attr-dict `:` type($operand_handle)";
152  let extraClassDeclaration = SingleOpMatcher.extraDeclaration;
153  let cppNamespace = "::mlir::test";
154}
155
156def TestAddTestExtensionOp
157  : Op<Transform_Dialect, "test_add_test_extension",
158       [DeclareOpInterfaceMethods<TransformOpInterface>,
159        NoMemoryEffect]> {
160  let arguments = (ins StrAttr:$message);
161  let assemblyFormat = "$message attr-dict";
162  let cppNamespace = "::mlir::test";
163}
164
165def TestCheckIfTestExtensionPresentOp
166  : Op<Transform_Dialect, "test_check_if_test_extension_present",
167       [DeclareOpInterfaceMethods<TransformOpInterface>,
168        DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
169  let arguments = (ins TransformHandleTypeInterface:$operand);
170  let assemblyFormat = "$operand attr-dict `:` type($operand)";
171  let cppNamespace = "::mlir::test";
172}
173
174def TestRemapOperandPayloadToSelfOp
175  : Op<Transform_Dialect, "test_remap_operand_to_self",
176       [DeclareOpInterfaceMethods<TransformOpInterface>,
177        DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
178  let arguments = (ins TransformHandleTypeInterface:$operand);
179  let results = (outs Optional<TransformHandleTypeInterface>:$out);
180  let assemblyFormat = "$operand attr-dict `:` functional-type($operand, $out)";
181  let cppNamespace = "::mlir::test";
182}
183
184def TestRemoveTestExtensionOp
185  : Op<Transform_Dialect, "test_remove_test_extension",
186       [DeclareOpInterfaceMethods<TransformOpInterface>,
187        NoMemoryEffect]> {
188  let assemblyFormat = "attr-dict";
189  let cppNamespace = "::mlir::test";
190}
191
192def TestReversePayloadOpsOp
193  : Op<Transform_Dialect, "test_reverse_payload_ops",
194    [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
195     DeclareOpInterfaceMethods<TransformOpInterface>]> {
196  let arguments = (ins TransformHandleTypeInterface:$target);
197  let results = (outs TransformHandleTypeInterface:$result);
198  let assemblyFormat = "$target attr-dict `:` functional-type(operands, results)";
199  let cppNamespace = "::mlir::test";
200}
201
202def TestTransformOpWithRegions
203  : Op<Transform_Dialect, "test_transform_op_with_regions",
204       [DeclareOpInterfaceMethods<TransformOpInterface>,
205        DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
206  let regions = (region AnyRegion:$first, AnyRegion:$second);
207  let assemblyFormat = "attr-dict-with-keyword regions";
208  let cppNamespace = "::mlir::test";
209}
210
211def TestBranchingTransformOpTerminator
212  : Op<Transform_Dialect, "test_branching_transform_op_terminator",
213       [Terminator, DeclareOpInterfaceMethods<TransformOpInterface>,
214        DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
215  let successors = (successor VariadicSuccessor<AnySuccessor>:$succ);
216  let cppNamespace = "::mlir::test";
217}
218
219def TestEmitRemarkAndEraseOperandOp
220  : Op<Transform_Dialect, "test_emit_remark_and_erase_operand",
221    [DeclareOpInterfaceMethods<TransformOpInterface>,
222     DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
223     FunctionalStyleTransformOpTrait]> {
224  let arguments = (ins TransformHandleTypeInterface:$target, StrAttr:$remark,
225                   UnitAttr:$fail_after_erase);
226  let assemblyFormat = "$target `,` $remark attr-dict `:` type($target)";
227  let cppNamespace = "::mlir::test";
228}
229
230def TestWrongNumberOfResultsOp
231  : Op<Transform_Dialect, "test_wrong_number_of_results",
232    [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
233     TransformEachOpTrait, TransformOpInterface]> {
234  let arguments = (ins TransformHandleTypeInterface:$target);
235  let results = (outs TransformHandleTypeInterface:$a,
236                      TransformHandleTypeInterface:$b,
237                      TransformHandleTypeInterface:$c);
238  let assemblyFormat =
239      "$target attr-dict `:` functional-type(operands, results)";
240  let cppNamespace = "::mlir::test";
241  let extraClassDeclaration = [{
242    ::mlir::DiagnosedSilenceableFailure applyToOne(
243        ::mlir::transform::TransformRewriter &rewriter,
244        ::mlir::Operation * target,
245        ::mlir::transform::ApplyToEachResultList &results,
246        ::mlir::transform::TransformState &state);
247  }];
248}
249
250def TestWrongNumberOfMultiResultsOp
251  : Op<Transform_Dialect, "test_wrong_number_of_multi_results",
252    [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
253     TransformEachOpTrait, TransformOpInterface]> {
254  let arguments = (ins TransformHandleTypeInterface:$target);
255  let results = (outs TransformHandleTypeInterface:$result);
256  let assemblyFormat =
257      "$target attr-dict `:` functional-type($target, $result)";
258  let cppNamespace = "::mlir::test";
259  let extraClassDeclaration = [{
260    ::mlir::DiagnosedSilenceableFailure applyToOne(
261        ::mlir::transform::TransformRewriter &rewriter,
262        ::mlir::Operation * target,
263        ::mlir::transform::ApplyToEachResultList &results,
264        ::mlir::transform::TransformState &state);
265  }];
266}
267
268def TestCorrectNumberOfMultiResultsOp
269  : Op<Transform_Dialect, "test_correct_number_of_multi_results",
270    [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
271     TransformEachOpTrait, TransformOpInterface]> {
272  let arguments = (ins TransformHandleTypeInterface:$target);
273  let results = (outs TransformHandleTypeInterface:$result1,
274                      TransformHandleTypeInterface:$result2);
275  let assemblyFormat =
276      "$target attr-dict `:` functional-type(operands, results)";
277  let cppNamespace = "::mlir::test";
278  let extraClassDeclaration = [{
279    ::mlir::DiagnosedSilenceableFailure applyToOne(
280        ::mlir::transform::TransformRewriter &rewriter,
281        ::mlir::Operation * target,
282        ::mlir::transform::ApplyToEachResultList &results,
283        ::mlir::transform::TransformState &state);
284  }];
285}
286
287def TestMixedNullAndNonNullResultsOp
288  : Op<Transform_Dialect, "test_mixed_null_and_non_null_results",
289    [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
290     TransformEachOpTrait, TransformOpInterface]> {
291  let arguments = (ins TransformHandleTypeInterface:$target);
292  let results = (outs TransformHandleTypeInterface:$null,
293                      TransformHandleTypeInterface:$non_null);
294  let assemblyFormat =
295      "$target attr-dict `:` functional-type(operands, results)";
296  let cppNamespace = "::mlir::test";
297  let extraClassDeclaration = [{
298    ::mlir::DiagnosedSilenceableFailure applyToOne(
299        ::mlir::transform::TransformRewriter &rewriter,
300        ::mlir::Operation * target,
301        ::mlir::transform::ApplyToEachResultList &results,
302        ::mlir::transform::TransformState &state);
303  }];
304}
305
306def TestMixedSuccessAndSilenceableOp
307  : Op<Transform_Dialect, "test_mixed_success_and_silenceable",
308    [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
309     TransformEachOpTrait, TransformOpInterface]> {
310  let arguments = (ins TransformHandleTypeInterface:$target);
311  let results = (outs);
312  let assemblyFormat = "$target attr-dict `:` type($target)";
313  let cppNamespace = "::mlir::test";
314  let extraClassDeclaration = [{
315    ::mlir::DiagnosedSilenceableFailure applyToOne(
316        ::mlir::transform::TransformRewriter &rewriter,
317        ::mlir::Operation * target,
318        ::mlir::transform::ApplyToEachResultList &results,
319        ::mlir::transform::TransformState &state);
320  }];
321}
322
323def TestCopyPayloadOp
324  : Op<Transform_Dialect, "test_copy_payload",
325       [DeclareOpInterfaceMethods<TransformOpInterface>,
326        DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
327  let arguments = (ins TransformHandleTypeInterface:$handle);
328  let results = (outs TransformHandleTypeInterface:$copy);
329  let cppNamespace = "::mlir::test";
330  let assemblyFormat =
331      "$handle attr-dict `:` functional-type(operands, results)";
332}
333
334def TestReportNumberOfTrackedHandlesNestedUnder
335  : Op<Transform_Dialect, "test_report_number_of_tracked_handles_nested_under",
336    [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
337     DeclareOpInterfaceMethods<TransformOpInterface>]> {
338  let arguments = (ins TransformHandleTypeInterface:$target);
339  let assemblyFormat = "$target attr-dict `:` type($target)";
340  let cppNamespace = "::mlir::test";
341}
342
343def TestAddToParamOp
344  : Op<Transform_Dialect, "test_add_to_param",
345       [MatchOpInterface,
346        MemoryEffectsOpInterface,
347        ParamProducerTransformOpTrait,
348        DeclareOpInterfaceMethods<TransformOpInterface>]> {
349  let arguments = (ins Optional<TestTransformTestDialectParamType>:$param,
350                       I32Attr:$addendum);
351  let results = (outs TestTransformTestDialectParamType:$result);
352  let assemblyFormat = "($param^ `,`)? $addendum attr-dict";
353  let cppNamespace = "::mlir::test";
354}
355
356def TestProduceParamWithNumberOfTestOps
357  : Op<Transform_Dialect, "test_produce_param_with_number_of_test_ops",
358       [MatchOpInterface,
359        MemoryEffectsOpInterface,
360        ParamProducerTransformOpTrait,
361        DeclareOpInterfaceMethods<TransformOpInterface>]> {
362  let arguments = (ins TransformHandleTypeInterface:$handle);
363  let results = (outs TestTransformTestDialectParamType:$result);
364  let assemblyFormat = "$handle attr-dict `:` type($handle)";
365  let cppNamespace = "::mlir::test";
366}
367
368def TestProduceParamOp
369  : Op<Transform_Dialect, "test_produce_param",
370       [MemoryEffectsOpInterface, ParamProducerTransformOpTrait,
371        DeclareOpInterfaceMethods<TransformOpInterface>]> {
372  let arguments = (ins AnyAttr:$attr);
373  let results = (outs TransformParamTypeInterface:$result);
374  let assemblyFormat = "`(` $attr `)` attr-dict `:` type($result)";
375  let cppNamespace = "::mlir::test";
376}
377
378def TestProduceTransformParamOrForwardOperandOp
379  : Op<Transform_Dialect, "test_produce_transform_param_or_forward_operand",
380       [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
381        TransformEachOpTrait, TransformOpInterface]> {
382  let arguments = (ins TransformHandleTypeInterface:$in,
383                       UnitAttr:$first_result_is_param,
384                       UnitAttr:$first_result_is_null,
385                       UnitAttr:$second_result_is_handle);
386  let results = (outs AnyType:$out,
387                      TransformParamTypeInterface:$param);
388  let assemblyFormat = "$in attr-dict `:` functional-type(operands, results)";
389  let cppNamespace = "::mlir::test";
390
391  let extraClassDeclaration = [{
392    ::mlir::DiagnosedSilenceableFailure applyToOne(
393        ::mlir::transform::TransformRewriter &rewriter,
394        ::mlir::Operation *target,
395        ::mlir::transform::ApplyToEachResultList &results,
396        ::mlir::transform::TransformState &state);
397  }];
398}
399
400def TestProduceNullPayloadOp
401  : Op<Transform_Dialect, "test_produce_null_payload",
402      [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
403       DeclareOpInterfaceMethods<TransformOpInterface>]> {
404  let results = (outs TransformHandleTypeInterface:$out);
405  let assemblyFormat = "attr-dict `:` type($out)";
406  let cppNamespace = "::mlir::test";
407}
408
409def TestProduceEmptyPayloadOp
410  : Op<Transform_Dialect, "test_produce_empty_payload",
411      [DeclareOpInterfaceMethods<TransformOpInterface>,
412       MemoryEffectsOpInterface, FunctionalStyleTransformOpTrait]> {
413  let results = (outs TransformHandleTypeInterface:$out);
414  let assemblyFormat = "attr-dict `:` type($out)";
415  let cppNamespace = "::mlir::test";
416}
417
418def TestProduceNullParamOp
419  : Op<Transform_Dialect, "test_produce_null_param",
420      [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
421       DeclareOpInterfaceMethods<TransformOpInterface>]> {
422  let results = (outs TransformParamTypeInterface:$out);
423  let assemblyFormat = "attr-dict `:` type($out)";
424  let cppNamespace = "::mlir::test";
425}
426
427def TestProduceNullValueOp
428  : Op<Transform_Dialect, "test_produce_null_value",
429       [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
430        DeclareOpInterfaceMethods<TransformOpInterface>]> {
431  let results = (outs TransformValueHandleTypeInterface:$out);
432  let assemblyFormat = "attr-dict `:` type($out)";
433  let cppNamespace = "::mlir::test";
434}
435
436def TestRequiredMemoryEffectsOp
437  : Op<Transform_Dialect, "test_required_memory_effects",
438      [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
439       DeclareOpInterfaceMethods<TransformOpInterface>]> {
440  let arguments = (ins TransformHandleTypeInterface:$in,
441                       UnitAttr:$has_operand_effect,
442                       UnitAttr:$has_result_effect,
443                       UnitAttr:$modifies_payload);
444  let results = (outs TransformHandleTypeInterface:$out);
445  let assemblyFormat = "$in attr-dict `:` functional-type(operands, results)";
446  let cppNamespace = "::mlir::test";
447}
448
449// This op is used as a payload op. It must be a registered op, so that it can
450// be created with "RewriterBase::replaceOpWithNewOp" (needed for a test case).
451// Since only TransformOpInterface can be injected into the transform dialect,
452// this op implements the interface, even though it is not used as a transform
453// op.
454def TestDummyPayloadOp
455  : Op<Transform_Dialect, "test_dummy_payload_op",
456      [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
457       TransformOpInterface]> {
458  let arguments = (ins Variadic<AnyType>:$args,
459                       UnitAttr:$fail_to_verify);
460  let results = (outs Variadic<AnyType>:$outs);
461  let assemblyFormat = "$args attr-dict `:` functional-type(operands, results)";
462  let cppNamespace = "::mlir::test";
463  let hasVerifier = 1;
464
465  let extraClassDeclaration = [{
466    DiagnosedSilenceableFailure apply(transform::TransformRewriter &rewriter,
467                                      transform::TransformResults &results,
468                                      transform::TransformState &state) {
469      llvm_unreachable("op should not be used as a transform");
470      return DiagnosedSilenceableFailure::definiteFailure();
471    }
472  }];
473}
474
475def TestTrackedRewriteOp
476  : Op<Transform_Dialect, "test_tracked_rewrite",
477      [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
478       DeclareOpInterfaceMethods<TransformOpInterface>]> {
479  let arguments = (ins TransformHandleTypeInterface:$in);
480  let results = (outs);
481  let assemblyFormat = "$in attr-dict `:` functional-type(operands, results)";
482  let cppNamespace = "::mlir::test";
483}
484
485def ApplyTestPatternsOp
486  : Op<Transform_Dialect, "apply_patterns.transform.test_patterns",
487      [DeclareOpInterfaceMethods<PatternDescriptorOpInterface>]> {
488  let arguments = (ins);
489  let results = (outs);
490  let assemblyFormat = "attr-dict";
491  let cppNamespace = "::mlir::test";
492}
493
494def ApplyTestConversionPatternsOp
495  : Op<Transform_Dialect, "apply_conversion_patterns.transform.test_conversion_patterns",
496      [DeclareOpInterfaceMethods<ConversionPatternDescriptorOpInterface>]> {
497  let arguments = (ins);
498  let results = (outs);
499  let assemblyFormat = "attr-dict";
500  let cppNamespace = "::mlir::test";
501}
502
503def TestTypeConverterOp
504  : Op<Transform_Dialect, "apply_conversion_patterns.transform.test_type_converter",
505      [DeclareOpInterfaceMethods<TypeConverterBuilderOpInterface,
506                                 ["getTypeConverter"]>]> {
507  let arguments = (ins);
508  let results = (outs);
509  let assemblyFormat = "attr-dict";
510  let cppNamespace = "::mlir::test";
511}
512
513def TestReEnterRegionOp
514  : Op<Transform_Dialect, "test_re_enter_region",
515       [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
516        DeclareOpInterfaceMethods<TransformOpInterface>]> {
517  let arguments = (ins Variadic<AnyType>:$args);
518  let regions = (region SizedRegion<1>:$body);
519  let assemblyFormat = "($args^ `:` type($args))? attr-dict-with-keyword regions";
520  let cppNamespace = "::mlir::test";
521  let hasVerifier = 1;
522}
523
524def TestNotifyPayloadOpReplacedOp
525  : Op<Transform_Dialect, "test_notify_payload_op_replaced",
526       [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
527        DeclareOpInterfaceMethods<TransformOpInterface>]> {
528  let arguments = (ins TransformHandleTypeInterface:$original,
529                       TransformHandleTypeInterface:$replacement);
530  let results = (outs);
531  let assemblyFormat = "$original `,` $replacement attr-dict `:` functional-type(operands, results)";
532  let cppNamespace = "::mlir::test";
533}
534
535def TestProduceInvalidIR
536  : Op<Transform_Dialect, "test_produce_invalid_ir",
537       [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
538        TransformOpInterface, TransformEachOpTrait]> {
539  let arguments = (ins TransformHandleTypeInterface:$target);
540  let results = (outs);
541  let assemblyFormat = "$target attr-dict `:` type($target)";
542  let cppNamespace = "::mlir::test";
543  let extraClassDeclaration = [{
544    ::mlir::DiagnosedSilenceableFailure applyToOne(
545        ::mlir::transform::TransformRewriter &rewriter,
546        ::mlir::Operation *target,
547        ::mlir::transform::ApplyToEachResultList &results,
548        ::mlir::transform::TransformState &state);
549  }];
550}
551
552def TestInitializerExtensionOp
553  : Op<Transform_Dialect, "test_initializer_extension",
554       [DeclareOpInterfaceMethods<TransformOpInterface>,
555        NoMemoryEffect]> {
556  let arguments = (ins StrAttr:$type);
557  let assemblyFormat = "$type attr-dict";
558  let cppNamespace = "::mlir::test";
559}
560
561#endif // MLIR_TESTTRANSFORMDIALECTEXTENSION_TD
562