[mlir][Transform] Make applyToOne return a DiagnosedSilenceableFailure

[nicolasvasilache]

Summary

This revision revisits the implementation of applyToOne and its handling
of recoverable errors as well as propagation of null handles.
The implementation is simplified to always require passing a vector<Operation*>
in which the results are returned, resulting in less template instantiation magic.

[nicolasvasilache]

Finish the impl.

[nicolasvasilache]

Add support for list of diagnostics.

[ftynse]

I think the entire null pointer mess should remain in the internal of applyToOne, i.e., if nulls are returned, just filter them out before calling results.set in the apply implementation by TransformEachTrait. The failure state is already propagated, so there is no reason to know about nulls above that. Furthermore, this will fail the moment two distinct results have nulls in them because it will create a conflict in the "payload op -> handle" mapping that expects only one handle per payload op and there will be multiple handles to null.

Even more, I don't think we want to expose the "null handle" idea to the op documentation. This is an implementation detail. It is also a handle pointing to some nulls and some ops, not a null handle AFAICS. We can instead explain the tri-state failure and describe the failure mode along the lines of "if the transformation fails to apply to a subset of payload IR ops associated with the operand handle, the resulting handles will be associated only with the payload IR operations produced by the successful applications; the overall result will be a silenceable failure that the containing operation may chose to silence or report".

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

101

Nit: I suppose we want to separate different messages by newlines or something.

166

I'd rather consider a SmallVector<Diagnostic, 1> here with the convention that empty vector means no silenceable diagnostic. Currently, we can have an empty vector set, which is interpreted as silenceable diagnostic, but doesn't have any meaningful message.

629

It is unclear what it should put in the vector in the normal case of success, and whether it can assume the vector to be empty or not.
Also, a better explanation of the convention "fill with nulls and return success" is desirable.

630

Nit: "this the"

632

Which op?

645–648

I'd mention that in the case of silenceable failure, the transformation will still be applied to the following target ops, but definite failures are propagated immediately.

796

Micro-nit.

801–807

Why changing the severity? Silenceable diagnostics from individual applications are likely errors, so this should be too. If the caller doesn't silence them, it will still be interpreted as failure.

865

893–896

Because of the change above from "not success" to "is definite failure", this now looks incorrect in the following case. A transform op with legitimately zero results returns a silenceable failure and zero results. This will now turn that silenceable failure into a success. instead of collecting the failure message properly.

927

Nit: this feels like a note that can be attached to the original message.

[nicolasvasilache]

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

645–648

Reworded with more detail.

893–896

Reworked that part.

927

I reworked this to force applyToOne to always produce the expected number of results.
It can make them all null but if the right number is not present, this is an error.

[ftynse]

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

927

I meant specifically the part that starts with a newline can be attached as a note to the error. This is how these things usually look: the error message, and the note "did you mean foo?"

[ftynse]

You seem have created separate review threads for the patches that were supposed to be addressing review in this one.

[nicolasvasilache]

Rebase.

[nicolasvasilache]

Fix test.

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

927

ah ok, thanks!

[nicolasvasilache]

Fix test.

[nicolasvasilache]

Rebase.

[ftynse]

Thanks!

mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td

30

s/vectorize/decompose

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

802

Nit: I'd drop the "null handle" part from here, the user doesn't necessarily know such details.

895–902

Nit: would be nice to have a test.

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

410–411

Ultra-nit: missing whitespace

[nicolasvasilache]

Address last comments.

[nicolasvasilache]

Rebase

[nicolasvasilache]

Improve error message with a note.

mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.h

 #define MLIR_DIALECT_LINALG_TRANSFORMOPS_LINALGTRANSFORMOPS_H
 
 #include "mlir/Dialect/PDL/IR/PDLTypes.h"
 #include "mlir/Dialect/Transform/IR/TransformInterfaces.h"
 #include "mlir/IR/OpImplementation.h"
 
 namespace mlir {
 namespace linalg {
+class GenericOp;
 class LinalgOp;
 } // namespace linalg
 } // namespace mlir
 
 //===----------------------------------------------------------------------===//
 // Linalg Transform Operations
 //===----------------------------------------------------------------------===//
 

mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td

 include "mlir/IR/OpBase.td"
 
 def DecomposeOp : Op<Transform_Dialect, "structured.decompose",
     [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
      TransformOpInterface, TransformEachOpTrait]> {
   let description = [{
     Decomposes named complex operations, such as higher-dimensional
     (depthwise) convolutions, into combinations of lower-dimensional equivalents
-    when possible. The operand handle must point to a list of such operations.
-    The returning handle points to the main produced computational operation,
-    such as the lower-dimensional convolution.
+    when possible.
+
+    Return modes:
+    =============
+    This operation always succeeds.
+
+    The returned handle points to the main produced computational operation.
+    If the operation is not decomposable, the returned handle is set to null.
   }];
 
   let arguments = (ins PDL_Operation:$target);
   let results = (outs PDL_Operation:$transformed);
   let assemblyFormat = "$target attr-dict";
 
   let extraClassDeclaration = [{
-    ::mlir::FailureOr<::mlir::linalg::LinalgOp> applyToOne(
-        ::mlir::linalg::LinalgOp target, TransformState &state);
+    ::mlir::DiagnosedSilenceableFailure applyToOne(
+        ::mlir::linalg::LinalgOp target, 
+        ::llvm::SmallVectorImpl<::mlir::Operation *> &results, 
+        ::mlir::transform::TransformState &state);
   }];
 }
 
 def FuseOp : Op<Transform_Dialect, "structured.fuse",
     [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
      DeclareOpInterfaceMethods<TransformOpInterface>]> {
   let description = [{
     Tiles the operations pointed to by the target handle and fuses their
def FuseOp : Op<Transform_Dialect, "structured.fuse",
   let hasVerifier = 1;
 }
 
 def GeneralizeOp : Op<Transform_Dialect, "structured.generalize",
     [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
      TransformOpInterface, TransformEachOpTrait]> {
   let description = [{
     Transforms a named structued operation into the generic form with the
-    explicit attached region. The operand handle must point to a list of
-    structured operations, it is consumed by the transformation and is not
-    expected to be used afterwards. The resulting handle points to the list
-    of equivalent generic operations, in the same order as the original named
-    operations.
+    explicit attached region. 
+    
+    Return modes:
+    =============
+    This operation always succeeds.
+
+    The returned handle points to the equivalent generic operation, this may be
+    the original op if it was already in generic form.
+    If the operation is not generalizable, the returned handle is set to null.
   }];
 
   let arguments = (ins PDL_Operation:$target);
   let results = (outs PDL_Operation:$transformed);
   let assemblyFormat = "$target attr-dict";
 
   let extraClassDeclaration = [{
-    ::mlir::FailureOr<::mlir::linalg::LinalgOp> applyToOne(
-        ::mlir::linalg::LinalgOp target, TransformState &state);
+    ::mlir::DiagnosedSilenceableFailure applyToOne(
+        ::mlir::linalg::LinalgOp target, 
+        ::llvm::SmallVectorImpl<::mlir::Operation *> &results, 
+        ::mlir::transform::TransformState &state);
   }];
 }
 
 def InterchangeOp : Op<Transform_Dialect, "structured.interchange",
     [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
     TransformOpInterface, TransformEachOpTrait]> {
   let description = [{
     Interchanges the iterators of the operations pointed to by the target handle
     using the iterator interchange attribute.
+
+    Return modes:
+    =============
+    This operation may produce a definiteFailure if the interchange attribute
+    is invalid.
+    If the transform is applied to the wrong op kind, the result is null and 
+    the operation produces a silenceableFailure.
+    Otherwise, it succeeds and returns the handle to the rewritten generic op.
+    This handle may be the original op if the permutation is the identity.
   }];
 
   let arguments =
     (ins PDL_Operation:$target,
          DefaultValuedAttr<I64ArrayAttr, "{}">:$iterator_interchange);
   let results = (outs PDL_Operation:$transformed);
 
   let assemblyFormat = "$target attr-dict";
   let hasVerifier = 1;
 
   let extraClassDeclaration = [{
-    ::mlir::FailureOr<::mlir::linalg::LinalgOp> applyToOne(
-        ::mlir::linalg::LinalgOp target, TransformState &state);
+    ::mlir::DiagnosedSilenceableFailure applyToOne(
+        ::mlir::linalg::GenericOp target, 
+        ::llvm::SmallVectorImpl<::mlir::Operation *> &results, 
+        ::mlir::transform::TransformState &state);
   }];
 }
 
 def PadOp : Op<Transform_Dialect, "structured.pad",
     [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
      TransformOpInterface, TransformEachOpTrait]> {
   let description = [{
     Pads the operations pointed to by the target handle using the options
     provides as operation attributes.
+
+    Return modes:
+    =============
+    This operation may produce a definiteFailure if the padding fails for any
+    reason.
+    Otherwise, it succeeds and returns the handle to the rewritten padded op.
   }];
 
   let arguments =
     (ins PDL_Operation:$target,
          DefaultValuedAttr<ArrayAttr, "{}">:$padding_values,
          DefaultValuedAttr<I64ArrayAttr, "{}">:$padding_dimensions,
          DefaultValuedAttr<I64ArrayAttr, "{}">:$pack_paddings,
          DefaultValuedAttr<I64ArrayAttr, "{}">:$hoist_paddings,
          DefaultValuedAttr<
           TypedArrayAttrBase<I64ArrayAttr, "array of arrays of i64">,
           "{}">:$transpose_paddings);
   let results = (outs PDL_Operation:$transformed);
 
   let assemblyFormat = "$target attr-dict";
   let hasVerifier = 1;
 
   let extraClassDeclaration = [{
-    ::mlir::FailureOr<::mlir::linalg::LinalgOp> applyToOne(
-        ::mlir::linalg::LinalgOp target, TransformState &state);
+    ::mlir::DiagnosedSilenceableFailure applyToOne(
+        ::mlir::linalg::LinalgOp target, 
+        ::llvm::SmallVectorImpl<::mlir::Operation *> &results, 
+        ::mlir::transform::TransformState &state);
   }];
 }
 
 def ScalarizeOp : Op<Transform_Dialect, "structured.scalarize",
     [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
      TransformOpInterface, TransformEachOpTrait]> {
   let description = [{
     Indicates that ops of a specific kind in the given function should be
     scalarized (i.e. their dynamic dimensions tiled by 1).
 
-    This operation returns the tiled op but not the loops.
+    Return modes:
+    =============
+    This operation produces `definiteFailure` if the scalarization fails for any
+    reason.
 
+    This operation returns the tiled op but not the loops.
     We make this design choice because it is hard to know ahead of time the
     number of loops that will be produced (it depends on the number of dynamic
     dimensions after multiple transformations have been applied).
   }];
 
   let arguments = (ins PDL_Operation:$target);
   let results = (outs PDL_Operation:$result);
 
   let assemblyFormat = "$target attr-dict";
 
   let extraClassDeclaration = [{
-    ::mlir::FailureOr<::mlir::linalg::LinalgOp> applyToOne(
-        ::mlir::linalg::LinalgOp target, TransformState &state);
+    ::mlir::DiagnosedSilenceableFailure applyToOne(
+        ::mlir::linalg::LinalgOp target, 
+        ::llvm::SmallVectorImpl<::mlir::Operation *> &results, 
+        ::mlir::transform::TransformState &state);
   }];
 }
 
 def SplitReductionOp : Op<Transform_Dialect, "structured.split_reduction",
        [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
         TransformEachOpTrait, TransformOpInterface]> {
   let description = [{
     Indicates that the given `target` op should be transformed with the 
     `splitReduction` transformation and split factor provided as attribute.
 
     The `splitReduction` transformation splits the first single linalg op 
     reduction into a parallel and reduction dimension. 
     A new `linalg.generic` op is created to perform the rest of the reduction. 
     
     The transformation supports different configurations attributes:
       - split_factor: the factor by which to split (i.e. the size of the 
         remaining reduction after splitting).
       - insert_split_dimension: the dimension in the temporary tensor into 
         which the new parallel dimension is inserted.
       - use_scaling_algorithm: whether to use a scaling based formulation that 
         does not create an ExpandShapeOp (default: do not use scaling)
       - use_alloc: whether to use an alloc op to allocate the temporary 
         tensor (default: do not use alloc op)
 
+    Return modes:
+    =============
+    This operation produces `definiteFailure` if the splitting fails for any
+    reason.
+
     This op returns 4 handles to:
       - the init op (or tensor_alloc op if use_alloc = true), 
       - the fill op used to initialize the neutral element, 
       - the split op and 
       - the result-combining op.
 
     Example (default: use_scaling_algorithm = false, use_alloc = false):
     ====================================================================
let arguments = (ins PDL_Operation:$target,
                    UnitAttr:$use_alloc);
   let results = (outs PDL_Operation:$fill_op,
                       PDL_Operation:$split_linalg_op,
                       PDL_Operation:$combining_linalg_op);
 
   let assemblyFormat = "$target attr-dict";
 
   let extraClassDeclaration = [{
-    ::mlir::FailureOr<::llvm::SmallVector<::mlir::Operation *>> applyToOne(
-        ::mlir::linalg::LinalgOp target, TransformState &state);
+    ::mlir::DiagnosedSilenceableFailure applyToOne(
+        ::mlir::linalg::LinalgOp target, 
+        ::llvm::SmallVectorImpl<::mlir::Operation *> &results, 
+        ::mlir::transform::TransformState &state);
   }];
 }
 
 def TileOp : Op<Transform_Dialect, "structured.tile",
        [DeclareOpInterfaceMethods<TransformOpInterface>,
         FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface]> {
   let description = [{
     Indicates that the given `target` op should be tiled with the options
let description = [{
     the "isolated from above property". If finer granularity is required, it can
     be achieved by outlining the target part of the payload IR into, e.g., a
     function, performing the transformation, and inlining it back. This
     transformation only fails if the entire pattern rewriting failed, i.e., it
     does **not** fail when no ops were vectorized.
 
     Note that this transformation is invalidating the handles to any payload IR
     operation that is contained inside the vectorization target.
+
+    Return modes:
+    =============
+    This operation produces `definiteFailure` if vectorization fails for any
+    reason.
+    The operation always returns the handle to the target op that is expected 
+    to be isolated from above.
   }];
 
   let arguments = (ins PDL_Operation:$target,
                    DefaultValuedAttr<BoolAttr, "false">:$vectorize_padding);
   let results = (outs PDL_Operation:$transformed);
 
   let assemblyFormat = "$target attr-dict";
 
   let extraClassDeclaration = [{
-    ::mlir::FailureOr<Operation *> applyToOne(
-      ::mlir::Operation *target, TransformState &state);
+    ::mlir::DiagnosedSilenceableFailure applyToOne(
+        ::mlir::Operation *target, 
+        ::llvm::SmallVectorImpl<::mlir::Operation *> &results, 
+        ::mlir::transform::TransformState &state);
   }];
 }
 
 #endif // LINALG_TRANSFORM_OPS

mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h

 /// the index accesses of `op`. This is an in-place transformation controlled by
 /// `interchangeVector`. An empty vector is interpreted as the identity
 /// permutation and the transformation returns early.
 ///
 /// E.g. the permutation `(i,j,k) -> (j,k,i)` is expressed with
 /// `interchangeVector = [1,2,0]`. All values in `interchangeVector` must be
 /// integers, in the range 0..`op.rank` without duplications
 /// (i.e. `[1,1,2]` is an invalid permutation).
+///
+/// Return failure if the permutation is not valid.
 FailureOr<GenericOp> interchangeGenericOp(RewriterBase &rewriter,
                                           GenericOp genericOp,
                                           ArrayRef<unsigned> interchangeVector);
 
 /// Create a GenericOp from the given named operation `namedOp` and replace
 /// namedOp.
 /// Return failure if `namedOp` is a GenericOp or misses a region builder.
 FailureOr<GenericOp> generalizeNamedOp(RewriterBase &rewriter,

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

def LoopOutlineOp : Op<Transform_Dialect, "loop.outline",
   let description = [{
      Moves the loop into a separate function with the specified name and
      replaces the loop in the Payload IR with a call to that function. Takes
      care of forwarding values that are used in the loop as function arguments.
      If the operand is associated with more than one loop, each loop will be
      outlined into a separate function. The provided name is used as a _base_
      for forming actual function names following SymbolTable auto-renaming
      scheme to avoid duplicate symbols. Expects that all ops in the Payload IR
-     have a SymbolTable ancestor (typically true because of the top-level 
+     have a SymbolTable ancestor (typically true because of the top-level
      module). Returns the handle to the list of outlined functions in the same
      order as the operand handle.
   }];
 
   let arguments = (ins PDL_Operation:$target,
                    StrAttr:$func_name);
   let results = (outs PDL_Operation:$transformed);
 
   let assemblyFormat = "$target attr-dict";
 }
 
 def LoopPeelOp : Op<Transform_Dialect, "loop.peel",
     [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
      TransformOpInterface, TransformEachOpTrait]> {
   let summary = "Peels the last iteration of the loop";
   let description = [{
      Updates the given loop so that its step evenly divides its range and puts
-     the remaining iteration into a separate loop or a conditional. Note that
-     even though the Payload IR modification may be performed in-place, this
-     operation consumes the operand handle and produces a new one. Applies to
-     each loop associated with the operand handle individually. The results
-     follow the same order as the operand.
-
-     Note: If it can be proven statically that the step already evenly divides
-     the range, this op is a no-op. In the absence of sufficient static
-     information, this op may peel a loop, even if the step always divides the
-     range evenly at runtime.
+     the remaining iteration into a separate loop or a conditional.
+
+     In the absence of sufficient static information, this op may peel a loop,
+     even if the step always divides the range evenly at runtime.
+
+     Return modes:
+     =============
+     This operation always succeeds and returns the scf::ForOp with the
+     postcondition: "the loop trip count is divisible by the step".
+     This operation may return the same unmodified loop handle when peeling did
+     not modify the IR (i.e. the loop trip count was already divisible).
+
+     Note that even though the Payload IR modification may be performed
+     in-place, this operation consumes the operand handle and produces a new
+     one.
+
+     TODO: Return both the peeled loop and the remainder loop.
   }];
 
   let arguments =
       (ins PDL_Operation:$target,
            DefaultValuedAttr<BoolAttr, "false">:$fail_if_already_divisible);
+  // TODO: Return both the peeled loop and the remainder loop. 
   let results = (outs PDL_Operation:$transformed);
 
   let assemblyFormat = "$target attr-dict";
 
   let extraClassDeclaration = [{
-    ::mlir::FailureOr<::mlir::scf::ForOp> applyToOne(
-      ::mlir::scf::ForOp loop, TransformState &state);
+    ::mlir::DiagnosedSilenceableFailure applyToOne(
+        ::mlir::scf::ForOp target, 
+        ::llvm::SmallVector<::mlir::Operation *> &results, 
+        ::mlir::transform::TransformState &state);
   }];
 }
  
 def LoopPipelineOp : Op<Transform_Dialect, "loop.pipeline",
     [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
      TransformOpInterface, TransformEachOpTrait]> {
   let summary = "Applies software pipelining to the loop";
   let description = [{
     Transforms the given loops one by one to achieve software pipelining for
     each of them. That is, performs some amount of reads from memory before the
     loop rather than inside the loop, the same amount of writes into memory
     after the loop, and updates each iteration to read the data for a following
-    iteration rather than the current one. The amount is specified by the
-    attributes. The values read and about to be stored are transferred as loop
-    iteration arguments. Currently supports memref and vector transfer
-    operations as memory reads/writes.
+    iteration rather than the current one. 
+    
+    The amount is specified by the attributes. 
+    
+    The values read and about to be stored are transferred as loop iteration
+    arguments. Currently supports memref and vector transfer operations as 
+    memory reads/writes.
+
+    Return modes:
+    =============
+    This operation succeeds and returns the pipelined loop when possible.
+    Otherwise, it succeeds and returns null to allow chaining in the cases where
+    further transformations are applied to only the pipelined loops.
   }];
 
   let arguments = (ins PDL_Operation:$target,
                    DefaultValuedAttr<I64Attr, "1">:$iteration_interval,
                    DefaultValuedAttr<I64Attr, "10">:$read_latency);
   let results = (outs PDL_Operation:$transformed);
 
   let assemblyFormat = "$target attr-dict";
 
   let extraClassDeclaration = [{
-    ::mlir::FailureOr<::mlir::scf::ForOp> applyToOne(
-      ::mlir::scf::ForOp loop, TransformState &state);
+    ::mlir::DiagnosedSilenceableFailure applyToOne(
+        ::mlir::scf::ForOp target, 
+        ::llvm::SmallVector<::mlir::Operation *> &results, 
+        ::mlir::transform::TransformState &state);
   }];
 }
 
 def LoopUnrollOp : Op<Transform_Dialect, "loop.unroll",
     [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
      TransformOpInterface, TransformEachOpTrait]> {
   let summary = "Unrolls the given loop with the given unroll factor";
   let description = [{
-     Unrolls each loop associated with the given handle to have up to the given
-     number of loop body copies per iteration. If the unroll factor is larger
-     than the loop trip count, the latter is used as the unroll factor instead.
-     Does not produce a new handle as the operation may result in the loop being
-     removed after a full unrolling.
+
+    Return modes:
+    ==============
+    This operation succeeds when loop unrolling occurred.
+    Otherwise, it produces a silenceableFailure to denote that the particular 
+    loop failed to unroll.
+
+    Does not return handles as the operation may result in the loop being
   }];
 
   let arguments = (ins PDL_Operation:$target,
                        Confined<I64Attr, [IntPositive]>:$factor);
 
   let assemblyFormat = "$target attr-dict";
 
   let extraClassDeclaration = [{
-    ::mlir::LogicalResult applyToOne(
-      ::mlir::scf::ForOp loop, TransformState &state);
+    ::mlir::DiagnosedSilenceableFailure applyToOne(
+        ::mlir::scf::ForOp target, 
+        ::llvm::SmallVector<::mlir::Operation *> &results, 
+        ::mlir::transform::TransformState &state);
   }];
 }
 
 #endif // SCF_TRANSFORM_OPS

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

 //===- TransformInterfaces.h - Transform Dialect Interfaces -----*- C++ -*-===//
 //
 // 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_TRANSFORMINTERFACES_H
 #define MLIR_DIALECT_TRANSFORM_IR_TRANSFORMINTERFACES_H
 
 #include "mlir/IR/OpDefinition.h"
 
 #include "mlir/Interfaces/SideEffectInterfaces.h"
+#include "llvm/ADT/ScopeExit.h"
 
 namespace mlir {
 
 /// The result of a transform IR operation application. This can have one of the
 /// three states:
 ///   - success;
-///   - silencable (recoverable) failure with yet-unreported diagnostic;
+///   - silenceable (recoverable) failure with yet-unreported diagnostic;
 ///   - definite failure.
 /// Silenceable failure is intended to communicate information about
 /// transformations that did not apply but in a way that supports recovery,
 /// for example, they did not modify the payload IR or modified it in some
 /// predictable way. They are associated with a Diagnostic that provides more
 /// details on the failure. Silenceable failure can be discarded, turning the
 /// result into success, or "reported", emitting the diagnostic and turning the
-/// result into definite failure. Transform IR operations containing other
-/// operations are allowed to do either with the results of the nested
-/// transformations, but must propagate definite failures as their diagnostics
-/// have been already reported to the user.
+/// result into definite failure.
+/// Transform IR operations containing other operations are allowed to do either
+/// with the results of the nested transformations, but must propagate definite
+/// failures as their diagnostics have been already reported to the user.
 class LLVM_NODISCARD DiagnosedSilenceableFailure {
 public:
   explicit DiagnosedSilenceableFailure(LogicalResult result) : result(result) {}
   DiagnosedSilenceableFailure(const DiagnosedSilenceableFailure &) = delete;
   DiagnosedSilenceableFailure &
   operator=(const DiagnosedSilenceableFailure &) = delete;
   DiagnosedSilenceableFailure(DiagnosedSilenceableFailure &&) = default;
   DiagnosedSilenceableFailure &
   operator=(DiagnosedSilenceableFailure &&) = default;
 
   /// Constructs a DiagnosedSilenceableFailure in the success state.
   static DiagnosedSilenceableFailure success() {
     return DiagnosedSilenceableFailure(::mlir::success());
   }
 
   /// Constructs a DiagnosedSilenceableFailure in the failure state. Typically,
   /// a diagnostic has been emitted before this.
   static DiagnosedSilenceableFailure definiteFailure() {
     return DiagnosedSilenceableFailure(::mlir::failure());
   }
 
-  /// Constructs a DiagnosedSilenceableFailure in the silencable failure state,
+  /// Constructs a DiagnosedSilenceableFailure in the silenceable failure state,
   /// ready to emit the given diagnostic. This is considered a failure
   /// regardless of the diagnostic severity.
-  static DiagnosedSilenceableFailure silencableFailure(Diagnostic &&diag) {
+  static DiagnosedSilenceableFailure silenceableFailure(Diagnostic &&diag) {
     return DiagnosedSilenceableFailure(std::forward<Diagnostic>(diag));
   }
+  static DiagnosedSilenceableFailure
+  silenceableFailure(SmallVector<Diagnostic> &&diag) {
+    return DiagnosedSilenceableFailure(
+        std::forward<SmallVector<Diagnostic>>(diag));
+  }
 
   /// Converts all kinds of failure into a LogicalResult failure, emitting the
   /// diagnostic if necessary. Must not be called more than once.
   LogicalResult checkAndReport() {
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
     assert(!reported && "attempting to report a diagnostic more than once");
     reported = true;
 #endif // LLVM_ENABLE_ABI_BREAKING_CHECKS
-    if (diagnostic) {
-      diagnostic->getLocation().getContext()->getDiagEngine().emit(
-          std::move(*diagnostic));
-      diagnostic.reset();
+    if (!diagnostics.empty()) {
+      for (auto &&diagnostic : diagnostics) {
+        diagnostic.getLocation().getContext()->getDiagEngine().emit(
+            std::move(diagnostic));
+      }
+      diagnostics.clear();
       result = ::mlir::failure();
     }
     return result;
   }
 
-  /// Returns `true` if this is a silencable failure.
-  bool isSilenceableFailure() const { return diagnostic.hasValue(); }
+  /// Returns `true` if this is a silenceable failure.
+  bool isDefiniteFailure() const { return result.failed(); }
+
+  /// Returns `true` if this is a silenceable failure.
+  bool isSilenceableFailure() const { return !diagnostics.empty(); }
 
   /// Returns `true` if this is a success.
   bool succeeded() const {
-    return !diagnostic.hasValue() && ::mlir::succeeded(result);
+    return diagnostics.empty() && ::mlir::succeeded(result);
   }
 
   /// Returns the diagnostic message without emitting it. Expects this object
-  /// to be a silencable failure.
-  std::string getMessage() const { return diagnostic->str(); }
+  /// to be a silenceable failure.
+  std::string getMessage() const {
+    std::string res;
+    for (auto &diagnostic : diagnostics) {
+      res.append(diagnostic.str());
+      res.append("\n");
+    }
+    return res;
+  }
 
-  /// Converts silencable failure into LogicalResult success without reporting
+  /// Returns a string representation of the failure mode (for error reporting).
+  std::string getStatusString() const {
+    if (succeeded())
+      return "success";
+    if (isSilenceableFailure())
+      return "silenceable failure";
+    return "definite failure";
+  }
+
+  /// Converts silenceable failure into LogicalResult success without reporting
   /// the diagnostic, preserves the other states.
   LogicalResult silence() {
-    if (diagnostic) {
-      diagnostic.reset();
+    if (!diagnostics.empty()) {
+      diagnostics.clear();
       result = ::mlir::success();
     }
     return result;
   }
 
-  /// Streams the given values into the diagnotic. Expects this object to be a
-  /// silencable failure.
+  /// Take the diagnostic and silence.
+  SmallVector<Diagnostic> &&takeDiagnostics() {
+    assert(!diagnostics.empty() && "expected a diagnostic to be present");
+    auto guard = llvm::make_scope_exit([&]() { diagnostics.clear(); });
+    return std::move(diagnostics);
+  }
+
+  /// Streams the given values into the last diagnotic.
+  /// Expects this object to be a silenceable failure.
   template <typename T>
   DiagnosedSilenceableFailure &operator<<(T &&value) & {
     assert(isSilenceableFailure() &&
-           "can only append output in silencable failure state");
-    *diagnostic << std::forward<T>(value);
+           "can only append output in silenceable failure state");
+    diagnostics.back() << std::forward<T>(value);
     return *this;
   }
   template <typename T>
   DiagnosedSilenceableFailure &&operator<<(T &&value) && {
     return std::move(this->operator<<(std::forward<T>(value)));
   }
 
-  /// Attaches a note to the diagnostic. Expects this object to be a silencable
-  /// failure.
+  /// Attaches a note to the last diagnostic.
+  /// Expects this object to be a silenceable failure.
   Diagnostic &attachNote(Optional<Location> loc = llvm::None) {
     assert(isSilenceableFailure() &&
-           "can only attach notes to silencable failures");
-    return diagnostic->attachNote(loc);
+           "can only attach notes to silenceable failures");
+    return diagnostics.back().attachNote(loc);
   }
 
 private:
   explicit DiagnosedSilenceableFailure(Diagnostic &&diagnostic)
-      : diagnostic(std::move(diagnostic)), result(failure()) {}
+      : diagnostics(), result(failure()) {
+    diagnostics.emplace_back(std::move(diagnostic));
+  }
+  explicit DiagnosedSilenceableFailure(SmallVector<Diagnostic> &&diagnostics)
+      : diagnostics(std::move(diagnostics)), result(failure()) {}
 
-  /// The diagnostic associated with this object. If present, the object is
-  /// considered to be in the silencable failure state regardless of the
+  /// The diagnostics associated with this object. If non-empty, the object is
+  /// considered to be in the silenceable failure state regardless of the
   /// `result` field.
-  Optional<Diagnostic> diagnostic;
+  SmallVector<Diagnostic, 1> diagnostics;
 
-  /// The "definite" logical state, either success or failure. Ignored if the
-  /// diagnostic message is present.
+  /// The "definite" logical state, either success or failure.
+  /// Ignored if the diagnostics message is present.
   LogicalResult result;
 
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
-  /// Whther the associated diagnostic have been reported. Diagnostic reporting
-  /// consumes the diagnostic, so we need a mechanism to differentiate a
-  /// reported diagnostic from a state where it was never created.
+  /// Whether the associated diagnostics have been reported.
+  /// Diagnostics reporting consumes the diagnostics, so we need a mechanism to
+  /// differentiate reported diagnostics from a state where it was never
+  /// created.
   bool reported = false;
 #endif // LLVM_ENABLE_ABI_BREAKING_CHECKS
 };
 
 namespace transform {
 
 class TransformOpInterface;
 
LogicalResult mapBlockArguments(TransformState &state) {
     assert(
         this->getOperation()->getNumRegions() == 1 &&
         "must indicate the region to map if the operation has more than one");
     return mapBlockArguments(state, this->getOperation()->getRegion(0));
   }
 };
 
 /// Trait implementing the TransformOpInterface for operations applying a
-/// transformation to a single operation handle and producing one or multiple
-/// operation handles.
-/// The op must implement a method with one of the following signatures:
-///   - FailureOr<convertible-to-Operation*> applyToOne(OpTy, state)
-///   - FailureOr<SmallVector<convertible-to-Operation*>>applyToOne(OpTy, state)
-///   - LogicalResult applyToOne(OpTy, state)
+/// transformation to a single operation handle and producing zero, one or
+/// multiple operation handles.
+/// The op must implement a method with the following signature:
+///   - DiagnosedSilenceableFailure applyToOne(OpTy,
+///       SmallVector<Operation*> &results, state)
 /// to perform a transformation that is applied in turn to all payload IR
 /// operations that correspond to the handle of the transform IR operation.
-/// In the functions above, OpTy is either Operation * or a concrete payload IR
-/// Op class that the transformation is applied to (NOT the class of the
-/// transform IR op). The op is expected to have a single operand.
+/// In `applyToOne`, OpTy is either Operation* or a concrete payload IR Op class
+/// that the transformation is applied to (and NOT the class of the transform IR
+/// op).
+/// The `applyToOne` method takes an empty `results` vector that it fills with
+/// zero, one or multiple operations depending on the number of resultd expected
+/// by the transform op.
+/// The number of results must match the number of results of the transform op.
+/// `applyToOne` is allowed to fill the `results` with all null elements to
+/// signify that the transformation did not apply to the payload IR operations.
+/// The transform op having this trait is expected to have a single operand.
 template <typename OpTy>
 class TransformEachOpTrait
     : public OpTrait::TraitBase<OpTy, TransformEachOpTrait> {
 public:
   /// Calls `applyToOne` for every payload operation associated with the operand
-  /// of this transform IR op. If `applyToOne` returns ops, associates them with
-  /// the result of this transform op.
+  /// of this transform IR op, the following case disjunction happens:
+  ///   1. If not target payload ops are associated to the operand then fill the
+  ///      results vector with the expected number of null elements and return
+  ///      success. This is the corner case handling that allows propagating
+  ///      the "no-op" case gracefully to improve usability.
+  ///   2. If any `applyToOne` returns definiteFailure, the transformation is
+  ///      immediately considered definitely failed and we return.
+  ///   3. All applications of `applyToOne` are checked to return a number of
+  ///      results expected by the transform IR op. If not, this is a definite
+  ///      failure and we return early.
+  ///   4. If `applyToOne` produces ops, associate them with the result of this
+  ///      transform op.
+  ///   5. If any `applyToOne` return silenceableFailure, the transformation is
+  ///      considered silenceable.
+  ///   6. Otherwise the transformation is considered successful.
   DiagnosedSilenceableFailure apply(TransformResults &transformResults,
                                     TransformState &state);
 
   /// Checks that the op matches the expectations of this trait.
   static LogicalResult verifyTrait(Operation *op);
 };
 
 /// Side effect resource corresponding to the mapping between Transform IR

 } // namespace transform
 } // namespace mlir
 
 #include "mlir/Dialect/Transform/IR/TransformInterfaces.h.inc"
 
 namespace mlir {
 namespace transform {
 namespace detail {
-/// Appends `result` to the vector assuming it corresponds to the success state
-/// in `FailureOr<convertible-to-Operation*>`. If `result` is just a
-/// `LogicalResult`, appends an empy vector.
-template <typename Ty>
-std::enable_if_t<std::is_same<Ty, LogicalResult>::value, LogicalResult>
-appendTransformResultToVector(
-    Ty result, SmallVectorImpl<SmallVector<Operation *>> &results) {
-  results.push_back(SmallVector<Operation *>());
-  return result;
-}
-
-template <typename Ty>
-std::enable_if_t<
-    llvm::conjunction<
-        llvm::negation<std::is_same<Ty, LogicalResult>>,
-        std::is_convertible<typename Ty::value_type, Operation *>>::value,
-    LogicalResult>
-appendTransformResultToVector(
-    Ty result, SmallVectorImpl<SmallVector<Operation *>> &results) {
-  if (failed(result))
-    return failure();
-  results.push_back(SmallVector<Operation *>{*result});
-  return success();
-}
-
-template <typename ContainerTy>
-std::enable_if_t<
-    llvm::conjunction<
-        llvm::negation<std::is_same<ContainerTy, LogicalResult>>,
-        llvm::negation<std::is_convertible<typename ContainerTy::value_type,
-                                           Operation *>>>::value,
-    LogicalResult>
-appendTransformResultToVector(
-    ContainerTy resultContainer,
-    SmallVectorImpl<SmallVector<Operation *>> &results) {
-  if (failed(resultContainer))
-    return failure();
-  results.push_back(*resultContainer);
-  return success();
-}
 /// Applies a one-to-one or a one-to-many transform to each of the given
 /// targets. Puts the results of transforms, if any, in `results` in the same
 /// order. Fails if any of the application fails. Individual transforms must be
-/// callable with one of the following signatures:
-///   - FailureOr<convertible-to-Operation*>(OpTy)
-///   - LogicalResult(OpTy)
-///   - FailureOr<SmallVectorImpl<convertible-to-Operation*>>(
-///       SmallVectorImpl<OpTy>)
-///   - LogicalResult(SmallVectorImpl<OpTy>)
+/// callable with the following signature:
+///   - DiagnosedSilenceableFailure(OpTy,
+///       SmallVector<Operation*> &results, state)
 /// where OpTy is either
 ///   - Operation *, in which case the transform is always applied;
 ///   - a concrete Op class, in which case a check is performed whether
-///   `targets` contains operations of the same class and a silencable failure
+///   `targets` contains operations of the same class and a silenceable failure
 ///   is reported if it does not.
 template <typename FnTy>
-DiagnosedSilenceableFailure
-applyTransformToEach(ArrayRef<Operation *> targets,
-                     SmallVectorImpl<SmallVector<Operation *>> &results,
-                     FnTy transform) {
+DiagnosedSilenceableFailure applyTransformToEach(
+    Location loc, int expectedNumResults, ArrayRef<Operation *> targets,
+    SmallVectorImpl<SmallVector<Operation *>> &results, FnTy transform) {
+  SmallVector<Diagnostic> silenceableStack;
   using OpTy = typename llvm::function_traits<FnTy>::template arg_t<0>;
   static_assert(std::is_convertible<OpTy, Operation *>::value,
                 "expected transform function to take an operation");
-  using RetTy = typename llvm::function_traits<FnTy>::result_t;
-  static_assert(std::is_convertible<RetTy, LogicalResult>::value,
-                "expected transform function to return LogicalResult or "
-                "FailureOr<convertible-to-Operation*>");
   for (Operation *target : targets) {
+    // Emplace back a placeholder for the returned new ops.
+    // This is filled with `expectedNumResults` if the op fails to apply.
+    results.push_back(SmallVector<Operation *>());
+
     auto specificOp = dyn_cast<OpTy>(target);
     if (!specificOp) {
-      Diagnostic diag(target->getLoc(), DiagnosticSeverity::Error);
-      diag << "attempted to apply transform to the wrong op kind";
-      return DiagnosedSilenceableFailure::silencableFailure(std::move(diag));
+      Diagnostic diag(loc, DiagnosticSeverity::Error);
+      diag << "transform applied to the wrong op kind, null handle returned";
+      diag.attachNote(target->getLoc()) << "when applied to this op";
+      // Producing `expectedNumResults` nullptr is a silenceableFailure mode.
+      results.back().assign(expectedNumResults, nullptr);
+      silenceableStack.push_back(std::move(diag));
+      continue;
     }
 
-    auto result = transform(specificOp);
-    if (failed(appendTransformResultToVector(result, results)))
-      return DiagnosedSilenceableFailure::definiteFailure();
+    DiagnosedSilenceableFailure result = transform(specificOp, results.back());
+    if (result.isDefiniteFailure())
+      return result;
+    if (result.isSilenceableFailure())
+      for (auto &&diag : result.takeDiagnostics())
+        silenceableStack.push_back(std::move(diag));
+  }
+  if (!silenceableStack.empty()) {
+    return DiagnosedSilenceableFailure::silenceableFailure(
+        std::move(silenceableStack));
   }
   return DiagnosedSilenceableFailure::success();
 }
 
-/// Helper function to transform M ops with N results into N results of M ops.
+/// Helper function: transpose MxN into NxM; assumes that the input is a valid.
 static inline SmallVector<SmallVector<Operation *, 1>>
 transposeResults(const SmallVector<SmallVector<Operation *>, 1> &m) {
   SmallVector<SmallVector<Operation *, 1>> res;
   if (m.empty())
     return res;
   int64_t rows = m.size(), cols = m[0].size();
   for (int64_t j = 0; j < cols; ++j)
     res.push_back(SmallVector<Operation *, 1>(rows, nullptr));

 template <typename OpTy>
 mlir::DiagnosedSilenceableFailure
 mlir::transform::TransformEachOpTrait<OpTy>::apply(
     TransformResults &transformResults, TransformState &state) {
   using TransformOpType = typename llvm::function_traits<
       decltype(&OpTy::applyToOne)>::template arg_t<0>;
   ArrayRef<Operation *> targets =
       state.getPayloadOps(this->getOperation()->getOperand(0));
-  // Handle the corner case where no target is specified.
+
+  // Step 1. Handle the corner case where no target is specified.
   // This is typically the case when the matcher fails to apply and we need to
   // propagate gracefully.
   // In this case, we fill all results with an empty vector.
   if (targets.empty()) {
-    SmallVector<Operation *> emptyResult;
+    SmallVector<Operation *> empty;
     for (auto r : this->getOperation()->getResults())
-      transformResults.set(r.template cast<OpResult>(), emptyResult);
+      transformResults.set(r.template cast<OpResult>(), empty);
     return DiagnosedSilenceableFailure::success();
   }
 
+  // Step 2. Call applyToOne on each target and record newly produced ops in its
+  // corresponding results entry.
+  int expectedNumResults = this->getOperation()->getNumResults();
   SmallVector<SmallVector<Operation *>, 1> results;
-  // In the multi-result case, collect the number of results each transform
-  // produced.
   DiagnosedSilenceableFailure result = detail::applyTransformToEach(
-      targets, results, [&](TransformOpType specificOp) {
-        return static_cast<OpTy *>(this)->applyToOne(specificOp, state);
+      this->getOperation()->getLoc(), expectedNumResults, targets, results,
+      [&](TransformOpType specificOp, SmallVector<Operation *> &partialResult) {
+        auto res = static_cast<OpTy *>(this)->applyToOne(specificOp,
+                                                         partialResult, state);
+        if (res.isDefiniteFailure())
+          return res;
+        if (static_cast<int>(partialResult.size()) != expectedNumResults) {
+          mlir::emitError(this->getOperation()->getLoc(), "applications of ")
+              << OpTy::getOperationName() << " expected to produce "
+              << expectedNumResults << " results (actually produced "
+              << partialResult.size() << ")."
+              << "\nIf you need variadic results, consider using a "
+                 "generic `apply` instead of the specialized `applyToOne`"
+              << "\nNote: producing " << expectedNumResults << " null results "
+              << "is reasonable.";
+          return DiagnosedSilenceableFailure::definiteFailure();
+        }
+        return res;
       });
-  // Propagate the failure (definite or silencable) if any.
-  if (!result.succeeded())
-    return result;
 
-  // Legitimately no results, bail early.
-  if (results.empty() && OpTy::template hasTrait<OpTrait::ZeroResults>())
-    return DiagnosedSilenceableFailure::success();
+  // Step 3. Propagate the definite failure if any and bail out.
+  if (result.isDefiniteFailure())
+    return result;
 
-  // Ensure all applications return the same number of results.
-  // Variadic cases are much trickier to handle in a generic fashion.
-  int64_t nRes = results.empty() ? 0 : results[0].size();
-  if (llvm::any_of(results, [&](const auto &r) {
-        return static_cast<int64_t>(r.size()) != nRes;
-      })) {
-    return static_cast<OpTy *>(this)->emitSilenceableError()
-           << "expected all applications of " << OpTy::getOperationName()
-           << " to produce " << nRes
-           << " results.\n If you need variadic results, consider using a "
-              "generic `apply` instead of the specialized `applyToOne`";
-  }
-  // Ensure the number of results agrees with what the transform op expects.
-  // Unless we see empty results, in which case we just want to propagate the
-  // emptiness.
-  if (this->getOperation()->getNumResults() != nRes) {
-    InFlightDiagnostic diag = static_cast<OpTy *>(this)->emitError()
-                              << "unexpected number of results (got " << nRes
-                              << " expected "
-                              << this->getOperation()->getNumResults() << ")";
-    return DiagnosedSilenceableFailure::definiteFailure();
-  }
+  // Step 4. If there are no results, return early.
+  if (OpTy::template hasTrait<OpTrait::ZeroResults>())
+    return result;
 
-  // Perform transposition of M applications producing N results each into N
-  // results for each of the M applications.
+  // Step 5. Perform transposition of M applications producing N results each
+  // into N results for each of the M applications.
   SmallVector<SmallVector<Operation *, 1>> transposedResults =
       detail::transposeResults(results);
-  // Single result applies to M ops produces one single M-result.
+
+  // Step 6. Single result applies to M ops produces one single M-result.
   if (OpTy::template hasTrait<OpTrait::OneResult>()) {
     assert(transposedResults.size() == 1 && "Expected single result");
     transformResults.set(
         this->getOperation()->getResult(0).template cast<OpResult>(),
         transposedResults[0]);
-    return DiagnosedSilenceableFailure::success();
+    // ApplyToOne may have returned silenceableFailure, propagate it.
+    return result;
   }
-  // M ops, N results each.
+
+  // Step 7. Set the transformResults: M ops, N results each.
   for (const auto &it :
        llvm::zip(this->getOperation()->getResults(), transposedResults)) {
     transformResults.set(std::get<0>(it).template cast<OpResult>(),
                          std::get<1>(it));
   }
-  return DiagnosedSilenceableFailure::success();
+
+  // Step 8. ApplyToOne may have returned silenceableFailure, propagate it.
+  return result;
 }
 
 template <typename OpTy>
 mlir::LogicalResult
 mlir::transform::TransformEachOpTrait<OpTy>::verifyTrait(Operation *op) {
   static_assert(OpTy::template hasTrait<OpTrait::OneOperand>(),
                 "expected single-operand op");
   if (!op->getName().getInterface<TransformOpInterface>()) {
     return op->emitError() << "TransformEachOpTrait should only be attached to "
                               "ops that implement TransformOpInterface";
   }
 
   return success();
 }
 
 #endif // DIALECT_TRANSFORM_IR_TRANSFORMINTERFACES_H

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

let extraSharedClassDeclaration = [{
     /// no further indication as to the reason of the failure.
     ::mlir::LogicalResult reportUnknownTransformError(
         ::mlir::Operation *target) {
       ::mlir::InFlightDiagnostic diag = $_op->emitError() << "failed to apply";
       diag.attachNote(target->getLoc()) << "attempted to apply to this op";
       return diag;
     }
 
-    /// Creates the silencable failure object with a diagnostic located at the
+    /// Creates the silenceable failure object with a diagnostic located at the
     /// current operation.
     DiagnosedSilenceableFailure emitSilenceableError() {
       Diagnostic diag($_op->getLoc(), DiagnosticSeverity::Error);
-      return DiagnosedSilenceableFailure::silencableFailure(std::move(diag));
+      return DiagnosedSilenceableFailure::silenceableFailure(std::move(diag));
     }
   }];
 }
 
 def FunctionalStyleTransformOpTrait
     : NativeOpTrait<"FunctionalStyleTransformOpTrait"> {
   let cppNamespace = "::mlir::transform";
 }

mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp

if (failed(result))
     return failure();
   return cast<LinalgOp>(result->getOperation());
 }
 
 //===----------------------------------------------------------------------===//
 // DecomposeOp
 //===----------------------------------------------------------------------===//
 
-FailureOr<LinalgOp> transform::DecomposeOp::applyToOne(LinalgOp target,
-                                                       TransformState &state) {
+DiagnosedSilenceableFailure
+transform::DecomposeOp::applyToOne(linalg::LinalgOp target,
+                                   SmallVectorImpl<Operation *> &results,
+                                   transform::TransformState &state) {
   FailureOr<LinalgOp> windowed =
       tryApply<DownscaleSizeOneWindowed2DConvolution>(target);
-  if (succeeded(windowed))
-    return windowed;
-
   FailureOr<LinalgOp> depthwise =
       tryApply<DownscaleDepthwiseConv2DNhwcHwcOp>(target);
-  if (succeeded(depthwise))
-    return depthwise;
-
-  return reportUnknownTransformError(target);
+  if (succeeded(windowed))
+    results.push_back(*windowed);
+  else if (succeeded(depthwise))
+    results.push_back(*depthwise);
+  else
+    results.push_back(nullptr);
+  return DiagnosedSilenceableFailure(success());
 }
 
 //===----------------------------------------------------------------------===//
 // FuseOp
 //===----------------------------------------------------------------------===//
 
 /// Apply a tiling transformation to all payload ops and store both the
 /// tiled operation as well as the created tile loops.
LogicalResult transform::FuseOp::verify() {
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // GeneralizeOp
 //===----------------------------------------------------------------------===//
 
-FailureOr<LinalgOp> transform::GeneralizeOp::applyToOne(LinalgOp target,
-                                                        TransformState &state) {
+DiagnosedSilenceableFailure
+transform::GeneralizeOp::applyToOne(linalg::LinalgOp target,
+                                    SmallVectorImpl<Operation *> &results,
+                                    transform::TransformState &state) {
   // Exit early if no transformation is needed.
-  if (isa<GenericOp>(target))
-    return target;
-
+  if (isa<GenericOp>(target)) {
+    results.push_back(target);
+    return DiagnosedSilenceableFailure(success());
+  }
   FailureOr<LinalgOp> generic = tryApply<LinalgGeneralizationPattern>(target);
-  if (succeeded(generic))
-    return generic;
-
-  return reportUnknownTransformError(target);
+  // If the generalization did not happen, push a nullptr.
+  results.push_back(succeeded(generic) ? generic->getOperation() : nullptr);
+  return DiagnosedSilenceableFailure(success());
 }
 
 //===----------------------------------------------------------------------===//
 // InterchangeOp
 //===----------------------------------------------------------------------===//
 
-FailureOr<LinalgOp>
-transform::InterchangeOp::applyToOne(LinalgOp target, TransformState &state) {
+DiagnosedSilenceableFailure
+transform::InterchangeOp::applyToOne(linalg::GenericOp target,
+                                     SmallVectorImpl<Operation *> &results,
+                                     transform::TransformState &state) {
   SmallVector<unsigned> interchangeVector =
       extractUIntArray(getIteratorInterchange());
   // Exit early if no transformation is needed.
-  if (interchangeVector.empty())
-    return target;
-
-  auto genericTarget = dyn_cast<GenericOp>(target.getOperation());
-  if (!genericTarget) {
-    InFlightDiagnostic diag = emitOpError()
-                              << "applies to " << GenericOp::getOperationName()
-                              << " ops";
-    diag.attachNote(target.getLoc()) << "attempted to apply to this op";
-    return diag;
+  if (interchangeVector.empty()) {
+    results.push_back(target);
+    return DiagnosedSilenceableFailure(success());
   }
 
-  return tryApply<GenericOpInterchangePattern>(target, interchangeVector);
+  SimpleRewriter rewriter(target->getContext());
+  FailureOr<GenericOp> res =
+      interchangeGenericOp(rewriter, target, interchangeVector);
+  if (failed(res))
+    return DiagnosedSilenceableFailure::definiteFailure();
+  results.push_back(res->getOperation());
+  return DiagnosedSilenceableFailure(success());
 }
 
 LogicalResult transform::InterchangeOp::verify() {
   SmallVector<unsigned> permutation =
       extractUIntArray(getIteratorInterchange());
   auto sequence = llvm::to_vector(llvm::seq<unsigned>(0, permutation.size()));
   if (!std::is_permutation(sequence.begin(), sequence.end(),
                            permutation.begin(), permutation.end())) {
     return emitOpError()
            << "expects iterator_interchange to be a permutation, found "
            << getIteratorInterchange();
   }
   return success();
 }
 
 //===---------------------------------------------------------------------===//
 // PadOp
 //===---------------------------------------------------------------------===//
 
-FailureOr<LinalgOp> transform::PadOp::applyToOne(LinalgOp target,
-                                                 TransformState &state) {
+DiagnosedSilenceableFailure
+transform::PadOp::applyToOne(linalg::LinalgOp target,
+                             SmallVectorImpl<Operation *> &results,
+                             transform::TransformState &state) {
   // Convert the integer packing flags to booleans.
   SmallVector<bool> packPaddings;
   for (int64_t packPadding : extractI64Array(getPackPaddings()))
     packPaddings.push_back(static_cast<bool>(packPadding));
 
   // Convert the padding values to attributes.
   SmallVector<Attribute> paddingValues;
   for (auto const &it :
        llvm::zip(getPaddingValues(), target->getOperandTypes())) {
     Attribute attr = std::get<0>(it);
     Type elementType = getElementTypeOrSelf(std::get<1>(it));
     // Try to parse string attributes to obtain an attribute of element type.
     if (auto stringAttr = attr.dyn_cast<StringAttr>()) {
       paddingValues.push_back(
           parseAttribute(attr.cast<StringAttr>(), elementType));
       if (!paddingValues.back()) {
-        InFlightDiagnostic diag = emitOpError()
-                                  << "expects a padding value that parses to "
-                                  << elementType << ", got " << std::get<0>(it);
+        auto diag = this->emitOpError("expects a padding that parses to ")
         diag.attachNote(target.getLoc()) << "when applied to this op";
-        return diag;
+        return DiagnosedSilenceableFailure::definiteFailure();
       }
       continue;
     }
     // Otherwise, add the attribute directly.
     if (attr.getType() != elementType) {
-      InFlightDiagnostic diag = emitOpError()
-                                << "expects a padding value of type "
-                                << elementType << ", got " << attr;
+      auto diag = this->emitOpError("expects a padding value of type ")
       diag.attachNote(target.getLoc()) << "when applied to this op";
-      return diag;
+      return DiagnosedSilenceableFailure::definiteFailure();
     }
     paddingValues.push_back(attr);
   }
 
   // Extract the transpose vectors.
   SmallVector<SmallVector<int64_t>> transposePaddings;
   for (Attribute transposeVector : getTransposePaddings().cast<ArrayAttr>())
     transposePaddings.push_back(
         extractI64Array(transposeVector.cast<ArrayAttr>()));
 
   LinalgPaddingOptions paddingOptions;
   paddingOptions.setPaddingValues(paddingValues);
   paddingOptions.setPaddingDimensions(extractI64Array(getPaddingDimensions()));
   paddingOptions.setPackPaddings(packPaddings);
   paddingOptions.setHoistPaddings(extractI64Array(getHoistPaddings()));
   paddingOptions.setTransposePaddings(transposePaddings);
 
   FailureOr<LinalgOp> result =
       tryApply<LinalgPaddingPattern>(target, paddingOptions);
-  if (succeeded(result))
-    return result;
+  if (succeeded(result)) {
+    results.push_back(result->getOperation());
+    return DiagnosedSilenceableFailure(success());
+  }
 
-  InFlightDiagnostic diag = emitError()
-                            << "failed to apply pattern to target op";
+  auto diag = this->emitOpError("failed to apply pattern to target op");
   diag.attachNote(target.getLoc()) << "target op";
-  return diag;
+  return DiagnosedSilenceableFailure::definiteFailure();
 }
 
 LogicalResult transform::PadOp::verify() {
   SmallVector<int64_t> packPaddings = extractI64Array(getPackPaddings());
   if (any_of(packPaddings, [](int64_t packPadding) {
         return packPadding != 0 && packPadding != 1;
       })) {
     return emitOpError()
LogicalResult transform::PadOp::verify() {
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // ScalarizeOp
 //===----------------------------------------------------------------------===//
 
-FailureOr<LinalgOp> transform::ScalarizeOp::applyToOne(LinalgOp target,
-                                                       TransformState &state) {
+DiagnosedSilenceableFailure
+transform::ScalarizeOp::applyToOne(linalg::LinalgOp target,
+                                   SmallVectorImpl<Operation *> &results,
+                                   transform::TransformState &state) {
   LinalgTilingOptions tilingOptions;
   tilingOptions.scalarizeDynamicDims();
   // Tiling with "scalarize_dyn_dims" actually sets the same lambda as the tile
   // sizes and asserts that it is not already set.
   SmallVector<int64_t> emptyTileSizes;
   LinalgTilingPattern pattern(getContext(), tilingOptions);
   SimpleRewriter rewriter(getContext());
   rewriter.setInsertionPoint(target);
   FailureOr<TiledLinalgOp> result =
       pattern.returningMatchAndRewrite(target, rewriter);
-  if (failed(result))
-    return failure();
+  if (failed(result)) {
+    auto diag = this->emitOpError("failed");
+    diag.attachNote(target.getLoc()) << "when applied to this op";
+    return DiagnosedSilenceableFailure::definiteFailure();
+  }
 
-  return result->op;
+  results.push_back(result->op);
+  return DiagnosedSilenceableFailure(success());
 }
 
 //===----------------------------------------------------------------------===//
 // SplitReductionOp
 //===----------------------------------------------------------------------===//
 
-FailureOr<SmallVector<Operation *>>
-transform::SplitReductionOp::applyToOne(LinalgOp target,
-                                        TransformState &state) {
+DiagnosedSilenceableFailure
+transform::SplitReductionOp::applyToOne(linalg::LinalgOp target,
+                                        SmallVectorImpl<Operation *> &results,
+                                        transform::TransformState &state) {
   ControlSplitReductionFn splitFn = [&](LinalgOp) {
     return std::pair<int64_t, unsigned>(getSplitFactor(),
                                         getInsertSplitDimension());
   };
   SimpleRewriter rewriter(getContext());
   rewriter.setInsertionPoint(target);
   FailureOr<SplitReductionResult> splitResult =
       (getUseScalingAlgorithm())
           ? splitReductionByScaling(rewriter, target, splitFn, getUseAlloc())
           : splitReduction(rewriter, target, splitFn, getUseAlloc());
-  if (failed(splitResult))
-    return getOperation()->emitError("failed to apply");
-  return SmallVector<Operation *>{splitResult->fillOp,
-                                  splitResult->splitLinalgOp,
-                                  splitResult->resultCombiningLinalgOp};
+  if (failed(splitResult)) {
+    auto diag = this->emitOpError("failed ");
+    diag.attachNote(target.getLoc()) << "when applied to this op";
+    return DiagnosedSilenceableFailure::definiteFailure();
+  }
+  results.push_back(splitResult->fillOp);
+  results.push_back(splitResult->splitLinalgOp);
+  results.push_back(splitResult->resultCombiningLinalgOp);
+  return DiagnosedSilenceableFailure(success());
 }
 
 //===----------------------------------------------------------------------===//
 // TileOp
 //===----------------------------------------------------------------------===//
 
 DiagnosedSilenceableFailure
 transform::TileOp::apply(TransformResults &transformResults,
void TileOp::print(OpAsmPrinter &p) {
   p << getTarget();
   p.printOptionalAttrDict((*this)->getAttrs());
 }
 
 //===----------------------------------------------------------------------===//
 // VectorizeOp
 //===----------------------------------------------------------------------===//
 
-FailureOr<Operation *> VectorizeOp::applyToOne(Operation *target,
-                                               TransformState &state) {
+DiagnosedSilenceableFailure
+transform::VectorizeOp::applyToOne(Operation *target,
+                                   SmallVectorImpl<Operation *> &results,
+                                   transform::TransformState &state) {
   if (!target->hasTrait<OpTrait::IsIsolatedFromAbove>()) {
-    InFlightDiagnostic diag = emitOpError()
-                              << "applies only to isolated-from-above targets";
+    auto diag = this->emitOpError("requires isolated-from-above targets");
     diag.attachNote(target->getLoc()) << "non-isolated target";
-    return diag;
+    return DiagnosedSilenceableFailure::definiteFailure();
   }
 
   MLIRContext *ctx = getContext();
   RewritePatternSet patterns(ctx);
   patterns.add<LinalgVectorizationPattern>(ctx);
 
   vector::populateVectorTransferPermutationMapLoweringPatterns(patterns);
   vector::populateVectorReductionToContractPatterns(patterns);
   patterns.add<linalg::LinalgCopyVTRForwardingPattern,
                linalg::LinalgCopyVTWForwardingPattern>(ctx,
                                                        /*benefit=*/2);
   vector::TransferReadOp::getCanonicalizationPatterns(patterns, ctx);
   vector::TransferWriteOp::getCanonicalizationPatterns(patterns, ctx);
   if (getVectorizePadding())
     linalg::populatePadOpVectorizationPatterns(patterns);
 
+  // Always return the isolated from above `target`, regardless of the failure
+  // mode.
+  results.push_back(target);
+
   if (failed(applyPatternsAndFoldGreedily(target, std::move(patterns))))
-    return reportUnknownTransformError(target);
-  return target;
+    return DiagnosedSilenceableFailure(reportUnknownTransformError(target));
+  return DiagnosedSilenceableFailure(success());
 }
 
 //===----------------------------------------------------------------------===//
 // Transform op registration
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// Registers new ops and declares PDL as dependent dialect since the additional

mlir/lib/Dialect/SCF/TransformOps/SCFTransformOps.cpp

transform::LoopOutlineOp::apply(transform::TransformResults &results,
   results.set(getTransformed().cast<OpResult>(), transformed);
   return DiagnosedSilenceableFailure::success();
 }
 
 //===----------------------------------------------------------------------===//
 // LoopPeelOp
 //===----------------------------------------------------------------------===//
 
-FailureOr<scf::ForOp> transform::LoopPeelOp::applyToOne(scf::ForOp loop,
-                                                        TransformState &state) {
+DiagnosedSilenceableFailure
+transform::LoopPeelOp::applyToOne(scf::ForOp target,
+                                  SmallVector<Operation *> &results,
+                                  transform::TransformState &state) {
   scf::ForOp result;
-  IRRewriter rewriter(loop->getContext());
+  IRRewriter rewriter(target->getContext());
+  // This helper returns failure when peeling does not occur (i.e. when the IR
+  // is not modified). This is not a failure for the op as the postcondition:
+  //    "the loop trip count is divisible by the step"
+  // is valid.
   LogicalResult status =
-      scf::peelAndCanonicalizeForLoop(rewriter, loop, result);
-  if (failed(status)) {
-    if (getFailIfAlreadyDivisible())
-      return reportUnknownTransformError(loop);
-    return loop;
-  }
-  return result;
+      scf::peelAndCanonicalizeForLoop(rewriter, target, result);
+  // TODO: Return both the peeled loop and the remainder loop.
+  results.push_back(failed(status) ? target : result);
+  return DiagnosedSilenceableFailure(success());
 }
 
 //===----------------------------------------------------------------------===//
 // LoopPipelineOp
 //===----------------------------------------------------------------------===//
 
 /// Callback for PipeliningOption. Populates `schedule` with the mapping from an
 /// operation to its logical time position given the iteration interval and the
loopScheduling(scf::ForOp forOp,
   for (const auto &it : wrappedSchedule) {
     for (Operation *op : it.second) {
       unsigned cycle = opCycles[op];
       schedule.emplace_back(op, cycle / iterationInterval);
     }
   }
 }
 
-FailureOr<scf::ForOp>
-transform::LoopPipelineOp::applyToOne(scf::ForOp loop, TransformState &state) {
+DiagnosedSilenceableFailure
+transform::LoopPipelineOp::applyToOne(scf::ForOp target,
+                                      SmallVector<Operation *> &results,
+                                      transform::TransformState &state) {
   scf::PipeliningOption options;
   options.getScheduleFn =
       [this](scf::ForOp forOp,
              std::vector<std::pair<Operation *, unsigned>> &schedule) mutable {
         loopScheduling(forOp, schedule, getIterationInterval(),
                        getReadLatency());
       };
 
-  scf::ForLoopPipeliningPattern pattern(options, loop->getContext());
+  scf::ForLoopPipeliningPattern pattern(options, target->getContext());
   SimpleRewriter rewriter(getContext());
-  rewriter.setInsertionPoint(loop);
+  rewriter.setInsertionPoint(target);
   FailureOr<scf::ForOp> patternResult =
-      pattern.returningMatchAndRewrite(loop, rewriter);
-  if (failed(patternResult))
-    return reportUnknownTransformError(loop);
-  return patternResult;
+      pattern.returningMatchAndRewrite(target, rewriter);
+  results.push_back(failed(patternResult) ? scf::ForOp() : *patternResult);
+  return DiagnosedSilenceableFailure(success());
 }
 
 //===----------------------------------------------------------------------===//
 // LoopUnrollOp
 //===----------------------------------------------------------------------===//
 
-LogicalResult transform::LoopUnrollOp::applyToOne(scf::ForOp loop,
-                                                  TransformState &state) {
-  if (failed(loopUnrollByFactor(loop, getFactor())))
-    return reportUnknownTransformError(loop);
-  return success();
+DiagnosedSilenceableFailure
+transform::LoopUnrollOp::applyToOne(scf::ForOp target,
+                                    SmallVector<Operation *> &results,
+                                    transform::TransformState &state) {
+  if (failed(loopUnrollByFactor(target, getFactor()))) {
+    Diagnostic diag(target->getLoc(), DiagnosticSeverity::Note);
+    diag << "op failed to unroll";
+    return DiagnosedSilenceableFailure::silenceableFailure(std::move(diag));
+  }
+  return DiagnosedSilenceableFailure(success());
 }
 
 //===----------------------------------------------------------------------===//
 // Transform op registration
 //===----------------------------------------------------------------------===//
 
 namespace {
 class SCFTransformDialectExtension

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

^bb1(%arg1: !pdl.operation):
     %0 = pdl_match @match_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 {{attempted to apply to this op}}
+  // 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):
   pdl.pattern @match_generic : benefit(1) {
     %args = operands
     %results = types
     %0 = pdl.operation "linalg.matmul"(%args : !pdl.range<value>) -> (%results : !pdl.range<type>)
     rewrite %0 with "transform.dialect"
   }
 
   transform.sequence %arg0 {
   ^bb1(%arg1: !pdl.operation):
     %0 = pdl_match @match_generic in %arg1
-    // expected-error @below {{applies to linalg.generic ops}}
+    // expected-error @below {{transform applied to the wrong op kind, null handle returned}}
     transform.structured.interchange %0 { iterator_interchange = [1, 0]}
   }
 }

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

pdl.pattern @pdl_target : benefit(1) {
     %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 {
   ^bb1(%arg1: !pdl.operation):
     %0 = pdl_match @pdl_target in %arg1
-    // expected-error @below {{expects a padding value that parses to 'f32', got "foo"}}
+    // 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>,

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

pdl.pattern @pdl_target : benefit(1) {
     %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 {
   ^bb1(%arg1: !pdl.operation):
     %0 = pdl_match @pdl_target in %arg1
-    // expected-error @below {{applies only to isolated-from-above targets}}
+    // expected-error @below {{op requires isolated-from-above targets}}
     %2 = transform.structured.vectorize %0
   }
 }

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

^bb1(%arg1: !pdl.operation):
     ^bb2(%arg2: !pdl.operation):
     }
   }
 }
 // -----
 
 transform.sequence {
 ^bb0(%arg0: !pdl.operation):
-  // expected-error @below {{unexpected number of results (got 0 expected 3)}}
+  // expected-error @below {{applications of transform.test_wrong_number_of_results expected to produce 3 results (actually produced 1)}}
   transform.test_wrong_number_of_results %arg0
 }
 
 // -----
 
 func.func @foo() {
   "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 {
   ^bb0(%arg1: !pdl.operation):
     %0 = pdl_match @some in %arg1
-    // expected-error @below {{expected all applications of transform.test_wrong_number_of_multi_results to produce 1 results}}
+    // expected-error @below {{applications of transform.test_wrong_number_of_multi_results expected to produce 1 results (actually produced 0)}}
     transform.test_wrong_number_of_multi_results %0
   }
 }
 
 // -----
 
 func.func @foo() {
   "op" () : () -> ()
   "op" () : () -> ()
   "op" () : () -> ()

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

DiagnosedSilenceableFailure mlir::test::TestEmitRemarkAndEraseOperandOp::apply(
   for (Operation *op : state.getPayloadOps(getTarget()))
     op->erase();
 
   if (getFailAfterErase())
     return emitSilenceableError() << "silencable error";
   return DiagnosedSilenceableFailure::success();
 }
 
-FailureOr<SmallVector<Operation *>>
-mlir::test::TestWrongNumberOfResultsOp::applyToOne(
-    Operation *, transform::TransformState &state) {
-  return SmallVector<Operation *>{};
+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));
+  return DiagnosedSilenceableFailure::success();
 }
 
-FailureOr<SmallVector<Operation *>>
+DiagnosedSilenceableFailure
 mlir::test::TestWrongNumberOfMultiResultsOp::applyToOne(
-    Operation *op, transform::TransformState &state) {
+    Operation *target, SmallVectorImpl<Operation *> &results,
+    transform::TransformState &state) {
   static int count = 0;
-  if (count++ > 0)
-    return SmallVector<Operation *>{};
-  OperationState opState(op->getLoc(), "foo");
-  return SmallVector<Operation *>{OpBuilder(op).create(opState)};
+  if (count++ == 0) {
+    OperationState opState(target->getLoc(), "foo");
+    results.push_back(OpBuilder(target).create(opState));
+  }
+  return DiagnosedSilenceableFailure::success();
 }
 
-FailureOr<SmallVector<Operation *>>
+DiagnosedSilenceableFailure
 mlir::test::TestCorrectNumberOfMultiResultsOp::applyToOne(
-    Operation *op, transform::TransformState &state) {
-  OperationState opState(op->getLoc(), "foo");
-  return SmallVector<Operation *>{OpBuilder(op).create(opState),
-                                  OpBuilder(op).create(opState)};
+    Operation *target, SmallVectorImpl<Operation *> &results,
+    transform::TransformState &state) {
+  OperationState opState(target->getLoc(), "foo");
+  results.push_back(OpBuilder(target).create(opState));
+  results.push_back(OpBuilder(target).create(opState));
+  return DiagnosedSilenceableFailure::success();
+  return DiagnosedSilenceableFailure::success();
 }
 
 namespace {
 /// Test extension of the Transform dialect. Registers additional ops and
 /// declares PDL as dependent dialect since the additional ops are using PDL
 /// types for operands and results.
 class TestTransformDialectExtension
     : public transform::TransformDialectExtension<

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

: Op<Transform_Dialect, "test_wrong_number_of_results",
      TransformEachOpTrait, TransformOpInterface]> {
   let arguments = (ins PDL_Operation:$target);
   let results = (outs PDL_Operation:$a,
                       PDL_Operation:$b,
                       PDL_Operation:$c);
   let assemblyFormat = "$target attr-dict";
   let cppNamespace = "::mlir::test";
   let extraClassDeclaration = [{
-    ::mlir::FailureOr<::llvm::SmallVector<::mlir::Operation *>> applyToOne(
-        ::mlir::Operation *target, transform::TransformState &state);
+    ::mlir::DiagnosedSilenceableFailure applyToOne(
+        ::mlir::Operation * target, 
+        ::llvm::SmallVectorImpl<::mlir::Operation *> &results, 
+        ::mlir::transform::TransformState &state);
   }];
 }
 
 def TestWrongNumberOfMultiResultsOp
   : Op<Transform_Dialect, "test_wrong_number_of_multi_results",
     [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface, 
      TransformEachOpTrait, TransformOpInterface]> {
   let arguments = (ins PDL_Operation:$target);
   let results = (outs PDL_Operation:$result);
   let assemblyFormat = "$target attr-dict";
   let cppNamespace = "::mlir::test";
   let extraClassDeclaration = [{
-    ::mlir::FailureOr<::llvm::SmallVector<::mlir::Operation *>> applyToOne(
-        ::mlir::Operation *target, transform::TransformState &state);
+    ::mlir::DiagnosedSilenceableFailure applyToOne(
+        ::mlir::Operation * target, 
+        ::llvm::SmallVectorImpl<::mlir::Operation *> &results, 
+        ::mlir::transform::TransformState &state);
   }];
 }
 
 def TestCorrectNumberOfMultiResultsOp
   : Op<Transform_Dialect, "test_correct_number_of_multi_results",
     [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface, 
      TransformEachOpTrait, TransformOpInterface]> {
   let arguments = (ins PDL_Operation:$target);
   let results = (outs PDL_Operation:$result1,
                       PDL_Operation:$result2);
   let assemblyFormat = "$target attr-dict";
   let cppNamespace = "::mlir::test";
   let extraClassDeclaration = [{
-    ::mlir::FailureOr<::llvm::SmallVector<::mlir::Operation *>> applyToOne(
-        ::mlir::Operation *target, transform::TransformState &state);
+    ::mlir::DiagnosedSilenceableFailure applyToOne(
+        ::mlir::Operation * target, 
+        ::llvm::SmallVectorImpl<::mlir::Operation *> &results, 
+        ::mlir::transform::TransformState &state);
   }];
 }
 
 #endif // MLIR_TESTTRANSFORMDIALECTEXTENSION_TD