ErrorHelper.h

Go to the documentation of this file.

//===-- ErrorHelper.h -------------------------------------------*- C++ -*-===//
//
// Part of the LLZK Project, under the Apache License v2.0.
// See LICENSE.txt for license information.
// Copyright 2025 Veridise Inc.
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
 
#pragma once
 
#include <mlir/IR/Diagnostics.h>
#include <mlir/IR/Operation.h>
 
#include <llvm/ADT/STLFunctionalExtras.h>
#include <llvm/ADT/Twine.h>
#include <llvm/Support/ErrorHandling.h>
 
#include <variant>
 
namespace llzk {

class InFlightDiagnosticWrapper {
private:
  class DefaultAndFailInFlightDiagnostic : public mlir::InFlightDiagnostic {
  public:
    DefaultAndFailInFlightDiagnostic(mlir::InFlightDiagnostic &&base)
        : mlir::InFlightDiagnostic(std::move(base)) {}
 
    DefaultAndFailInFlightDiagnostic(DefaultAndFailInFlightDiagnostic &&other) noexcept
        : mlir::InFlightDiagnostic(std::move(other)) {}
 
    ~DefaultAndFailInFlightDiagnostic() {
      if (getUnderlyingDiagnostic()) {
        report();
      }
    }
 
    // Intentional hiding: std::visit dispatches using the concrete type,
    // and the derived destructor explicitly calls this method.
    // NOLINTNEXTLINE(bugprone-derived-method-shadowing-base-method)
    void report() {
      InFlightDiagnostic::report();
      assert(false);
    }
  };
 
  std::variant<mlir::InFlightDiagnostic, DefaultAndFailInFlightDiagnostic> inner;
 
  explicit InFlightDiagnosticWrapper(DefaultAndFailInFlightDiagnostic &&diag)
      : inner(std::move(diag)) {}
 
public:
  explicit InFlightDiagnosticWrapper(mlir::InFlightDiagnostic &&diag) : inner(std::move(diag)) {}

  explicit InFlightDiagnosticWrapper(mlir::MLIRContext *ctx)
      : InFlightDiagnosticWrapper(
            DefaultAndFailInFlightDiagnostic(mlir::detail::getDefaultDiagnosticEmitFn(ctx)())
        ) {}

  explicit InFlightDiagnosticWrapper(const mlir::Location &loc)
      : InFlightDiagnosticWrapper(loc.getContext()) {}

  static InFlightDiagnosticWrapper createSilent(mlir::MLIRContext *ctx) {
    mlir::InFlightDiagnostic d = mlir::emitRemark(mlir::UnknownLoc::get(ctx));
    d.abandon();
    return InFlightDiagnosticWrapper(std::move(d));
  }

  template <typename Arg> InFlightDiagnosticWrapper &operator<<(Arg &&arg) & {
    return append(std::forward<Arg>(arg));
  }

  template <typename Arg> InFlightDiagnosticWrapper &&operator<<(Arg &&arg) && {
    return std::move(append(std::forward<Arg>(arg)));
  }

  template <typename... Args> InFlightDiagnosticWrapper &append(Args &&...args) & {
    std::visit([&](auto &diag) { diag.append(std::forward<Args>(args)...); }, inner);
    return *this;
  }

  template <typename... Args> InFlightDiagnosticWrapper &&append(Args &&...args) && {
    return std::move(append(std::forward<Args>(args)...));
  }

  mlir::Diagnostic &attachNote(std::optional<mlir::Location> noteLoc = std::nullopt) {
    return std::visit([&](auto &diag) -> mlir::Diagnostic & {
      return diag.attachNote(noteLoc);
    }, inner);
  }

  mlir::Diagnostic *getUnderlyingDiagnostic() {
    return std::visit([](auto &diag) -> mlir::Diagnostic * {
      return diag.getUnderlyingDiagnostic();
    }, inner);
  }

  void report() {
    std::visit([](auto &diag) { diag.report(); }, inner);
  }

  void abandon() {
    std::visit([](auto &diag) { diag.abandon(); }, inner);
  }

  operator mlir::LogicalResult() const {
    return std::visit([](const auto &diag) -> mlir::LogicalResult { return diag; }, inner);
  }

  operator mlir::ParseResult() const { return mlir::ParseResult(mlir::LogicalResult(*this)); }

  template <typename T> operator mlir::FailureOr<T>() const { return mlir::failure(); }
 
  // Match move/copy semantics of InFlightDiagnostic
  InFlightDiagnosticWrapper(InFlightDiagnosticWrapper &&) = default;
  InFlightDiagnosticWrapper(const InFlightDiagnosticWrapper &) = delete;
  InFlightDiagnosticWrapper &operator=(InFlightDiagnosticWrapper &&) = delete;
  InFlightDiagnosticWrapper &operator=(const InFlightDiagnosticWrapper &) = delete;
};

using EmitErrorFn = llvm::function_ref<InFlightDiagnosticWrapper()>;

using OwningEmitErrorFn = std::function<InFlightDiagnosticWrapper()>;
 
inline OwningEmitErrorFn getEmitOpErrFn(mlir::Operation *op) {
  return [op]() { return InFlightDiagnosticWrapper(op->emitOpError()); };
}
 
template <typename OpImplClass> inline OwningEmitErrorFn getEmitOpErrFn(OpImplClass *opImpl) {
  return getEmitOpErrFn(opImpl->getOperation());
}
 
inline void ensure(bool condition, const llvm::Twine &errMsg) {
  if (!condition) {
    llvm::report_fatal_error(errMsg);
  }
}

inline OwningEmitErrorFn wrapNullableInFlightDiagnostic(
    llvm::function_ref<mlir::InFlightDiagnostic()> emitError, mlir::MLIRContext *ctx
) {
  if (emitError) {
    return [emitError]() -> auto { return InFlightDiagnosticWrapper(emitError()); };
  } else {
    return [ctx]() -> auto { return InFlightDiagnosticWrapper(ctx); };
  }
}
 
inline OwningEmitErrorFn
wrapNonNullableInFlightDiagnostic(llvm::function_ref<mlir::InFlightDiagnostic()> emitError) {
  assert(emitError && "emitError must be non-null");
  return [emitError]() -> auto { return InFlightDiagnosticWrapper(emitError()); };
}
 
} // namespace llzk