[mlir] NFC: move DiagnosedSilenceableFailure to Utils in Transform dialect

[ftynse]

Summary

It was originally placed in TransformInterfaces for convenience, but it
is really a generic utility. It may also create an include cycle between
TransformTypes and TransformInterfaces if the latter needs to include
the former because the former uses the failure util.

[springerm]

commit message can be marked [NFC]

[ftynse]

Rebase.

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/Dialect/Transform/IR/TransformTypes.h"
+#include "mlir/Dialect/Transform/Utils/DiagnosedSilenceableFailure.h"
 #include "mlir/IR/OpDefinition.h"
 
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Support/LogicalResult.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;
-///   - 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.
-class [[nodiscard]] DiagnosedSilenceableFailure {
-public:
-  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 silenceable failure state,
-  /// ready to emit the given diagnostic. This is considered a failure
-  /// regardless of the diagnostic severity.
-  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 (!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 success.
-  bool succeeded() const {
-    return ::mlir::succeeded(result) && diagnostics.empty();
-  }
-
-  /// Returns `true` if this is a definite failure.
-  bool isDefiniteFailure() const {
-    return ::mlir::failed(result) && diagnostics.empty();
-  }
-
-  /// Returns `true` if this is a silenceable failure.
-  bool isSilenceableFailure() const { return !diagnostics.empty(); }
-
-  /// Returns the diagnostic message without emitting it. Expects this object
-  /// 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;
-  }
-
-  /// 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 (!diagnostics.empty()) {
-      diagnostics.clear();
-      result = ::mlir::success();
-    }
-    return result;
-  }
-
-  /// Take the diagnostics and silence.
-  void takeDiagnostics(SmallVectorImpl<Diagnostic> &diags) {
-    assert(!diagnostics.empty() && "expected a diagnostic to be present");
-    diags.append(std::make_move_iterator(diagnostics.begin()),
-                 std::make_move_iterator(diagnostics.end()));
-  }
-
-  /// Streams the given values into the last diagnostic.
-  /// Expects this object to be a silenceable failure.
-  template <typename T>
-  DiagnosedSilenceableFailure &operator<<(T &&value) & {
-    assert(isSilenceableFailure() &&
-           "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 last diagnostic.
-  /// Expects this object to be a silenceable failure.
-  Diagnostic &attachNote(Optional<Location> loc = std::nullopt) {
-    assert(isSilenceableFailure() &&
-           "can only attach notes to silenceable failures");
-    return diagnostics.back().attachNote(loc);
-  }
-
-private:
-  explicit DiagnosedSilenceableFailure(LogicalResult result) : result(result) {}
-  explicit DiagnosedSilenceableFailure(Diagnostic &&diagnostic)
-      : result(failure()) {
-    diagnostics.emplace_back(std::move(diagnostic));
-  }
-  explicit DiagnosedSilenceableFailure(SmallVector<Diagnostic> &&diagnostics)
-      : diagnostics(std::move(diagnostics)), result(failure()) {}
-
-  /// 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.
-  SmallVector<Diagnostic, 1> diagnostics;
-
-  /// The "definite" logical state, either success or failure.
-  /// Ignored if the diagnostics message is present.
-  LogicalResult result;
-
-#if LLVM_ENABLE_ABI_BREAKING_CHECKS
-  /// 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
-};
-
-class DiagnosedDefiniteFailure;
-
-DiagnosedDefiniteFailure emitDefiniteFailure(Location loc,
-                                             const Twine &message = {});
-
-/// A compatibility class connecting `InFlightDiagnostic` to
-/// `DiagnosedSilenceableFailure` while providing an interface similar to the
-/// former. Implicitly convertible to `DiagnosticSilenceableFailure` in definite
-/// failure state and to `LogicalResult` failure. Reports the error on
-/// conversion or on destruction. Instances of this class can be created by
-/// `emitDefiniteFailure()`.
-class DiagnosedDefiniteFailure {
-  friend DiagnosedDefiniteFailure emitDefiniteFailure(Location loc,
-                                                      const Twine &message);
-
-public:
-  /// Only move-constructible because it carries an in-flight diagnostic.
-  DiagnosedDefiniteFailure(DiagnosedDefiniteFailure &&) = default;
-
-  /// Forward the message to the diagnostic.
-  template <typename T>
-  DiagnosedDefiniteFailure &operator<<(T &&value) & {
-    diag << std::forward<T>(value);
-    return *this;
-  }
-  template <typename T>
-  DiagnosedDefiniteFailure &&operator<<(T &&value) && {
-    return std::move(this->operator<<(std::forward<T>(value)));
-  }
-
-  /// Attaches a note to the error.
-  Diagnostic &attachNote(Optional<Location> loc = std::nullopt) {
-    return diag.attachNote(loc);
-  }
-
-  /// Implicit conversion to DiagnosedSilenceableFailure in the definite failure
-  /// state. Reports the error.
-  operator DiagnosedSilenceableFailure() {
-    diag.report();
-    return DiagnosedSilenceableFailure::definiteFailure();
-  }
-
-  /// Implicit conversion to LogicalResult in the failure state. Reports the
-  /// error.
-  operator LogicalResult() {
-    diag.report();
-    return failure();
-  }
-
-private:
-  /// Constructs a definite failure at the given location with the given
-  /// message.
-  explicit DiagnosedDefiniteFailure(Location loc, const Twine &message)
-      : diag(emitError(loc, message)) {}
-
-  /// Copy-construction and any assignment is disallowed to prevent repeated
-  /// error reporting.
-  DiagnosedDefiniteFailure(const DiagnosedDefiniteFailure &) = delete;
-  DiagnosedDefiniteFailure &
-  operator=(const DiagnosedDefiniteFailure &) = delete;
-  DiagnosedDefiniteFailure &operator=(DiagnosedDefiniteFailure &&) = delete;
-
-  /// The error message.
-  InFlightDiagnostic diag;
-};
-
-/// Emits a definite failure with the given message. The returned object allows
-/// for last-minute modification to the error message, such as attaching notes
-/// and completing the message. It will be reported when the object is
-/// destructed or converted.
-inline DiagnosedDefiniteFailure emitDefiniteFailure(Location loc,
-                                                    const Twine &message) {
-  return DiagnosedDefiniteFailure(loc, message);
-}
-inline DiagnosedDefiniteFailure emitDefiniteFailure(Operation *op,
-                                                    const Twine &message = {}) {
-  return emitDefiniteFailure(op->getLoc(), message);
-}
-
-/// Emits a silenceable failure with the given message. A silenceable failure
-/// must be either suppressed or converted into a definite failure and reported
-/// to the user.
-inline DiagnosedSilenceableFailure
-emitSilenceableFailure(Location loc, const Twine &message = {}) {
-  Diagnostic diag(loc, DiagnosticSeverity::Error);
-  diag << message;
-  return DiagnosedSilenceableFailure::silenceableFailure(std::move(diag));
-}
-inline DiagnosedSilenceableFailure
-emitSilenceableFailure(Operation *op, const Twine &message = {}) {
-  return emitSilenceableFailure(op->getLoc(), message);
-}
-
 namespace transform {
 
 class TransformOpInterface;
 
 /// Options controlling the application of transform operations by the
 /// TransformState.
 class TransformOptions {
 public:

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

 //===- TransformDialect.h - Transform dialect operations --------*- 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_TRANSFORMOPS_H
 #define MLIR_DIALECT_TRANSFORM_IR_TRANSFORMOPS_H
 
 #include "mlir/Dialect/PDL/IR/PDLTypes.h"
+#include "mlir/Dialect/Transform/IR/TransformInterfaces.h"
 #include "mlir/Dialect/Transform/IR/TransformTypes.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Interfaces/CastInterfaces.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 
 namespace mlir {

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

 //===- TransformTypes.h - Transform dialect types ---------------*- 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_TRANSFORMTYPES_H
 #define MLIR_DIALECT_TRANSFORM_IR_TRANSFORMTYPES_H
 
-#include "mlir/Dialect/Transform/IR/TransformInterfaces.h"
+#include "mlir/Dialect/Transform/Utils/DiagnosedSilenceableFailure.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Support/LLVM.h"
 
 namespace mlir {
 class DiagnosedSilenceableFailure;
 class Operation;
 class Type;
 } // namespace mlir
 
 #include "mlir/Dialect/Transform/IR/TransformTypeInterfaces.h.inc"
 #define GET_TYPEDEF_CLASSES
 #include "mlir/Dialect/Transform/IR/TransformTypes.h.inc"
 
 #endif // MLIR_DIALECT_TRANSFORM_IR_TRANSFORMTYPES_H

mlir/include/mlir/Dialect/Transform/Utils/DiagnosedSilenceableFailure.h

+//===- DiagnosedSilenceableFailure.h - Tri-state result ----------- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the DiagnosedSilenceableFailure class allowing to store
+// a tri-state result (definite failure, recoverable failure, success) with an
+// optional associated list of diagnostics.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/IR/Diagnostics.h"
+#include "mlir/IR/Operation.h"
+
+#ifndef MLIR_DIALECT_TRANSFORM_UTILS_DIAGNOSEDSILENCEABLEFAILURE_H
+#define MLIR_DIALECT_TRANSFORM_UTILS_DIAGNOSEDSILENCEABLEFAILURE_H
+
+namespace mlir {
+/// The result of a transform IR operation application. This can have one of the
+/// three states:
+///   - success;
+///   - 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.
+class [[nodiscard]] DiagnosedSilenceableFailure {
+public:
+  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 silenceable failure state,
+  /// ready to emit the given diagnostic. This is considered a failure
+  /// regardless of the diagnostic severity.
+  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();
+
+  /// Returns `true` if this is a success.
+  bool succeeded() const {
+    return ::mlir::succeeded(result) && diagnostics.empty();
+  }
+
+  /// Returns `true` if this is a definite failure.
+  bool isDefiniteFailure() const {
+    return ::mlir::failed(result) && diagnostics.empty();
+  }
+
+  /// Returns `true` if this is a silenceable failure.
+  bool isSilenceableFailure() const { return !diagnostics.empty(); }
+
+  /// Returns the diagnostic message without emitting it. Expects this object
+  /// 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;
+  }
+
+  /// 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 (!diagnostics.empty()) {
+      diagnostics.clear();
+      result = ::mlir::success();
+    }
+    return result;
+  }
+
+  /// Take the diagnostics and silence.
+  void takeDiagnostics(SmallVectorImpl<Diagnostic> &diags) {
+    assert(!diagnostics.empty() && "expected a diagnostic to be present");
+    diags.append(std::make_move_iterator(diagnostics.begin()),
+                 std::make_move_iterator(diagnostics.end()));
+  }
+
+  /// Streams the given values into the last diagnostic.
+  /// Expects this object to be a silenceable failure.
+  template <typename T>
+  DiagnosedSilenceableFailure &operator<<(T &&value) & {
+    assert(isSilenceableFailure() &&
+           "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 last diagnostic.
+  /// Expects this object to be a silenceable failure.
+  Diagnostic &attachNote(Optional<Location> loc = std::nullopt) {
+    assert(isSilenceableFailure() &&
+           "can only attach notes to silenceable failures");
+    return diagnostics.back().attachNote(loc);
+  }
+
+private:
+  explicit DiagnosedSilenceableFailure(LogicalResult result) : result(result) {}
+  explicit DiagnosedSilenceableFailure(Diagnostic &&diagnostic)
+      : result(failure()) {
+    diagnostics.emplace_back(std::move(diagnostic));
+  }
+  explicit DiagnosedSilenceableFailure(SmallVector<Diagnostic> &&diagnostics)
+      : diagnostics(std::move(diagnostics)), result(failure()) {}
+
+  /// 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.
+  SmallVector<Diagnostic, 1> diagnostics;
+
+  /// The "definite" logical state, either success or failure.
+  /// Ignored if the diagnostics message is present.
+  LogicalResult result;
+
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
+  /// 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
+};
+
+class DiagnosedDefiniteFailure;
+
+DiagnosedDefiniteFailure emitDefiniteFailure(Location loc,
+                                             const Twine &message = {});
+
+/// A compatibility class connecting `InFlightDiagnostic` to
+/// `DiagnosedSilenceableFailure` while providing an interface similar to the
+/// former. Implicitly convertible to `DiagnosticSilenceableFailure` in definite
+/// failure state and to `LogicalResult` failure. Reports the error on
+/// conversion or on destruction. Instances of this class can be created by
+/// `emitDefiniteFailure()`.
+class DiagnosedDefiniteFailure {
+  friend DiagnosedDefiniteFailure emitDefiniteFailure(Location loc,
+                                                      const Twine &message);
+
+public:
+  /// Only move-constructible because it carries an in-flight diagnostic.
+  DiagnosedDefiniteFailure(DiagnosedDefiniteFailure &&) = default;
+
+  /// Forward the message to the diagnostic.
+  template <typename T>
+  DiagnosedDefiniteFailure &operator<<(T &&value) & {
+    diag << std::forward<T>(value);
+    return *this;
+  }
+  template <typename T>
+  DiagnosedDefiniteFailure &&operator<<(T &&value) && {
+    return std::move(this->operator<<(std::forward<T>(value)));
+  }
+
+  /// Attaches a note to the error.
+  Diagnostic &attachNote(Optional<Location> loc = std::nullopt) {
+    return diag.attachNote(loc);
+  }
+
+  /// Implicit conversion to DiagnosedSilenceableFailure in the definite failure
+  /// state. Reports the error.
+  operator DiagnosedSilenceableFailure() {
+    diag.report();
+    return DiagnosedSilenceableFailure::definiteFailure();
+  }
+
+  /// Implicit conversion to LogicalResult in the failure state. Reports the
+  /// error.
+  operator LogicalResult() {
+    diag.report();
+    return failure();
+  }
+
+private:
+  /// Constructs a definite failure at the given location with the given
+  /// message.
+  explicit DiagnosedDefiniteFailure(Location loc, const Twine &message)
+      : diag(emitError(loc, message)) {}
+
+  /// Copy-construction and any assignment is disallowed to prevent repeated
+  /// error reporting.
+  DiagnosedDefiniteFailure(const DiagnosedDefiniteFailure &) = delete;
+  DiagnosedDefiniteFailure &
+  operator=(const DiagnosedDefiniteFailure &) = delete;
+  DiagnosedDefiniteFailure &operator=(DiagnosedDefiniteFailure &&) = delete;
+
+  /// The error message.
+  InFlightDiagnostic diag;
+};
+
+/// Emits a definite failure with the given message. The returned object allows
+/// for last-minute modification to the error message, such as attaching notes
+/// and completing the message. It will be reported when the object is
+/// destructed or converted.
+inline DiagnosedDefiniteFailure emitDefiniteFailure(Location loc,
+                                                    const Twine &message) {
+  return DiagnosedDefiniteFailure(loc, message);
+}
+inline DiagnosedDefiniteFailure emitDefiniteFailure(Operation *op,
+                                                    const Twine &message = {}) {
+  return emitDefiniteFailure(op->getLoc(), message);
+}
+
+/// Emits a silenceable failure with the given message. A silenceable failure
+/// must be either suppressed or converted into a definite failure and reported
+/// to the user.
+inline DiagnosedSilenceableFailure
+emitSilenceableFailure(Location loc, const Twine &message = {}) {
+  Diagnostic diag(loc, DiagnosticSeverity::Error);
+  diag << message;
+  return DiagnosedSilenceableFailure::silenceableFailure(std::move(diag));
+}
+inline DiagnosedSilenceableFailure
+emitSilenceableFailure(Operation *op, const Twine &message = {}) {
+  return emitSilenceableFailure(op->getLoc(), message);
+}
+} // namespace mlir
+
+#endif // MLIR_DIALECT_TRANSFORM_UTILS_DIAGNOSEDSILENCEABLEFAILURE_H

mlir/include/mlir/Dialect/Transform/Utils/Utils.h

 //===- Utils.h - Transform dialect utilities --------------------*- 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_TRANSFORMS_UTILS_UTILS_H
 #define MLIR_DIALECT_TRANSFORMS_UTILS_UTILS_H
 
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/Value.h"
 #include "mlir/IR/ValueRange.h"
 #include "mlir/Support/LLVM.h"
 
-#include "llvm/ADT/SmallVector.h"
-
 namespace mlir {
 class OpAsmPrinter;
 
 namespace transform {
 class TransformState;
 
 /// Printer hook for custom directive in assemblyFormat.
 ///

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

 #include "mlir/Dialect/Transform/IR/TransformInterfaces.h"
 #include "mlir/Dialect/Transform/IR/TransformUtils.h"
 #include "mlir/Dialect/Transform/Utils/Utils.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/Interfaces/TilingInterface.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
+#include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/Debug.h"
 
 using namespace mlir;
 using namespace mlir::linalg;
 using namespace mlir::transform;
 
 #define DEBUG_TYPE "linalg-transforms"

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

add_mlir_dialect_library(MLIRTransformDialect
 
   LINK_LIBS PUBLIC
   MLIRIR
   MLIRParser
   MLIRPDLDialect
   MLIRPDLInterpDialect
   MLIRRewrite
   MLIRSideEffectInterfaces
+  MLIRTransformDialectUtils
   )

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

 //===- TransformInterfaces.cpp - Transform Dialect Interfaces -------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Transform/IR/TransformInterfaces.h"
 #include "mlir/Dialect/Transform/IR/TransformTypes.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Operation.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/ScopeExit.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 
 #define DEBUG_TYPE "transform-dialect"
 #define DEBUG_PRINT_AFTER_ALL "transform-dialect-print-top-level-after-all"
 #define DBGS() (llvm::dbgs() << "[" DEBUG_TYPE "] ")
 
 using namespace mlir;

mlir/lib/Dialect/Transform/Utils/CMakeLists.txt

 add_mlir_dialect_library(MLIRTransformDialectUtils
+  DiagnosedSilenceableFailure.cpp
   Utils.cpp
+
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Transform
+
   LINK_LIBS PUBLIC
   MLIRDialectUtils
   MLIRIR
   MLIRSupport
-  MLIRTransformDialect
+  MLIRViewLikeInterface
 )

mlir/lib/Dialect/Transform/Utils/DiagnosedSilenceableFailure.cpp

+//===- DiagnosedSilenceableFailure.cpp - Tri-state result -----------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the DiagnosedSilenceableFailure class allowing to store
+// a tri-state result (definite failure, recoverable failure, success) with an
+// optional associated list of diagnostics.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/Transform/Utils/DiagnosedSilenceableFailure.h"
+
+using namespace mlir;
+
+LogicalResult mlir::DiagnosedSilenceableFailure::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 (!diagnostics.empty()) {
+    for (auto &&diagnostic : diagnostics) {
+      diagnostic.getLocation().getContext()->getDiagEngine().emit(
+          std::move(diagnostic));
+    }
+    diagnostics.clear();
+    result = ::mlir::failure();
+  }
+  return result;
+}

mlir/lib/Dialect/Transform/Utils/Utils.cpp

 //===- Utils.cpp - Transform dialect utilities ----------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Transform/Utils/Utils.h"
 
-#include "mlir/Dialect/Transform/IR/TransformDialect.h"
-#include "mlir/Dialect/Transform/IR/TransformTypes.h"
-#include "mlir/Dialect/Utils/StaticValueUtils.h"
-#include "mlir/IR/Matchers.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/Interfaces/ViewLikeInterface.h"
 
 using namespace mlir;
 using namespace mlir::transform;
 
-void transform::printPackedOrDynamicIndexList(OpAsmPrinter &printer,
-                                              Operation *op, Value packed,
-                                              OperandRange values,
-                                              ArrayRef<int64_t> integers) {
+void mlir::transform::printPackedOrDynamicIndexList(
+    OpAsmPrinter &printer, Operation *op, Value packed, OperandRange values,
   if (packed) {
     assert(values.empty() && integers.empty() && "expected no values/integers");
     printer << packed;
     return;
   }
   printDynamicIndexList(printer, op, values, integers);
 }
 
-ParseResult transform::parsePackedOrDynamicIndexList(
+ParseResult mlir::transform::parsePackedOrDynamicIndexList(
     OpAsmParser &parser, std::optional<OpAsmParser::UnresolvedOperand> &packed,
     SmallVectorImpl<OpAsmParser::UnresolvedOperand> &values,
     DenseI64ArrayAttr &integers) {
   OpAsmParser::UnresolvedOperand packedOperand;
   if (parser.parseOptionalOperand(packedOperand).has_value()) {
     packed.emplace(packedOperand);
     integers = parser.getBuilder().getDenseI64ArrayAttr({});
     return success();
   }
   return parseDynamicIndexList(parser, values, integers);
 }

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

deps = [
         ":PDLDialect",
         ":PDLInterpDialect",
         ":Rewrite",
         ":SideEffectInterfaces",
         ":Support",
         ":TransformDialectEnumsIncGen",
         ":TransformDialectIncGen",
         ":TransformDialectInterfacesIncGen",
+        ":TransformDialectUtils",
         ":TransformOpsIncGen",
         ":TransformTypesIncGen",
         "//llvm:Support",
     ],
 )
 
 td_library(
     name = "TransformDialectTransformsTdFiles",
deps = [
         ":TransformDialect",
         ":TransformDialectTransformsIncGen",
         "//llvm:Support",
     ],
 )
 
 cc_library(
     name = "TransformDialectUtils",
-    srcs = ["lib/Dialect/Transform/Utils/Utils.cpp"],
-    hdrs = ["include/mlir/Dialect/Transform/Utils/Utils.h"],
+    srcs = glob(["lib/Dialect/Transform/Utils/*cpp"]),
+    hdrs = glob(["include/mlir/Dialect/Transform/Utils/*.h"]),
     includes = ["include"],
     deps = [
         ":DialectUtils",
         ":IR",
         ":Support",
-        ":TransformDialect",
         ":ViewLikeInterface",
         "//llvm:Support",
     ],
 )
 
 td_library(
     name = "ComplexOpsTdFiles",
     srcs = [