[mlir][transform] failure propagation mode in sequence

[ftynse]

Summary

Introduce two different failure propagation mode in the Transform
dialect's Sequence operation. These modes specify whether silenceable
errors produced by nested ops are immediately propagated, thus stopping
the sequence, or suppressed. The latter is useful in end-to-end
transform application scenarios where the user cannot correct the
transformation, but it is robust enough to silenceable failures. It
can be combined with the "alternatives" operation. There is
intentionally no default value to avoid favoring one mode over the
other.

Downstreams can update their tests using:

S='s/sequence \(%.*\) {/sequence \1 failures(propagate) {/'
T='s/sequence {/sequence failures(propagate) {/'
git grep -l transform.sequence | xargs sed -i -e "$S"
git grep -l transform.sequence | xargs sed -i -e "$T"

mlir/include/mlir/Dialect/Transform/IR/CMakeLists.txt

 # Generate the dialect files from the dialect .td.
 #
 # TODO: Make it possible to use XDialect instead of XOpsDialect in
 # add_mlir_dialect.
 set(LLVM_TARGET_DEFINITIONS TransformDialect.td)
 mlir_tablegen(TransformDialect.h.inc -gen-dialect-decls -dialect=transform)
 mlir_tablegen(TransformDialect.cpp.inc -gen-dialect-defs -dialect=transform)
 add_public_tablegen_target(MLIRTransformDialectIncGen)
 add_dependencies(mlir-headers MLIRTransformDialectIncGen)
 
+set(LLVM_TARGET_DEFINITIONS TransformAttrs.td)
+mlir_tablegen(TransformDialectEnums.h.inc -gen-enum-decls)
+mlir_tablegen(TransformDialectEnums.cpp.inc -gen-enum-defs)
+add_public_tablegen_target(MLIRTransformDialectEnumIncGen)
+add_dependencies(mlir-headers MLIRTransformDialectEnumIncGen)
+
 add_mlir_dialect(TransformOps transform)
 add_mlir_doc(TransformOps TransformOps Dialects/ -gen-dialect-doc -dialect=transform)
 
 add_mlir_interface(TransformInterfaces)
 add_mlir_doc(TransformInterfaces TransformOpInterfaces Dialects/ -gen-op-interface-docs)

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

+//===- TransformAttrs.td - Transform dialect attributes ----*- 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_TRANSFORMATTRS
+#define MLIR_DIALECT_TRANSFORM_IR_TRANSFORMATTRS
+
+include "mlir/IR/EnumAttr.td"
+
+def PropagateFailuresCase : I32EnumAttrCase<"Propagate", 1, "propagate">;
+def SuppressFailuresCase : I32EnumAttrCase<"Suppress", 2, "suppress">;
+
+def FailurePropagationMode : I32EnumAttr<
+    "FailurePropagationMode", "Silenceable error propagation policy",
+    [PropagateFailuresCase, SuppressFailuresCase]> {
+  let cppNamespace = "::mlir::transform";
+}
+
+#endif  // MLIR_DIALECT_TRANSFORM_IR_TRANSFORMATTRS

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

 class BuildOnly : public DerivedTy {
 public:
   BuildOnly() : DerivedTy(/*buildOnly=*/true) {}
 };
 
 } // namespace transform
 } // namespace mlir
 
+#include "mlir/Dialect/Transform/IR/TransformDialectEnums.h.inc"
+
 #endif // MLIR_DIALECT_TRANSFORM_IR_TRANSFORMDIALECT_H

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

 
 #include "mlir/Dialect/PDL/IR/PDLTypes.h"
 #include "mlir/Dialect/Transform/IR/TransformInterfaces.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 
+namespace mlir {
+namespace transform {
+enum class FailurePropagationMode : uint32_t;
+class FailurePropagationModeAttr;
+} // namespace transform
+} // namespace mlir
+
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Transform/IR/TransformOps.h.inc"
 
 #endif // MLIR_DIALECT_TRANSFORM_IR_TRANSFORMOPS_H

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

 //===- TransformOps.td - Transform dialect operations ------*- 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_TRANSFORMOPS
 #define MLIR_DIALECT_TRANSFORM_IR_TRANSFORMOPS
 
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/IR/OpAsmInterface.td"
 include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Dialect/PDL/IR/PDLTypes.td"
+include "mlir/Dialect/Transform/IR/TransformAttrs.td"
 include "mlir/Dialect/Transform/IR/TransformDialect.td"
 include "mlir/Dialect/Transform/IR/TransformEffects.td"
 include "mlir/Dialect/Transform/IR/TransformInterfaces.td"
 
 def AlternativesOp : TransformDialectOp<"alternatives",
     [DeclareOpInterfaceMethods<RegionBranchOpInterface,
         ["getSuccessorEntryOperands", "getSuccessorRegions",
          "getRegionInvocationBounds"]>,
def SequenceOp : TransformDialectOp<"sequence",
      DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
      OpAsmOpInterface, PossibleTopLevelTransformOpTrait,
      SingleBlockImplicitTerminator<"::mlir::transform::YieldOp">]> {
   let summary = "Contains a sequence of other transform ops to apply";
   let description = [{
     The transformations indicated by the sequence are applied in order of their
     appearance. Each value produced by a transformation within the sequence
     corresponds to an operation or a group of operations in the payload IR.
-    During application, if any transformation in the sequence fails, the entire
-    sequence fails immediately leaving the payload IR in potentially invalid
-    state, i.e., this operation offers no transformation rollback capabilities.
+    The behavior of the operation when a nested transformation produces a
+    silenceable error is controlled by the `failure_propagation_mode` attribute.
+    When set to `propagate`, the failure of any nested transformation in the
+    sequence implies immediate failure of the entire sequence with a silenceable
+    error, and no further transformation is attempted. When set to `suppress`,
+    silenceable errors in nested operations are ignored and further
+    transformations are applied. Beware that even silenceable errors may leave
+    the payload IR in a state unsuitable for further transformations. It is
+    the responsibility of the caller to ensure the following transformations
+    are robust enough when errors are suppressed. Definite errors reported by
+    nested transformations abort the sequence regardless of the propagation
+    mode. The set of modes may be extended in the future, e.g., to collect
+    silenceable errors and report them after attempting all transformations in
+    the sequence.
 
     The entry block of this operation has a single argument that maps to either
     the operand if provided or the top-level container operation of the payload
     IR, typically the root operation of the pass interpreting the transform
     dialect. Operand omission is only allowed for sequences not contained in
     another sequence.
   }];
 
-  let arguments = (ins Optional<PDL_Operation>:$root);
+  let arguments = (ins FailurePropagationMode:$failure_propagation_mode,
+                       Optional<PDL_Operation>:$root);
   let results = (outs Variadic<AnyType>:$results);
   let regions = (region SizedRegion<1>:$body);
 
   let assemblyFormat =
-    "($root^)? attr-dict-with-keyword regions (`:` type($results)^)?";
+    "($root^)? `failures` `(` $failure_propagation_mode `)` attr-dict-with-keyword regions (`:` type($results)^)?";
 
   let extraClassDeclaration = [{
     /// Allow the dialect prefix to be omitted.
     static StringRef getDefaultDialect() { return "transform"; }
   }];
 
   let hasVerifier = 1;
 }
let description = [{
     transform.with_pdl_patterns {
     ^bb0(%arg0: !pdl.operation):
       pdl.pattern @my_pattern : benefit(1) {
         %0 = pdl.operation //...
         // Regular PDL goes here.
         pdl.rewrite %0 with "transform.dialect"
       }
 
-      sequence %arg0 {
+      sequence %arg0 failures(propagate) {
       ^bb0(%arg1: !pdl.operation):
         %1 = pdl_match @my_pattern in %arg1
         // Use %1 as handle
       }
     }
     ```
 
     Note that the pattern is expected to finish with a `pdl.rewrite` terminator

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

void transform::TransformDialect::mergeInPDLMatchHooks(
   for (auto &it : constraintFns)
     pdlMatchHooks.registerConstraintFunction(it.getKey(), std::move(it.second));
 }
 
 const llvm::StringMap<PDLConstraintFunction> &
 transform::TransformDialect::getPDLConstraintHooks() const {
   return pdlMatchHooks.getConstraintFunctions();
 }
+
+#include "mlir/Dialect/Transform/IR/TransformDialectEnums.cpp.inc"

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

transform::SequenceOp::apply(transform::TransformResults &results,
   auto scope = state.make_region_scope(*getBodyBlock()->getParent());
   if (failed(mapBlockArguments(state)))
     return DiagnosedSilenceableFailure::definiteFailure();
 
   // Apply the sequenced ops one by one.
   for (Operation &transform : getBodyBlock()->without_terminator()) {
     DiagnosedSilenceableFailure result =
         state.applyTransform(cast<TransformOpInterface>(transform));
-    if (!result.succeeded())
+    if (result.isDefiniteFailure())
       return result;
+
+    if (result.isSilenceableFailure()) {
+      if (getFailurePropagationMode() == FailurePropagationMode::Propagate)
+        return result;
+      (void)result.silence();
+    }
   }
 
   // Forward the operation mapping for values yielded from the sequence to the
   // values produced by the sequence op.
   forwardTerminatorOperands(getBodyBlock(), state, results);
   return DiagnosedSilenceableFailure::success();
 }
 

mlir/python/mlir/dialects/_transform_ops_ext.py

 #  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
 
 try:
   from ..ir import *
   from ._ods_common import get_op_result_or_value as _get_op_result_or_value, get_op_results_or_values as _get_op_results_or_values
   from ..dialects import pdl
 except ImportError as e:
   raise RuntimeError("Error loading imports from extension module") from e
 
+from argparse import SUPPRESS
 from typing import Optional, overload, Sequence, Union
 
 
 def _get_symbol_ref_attr(value: Union[Attribute, str]):
   if isinstance(value, Attribute):
     return value
   return FlatSymbolRefAttr.get(value)
 
super().__init__(
         [_get_op_result_or_value(h) for h in handles],
         loc=loc,
         ip=ip)
 
 
 class SequenceOp:
 
   @overload
-  def __init__(self, resultsOrRoot: Sequence[Type],
+  def __init__(self, failure_propagation_mode,
+               resultsOrRoot: Sequence[Type],
                optionalRoot: Optional[Union[Operation, Value]]):
     ...
 
   @overload
-  def __init__(self, resultsOrRoot: Optional[Union[Operation, Value]],
-               optionalRoot: NoneType):
+  def __init__(self, failure_propagation_mode,
+               resultsOrRoot: Optional[Union[Operation,
+                                             Value]], optionalRoot: NoneType):
     ...
 
-  def __init__(self, resultsOrRoot=None, optionalRoot=None):
+  def __init__(self, failure_propagation_mode, resultsOrRoot=None, optionalRoot=None):
     results = resultsOrRoot if isinstance(resultsOrRoot, Sequence) else []
     root = (
         resultsOrRoot
         if not isinstance(resultsOrRoot, Sequence) else optionalRoot)
     root = _get_op_result_or_value(root) if root else None
-    super().__init__(results_=results, root=root)
+    if not isinstance(failure_propagation_mode, Attribute):
+      failure_propagation_mode_attr = IntegerAttr.get(
+          IntegerType.get_signless(32), failure_propagation_mode._as_int())
+    else:
+      failure_propagation_mode = failure_propagation_mode
+    super().__init__(results_=results,
+                     failure_propagation_mode=failure_propagation_mode_attr,
+                     root=root)
     self.regions[0].blocks.append(pdl.OperationType.get())
 
   @property
   def body(self) -> Block:
     return self.regions[0].blocks[0]
 
   @property
   def bodyTarget(self) -> Value:

mlir/python/mlir/dialects/transform/__init__.py

 #  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
 
+from enum import Enum
+
+
+class FailurePropagationMode(Enum):
+  """Propagation mode for silenceable errors."""
+  PROPAGATE = 1
+  SUPPRESS = 2
+
+  def _as_int(self):
+    if self is FailurePropagationMode.PROPAGATE:
+      return 1
+
+    assert self is FailurePropagationMode.SUPPRESS
+    return 2
+
 from .._transform_ops_gen import *

mlir/test/Dialect/Bufferization/Transforms/transform-ops.mlir

 // RUN: mlir-opt --test-transform-dialect-interpreter %s -split-input-file -verify-diagnostics | FileCheck %s
 
 // Test One-Shot Bufferize.
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
     ^bb0(%arg1: !pdl.operation):
       %0 = transform.structured.match ops{["func.func"]} in %arg1
       transform.bufferization.one_shot_bufferize %0
           {target_is_module = false}
   }
 }
 
 // CHECK-LABEL: func @test_function(

 }
 
 // -----
 
 // Test analysis of One-Shot Bufferize only.
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
     ^bb0(%arg1: !pdl.operation):
       %0 = transform.structured.match ops{["func.func"]} in %arg1
       transform.bufferization.one_shot_bufferize %0
           {target_is_module = false, test_analysis_only = true}
   }
 }
 
 // CHECK-LABEL: func @test_function_analysis(

 
 // -----
 
 // Test One-Shot Bufferize transform failure with an unknown op. This would be
 // allowed with `allow_unknown_ops`.
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
     ^bb0(%arg1: !pdl.operation):
       %0 = transform.structured.match ops{["func.func"]} in %arg1
       // expected-error @+1 {{bufferization failed}}
       transform.bufferization.one_shot_bufferize %0 {target_is_module = false}
   }
 }
 
 func.func @test_unknown_op_failure() -> (tensor<?xf32>) {
   // expected-error @+1 {{op was not bufferized}}
   %0 = "test.dummy_op"() : () -> (tensor<?xf32>)
   return %0 : tensor<?xf32>
 }
 
 // -----
 
 // Test One-Shot Bufferize transform failure with a module op.
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
     ^bb0(%arg1: !pdl.operation):
       // %arg1 is the module
       transform.bufferization.one_shot_bufferize %arg1
   }
 }
 
 module {
   // CHECK-LABEL: func @test_function(

mlir/test/Dialect/Linalg/multisize-tiling-full.mlir

 // RUN: mlir-opt --test-transform-dialect-interpreter --canonicalize %s | FileCheck %s
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
   // This implements a 2D multisize tiling with target sizes [3, 10].
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.generic"]} in %arg1
     %1:3 = transform.structured.multitile_sizes %0 { dimension = 0, target_size = 3}
     %t:3 = transform.structured.multitile_sizes %0 { dimension = 1, target_size = 10}
     %2:2 = transform.structured.split %0 after %1#2 { dimension = 0 }
     %3:2 = transform.structured.tile %2#0 [%1#0]
     %4:2 = transform.structured.tile %2#1 [%1#1]
     %5 = merge_handles %3#0, %4#0

mlir/test/Dialect/Linalg/promote.mlir

 //       CHECK:           memref<?x?xf32, #[[$strided2D]]>
 //
 //   CHECK-NOT:         memref.dealloc %[[tmpA]] : memref<32xi8>
 //   CHECK-NOT:         memref.dealloc %[[tmpB]] : memref<48xi8>
 //   CHECK-NOT:         memref.dealloc %[[tmpC]] : memref<24xi8>
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
     ^bb0(%arg1: !pdl.operation):
       %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
       %1 = transform.structured.promote %0 { use_alloca }
   }
 }
 
 // -----
 

 //       CHECK:           memref<?x?xf64, #[[$strided2D]]>
 //
 //       CHECK:         memref.dealloc %[[tmpA_f64]] : memref<64xi8>
 //       CHECK:         memref.dealloc %[[tmpB_f64]] : memref<96xi8>
 //       CHECK:         memref.dealloc %[[tmpC_f64]] : memref<48xi8>
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
     ^bb0(%arg1: !pdl.operation):
       %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
       %1 = transform.structured.promote %0
   }
 }
 
 
 // -----
^bb0(%arg9: f32, %arg10: f32, %arg11: f32):
     linalg.yield %16 : f32
   }
 
   return
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
     ^bb0(%arg1: !pdl.operation):
       %0 = transform.structured.match interface{LinalgOp} in %arg1
       %1 = transform.structured.promote %0
   }
 }

mlir/test/Dialect/Linalg/promotion_options.mlir

 //      CHECK:       memref.copy %[[T17]], %[[T21]]
 //      CHECK:       linalg.matmul ins(%[[T19]], %[[T12]]{{.*}} outs(%[[T21]]
 //      CHECK:       memref.copy %[[T21]], %[[T17]]
 //      CHECK:       memref.dealloc %[[A0]]
 //      CHECK:       memref.dealloc %[[A1]]
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
     ^bb0(%arg1: !pdl.operation):
       %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
       %1, %loops:3 = transform.structured.tile %0 [16, 16, 16]
       %2 = transform.structured.promote %1 { operands_to_promote = [0, 2], force_full_tiles = [false, false] }
   }
 }

mlir/test/Dialect/Linalg/tile-to-foreach-thread.mlir

//  CHECK-SAME:   %[[C:[0-9a-z]+]]: tensor<?x?xf32>
   // CHECK-NEXT: } {thread_dim_mapping = [1, 0]}
     %0 = linalg.matmul ins(%A, %B : tensor<?x?xf32>, tensor<?x?xf32>)
                       outs(%C : tensor<?x?xf32>) -> (tensor<?x?xf32>)
     return %0 : tensor<?x?xf32>
   }
 
   transform.with_pdl_patterns {
   ^bb0(%arg0: !pdl.operation):
-    transform.sequence %arg0 {
+    transform.sequence %arg0 failures(propagate) {
     ^bb1(%arg1: !pdl.operation):
       %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
       %1:2 = transform.structured.tile_to_foreach_thread_op %0 num_threads [10, 20] (mapped to dims [1, 0])
     }
   }
 }
 
 // -----
func.func @matmul_static(%A: tensor<100x200xf32>, %B: tensor<200x300xf32>, %C: tensor<100x300xf32>) -> tensor<100x300xf32> {
   // CHECK-NEXT:    tensor.parallel_insert_slice
   %0 = linalg.matmul ins(%A, %B : tensor<100x200xf32>, tensor<200x300xf32>)
                     outs(%C : tensor<100x300xf32>) -> (tensor<100x300xf32>)
   return %0 : tensor<100x300xf32>
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
     %1:2 = transform.structured.tile_to_foreach_thread_op %0 num_threads [10, 21]
   }
 }
 
 
 // -----
func.func @matmul_tile_size_dynamic(%A: tensor<?x?xf32>, %B: tensor<?x?xf32>, %C: tensor<?x?xf32>) -> tensor<?x?xf32> {
   // CHECK-NEXT:    tensor.parallel_insert_slice
   %0 = linalg.matmul ins(%A, %B : tensor<?x?xf32>, tensor<?x?xf32>)
                     outs(%C : tensor<?x?xf32>) -> (tensor<?x?xf32>)
   return %0 : tensor<?x?xf32>
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):    
     %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
     %1:2 = transform.structured.tile_to_foreach_thread_op %0 tile_sizes [10, 20]
   }
 }
 
 // -----
 
func.func @matmul_tile_size_static(%A: tensor<100x200xf32>, %B: tensor<200x300xf32>, %C: tensor<100x300xf32>) -> tensor<100x300xf32> {
   // CHECK-NEXT:    tensor.parallel_insert_slice
   %0 = linalg.matmul ins(%A, %B : tensor<100x200xf32>, tensor<200x300xf32>)
                     outs(%C : tensor<100x300xf32>) -> (tensor<100x300xf32>)
   return %0 : tensor<100x300xf32>
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
     %1:2 = transform.structured.tile_to_foreach_thread_op %0 tile_sizes [10, 21]
   }
 }

mlir/test/Dialect/Linalg/transform-op-decompose.mlir

%0 = linalg.depthwise_conv_2d_nhwc_hwc {dilations = dense<1> : vector<2xi64>, strides = dense<2> : vector<2xi64>}
          ins(%input, %filter: tensor<1x1x113x96xf32>, tensor<1x3x96xf32>)
          outs(%init: tensor<1x1x56x96xf32>) -> tensor<1x1x56x96xf32>
   // CHECK: %[[INSERTED]]
   return %0: tensor<1x1x56x96xf32>
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match interface{LinalgOp} in %arg1
     %1 = transform.structured.decompose %0
   }
 }

mlir/test/Dialect/Linalg/transform-op-fuse-into-containing.mlir

module {
 
   // Check no failure when nothing happens.
   func.func @dummy1() { return }
   func.func @dummy2() { return }
   func.func @dummy3() { return }
 
   transform.with_pdl_patterns {
   ^bb0(%arg0: !pdl.operation):
-    transform.sequence %arg0 {
+    transform.sequence %arg0 failures(propagate) {
     ^bb1(%arg1: !pdl.operation):
       %0 = transform.structured.match ops{["linalg.fill"]} in %arg1
       %1 = transform.structured.match ops{["scf.foreach_thread"]} in %arg1
 
       // linalg.fill is tileable. The op is tiled and fused.
       transform.structured.fuse_into_containing_op %0 into %1
     }
   }
func.func @fuse_untileable_op(%arg0: index, %arg1: tensor<64xf32>, %arg2: tensor<64xf32>) -> tensor<64xf32> {
     }
     // CHECK: }
 
     func.return %2 : tensor<64xf32>
   }
 
   transform.with_pdl_patterns {
   ^bb0(%arg0: !pdl.operation):
-    transform.sequence %arg0 {
+    transform.sequence %arg0 failures(propagate) {
     ^bb1(%arg1: !pdl.operation):
       %0 = transform.structured.match ops{["linalg.init_tensor"]} in %arg1
       %1 = transform.structured.match ops{["scf.foreach_thread"]} in %arg1
 
       // linalg.init_tensor is not tileable. The op is cloned and fused.
       transform.structured.fuse_into_containing_op %0 into %1
     }
   }
 }

mlir/test/Dialect/Linalg/transform-op-fuse.mlir

%0 = linalg.elemwise_unary ins(%arg0 : tensor<?x?xf32>)
                              outs(%arg1: tensor<?x?xf32>) -> tensor<?x?xf32>
   %1 = linalg.elemwise_binary ins(%0, %arg0 : tensor<?x?xf32>, tensor<?x?xf32>)
                              outs(%arg1: tensor<?x?xf32>) -> tensor<?x?xf32>
   return %1 : tensor<?x?xf32>
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.elemwise_binary"]} in %arg1
     %1, %loops:2 = transform.structured.fuse %0 {tile_sizes = [32, 32], tile_interchange = [0, 1]}
   }
 }
 
 // -----
 
%0 = linalg.elemwise_unary ins(%arg0 : tensor<?x?xf32>)
                              outs(%arg1: tensor<?x?xf32>) -> tensor<?x?xf32>
   %1 = linalg.elemwise_binary ins(%0, %arg0 : tensor<?x?xf32>, tensor<?x?xf32>)
                              outs(%arg1: tensor<?x?xf32>) -> tensor<?x?xf32>
   return %1 : tensor<?x?xf32>
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.elemwise_binary"]} in %arg1
     %1, %loops:2 = transform.structured.fuse %0 {tile_sizes = [32, 32], tile_interchange = [0, 1]}
     transform.loop.peel %loops#0
   }
 }
 
 // -----
^bb0(%arg0: f32, %arg1: f32):
     %2 = arith.addf %arg0, %arg1 : f32
     linalg.yield %2 : f32
   } -> tensor<12x25xf32>
   func.return %0 : tensor<12x25xf32>
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.generic"]} in %arg1
     %1, %loops:3 = transform.structured.fuse %0 {tile_sizes = [5, 4, 7], tile_interchange = [0, 2, 1]}
   }
 }

mlir/test/Dialect/Linalg/transform-op-generalize.mlir

 // RUN: mlir-opt --test-transform-dialect-interpreter %s | FileCheck %s
 
 // CHECK-LABEL: func.func @generalize_unary
 func.func @generalize_unary(%arg0: tensor<?x?xf32>, %arg1: tensor<?x?xf32>) -> tensor<?x?xf32> {
 
   // CHECK-NOT:   linalg.elemwise_unary
   //     CHECK:   linalg.generic
   %0 = linalg.elemwise_unary ins(%arg0 : tensor<?x?xf32>)
                              outs(%arg1: tensor<?x?xf32>) -> tensor<?x?xf32>
   return %0 : tensor<?x?xf32>
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.elemwise_unary"]} in %arg1
     %1 = transform.structured.generalize %0
   }
 }

mlir/test/Dialect/Linalg/transform-op-interchange.mlir

^bb0(%arg2: f32, %arg3: f32):
     %1 = math.exp %arg2 : f32
     linalg.yield %1 : f32
   } -> tensor<?x?xf32>
   return %0 : tensor<?x?xf32>
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.generic"]} in %arg1
     transform.structured.interchange %0 { iterator_interchange = [1, 0]}
   }
 }
 
 // -----
 
 func.func @interchange_matmul(%arg0: tensor<?x?xf32>, %arg1: tensor<?x?xf32>, %arg2: tensor<?x?xf32>) -> tensor<?x?xf32> {
   // expected-note @below {{when applied to this op}}
   %0 = linalg.matmul ins(%arg0, %arg1 : tensor<?x?xf32>, tensor<?x?xf32>) outs(%arg2 : tensor<?x?xf32>) -> tensor<?x?xf32>
   return %0 : tensor<?x?xf32>
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
     // expected-error @below {{transform applied to the wrong op kind}}
     transform.structured.interchange %0 { iterator_interchange = [1, 0]}
   }
 }

mlir/test/Dialect/Linalg/transform-op-match.mlir

 // RUN: mlir-opt %s --test-transform-dialect-interpreter -allow-unregistered-dialect --split-input-file --verify-diagnostics
 
 func.func @bar() {
   // expected-remark @below {{matched op name}}
   // expected-remark @below {{matched attr name}}
   %0 = arith.constant {my_attr} 0: i32
   // expected-remark @below {{matched op name}}
   %1 = arith.constant 1 : i32
   return
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %match_name = transform.structured.match ops{["arith.constant"]} in %arg1
     transform.test_print_remark_at_operand %match_name, "matched op name"
     transform.test_consume_operand %match_name
 
     %match_attr = transform.structured.match ops{["arith.constant"]} attributes{my_attr} in %arg1
     transform.test_print_remark_at_operand %match_attr, "matched attr name"
     transform.test_consume_operand %match_attr

mlir/test/Dialect/Linalg/transform-op-multitile-sizes.mlir

 // RUN: mlir-opt %s --test-transform-dialect-interpreter --split-input-file | FileCheck %s
 
 // CHECK-DAG: #[[$MAP13:.+]] = affine_map<() -> (13)>
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
     ^bb0(%arg1: !pdl.operation):
       %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
       transform.structured.multitile_sizes %0 { target_size = 3, dimension = 0 }
   }
 }
 
 // CHECK-LABEL: @multitile_sizes_static
 func.func @multitile_sizes_static(
func.func @multitile_sizes_static(
 
   return %0 : tensor<13x42xf32>
 }
 
 // -----
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
     ^bb0(%arg1: !pdl.operation):
       %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
       transform.structured.multitile_sizes %0 { target_size = 3, divisor = 2, dimension = 0 }
   }
 }
 
 // CHECK: #[[$MAP_A:.+]] = affine_map<()[s0] -> ([[A_IMPL:s0 floordiv 2]])>
 // CHECK: #[[$MAP_T:.+]] = affine_map<() -> (2)>

mlir/test/Dialect/Linalg/transform-op-pad.mlir

func.func @static_sizes_output_divisible(%arg0: tensor<24x12xf32>,
   // CHECK-SAME:              outs(%[[T2]] : tensor<4x5xf32>)
   %4 = linalg.matmul ins(%1, %2 : tensor<4x?xf32>, tensor<?x5xf32>) outs(%3 : tensor<4x5xf32>) -> tensor<4x5xf32>
   %5 = tensor.insert_slice %4 into %arg2[%iv0, %iv1] [4, 5] [1, 1] : tensor<4x5xf32> into tensor<24x25xf32>
   func.return %5 : tensor<24x25xf32>
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
     %1 = transform.structured.pad %0 {padding_values=[0.0 : f32, 0.0 : f32, 0.0 : f32], padding_dimensions=[0, 1, 2], pack_paddings=[1, 1, 0]}
   }
 }
 
 // -----
 
 func.func @pad(%arg0: tensor<24x12xf32>,
                %arg1: tensor<12x25xf32>,
                %arg2: tensor<24x25xf32>) -> tensor<24x25xf32> {
   // expected-note @below {{when applied to this op}} 
   %0 = linalg.matmul ins(%arg0, %arg1 : tensor<24x12xf32>, tensor<12x25xf32>) outs(%arg2 : tensor<24x25xf32>) -> tensor<24x25xf32>
   func.return %0 : tensor<24x25xf32>
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
     // expected-error @below {{op expects a padding value of type 'f32', got 0 : i32}}
     %1 = transform.structured.pad %0 {padding_values=[0: i32, 0.0 : f32, 0.0 : f32], padding_dimensions=[0, 1, 2], pack_paddings=[1, 1, 0]}
   }
 }
 
 // -----
 
 func.func @pad(%arg0: tensor<24x12xf32>,
                %arg1: tensor<12x25xf32>,
                %arg2: tensor<24x25xf32>) -> tensor<24x25xf32> {
   // expected-note @below {{when applied to this op}}
   %0 = linalg.matmul ins(%arg0, %arg1 : tensor<24x12xf32>, tensor<12x25xf32>) outs(%arg2 : tensor<24x25xf32>) -> tensor<24x25xf32>
   func.return %0 : tensor<24x25xf32>
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
     // expected-error @below {{expects a padding that parses to 'f32', got "foo"}}
     %1 = transform.structured.pad %0 {padding_values=["foo", 0.0 : f32, 0.0 : f32], padding_dimensions=[0, 1, 2], pack_paddings=[1, 1, 0]}
   }
 }
 
 // -----
 
 func.func @pad(%arg0: tensor<24x12xf32>,
                %arg1: tensor<12x25xf32>,
                %arg2: tensor<24x25xf32>) -> tensor<24x25xf32> {
   // This is attached to an error that is silenceable and is not reported by this transform
   //   {{when applied to this op}}
   %0 = linalg.matmul ins(%arg0, %arg1 : tensor<24x12xf32>, tensor<12x25xf32>) outs(%arg2 : tensor<24x25xf32>) -> tensor<24x25xf32>
   func.return %0 : tensor<24x25xf32>
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
     // This error is silenceable and is not reported by this transform
     //   {{transform.structured.pad failed to apply}}
     %1 = transform.structured.pad %0 {padding_values=[0.0 : f32, 0.0 : f32, 0.0 : f32], padding_dimensions=[0, 1, 2], pack_paddings=[1, 1, 0]}
   }
 }

mlir/test/Dialect/Linalg/transform-op-scalarize.mlir

 // RUN: mlir-opt -test-transform-dialect-interpreter %s | FileCheck %s
 
 func.func @scalarize(%arg0: tensor<24x12xf32>,
                      %arg1: tensor<12x25xf32>,
                      %arg2: tensor<24x25xf32>) -> tensor<24x25xf32> {
   // The op is first tiled by 10 in the first dimension, which creates a
   // dynamic size, and then scalarized, which brings the dimension to static 1.
   // CHECK: linalg.matmul ins(%{{.*}}, %{{.*}} : tensor<1x12
   %0 = linalg.matmul ins(%arg0, %arg1 : tensor<24x12xf32>, tensor<12x25xf32>) outs(%arg2 : tensor<24x25xf32>) -> tensor<24x25xf32>
   func.return %0 : tensor<24x25xf32>
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
     %1, %loops = transform.structured.tile %0 [10, 0, 0]
     %2 = transform.structured.scalarize %1
   }
 }

mlir/test/Dialect/Linalg/transform-op-split-reduction-by-scaling.mlir

func.func @matmul_split(%A : tensor<?x256xf32>, %B: tensor<256x32xf32>, %C: tensor<?x32xf32>) -> tensor<?x32xf32> {
   // CHECK-SAME: outs(%{{[a-zA-Z0-9]*}} : tensor<?x32xf32>) {
   %0 = linalg.matmul ins(%A, %B: tensor<?x256xf32>, tensor<256x32xf32>)
                     outs(%C: tensor<?x32xf32>) -> tensor<?x32xf32>
   return %0: tensor<?x32xf32>
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
     %1:4 = transform.structured.split_reduction %0 
       { split_factor = 4, insert_split_dimension = 2, use_scaling_algorithm, use_alloc}
   }
 }

mlir/test/Dialect/Linalg/transform-op-split-reduction.mlir

func.func @matmul_split(%A : tensor<16x256xf32>, %B: tensor<256x32xf32>, %C: tensor<16x32xf32>) -> tensor<16x32xf32> {
   // CHECK-SAME: outs(%{{[a-zA-Z0-9]*}} : tensor<16x32xf32>) {
   %0 = linalg.matmul ins(%A, %B: tensor<16x256xf32>, tensor<256x32xf32>)
                     outs(%C: tensor<16x32xf32>) -> tensor<16x32xf32>
   return %0: tensor<16x32xf32>
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
     %1:4 = transform.structured.split_reduction %0 { split_factor = 4, insert_split_dimension = 2}
   }
 }

mlir/test/Dialect/Linalg/transform-op-split.mlir

 // RUN: mlir-opt %s --test-transform-dialect-interpreter --split-input-file -verify-diagnostics | FileCheck %s
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.generic"]} in %arg1
     %1:2 = transform.structured.split %0 after 42 { dimension = 0 }
   }
 }
 
 func.func private @elem(%arg0: f32, %arg1: index, %arg2: index) -> f32
 
func.func @one_d_static_overflow(%arg0: tensor<10xf32>, %arg1: tensor<10xf32>) -> tensor<10xf32> {
   } -> tensor<10xf32>
   return %0 : tensor<10xf32>
 }
 
 // -----
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.generic"]} in %arg1
     %1 = transform.structured.match ops{["func.call"]} in %arg1
     transform.structured.split %0 after %1 { dimension = 0 }
   }
 }
 
 func.func private @get_size() -> index
func.func @dynamic(%arg0: tensor<100xf32>, %arg1: tensor<100xf32>) -> tensor<100xf32> {
   } -> tensor<100xf32>
   return %1 : tensor<100xf32>
 }
 
 // -----
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.generic"]} in %arg1
     %1:2 = transform.structured.split %0 after 4 { dimension = 0}
     %2:2 = transform.structured.split %1#1 after 16 { dimension = 1 }
   }
 }
 
 func.func private @elem(%arg0: f32, %arg1: index, %arg2: index) -> f32
^bb0(%0: f32, %1: f32):
     %call_res = func.call @elem(%0, %i, %j) : (f32, index, index) -> f32
     linalg.yield %call_res : f32
   } -> tensor<10x34xf32>
   return %0 : tensor<10x34xf32>
 }
 
 // -----
 
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb1(%arg1: !pdl.operation):
   // expected-error @below {{expects either a dynamic or a static split point to be provided}}
   %0:2 = "transform.structured.split"(%arg1) { dimension = 1, static_split_point = -1 } : (!pdl.operation) -> (!pdl.operation, !pdl.operation)
 }
 
 // -----
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.generic"]} in %arg1
     %1 = transform.structured.match ops{["func.call"]} in %arg1
     // expected-error @below {{expected dynamic split point handle to point to a single-result index-typed op}}
     transform.structured.split %0 after %1 { dimension = 0 }
   }
 }
 
func.func @dynamic(%arg0: tensor<100xf32>, %arg1: tensor<100xf32>) -> tensor<100xf32> {
   } -> tensor<100xf32>
   return %1 : tensor<100xf32>
 }
 
 // -----
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.generic"]} in %arg1
     %1 = transform.structured.match ops{["func.call"]} in %arg1
     // expected-error @below {{expected the dynamic split point handle to point to as many operations (0) as the target handle (1)}}
     transform.structured.split %0 after %1 { dimension = 0 }
   }
 }
 

 ^bb0(%arg0: !pdl.operation):
   pdl.pattern @func_return : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
     %2 = pdl.operation "func.return"(%0 : !pdl.range<value>) -> (%1 : !pdl.range<type>)
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["func.return"]} in %arg1
     // expected-error @below {{only applies to structured ops}}
     transform.structured.split %0 after 16 { dimension = 1 }
   }
 }
 
 func.func @noop(%arg0: tensor<100xf32>, %arg1: tensor<100xf32>) -> tensor<100xf32> {
   // expected-note @below {{target op}}
   return %arg0 : tensor<100xf32>
 }
 
 // -----
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
   pdl.pattern @linalg_generic : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
     %2 = pdl.operation "linalg.generic"(%0 : !pdl.range<value>) -> (%1 : !pdl.range<type>)
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.generic"]} in %arg1
     // expected-error @below {{dimension 1 does not exist in target op}}
     transform.structured.split %0 after 16 { dimension = 1 }
   }
 }
 
 func.func @one_d_static(%arg0: tensor<100xf32>, %arg1: tensor<100xf32>) -> tensor<100xf32> {

mlir/test/Dialect/Linalg/transform-op-tile.mlir

 // RUN: mlir-opt --test-transform-dialect-interpreter --split-input-file %s | FileCheck %s
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
     ^bb0(%arg1: !pdl.operation):
       %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
       %1, %loops:3 = transform.structured.tile %0 [4, 4, 4]
   }
 }
 
 // CHECK-LABEL: func @tile_linalg_matmul(
 // CHECK-SAME:    %[[TA:[0-9a-z]+]]: tensor<128x128xf32>

 //      CHECK: return %[[TD0]] : tensor<128x128xf32>
   return %0 : tensor<128x128xf32>
 }
 
 // -----
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
     ^bb0(%arg1: !pdl.operation):
       %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
       %1 = transform.structured.match ops{["func.call"]} in %arg1
       %2, %loops:3 = transform.structured.tile %0 [%1, %1, 4]
   }
 }
 
 func.func private @get_dynamic_tile_size() -> index

mlir/test/Dialect/Linalg/transform-op-vectorize.mlir

^bb0(%arg0: !pdl.operation):
   pdl.pattern @pdl_target : benefit(1) {
     %args = operands
     %results = types
     %0 = pdl.operation "linalg.matmul"(%args : !pdl.range<value>) -> (%results : !pdl.range<type>)
     // TODO: we don't want this, but it is the required terminator for pdl.pattern
     rewrite %0 with "transform.dialect"
   }
 
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
     %1 = get_closest_isolated_parent %0
     %2 = transform.structured.vectorize %1
   }
 }
 
 // -----
func.func @vectorize_keep_pad(
   // CHECK: vector.transfer_write %[[vR]], %[[C]]
   %8 = linalg.matmul ins(%5, %7 : tensor<4x7xf32>, tensor<7x5xf32>) outs(%3 : tensor<4x5xf32>) -> tensor<4x5xf32>
   %9 = tensor.insert_slice %8 into %arg2[%arg3, %arg4] [4, 5] [1, 1] : tensor<4x5xf32> into tensor<24x25xf32>
   return %9 : tensor<24x25xf32>
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
     %1 = get_closest_isolated_parent %0
     %2 = transform.structured.vectorize %1
   }
 }
 
 // -----
func.func @vectorize_pad(
   // CHECK: vector.transfer_write %[[vR]], %[[C]]
   %8 = linalg.matmul ins(%5, %7 : tensor<4x7xf32>, tensor<7x5xf32>) outs(%3 : tensor<4x5xf32>) -> tensor<4x5xf32>
   %9 = tensor.insert_slice %8 into %arg2[%arg3, %arg4] [4, 5] [1, 1] : tensor<4x5xf32> into tensor<24x25xf32>
   return %9 : tensor<24x25xf32>
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
     %1 = get_closest_isolated_parent %0
     %2 = transform.structured.vectorize %1 {vectorize_padding = true}
   }
 }
 
 // -----
 
 func.func @vectorize(%arg0: tensor<24x12xf32>,
                      %arg1: tensor<12x25xf32>,
                      %arg2: tensor<24x25xf32>) -> tensor<24x25xf32> {
   // expected-note @below {{non-isolated target}}
   %0 = linalg.matmul ins(%arg0, %arg1 : tensor<24x12xf32>, tensor<12x25xf32>) outs(%arg2 : tensor<24x25xf32>) -> tensor<24x25xf32>
   func.return %0 : tensor<24x25xf32>
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
     // expected-error @below {{op requires isolated-from-above targets}}
     %2 = transform.structured.vectorize %0
   }
 }

mlir/test/Dialect/Linalg/transform-ops-invalid.mlir

 // RUN: mlir-opt %s --split-input-file --verify-diagnostics
 
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):
   // expected-error@below {{expects iterator_interchange to be a permutation, found [1, 1]}}
   transform.structured.interchange %arg0 {iterator_interchange = [1, 1]}
 }
 
 // -----
 
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):
   // expected-error@below {{expects padding_dimensions to contain positive integers, found [1, -7]}}
   transform.structured.pad %arg0 {padding_dimensions=[1, -7]}
 }
 
 // -----
 
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):
   // expected-error@below {{expects pack_paddings to contain booleans (0/1), found [1, 7]}}
   transform.structured.pad %arg0 {pack_paddings=[1, 7]}
 }
 
 // -----
 
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):
   // expected-error@below {{expects hoist_paddings to contain positive integers, found [1, -7]}}
   transform.structured.pad %arg0 {hoist_paddings=[1, -7]}
 }
 
 // -----
 
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):
   // expected-error@below {{expects transpose_paddings to be a permutation, found [1, 1]}}
   transform.structured.pad %arg0 {transpose_paddings=[[1, 1]]}
 }

mlir/test/Dialect/Linalg/transform-ops.mlir

 // RUN: mlir-opt %s | mlir-opt | FileCheck %s
 
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb1(%arg0: !pdl.operation):
   // CHECK %{{.*}}, %{{.*}}:2 = transform.structured.tile
   %0, %1:2 = transform.structured.tile %arg0 [2, 0, 3]
 }
 
 //===----------------------------------------------------------------------===//
 // Check that operations are registered correctly through the extension
 // mechanism. Their syntax is generated and requries no additional testing since
 // we test the generator.
 //===----------------------------------------------------------------------===//
 
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb1(%arg0: !pdl.operation):
   // CHECK: transform.structured.pad
   %0 = transform.structured.pad %arg0
 }
 
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb1(%arg0: !pdl.operation):
   // CHECK: transform.structured.interchange
   %0 = transform.structured.interchange %arg0
 }
 
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb1(%arg0: !pdl.operation):
   // CHECK: transform.structured.scalarize
   %0 = transform.structured.scalarize %arg0
 }

mlir/test/Dialect/Linalg/transform-promotion.mlir

 // CHECK:               memref.copy %[[s1]], %[[l1]] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
 // CHECK:               memref.copy %[[s2]], %[[l2]] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
 // CHECK:               linalg.matmul
 // CHECK-SAME:                 ins(%[[v0]], %[[v1]] : memref<?x?xf32>, memref<?x?xf32>)
 // CHECK-SAME:                outs(%[[v2]] : memref<?x?xf32>)
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
     ^bb0(%arg1: !pdl.operation):
       %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
       %1 = transform.structured.promote %0 { operands_to_promote = [0, 1, 2], use_full_tiles_by_default }
   }
 }
 
 // -----
 

 // CHECK:         memref.copy %[[s0]], %[[l0]] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
 // CHECK-NOT:     memref.copy
 // CHECK:         linalg.matmul
 // CHECK-SAME:           ins(%[[v0]], %[[s1]] : memref<?x?xf32>, memref<?x?xf32, #[[$STRIDED_2D]]>)
 // CHECK-SAME:          outs(%[[s2]] : memref<?x?xf32, #[[$STRIDED_2D]]>)
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
     ^bb0(%arg1: !pdl.operation):
       %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1
       %1 = transform.structured.promote %0 { operands_to_promote = [0], use_full_tiles_by_default }
   }
 }
 
 // -----
 

 // CHECK:         %[[v0:.*]] = memref.view %[[a0]]{{.*}} : memref<32000000xi8> to memref<?x?xf32>
 // CHECK:         %[[l0:.*]] = memref.subview %[[v0]][0, 0] [%{{.*}}, %{{.*}}] [1, 1] : memref<?x?xf32> to memref<?x?xf32, #[[$STRIDED_2D_u_1]]>
 // CHECK:         linalg.fill ins({{.*}} : f32) outs(%[[v0]] : memref<?x?xf32>)
 // CHECK:         memref.copy %[[s0]], %[[l0]] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
 // CHECK:         linalg.fill ins(%[[cf]] : f32) outs(%[[v0]] : memref<?x?xf32>)
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
     ^bb0(%arg1: !pdl.operation):
       %0 = transform.structured.match ops{["linalg.fill"]} in %arg1
       %1 = transform.structured.promote %0 { operands_to_promote = [1], use_full_tile_buffers = [false, true], alignment = 32}
   }
 }
 
 // -----
 

 // CHECK:         %[[v0:.*]] = memref.view %[[a0]]{{.*}} : memref<64000000xi8> to memref<?x?xcomplex<f32>>
 // CHECK:         %[[l0:.*]] = memref.subview %[[v0]][0, 0] [%{{.*}}, %{{.*}}] [1, 1] : memref<?x?xcomplex<f32>> to memref<?x?xcomplex<f32>, #[[$STRIDED_2D_u_1]]>
 // CHECK:         linalg.fill ins({{.*}} : complex<f32>) outs(%[[v0]] : memref<?x?xcomplex<f32>>)
 // CHECK:         memref.copy %[[s0]], %[[l0]] : memref<?x?xcomplex<f32>, #map{{.*}}> to memref<?x?xcomplex<f32>, #map{{.*}}>
 // CHECK:         linalg.fill ins(%[[cc]] : complex<f32>) outs(%[[v0]] : memref<?x?xcomplex<f32>>)
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
     ^bb0(%arg1: !pdl.operation):
       %0 = transform.structured.match ops{["linalg.fill"]} in %arg1
       %1 = transform.structured.promote %0 { operands_to_promote = [1], use_full_tile_buffers = [false, true], alignment = 32}
   }
 }

mlir/test/Dialect/Linalg/transform-tile-and-fuse.mlir

^bb0(%arg2: f32, %arg3: f32, %arg4: f32):
       %18 = arith.select %17, %cst, %16 : f32
       linalg.yield %18 : f32
     } -> tensor<?x?xf32>
     return %7 : tensor<?x?xf32>
   }
 
   transform.with_pdl_patterns {
   ^bb0(%arg0: !pdl.operation):
-    transform.sequence %arg0 {
+    transform.sequence %arg0 failures(propagate) {
     ^bb1(%arg1: !pdl.operation):
       // Find the root and all producers.
       %root = transform.structured.match attributes{"__root__"} in %arg1
       %producers = transform.structured.match attributes{"__producer__"} in %arg1
 
       // Tile the root.
       %foreach_thread_op, %tiled_op = transform.structured.tile_to_foreach_thread_op %root num_threads [10, 20]
 
^bb0(%arg2: f32, %arg3: f32, %arg4: f32):
       %18 = arith.select %17, %cst, %16 : f32
       linalg.yield %18 : f32
     } -> tensor<?x?xf32>
     return %7 : tensor<?x?xf32>
   }
 
   transform.with_pdl_patterns {
   ^bb0(%arg0: !pdl.operation):
-    transform.sequence %arg0 {
+    transform.sequence %arg0 failures(propagate) {
     ^bb1(%arg1: !pdl.operation):
       // Find the root and all producers.
       %root = transform.structured.match attributes{"__root__"} in %arg1
       %producers = transform.structured.match attributes{"__producer__"} in %arg1
       %reversed_producers = transform.test_reverse_payload_ops %producers
 
       // Tile the root.
       %foreach_thread_op, %tiled_op = transform.structured.tile_to_foreach_thread_op %root num_threads [10, 20]
 
       // Fuse all producers.
       transform.structured.fuse_into_containing_op %reversed_producers into %foreach_thread_op
     }
   }
 }

mlir/test/Dialect/SCF/transform-ops.mlir

scf.for %j = %arg0 to %arg1 step %arg2 {
       }
     }
   }
   return
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["arith.addi"]} in %arg1
     // CHECK: = transform.loop.get_parent_for
     %1 = transform.loop.get_parent_for %0
     %2 = transform.loop.get_parent_for %0 { num_loops = 2 }
     %3 = transform.loop.get_parent_for %0 { num_loops = 3 }
     transform.test_print_remark_at_operand %1, "third loop"
     transform.test_print_remark_at_operand %2, "second loop"
     transform.test_print_remark_at_operand %3, "first loop"
   }
 }
 
 // -----
 
 func.func @get_parent_for_op_no_loop(%arg0: index, %arg1: index) {
   // expected-note @below {{target op}}
   arith.addi %arg0, %arg1 : index  
   return
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["arith.addi"]} in %arg1
     // expected-error @below {{could not find an 'scf.for' parent}}
     %1 = transform.loop.get_parent_for %0
   }
 }
 
 // -----
func.func @loop_outline_op(%arg0: index, %arg1: index, %arg2: index) {
   scf.for %j = %arg0 to %arg1 step %arg2 {
     arith.addi %j, %j : index
   }
   return
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["arith.addi"]} in %arg1
     %1 = transform.loop.get_parent_for %0
     // CHECK: = transform.loop.outline %{{.*}}
     transform.loop.outline %1 {func_name = "foo"}
   }
 }
 
^bb0:
     func.call @body() : () -> ()
     scf.yield
   }
   return
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["scf.while"]} in %arg1
     // expected-error @below {{failed to outline}}
     transform.loop.outline %0 {func_name = "foo"}
   }
 }
 
 // -----
func.func @loop_peel_op() {
   scf.for %i = %0 to %1 step %2 {
     arith.addi %i, %i : index
   }
   return
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["arith.addi"]} in %arg1
     %1 = transform.loop.get_parent_for %0
     transform.loop.peel %1
   }
 }
 
 // -----
scf.for %i0 = %c0 to %c4 step %c1 {
     %A1_elem = arith.addf %A_elem, %cf : f32
     memref.store %A1_elem, %result[%i0] : memref<?xf32>
   }
   return
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["arith.addf"]} in %arg1
     %1 = transform.loop.get_parent_for %0
     %2 = transform.loop.pipeline %1
     // Verify that the returned handle is usable.
     transform.test_print_remark_at_operand %2, "transformed"
   }
 }
scf.for %i = %c0 to %c42 step %c5 {
     // CHECK-COUNT-4: arith.addi %[[I]]
     arith.addi %i, %i : index
   }
   return
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.structured.match ops{["arith.addi"]} in %arg1
     %1 = transform.loop.get_parent_for %0
     transform.loop.unroll %1 { factor = 4 }
   }
 }
 

mlir/test/Dialect/Transform/check-use-after-free.mlir

func.func @use_after_free_branching_control_flow() {
   ^bb1:
     // expected-note @below {{freed here}}
     transform.test_consume_operand_if_matches_param_or_fail %0[42]
     "transform.test_branching_transform_op_terminator"()[^bb3] : () -> ()
   ^bb2:
     "transform.test_branching_transform_op_terminator"()[^bb3] : () -> ()
   ^bb3:
     // expected-warning @below {{operand #0 may be used after free}}
-    transform.sequence %0 {
+    transform.sequence %0 failures(propagate) {
     ^bb0(%arg0: !pdl.operation):
     }
     "transform.test_branching_transform_op_terminator"() : () -> ()
   }
   return
 }
 
 // -----
^bb1:
     transform.test_consume_operand_if_matches_param_or_fail %0[42]
     "transform.test_branching_transform_op_terminator"()[^bb3] : () -> ()
   ^bb2:
     "transform.test_branching_transform_op_terminator"()[^bb3] : () -> ()
   ^bb3:
     "transform.test_branching_transform_op_terminator"() : () -> ()
   }
   // expected-warning @below {{operand #0 may be used after free}}
-  transform.sequence %0 {
+  transform.sequence %0 failures(propagate) {
     ^bb0(%arg0: !pdl.operation):
   }
   return
 }
 
 // -----
 
 func.func @use_after_free_recursive_side_effects() {
-  transform.sequence {
+  transform.sequence failures(propagate) {
   ^bb0(%arg0: !pdl.operation):
     // expected-note @below {{allocated here}}
-    %0 = transform.sequence %arg0 attributes { ord = 1 } {
+    %0 = transform.sequence %arg0 failures(propagate) attributes { ord = 1 } {
     ^bb1(%arg1: !pdl.operation):
       yield %arg1 : !pdl.operation
     } : !pdl.operation
-    transform.sequence %0 attributes { ord = 2 } {
+    transform.sequence %0 failures(propagate) attributes { ord = 2 } {
     ^bb2(%arg2: !pdl.operation):
     }
-    transform.sequence %0 attributes { ord = 3 } {
+    transform.sequence %0 failures(propagate) attributes { ord = 3 } {
     ^bb3(%arg3: !pdl.operation):
     }
     
     // `transform.sequence` has recursive side effects so it has the same "free"
     // as the child op it contains.
     // expected-note @below {{freed here}}
-    transform.sequence %0 attributes { ord = 4 } {
+    transform.sequence %0 failures(propagate) attributes { ord = 4 } {
     ^bb4(%arg4: !pdl.operation):
       test_consume_operand_if_matches_param_or_fail %0[42]
     }
     // expected-warning @below {{operand #0 may be used after free}}
-    transform.sequence %0 attributes { ord = 5 } {
+    transform.sequence %0 failures(propagate) attributes { ord = 5 } {
     ^bb3(%arg3: !pdl.operation):
     }
   }
   return
 }
 
 // -----
 
 func.func @use_after_free() {
-  transform.sequence {
+  transform.sequence failures(propagate) {
   ^bb0(%arg0: !pdl.operation):
     // expected-note @below {{allocated here}}
-    %0 = transform.sequence %arg0 attributes { ord = 1 } {
+    %0 = transform.sequence %arg0 failures(propagate) attributes { ord = 1 } {
     ^bb1(%arg1: !pdl.operation):
       yield %arg1 : !pdl.operation
     } : !pdl.operation
-    transform.sequence %0 attributes { ord = 2 } {
+    transform.sequence %0 failures(propagate) attributes { ord = 2 } {
     ^bb2(%arg2: !pdl.operation):
     }
-    transform.sequence %0 attributes { ord = 3 } {
+    transform.sequence %0 failures(propagate) attributes { ord = 3 } {
     ^bb3(%arg3: !pdl.operation):
     }
     
     // expected-note @below {{freed here}}
     test_consume_operand_if_matches_param_or_fail %0[42]
     // expected-warning @below {{operand #0 may be used after free}}
-    transform.sequence %0 attributes { ord = 5 } {
+    transform.sequence %0 failures(propagate) attributes { ord = 5 } {
     ^bb3(%arg3: !pdl.operation):
     }
   }
   return
 }
 
 // -----
 
 // In the case of a control flow cycle, the operation that uses the value may
 // precede the one that frees it in the same block. Both operations should
 // be reported as use-after-free.
 func.func @use_after_free_self_cycle() {
   // expected-note @below {{allocated here}}
   %0 = transform.test_produce_param_or_forward_operand 42
   transform.test_transform_op_with_regions {
     "transform.test_branching_transform_op_terminator"() : () -> ()
   },
   {
   ^bb0:
     "transform.test_branching_transform_op_terminator"()[^bb1] : () -> ()
   ^bb1:
     // expected-warning @below {{operand #0 may be used after free}}
-    transform.sequence %0 {
+    transform.sequence %0 failures(propagate) {
     ^bb0(%arg0: !pdl.operation):
     }
     // expected-warning @below {{operand #0 may be used after free}}
     // expected-note @below {{freed here}}
     transform.test_consume_operand_if_matches_param_or_fail %0[42]
     "transform.test_branching_transform_op_terminator"()[^bb1, ^bb2] : () -> ()
   ^bb2:
     "transform.test_branching_transform_op_terminator"() : () -> ()

mlir/test/Dialect/Transform/expensive-checks.mlir

 ^bb0(%arg0: !pdl.operation):
   pdl.pattern @return : benefit(1) {
     %0 = operands
     %1 = types
     %2 = operation "func.return"(%0 : !pdl.range<value>) -> (%1 : !pdl.range<type>)
     rewrite %2 with "transform.dialect"
   }
 
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     // expected-note @below {{other handle}}
     %0 = pdl_match @return in %arg1
     %1 = get_closest_isolated_parent %0
     // expected-error @below {{invalidated the handle to payload operations nested in the payload operation associated with its operand #0}}
     test_consume_operand %1
     test_print_remark_at_operand %0, "remark"
   }
^bb0(%arg0: !pdl.operation):
   }
   pdl.pattern @return : benefit(1) {
     %0 = operands
     %1 = types
     %2 = operation "func.return"(%0 : !pdl.range<value>) -> (%1 : !pdl.range<type>)
     rewrite %2 with "transform.dialect"
   }
 
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = pdl_match @func in %arg1
     %1 = pdl_match @return in %arg1
     %2 = replicate num(%0) %1
     // expected-error @below {{a handle passed as operand #0 and consumed by this operation points to a payload operation more than once}}
     test_consume_operand %2
     test_print_remark_at_operand %0, "remark"
   }
 }

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 '!pdl.operation'}}
-transform.sequence {
+transform.sequence failures(propagate) {
 }
 
 // -----
 
 // expected-note @below {{nested in another possible top-level op}}
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):
   // expected-error @below {{expects the root operation to be provided for a nested op}}
-  transform.sequence {
+  transform.sequence failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
   }
 }
 
 // -----
 
 // expected-error @below {{expected children ops to implement TransformOpInterface}}
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):
   // expected-note @below {{op without interface}}
   arith.constant 42.0 : f32
 }
 
 // -----
 
 // expected-error @below {{expects the types of the terminator operands to match the types of the resul}}
-%0 = transform.sequence {
+%0 = transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):
   // expected-note @below {{terminator}}
   transform.yield
 } : !pdl.operation
 
 // -----
 
 // expected-note @below {{nested in another possible top-level op}}
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
   // expected-error @below {{expects the root operation to be provided for a nested op}}
-  transform.sequence {
+  transform.sequence failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
   }
 }
 
 // -----
 
 // expected-error @below {{expects only one non-pattern op in its body}}
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
   // expected-note @below {{first non-pattern op}}
-  transform.sequence {
+  transform.sequence failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
   }
   // expected-note @below {{second non-pattern op}}
-  transform.sequence {
+  transform.sequence failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
   }
 }
 
 // -----
 
 // expected-error @below {{expects only pattern and top-level transform ops in its body}}
 transform.with_pdl_patterns {

 ^bb0(%arg0: !pdl.operation):
   "test.potential_terminator"() : () -> ()
 ^bb1:
   "test.potential_terminator"() : () -> ()
 }) : () -> ()
 
 // -----
 
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):
   // expected-error @below {{result #0 has more than one potential consumer}}
   %0 = test_produce_param_or_forward_operand 42
   // expected-note @below {{used here as operand #0}}
   test_consume_operand_if_matches_param_or_fail %0[42]
   // expected-note @below {{used here as operand #0}}
   test_consume_operand_if_matches_param_or_fail %0[42]
 }
 
 // -----
 
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):
   // expected-error @below {{result #0 has more than one potential consumer}}
   %0 = test_produce_param_or_forward_operand 42
   // expected-note @below {{used here as operand #0}}
   test_consume_operand_if_matches_param_or_fail %0[42]
   // expected-note @below {{used here as operand #0}}
-  transform.sequence %0 {
+  transform.sequence %0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     test_consume_operand_if_matches_param_or_fail %arg1[42]
   }
 }
 
 // -----
 
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):
   // expected-error @below {{result #0 has more than one potential consumer}}
   %0 = test_produce_param_or_forward_operand 42
   // expected-note @below {{used here as operand #0}}
   test_consume_operand_if_matches_param_or_fail %0[42]
-  transform.sequence %0 {
+  transform.sequence %0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     // expected-note @below {{used here as operand #0}}
     test_consume_operand_if_matches_param_or_fail %0[42]
   }
 }
 
 // -----
 
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):
   // expected-error @below {{result #0 has more than one potential consumer}}
   %0 = test_produce_param_or_forward_operand 42
   // expected-note @below {{used here as operand #0}}
   test_consume_operand_if_matches_param_or_fail %0[42]
   // expected-note @below {{used here as operand #0}}
-  transform.sequence %0 {
+  transform.sequence %0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
-    transform.sequence %arg1 {
+    transform.sequence %arg1 failures(propagate) {
     ^bb2(%arg2: !pdl.operation):
       test_consume_operand_if_matches_param_or_fail %arg2[42]
     }
   }
 }
 
 // -----
 
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb1(%arg1: !pdl.operation):
   // expected-error @below {{expects at least one region}}
   transform.alternatives
 }
 
 // -----
 
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb1(%arg1: !pdl.operation):
   // expected-error @below {{expects terminator operands to have the same type as results of the operation}}
   %2 = transform.alternatives %arg1 -> !pdl.operation {
   ^bb2(%arg2: !pdl.operation):
     transform.yield %arg2 : !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 '!pdl.operation'}}
 transform.alternatives {
 ^bb0:
   transform.yield
 }
 
 // -----
 
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):
   // expected-error @below {{result #0 has more than one potential consumer}}
   %0 = test_produce_param_or_forward_operand 42
   // expected-note @below {{used here as operand #0}}
   transform.foreach %0 {
   ^bb1(%arg1: !pdl.operation):
     transform.test_consume_operand %arg1
   }
   // expected-note @below {{used here as operand #0}}
   transform.test_consume_operand %0
 }

mlir/test/Dialect/Transform/ops.mlir

 // RUN: mlir-opt %s | mlir-opt | FileCheck %s
 
 // CHECK: transform.sequence
 // CHECK: ^{{.+}}(%{{.+}}: !pdl.operation):
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):
   // CHECK: sequence %{{.+}}
   // CHECK: ^{{.+}}(%{{.+}}: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
   }
 }
 
 // CHECK: transform.with_pdl_patterns
 // CHECK: ^{{.+}}(%[[ARG:.+]]: !pdl.operation):
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
   // CHECK: sequence %[[ARG]]
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
   }
 }
 
 // CHECK: transform.sequence
 // CHECK: ^{{.+}}(%[[ARG:.+]]: !pdl.operation):
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):
   // CHECK: with_pdl_patterns %[[ARG]]
   with_pdl_patterns %arg0 {
   ^bb1(%arg1: !pdl.operation):
   }
 }
 
 // Using the same value multiple times without consuming it is fine.
 // CHECK: transform.sequence
 // CHECK: %[[V:.+]] = sequence
 // CHECK: sequence %[[V]]
 // CHECK: sequence %[[V]]
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):
-  %0 = transform.sequence %arg0 {
+  %0 = transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     yield %arg1 : !pdl.operation
   } : !pdl.operation
-  transform.sequence %0 {
+  transform.sequence %0 failures(propagate) {
   ^bb2(%arg2: !pdl.operation):
   }
-  transform.sequence %0 {
+  transform.sequence %0 failures(propagate) {
   ^bb3(%arg3: !pdl.operation):
   }
 }
 
 // CHECK: transform.sequence
 // CHECK: foreach
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):
   transform.foreach %arg0 {
   ^bb1(%arg1: !pdl.operation):
   }
 }

mlir/test/Dialect/Transform/selective-targeting.mlir

pdl.pattern @pdl_target_attrC : benefit(1) {
     %args = operands
     %results = types
     %attr = attribute
     %0 = operation "linalg.matmul"(%args : !pdl.range<value>) {"test.attrC" = %attr}-> (%results : !pdl.range<type>)
     // TODO: we don't want this, but it is the required terminator for pdl.pattern
     rewrite %0 with "transform.dialect"
   }
 
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = pdl_match @pdl_target_attrA in %arg1
     transform.structured.tile %0 [4, 4, 4]
     %1 = pdl_match @pdl_target_attrC in %arg1
     %2 = transform.get_closest_isolated_parent %1
     transform.structured.vectorize %2
   }
 }
pdl.pattern @pdl_target : benefit(1) {
     %args = operands
     %results = types
     %attr = attribute
     %0 = operation "linalg.matmul"(%args : !pdl.range<value>) {"test.attrA" = %attr}-> (%results : !pdl.range<type>)
     // TODO: we don't want this, but it is the required terminator for pdl.pattern
     rewrite %0 with "transform.dialect"
   }
 
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = pdl_match @pdl_target in %arg1
     %1 = get_closest_isolated_parent %0
     transform.structured.vectorize %1
   }
 }
 
 // -----
%0 = linalg.matmul {test.attrA}
     -> tensor<128x128xf32>
   // CHECK: vector.contract
   %1 = linalg.matmul ins(%arg0, %0: tensor<128x128xf32>, tensor<128x128xf32>)
                      outs(%arg3: tensor<128x128xf32>)
     -> tensor<128x128xf32>
   return %1 : tensor<128x128xf32>
 }
 
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):
   transform.structured.vectorize %arg0
 }

mlir/test/Dialect/Transform/test-interpreter.mlir

 %1 = transform.test_produce_param_or_forward_operand from %0
 // expected-note @below {{handle}}
 %2 = transform.test_produce_param_or_forward_operand from %0
 transform.test_consume_operand_if_matches_param_or_fail %1[42]
 transform.test_consume_operand_if_matches_param_or_fail %2[42]
 
 // -----
 
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
   ^bb0(%arg1: !pdl.operation):
     // expected-remark @below {{applying transformation "a"}}
     test_transform_op "a"
     // expected-remark @below {{applying transformation "b"}}
     test_transform_op "b"
     // expected-remark @below {{applying transformation "c"}}
     test_transform_op "c"
   }
   // expected-remark @below {{applying transformation "d"}}
   test_transform_op "d"
   // expected-remark @below {{applying transformation "e"}}
   test_transform_op "e"
 }
 
 // -----
 
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):
   %0 = test_produce_param_or_forward_operand 42
-  sequence %0 {
+  sequence %0 failures(propagate) {
   ^bb0(%arg1: !pdl.operation):
     // expected-remark @below {{succeeded}}
     test_consume_operand_if_matches_param_or_fail %arg1[42]
   }
 }
 
 // -----
 
-transform.sequence {
+transform.sequence failures(propagate) {
 ^bb0(%arg0: !pdl.operation):
-  %0 = sequence %arg0 {
+  %0 = sequence %arg0 failures(propagate) {
   ^bb0(%arg1: !pdl.operation):
     %1 = test_produce_param_or_forward_operand 42
     yield %1 : !pdl.operation
   } : !pdl.operation
   // expected-remark @below {{succeeded}}
   test_consume_operand_if_matches_param_or_fail %0[42]
 }
 
 // -----
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
   ^bb0(%arg1: !pdl.operation):
     %0 = pdl_match @some in %arg1
     test_print_remark_at_operand %0, "matched"
   }
 
   pdl.pattern @some : benefit(1) {
     %0 = pdl.operation "test.some_op"
     pdl.rewrite %0 with "transform.dialect"

 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
   pdl.pattern @const : benefit(1) {
     %r = pdl.types
     %0 = pdl.operation "arith.constant" -> (%r : !pdl.range<type>)
     pdl.rewrite %0 with "transform.dialect"
   }
 
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %f = pdl_match @const in %arg1
     // CHECK: %{{.+}} = get_closest_isolated_parent %{{.+}}
     %m = get_closest_isolated_parent %f
     test_print_remark_at_operand %m, "parent function"
   }
 }
 
 // -----
 
 func.func @foo() {
   %0 = arith.constant 0 : i32
   return
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
   pdl.pattern @match_func : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
     %2 = pdl.operation "func.func"(%0 : !pdl.range<value>) -> (%1 : !pdl.range<type>)
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     // This is necessary to run the transformation on something other than the
     // top-level module, "alternatives" cannot be run on that.
     %0 = pdl_match @match_func in %arg1
     transform.alternatives %0 {
     ^bb2(%arg2: !pdl.operation):
       %1 = transform.test_produce_param_or_forward_operand 42
       // This operation fails, which triggers the next alternative without

 ^bb0(%arg0: !pdl.operation):
   pdl.pattern @match_call : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
     %2 = pdl.operation "func.call"(%0 : !pdl.range<value>) -> (%1 : !pdl.range<type>)
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = pdl_match @match_call in %arg1
     %1 = get_closest_isolated_parent %0
     // expected-error @below {{all alternatives failed}}
     transform.alternatives %1 {
     ^bb2(%arg2: !pdl.operation):
       %2 = transform.pdl_match @match_call in %arg2
       // expected-remark @below {{applying}}

 ^bb0(%arg0: !pdl.operation):
   pdl.pattern @match_call : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
     %2 = pdl.operation "func.call"(%0 : !pdl.range<value>) -> (%1 : !pdl.range<type>)
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = pdl_match @match_call in %arg1
     %1 = get_closest_isolated_parent %0
     transform.alternatives %1 {
     ^bb2(%arg2: !pdl.operation):
       %2 = transform.pdl_match @match_call in %arg2
       // expected-remark @below {{applying}}
       transform.test_emit_remark_and_erase_operand %2, "applying" {fail_after_erase}

 ^bb0(%arg0: !pdl.operation):
   pdl.pattern @match_call : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
     %2 = pdl.operation "func.call"(%0 : !pdl.range<value>) -> (%1 : !pdl.range<type>)
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = pdl_match @match_call in %arg1
     %1 = get_closest_isolated_parent %0
     transform.alternatives %1 {
     ^bb2(%arg2: !pdl.operation):
       %2 = transform.pdl_match @match_call in %arg2
       // expected-remark @below {{applying}}
       transform.test_emit_remark_and_erase_operand %2, "applying" {fail_after_erase}

 ^bb0(%arg0: !pdl.operation):
   pdl.pattern @match_call : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
     %2 = pdl.operation "func.call"(%0 : !pdl.range<value>) -> (%1 : !pdl.range<type>)
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = pdl_match @match_call in %arg1
     %1 = get_closest_isolated_parent %0
     %2 = transform.alternatives %1 -> !pdl.operation {
     ^bb2(%arg2: !pdl.operation):
       %3 = transform.pdl_match @match_call in %arg2
       // expected-remark @below {{applying}}
       transform.test_emit_remark_and_erase_operand %3, "applying" {fail_after_erase}
module {
   }
 
   func.func @bar() {
     %0 = arith.constant 0 : i32
     %1 = arith.constant 1 : i32
     return
   }
 
-  transform.sequence {
+  transform.sequence failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     // expected-error @below {{scope must not contain the transforms being applied}}
     transform.alternatives %arg1 {
     ^bb2(%arg2: !pdl.operation):
       %0 = transform.test_produce_param_or_forward_operand 42
       transform.test_consume_operand_if_matches_param_or_fail %0[43]
     }, {
     ^bb2(%arg2: !pdl.operation):
^bb0(%arg0: !pdl.operation):
   pdl.pattern @match_const : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
     %2 = pdl.operation "arith.constant"(%0 : !pdl.range<value>) -> (%1 : !pdl.range<type>)
     pdl.rewrite %2 with "transform.dialect"
   }
 
 
-  sequence %arg0 {
+  sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %0 = transform.pdl_match @match_const in %arg1
     %1 = transform.loop.get_parent_for %0
     // expected-error @below {{only isolated-from-above ops can be alternative scopes}}
     alternatives %1 {
     ^bb2(%arg2: !pdl.operation):
     }
   }

 ^bb0(%arg0: !pdl.operation):
   pdl.pattern @some : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
     %2 = pdl.operation "op"(%0 : !pdl.range<value>) -> (%1 : !pdl.range<type>)
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb0(%arg1: !pdl.operation):
     %0 = pdl_match @some in %arg1
     // expected-error @below {{applications of transform.test_wrong_number_of_results expected to produce 3 results (actually produced 1).}}
     // expected-note @below {{If you need variadic results, consider a generic `apply` instead of the specialized `applyToOne`.}}
     // expected-note @below {{Producing 3 null results is allowed if the use case warrants it.}}
     transform.test_wrong_number_of_results %0
   }
 }

 ^bb0(%arg0: !pdl.operation):
   pdl.pattern @some : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
     %2 = pdl.operation "op"(%0 : !pdl.range<value>) -> (%1 : !pdl.range<type>)
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb0(%arg1: !pdl.operation):
     %0 = pdl_match @some in %arg1
     // expected-error @below {{applications of transform.test_wrong_number_of_multi_results expected to produce 1 results (actually produced 0)}}
     // expected-note @below {{If you need variadic results, consider a generic `apply` instead of the specialized `applyToOne`.}}
     // expected-note @below {{Producing 1 null results is allowed if the use case warrants it.}}
     transform.test_wrong_number_of_multi_results %0
   }
 }

 ^bb0(%arg0: !pdl.operation):
   pdl.pattern @some : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
     %2 = pdl.operation "op"(%0 : !pdl.range<value>) -> (%1 : !pdl.range<type>)
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb0(%arg1: !pdl.operation):
     %0 = pdl_match @some in %arg1
     // Transform matches 3 ops and produces 2 results.
     %1:2 = transform.test_correct_number_of_multi_results %0
   }
 }
 
 // -----
 
 func.func @foo() {
   "wrong_op_name" () : () -> ()
   return
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
   pdl.pattern @some : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
     %2 = pdl.operation "op"(%0 : !pdl.range<value>) -> (%1 : !pdl.range<type>)
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb0(%arg1: !pdl.operation):
     %0 = pdl_match @some in %arg1
     // Transform fails to match any but still produces 2 results.
     %1:2 = transform.test_correct_number_of_multi_results %0
   }
 }
 
 // -----
 
 func.func @foo() {
   // expected-note @below {{when applied to this op}}
   "op" () : () -> ()
   return
 }
 
 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
   pdl.pattern @some : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
     %2 = pdl.operation "op"(%0 : !pdl.range<value>) -> (%1 : !pdl.range<type>)
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb0(%arg1: !pdl.operation):
     %0 = pdl_match @some in %arg1
     // expected-error @below {{unexpected application of transform.test_mixed_null_and_non_null_results produces both null and non null results.}}
     transform.test_mixed_null_and_non_null_results %0
   }
 }
 
 // -----
^bb0(%arg0: !pdl.operation):
   }
   pdl.pattern @subi : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
     %2 = pdl.operation "arith.subi"(%0 : !pdl.range<value>) -> (%1 : !pdl.range<type>)
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb0(%arg1: !pdl.operation):
     %0 = pdl_match @addi in %arg1
     %1 = pdl_match @subi in %arg1
     %2 = merge_handles %0, %1
     test_print_remark_at_operand %2, "matched"
   }
 }
 

 ^bb0(%arg0: !pdl.operation):
   pdl.pattern @some : benefit(1) {
     %0 = pdl.operands
     %1 = pdl.types
     %2 = pdl.operation "op"(%0 : !pdl.range<value>) -> (%1 : !pdl.range<type>)
     pdl.rewrite %2 with "transform.dialect"
   }
 
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb0(%arg1: !pdl.operation):
     %0 = pdl_match @some in %arg1
     transform.test_mixed_sucess_and_silenceable %0
   }
 }
 
 // -----
 
+func.func @foo() {
+  "op" () : () -> ()
+  return
+}
+
+transform.with_pdl_patterns {
+^bb0(%arg0: !pdl.operation):
+  pdl.pattern @some : benefit(1) {
+    %0 = pdl.operands
+    %1 = pdl.types
+    %2 = pdl.operation "op"(%0 : !pdl.range<value>) -> (%1 : !pdl.range<type>)
+    pdl.rewrite %2 with "transform.dialect"
+  }
+
+  transform.sequence %arg0 failures(suppress) {
+  ^bb0(%arg1: !pdl.operation):
+    %0 = pdl_match @some in %arg1
+    // Not expecting error here because we are suppressing it.
+    // expected-remark @below {{foo}}
+    test_emit_remark_and_erase_operand %0, "foo" {fail_after_erase}
+  }
+}
+
+// -----
+
+func.func @foo() {
+  "op" () : () -> ()
+  return
+}
+
+transform.with_pdl_patterns {
+^bb0(%arg0: !pdl.operation):
+  pdl.pattern @some : benefit(1) {
+    %0 = pdl.operands
+    %1 = pdl.types
+    %2 = pdl.operation "op"(%0 : !pdl.range<value>) -> (%1 : !pdl.range<type>)
+    pdl.rewrite %2 with "transform.dialect"
+  }
+
+  transform.sequence %arg0 failures(propagate) {
+  ^bb0(%arg1: !pdl.operation):
+    %0 = pdl_match @some in %arg1
+    // expected-error @below {{silenceable error}}
+    // expected-remark @below {{foo}}
+    test_emit_remark_and_erase_operand %0, "foo" {fail_after_erase}
+  }
+}
+
+
+// -----
+
 module {
   func.func private @foo()
   func.func private @bar()
 
   transform.with_pdl_patterns {
   ^bb0(%arg0: !pdl.operation):
     pdl.pattern @func : benefit(1) {
       %0 = pdl.operands
       %1 = pdl.types
       %2 = pdl.operation "func.func"(%0 : !pdl.range<value>) -> (%1 : !pdl.range<type>)
       pdl.rewrite %2 with "transform.dialect"
     }
 
-    transform.sequence %arg0 {
+    transform.sequence %arg0 failures(propagate) {
     ^bb0(%arg1: !pdl.operation):
       %0 = pdl_match @func in %arg1
       %1 = replicate num(%0) %arg1
       // expected-remark @below {{2}}
       test_print_number_of_associated_payload_ir_ops %1
       %2 = replicate num(%0) %1
       // expected-remark @below {{4}}
       test_print_number_of_associated_payload_ir_ops %2

 transform.with_pdl_patterns {
 ^bb0(%arg0: !pdl.operation):
   pdl.pattern @const : benefit(1) {
     %r = pdl.types
     %0 = pdl.operation "arith.constant" -> (%r : !pdl.range<type>)
     pdl.rewrite %0 with "transform.dialect"
   }
 
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %f = pdl_match @const in %arg1
     transform.foreach %f {
     ^bb2(%arg2: !pdl.operation):
       // expected-remark @below {{1}}
       transform.test_print_number_of_associated_payload_ir_ops %arg2
       transform.test_print_remark_at_operand %arg2, "transform applied"
     }
^bb0(%arg0: !pdl.operation):
   }
 
   pdl.pattern @execute_region : benefit(1) {
     %r = pdl.types
     %0 = pdl.operation "scf.execute_region" -> (%r : !pdl.range<type>)
     pdl.rewrite %0 with "transform.dialect"
   }
 
-  transform.sequence %arg0 {
+  transform.sequence %arg0 failures(propagate) {
   ^bb1(%arg1: !pdl.operation):
     %f = pdl_match @execute_region in %arg1
     %results = transform.foreach %f -> !pdl.operation {
     ^bb2(%arg2: !pdl.operation):
       %g = transform.pdl_match @const in %arg2
       transform.yield %g : !pdl.operation
     }
 
     // expected-remark @below {{3}}
     transform.test_print_number_of_associated_payload_ir_ops %results
     transform.test_print_remark_at_operand %results, "transform applied"
   }
 }

mlir/test/Dialect/Transform/transform-state-extension.mlir

 // RUN: mlir-opt %s -test-transform-dialect-interpreter -verify-diagnostics -split-input-file
 
 // expected-note @below {{associated payload op}}
 module {
-  transform.sequence {
+  transform.sequence failures(propagate) {
   ^bb0(%arg0: !pdl.operation):
     // expected-remark @below {{extension absent}}
     test_check_if_test_extension_present %arg0
     test_add_test_extension "A"
     // expected-remark @below {{extension present, A}}
     test_check_if_test_extension_present %arg0
     test_remove_test_extension
     // expected-remark @below {{extension absent}}
     test_check_if_test_extension_present %arg0
   }
 }
 
 // -----
 
 // expected-note @below {{associated payload op}}
 module {
-  transform.sequence {
+  transform.sequence failures(propagate) {
   ^bb0(%arg0: !pdl.operation):
     test_add_test_extension "A"
     test_remove_test_extension
     test_add_test_extension "B"
     // expected-remark @below {{extension present, B}}
     test_check_if_test_extension_present %arg0
   }
 }
 
 // -----
 
 // expected-note @below {{associated payload op}}
 module {
-  transform.sequence {
+  transform.sequence failures(propagate) {
   ^bb0(%arg0: !pdl.operation):
     test_add_test_extension "A"
     // expected-remark @below {{extension present, A}}
     test_check_if_test_extension_present %arg0
     // expected-note @below {{associated payload op}}
     test_remap_operand_to_self %arg0
     // expected-remark @below {{extension present, A}}
     test_check_if_test_extension_present %arg0
   }
 }

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

 
 DiagnosedSilenceableFailure mlir::test::TestEmitRemarkAndEraseOperandOp::apply(
     transform::TransformResults &results, transform::TransformState &state) {
   emitRemark() << getRemark();
   for (Operation *op : state.getPayloadOps(getTarget()))
     op->erase();
 
   if (getFailAfterErase())
-    return emitSilenceableError() << "silencable error";
+    return emitSilenceableError() << "silenceable error";
   return DiagnosedSilenceableFailure::success();
 }
 
 DiagnosedSilenceableFailure mlir::test::TestWrongNumberOfResultsOp::applyToOne(
     Operation *target, SmallVectorImpl<Operation *> &results,
     transform::TransformState &state) {
   OperationState opState(target->getLoc(), "foo");
   results.push_back(OpBuilder(target).create(opState));

mlir/test/python/.style.yapf

+[style]
+  based_on_style = google
+  column_limit = 80
+  indent_width = 2

mlir/test/python/dialects/transform.py

with InsertionPoint(module.body):
       print("\nTEST:", f.__name__)
       f()
     print(module)
   return f
 
 
 @run
 def testSequenceOp():
-  sequence = transform.SequenceOp([pdl.OperationType.get()])
+  sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE,
+                                  [pdl.OperationType.get()])
   with InsertionPoint(sequence.body):
     transform.YieldOp([sequence.bodyTarget])
   # CHECK-LABEL: TEST: testSequenceOp
-  # CHECK: = transform.sequence {
+  # CHECK: = transform.sequence failures(propagate) {
   # CHECK: ^{{.*}}(%[[ARG0:.+]]: !pdl.operation):
   # CHECK:   yield %[[ARG0]] : !pdl.operation
   # CHECK: } : !pdl.operation
 
 
 @run
 def testNestedSequenceOp():
-  sequence = transform.SequenceOp()
+  sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE)
   with InsertionPoint(sequence.body):
-    nested = transform.SequenceOp(sequence.bodyTarget)
+    nested = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE, sequence.bodyTarget)
     with InsertionPoint(nested.body):
-      doubly_nested = transform.SequenceOp([pdl.OperationType.get()],
-                                           nested.bodyTarget)
+      doubly_nested = transform.SequenceOp(
+          transform.FailurePropagationMode.PROPAGATE,
+          [pdl.OperationType.get()], nested.bodyTarget)
       with InsertionPoint(doubly_nested.body):
         transform.YieldOp([doubly_nested.bodyTarget])
       transform.YieldOp()
     transform.YieldOp()
   # CHECK-LABEL: TEST: testNestedSequenceOp
-  # CHECK: transform.sequence {
+  # CHECK: transform.sequence failures(propagate) {
   # CHECK: ^{{.*}}(%[[ARG0:.+]]: !pdl.operation):
-  # CHECK:   sequence %[[ARG0]] {
+  # CHECK:   sequence %[[ARG0]] failures(propagate) {
   # CHECK:   ^{{.*}}(%[[ARG1:.+]]: !pdl.operation):
-  # CHECK:     = sequence %[[ARG1]] {
+  # CHECK:     = sequence %[[ARG1]] failures(propagate) {
   # CHECK:     ^{{.*}}(%[[ARG2:.+]]: !pdl.operation):
   # CHECK:       yield %[[ARG2]] : !pdl.operation
   # CHECK:     } : !pdl.operation
   # CHECK:   }
   # CHECK: }
 
 
 @run
 def testTransformPDLOps():
   withPdl = transform.WithPDLPatternsOp()
   with InsertionPoint(withPdl.body):
-    sequence = transform.SequenceOp([pdl.OperationType.get()],
+    sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE,
+                                    [pdl.OperationType.get()],
                                     withPdl.bodyTarget)
     with InsertionPoint(sequence.body):
       match = transform.PDLMatchOp(sequence.bodyTarget, "pdl_matcher")
       transform.YieldOp(match)
   # CHECK-LABEL: TEST: testTransformPDLOps
   # CHECK: transform.with_pdl_patterns {
   # CHECK: ^{{.*}}(%[[ARG0:.+]]: !pdl.operation):
-  # CHECK:   = sequence %[[ARG0]] {
+  # CHECK:   = sequence %[[ARG0]] failures(propagate) {
   # CHECK:   ^{{.*}}(%[[ARG1:.+]]: !pdl.operation):
   # CHECK:     %[[RES:.+]] = pdl_match @pdl_matcher in %[[ARG1]]
   # CHECK:     yield %[[RES]] : !pdl.operation
   # CHECK:   } : !pdl.operation
   # CHECK: }
 
 
 @run
 def testGetClosestIsolatedParentOp():
-  sequence = transform.SequenceOp()
+  sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE)
   with InsertionPoint(sequence.body):
     transform.GetClosestIsolatedParentOp(sequence.bodyTarget)
     transform.YieldOp()
   # CHECK-LABEL: TEST: testGetClosestIsolatedParentOp
   # CHECK: transform.sequence
   # CHECK: ^{{.*}}(%[[ARG1:.+]]: !pdl.operation):
   # CHECK:   = get_closest_isolated_parent %[[ARG1]]
 
 
 @run
 def testMergeHandlesOp():
-  sequence = transform.SequenceOp()
+  sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE)
   with InsertionPoint(sequence.body):
     transform.MergeHandlesOp([sequence.bodyTarget])
     transform.YieldOp()
   # CHECK-LABEL: TEST: testMergeHandlesOp
   # CHECK: transform.sequence
   # CHECK: ^{{.*}}(%[[ARG1:.+]]: !pdl.operation):
   # CHECK:   = merge_handles %[[ARG1]]
 
 
 @run
 def testReplicateOp():
   with_pdl = transform.WithPDLPatternsOp()
   with InsertionPoint(with_pdl.body):
-    sequence = transform.SequenceOp(with_pdl.bodyTarget)
+    sequence = transform.SequenceOp(
+        transform.FailurePropagationMode.PROPAGATE, with_pdl.bodyTarget)
     with InsertionPoint(sequence.body):
       m1 = transform.PDLMatchOp(sequence.bodyTarget, "first")
       m2 = transform.PDLMatchOp(sequence.bodyTarget, "second")
       transform.ReplicateOp(m1, [m2])
       transform.YieldOp()
   # CHECK-LABEL: TEST: testReplicateOp
   # CHECK: %[[FIRST:.+]] = pdl_match
   # CHECK: %[[SECOND:.+]] = pdl_match
   # CHECK: %{{.*}} = replicate num(%[[FIRST]]) %[[SECOND]]

mlir/test/python/dialects/transform_loop_ext.py

with InsertionPoint(module.body):
       print("\nTEST:", f.__name__)
       f()
     print(module)
   return f
 
 
 @run
 def getParentLoop():
-  sequence = transform.SequenceOp()
+  sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE)
   with InsertionPoint(sequence.body):
     loop.GetParentForOp(sequence.bodyTarget, num_loops=2)
     transform.YieldOp()
   # CHECK-LABEL: TEST: getParentLoop
   # CHECK: = transform.loop.get_parent_for %
   # CHECK: num_loops = 2
 
 
 @run
 def loopOutline():
-  sequence = transform.SequenceOp()
+  sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE)
   with InsertionPoint(sequence.body):
     loop.LoopOutlineOp(sequence.bodyTarget, func_name="foo")
     transform.YieldOp()
   # CHECK-LABEL: TEST: loopOutline
   # CHECK: = transform.loop.outline %
   # CHECK: func_name = "foo"
 
 
 @run
 def loopPeel():
-  sequence = transform.SequenceOp()
+  sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE)
   with InsertionPoint(sequence.body):
     loop.LoopPeelOp(sequence.bodyTarget)
     transform.YieldOp()
   # CHECK-LABEL: TEST: loopPeel
   # CHECK: = transform.loop.peel %
 
 
 @run
 def loopPipeline():
-  sequence = transform.SequenceOp()
+  sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE)
   with InsertionPoint(sequence.body):
     loop.LoopPipelineOp(sequence.bodyTarget, iteration_interval=3)
     transform.YieldOp()
   # CHECK-LABEL: TEST: loopPipeline
   # CHECK: = transform.loop.pipeline %
   # CHECK-DAG: iteration_interval = 3
   # CHECK-DAG: read_latency = 10
 
 
 @run
 def loopUnroll():
-  sequence = transform.SequenceOp()
+  sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE)
   with InsertionPoint(sequence.body):
     loop.LoopUnrollOp(sequence.bodyTarget, factor=42)
     transform.YieldOp()
   # CHECK-LABEL: TEST: loopUnroll
   # CHECK: transform.loop.unroll %
   # CHECK: factor = 42

mlir/test/python/dialects/transform_structured_ext.py

with InsertionPoint(module.body):
       print("\nTEST:", f.__name__)
       f()
     print(module)
   return f
 
 
 @run
 def testDecompose():
-  sequence = transform.SequenceOp()
+  sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE)
   with InsertionPoint(sequence.body):
     structured.DecomposeOp(sequence.bodyTarget)
     transform.YieldOp()
   # CHECK-LABEL: TEST: testDecompose
   # CHECK: transform.sequence
   # CHECK: transform.structured.decompose
 
 
 @run
 def testGeneralize():
-  sequence = transform.SequenceOp()
+  sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE)
   with InsertionPoint(sequence.body):
     structured.GeneralizeOp(sequence.bodyTarget)
     transform.YieldOp()
   # CHECK-LABEL: TEST: testGeneralize
   # CHECK: transform.sequence
   # CHECK: transform.structured.generalize
 
 
 @run
 def testInterchange():
-  sequence = transform.SequenceOp()
+  sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE)
   with InsertionPoint(sequence.body):
     structured.InterchangeOp(
         sequence.bodyTarget,
         iterator_interchange=[
             IntegerAttr.get(IntegerType.get_signless(64), 1), 0
         ])
     transform.YieldOp()
   # CHECK-LABEL: TEST: testInterchange
   # CHECK: transform.sequence
   # CHECK: transform.structured.interchange
   # CHECK: iterator_interchange = [1, 0]
 
 
 @run
 def testMultitileSizes():
-  sequence = transform.SequenceOp()
+  sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE)
   with InsertionPoint(sequence.body):
     structured.MultiTileSizesOp(
         sequence.bodyTarget, dimension=1, target_size=42)
     transform.YieldOp()
   # CHECK-LABEL: TEST: testMultitileSizes
   # CHECK: transform.sequence
   # CHECK: transform.structured.multitile_sizes
   # CHECK-DAG: dimension = 1
   # CHECK-DAG: target_size = 42
 
 
 @run
 def testPad():
-  sequence = transform.SequenceOp()
+  sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE)
   with InsertionPoint(sequence.body):
     structured.PadOp(
         sequence.bodyTarget,
         padding_values=[FloatAttr.get_f32(42.0)],
         padding_dimensions=[1],
         transpose_paddings=[[1, 0]])
     transform.YieldOp()
   # CHECK-LABEL: TEST: testPad
   # CHECK: transform.sequence
   # CHECK: transform.structured.pad
   # CHECK-DAG: padding_values = [4.200000e+01 : f32]
   # CHECK-DAG: padding_dimensions = [1]
   # CHECK-DAG: transpose_paddings = {{\[}}[1, 0]]
   # CHECK-DAG: hoist_paddings = []
   # CHECK-DAG: pack_paddings = []
 
 
 @run
 def testScalarize():
-  sequence = transform.SequenceOp()
+  sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE)
   with InsertionPoint(sequence.body):
     structured.ScalarizeOp(sequence.bodyTarget)
     transform.YieldOp()
   # CHECK-LABEL: TEST: testScalarize
   # CHECK: transform.structured.scalarize
 
 
 @run
 def testSplit():
-  sequence = transform.SequenceOp()
+  sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE)
   with InsertionPoint(sequence.body):
     split = structured.SplitOp(sequence.bodyTarget, dimension=1, split_point=42)
     structured.SplitOp(
         split.results[0], dimension=3, split_point=split.results[1])
     transform.YieldOp()
   # CHECK-LABEL: TEST: testSplit
   # CHECK: %[[F:.+]], %[[S:.+]] = transform.structured.split %{{.*}} after 42 {dimension = 1
   # CHECK: transform.structured.split %[[F]] after %[[S]] {dimension = 3
 
 
 @run
 def testTileCompact():
-  sequence = transform.SequenceOp()
+  sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE)
   with InsertionPoint(sequence.body):
     structured.TileOp(sequence.bodyTarget, sizes=[4, 8], interchange=[0, 1])
     transform.YieldOp()
   # CHECK-LABEL: TEST: testTileCompact
   # CHECK: transform.sequence
   # CHECK: %{{.+}}, %{{.+}}:2 = transform.structured.tile %{{.*}}[4, 8]
   # CHECK: interchange = [0, 1]
 
 
 @run
 def testTileAttributes():
-  sequence = transform.SequenceOp()
+  sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE)
   attr = ArrayAttr.get(
       [IntegerAttr.get(IntegerType.get_signless(64), x) for x in [4, 8]])
   ichange = ArrayAttr.get(
       [IntegerAttr.get(IntegerType.get_signless(64), x) for x in [0, 1]])
   with InsertionPoint(sequence.body):
     structured.TileOp(sequence.bodyTarget, sizes=attr, interchange=ichange)
     transform.YieldOp()
   # CHECK-LABEL: TEST: testTileAttributes
   # CHECK: transform.sequence
   # CHECK: %{{.+}}, %{{.+}}:2 = transform.structured.tile %{{.*}}[4, 8]
   # CHECK: interchange = [0, 1]
 
 
 @run
 def testTileZero():
-  sequence = transform.SequenceOp()
+  sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE)
   with InsertionPoint(sequence.body):
     structured.TileOp(
         sequence.bodyTarget, sizes=[4, 0, 2, 0], interchange=[0, 1, 2, 3])
     transform.YieldOp()
   # CHECK-LABEL: TEST: testTileZero
   # CHECK: transform.sequence
   # CHECK: %{{.+}}, %{{.+}}:2 = transform.structured.tile %{{.*}}[4, 0, 2, 0]
   # CHECK: interchange = [0, 1, 2, 3]
 
 
 @run
 def testTileDynamic():
   with_pdl = transform.WithPDLPatternsOp()
   with InsertionPoint(with_pdl.body):
-    sequence = transform.SequenceOp(with_pdl.bodyTarget)
+    sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE,
+                                    with_pdl.bodyTarget)
     with InsertionPoint(sequence.body):
       m1 = transform.PDLMatchOp(sequence.bodyTarget, "first")
       m2 = transform.PDLMatchOp(sequence.bodyTarget, "second")
       structured.TileOp(sequence.bodyTarget, sizes=[m1, 3, m2, 0])
       transform.YieldOp()
   # CHECK-LABEL: TEST: testTileDynamic
   # CHECK: %[[FIRST:.+]] = pdl_match
   # CHECK: %[[SECOND:.+]] = pdl_match
   # CHECK: %{{.+}}, %{{.+}}:3 = transform.structured.tile %{{.*}}[%[[FIRST]], 3, %[[SECOND]], 0]
 
 
 @run
 def testVectorize():
-  sequence = transform.SequenceOp()
+  sequence = transform.SequenceOp(transform.FailurePropagationMode.PROPAGATE)
   with InsertionPoint(sequence.body):
     structured.VectorizeOp(sequence.bodyTarget, vectorize_padding=True)
     transform.YieldOp()
   # CHECK-LABEL: TEST: testVectorize
   # CHECK: transform.sequence
   # CHECK: = transform.structured.vectorize
   # CHECK: vectorize_padding = true

utils/bazel/llvm-project-overlay/mlir/BUILD.bazel

deps = [
         ":ControlFlowInterfacesTdFiles",
         ":OpBaseTdFiles",
         ":PDLDialectTdFiles",
         ":SideEffectInterfacesTdFiles",
     ],
 )
 
 gentbl_cc_library(
+    name = "TransformDialectEnumsIncGen",
+    strip_include_prefix = "include",
+    tbl_outs = [
+        (
+            [
+                "-gen-enum-decls",
+            ],
+            "include/mlir/Dialect/Transform/IR/TransformDialectEnums.h.inc",
+        ),
+        (
+            [
+                "-gen-enum-defs",
+            ],
+            "include/mlir/Dialect/Transform/IR/TransformDialectEnums.cpp.inc",
+        ),
+    ],
+    tblgen = ":mlir-tblgen",
+    td_file = "include/mlir/Dialect/Transform/IR/TransformAttrs.td",
+    deps = [":TransformDialectTdFiles"],
+)
+
+gentbl_cc_library(
     name = "TransformDialectInterfacesIncGen",
     strip_include_prefix = "include",
     tbl_outs = [
         (
             [
                 "-gen-op-interface-decls",
             ],
             "include/mlir/Dialect/Transform/IR/TransformInterfaces.h.inc",
cc_library(
     deps = [
         ":ControlFlowInterfaces",
         ":IR",
         ":PDLDialect",
         ":PDLInterpDialect",
         ":Rewrite",
         ":SideEffectInterfaces",
         ":Support",
+        ":TransformDialectEnumsIncGen",
         ":TransformDialectIncGen",
         ":TransformDialectInterfacesIncGen",
         ":TransformOpsIncGen",
         "//llvm:Support",
     ],
 )
 
 td_library(