[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

91

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

135

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.

599

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.

600

Nit: "this the"

602

Which op?

610–613

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.

757

Micro-nit.

763–769

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.

824

837–840

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.

872

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

[nicolasvasilache]

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

610–613

Reworded with more detail.

837–840

Reworked that part.

872

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

872

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

872

ah ok, thanks!

[nicolasvasilache]

Fix test.

[nicolasvasilache]

Rebase.

[ftynse]

Thanks!

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

30 ↗

(On Diff #442889)

s/vectorize/decompose

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

764

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

853–860

Nit: would be nice to have a test.

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

412–413 ↗

(On Diff #442889)

Ultra-nit: missing whitespace

[nicolasvasilache]

Address last comments.

[nicolasvasilache]

Rebase

[nicolasvasilache]

Improve error message with a note.

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

 
 #include "mlir/Interfaces/SideEffectInterfaces.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));
   }
 
   /// 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();
       result = ::mlir::failure();
     }
     return result;
   }
 
-  /// Returns `true` if this is a silencable failure.
+  /// Returns `true` if this is a silenceable failure.
   bool isSilenceableFailure() const { return diagnostic.hasValue(); }
 
   /// Returns `true` if this is a success.
   bool succeeded() const {
     return !diagnostic.hasValue() && ::mlir::succeeded(result);
   }
 
   /// Returns the diagnostic message without emitting it. Expects this object
-  /// to be a silencable failure.
+  /// to be a silenceable failure.
   std::string getMessage() const { return diagnostic->str(); }
 
-  /// Converts silencable failure into LogicalResult success without reporting
+  /// Converts silenceable failure into LogicalResult success without reporting
   /// the diagnostic, preserves the other states.
   LogicalResult silence() {
     if (diagnostic) {
       diagnostic.reset();
       result = ::mlir::success();
     }
     return result;
   }
 
+  /// Take the diagnostic and silence.
+  Diagnostic &&takeDiagnostic() {
+    assert(diagnostic && "expected a diagnostic to be present");
+    auto guard = llvm::make_scope_exit([&]() { diagnostic.reset(); });
+    return std::move(*diagnostic);
+  }
+
   /// Streams the given values into the diagnotic. Expects this object to be a
-  /// silencable failure.
+  /// silenceable failure.
   template <typename T>
   DiagnosedSilenceableFailure &operator<<(T &&value) & {
     assert(isSilenceableFailure() &&
-           "can only append output in silencable failure state");
+           "can only append output in silenceable failure state");
     *diagnostic << 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
+  /// Attaches a note to the 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");
+           "can only attach notes to silenceable failures");
     return diagnostic->attachNote(loc);
   }
 
 private:
   explicit DiagnosedSilenceableFailure(Diagnostic &&diagnostic)
       : diagnostic(std::move(diagnostic)), result(failure()) {}
 
   /// The diagnostic associated with this object. If present, the object is
-  /// considered to be in the silencable failure state regardless of the
+  /// considered to be in the silenceable failure state regardless of the
   /// `result` field.
   Optional<Diagnostic> diagnostic;
 
   /// The "definite" logical state, either success or failure. Ignored if the
   /// diagnostic 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
assert(
         "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)
+/// The op must implement a method with the following signature:
+///   - DiagnosedSilenceableFailure applyToOne(OpTy,
+///       SmallVector<convertible-to-Operation*> &newOps, 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
+/// 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.
+/// transform IR op).
+/// The `applyToOne` method is allowed to fill the `newOps` vector with
+/// NULL elements to signify that the transformation did not apply to this the
+/// payload IR operations.
+/// The op 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. If `applyToOne` produces ops, associate them with
+  /// the result of this transform op. If any `applyToOne` returns
+  /// definiteFailure, the transformation is considered failed. If all
+  /// `applyToOne` return success, the transformation is considered succeeded.
+  /// If some `applyToOne` return silenceableFailure, the transformation is
+  /// considered silenceable.
   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
+/// targets. Puts the newOps of transforms, if any, in `newOps` 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<convertible-to-Operation*> &newOps, 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,
+                     SmallVectorImpl<SmallVector<Operation *>> &newOps,
                      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) {
+    //
+    newOps.push_back(SmallVector<Operation *>());
+
     auto specificOp = dyn_cast<OpTy>(target);
     if (!specificOp) {
-      Diagnostic diag(target->getLoc(), DiagnosticSeverity::Error);
+      Diagnostic diag(target->getLoc(), DiagnosticSeverity::Warning);
       diag << "attempted to apply transform to the wrong op kind";
-      return DiagnosedSilenceableFailure::silencableFailure(std::move(diag));
+      // TODO: Should this return immediately or just add to the stack?
+      // Producing 0-newOps when successful paths produce a fixed number of
+      // newOps is a reasonable silenceableFailure mode.
+      silenceableStack.push_back(std::move(diag));
+      // Old code:
+      // return
+      // DiagnosedSilenceableFailure::silenceableFailure(std::move(diag));
     }
 
-    auto result = transform(specificOp);
-    if (failed(appendTransformResultToVector(result, results)))
-      return DiagnosedSilenceableFailure::definiteFailure();
+    DiagnosedSilenceableFailure result = transform(specificOp, newOps.back());
+    if (failed(result))
+      return result;
+    if (result.isSilenceableFailure())
+      silenceableStack.push_back(std::move(result.takeDiagnostic()));
   }
+  // TODO: return the stack of diagnostics.
+  if (!silenceableStack.empty())
+    return DiagnosedSilenceableFailure::silenceableFailure();
   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.
+  // In this case, we fill all newOps 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();
   }
 
-  SmallVector<SmallVector<Operation *>, 1> results;
-  // In the multi-result case, collect the number of results each transform
-  // produced.
+  // Step 2. Call applyToOne on each target and recorde newly produced ops in
+  // its corresponding newOps entry.
+  SmallVector<SmallVector<Operation *>, 1> newOps;
   DiagnosedSilenceableFailure result = detail::applyTransformToEach(
-      targets, results, [&](TransformOpType specificOp) {
-        return static_cast<OpTy *>(this)->applyToOne(specificOp, state);
+      targets, newOps,
+      [&](TransformOpType specificOp, SmallVector<Operation *> &partialResult) {
+        return static_cast<OpTy *>(this)->applyToOne(specificOp, partialResult,
+                                                     state);
       });
-  // Propagate the failure (definite or silencable) if any.
-  if (!result.succeeded())
+
+  // Step 3. Propagate the definite failure if any and bail out.
+  if (result.failed())
     return result;
 
-  // Legitimately no results, bail early.
-  if (results.empty() && OpTy::template hasTrait<OpTrait::ZeroResults>())
+  // Step 4. If there are legitimately no newOps, return early.
+  if (newOps.empty() && OpTy::template hasTrait<OpTrait::ZeroResults>())
     return DiagnosedSilenceableFailure::success();
 
-  // 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() << ")";
+  // Step 5. Ensure all applications return the same number of newOps.
+  // Also allow a particular application of applyToOne to return no newOps,
+  // which must mean that we have a silenceableFailure result. In this case, we
+  // normalize the
+  //
+  // Note: variadic cases are not supported here as they are much trickier to
+  // handle in a generic fashion.
+  int nRes = this->getOperation()->getNumResults();
+  bool normalized = llvm::any_of(newOps, [&](auto &r) {
+    if (nRes > 0 && r.empty()) {
+      r.resize(nRes, nullptr);
+      assert(result.isSilenceableFailure() &&
+             "applyToOne produced 0 new ops when the transform expected "
+             "non-zero: this must be a silenceableFailure");
+    }
+  });
+  if (!normalized) {
+    mlir::emitError(target->getLoc(), "expected all applications of ")
+        << OpTy::getOperationName()
+        << " to produce 0 (silenceableFailure case) or " << nRes
+        << " (success case) newOps."
+        << "\nIf you need variadic newOps, consider using a "
     return DiagnosedSilenceableFailure::definiteFailure();
   }
 
-  // Perform transposition of M applications producing N results each into N
-  // results for each of the M applications.
+  // Step 6. Perform transposition of M applications producing N newOps each
+  // into N newOps 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.
+      detail::transposeResults(newOps);
+
+  // Step 7. 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 8. Set the transformResults: M ops, N newOps 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 9. 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";
 }