Move mlir LogicalResult to llvm Support library

[ezhulenev]

Summary

Inconsistent use of boolean to report success or failure in the LLVM code base was mentioned couple of times, one example: https://lists.llvm.org/pipermail/llvm-dev/2018-September/126182.html

S-u-m-m-a-r-y:

1. mlir::LogicalResult moved to llvm::LogicalResult (llvm/Support/LogicalResult.h)
2. mlir::FailureOr moved to llvm::FailureOr
3. mlir defines aliases to bring them back into the mlir namespace
4. mlir::ParseResult stays in the mlir/Support/LogicalResult.h because it's very MLIR specific

[kuhar]

+1, I like this direction. bool return values confused me numerous times in functions like check*, verify*, etc., and many places in LLVM would benefit from this.

[mehdi_amini]

Adding some non-MLIR folks to review the addition to LLVM libSupport (@dexonsmith and @dblaikie )

[rriddle]

I mean this looks fine to me, but would love review from those Mehdi linked.

llvm/include/llvm/Support/LogicalResult.h

76

The formatting here looks off.

102

I know some downstream users would benefit from this, not sure how that would manifest (rename or something) if we find it desirable.

[dexonsmith]

SGTM in general (I like the idea) but I don’t have time to look in detail or think hard about it for at least a few weeks (no need to wait for me).

CC: @lhames as well (author of Error/Expected).

[ezhulenev]

Roll back some of formatting changes

[ezhulenev]

llvm/include/llvm/Support/LogicalResult.h

76

That's how the arcanist reformats the code once I upload it

[rriddle]

llvm/include/llvm/Support/LogicalResult.h

76

Weird, oh well. Do whatever the formatter tells you.

[dblaikie]

llvm/include/llvm/Support/LogicalResult.h

96

Seems unfortunate that this type (FailureOr) will have different API than ErrorOr though - any chance this could keep an explicit operator bool?

& making something private that's inherited is pretty awkward - since you can still access the private things via a base reference, or slicing, etc.

I guess alternatively, maybe ErrorOr ends up with operator LogicalResult instead of explicit operator bool? (@lhames )

[ezhulenev]

llvm/include/llvm/Support/LogicalResult.h

96

If I got the history correctly that's a very deliberate decision (cc @rriddle), only the mlir::ParseResult allows implicit casting to bool, because it's intended for use in a very narrow context of parsing. Because if FailureOr would have implicit casting it would be another source of confusion, I myself always double check the rules for casting llvm::Error and llvm::Expected.

[rriddle]

llvm/include/llvm/Support/LogicalResult.h

96

Yeah, no conversions to bool was an explicit choice. Alongside LogicalResult, we wanted something that is explicit about bool treatment.

The choice of using Optional is the base class was just convenience, we could change to something cleaner.

[dblaikie]

llvm/include/llvm/Support/LogicalResult.h

96

Oh, no doubt it was deliberate - but I guess to summarize: given the similarities with Error/ErrorOr, it seems important these have similar/the same API in this regard. So I think it's important to at least have a plan everyone agrees to about how these'll all end up the same in relatively short order before this gets added to LLVM. (& ideally, avoid even temporary divergence if practical/if some of it can be frontloaded (I guess that'd involve introducing LogicalResult first, using that in ErrorOr, then introducing FailureOr at that point since it would be consistent at that point))

[rriddle]

llvm/include/llvm/Support/LogicalResult.h

96

I don't think FailureOr should have any kind of boolean conversion (whether implicit/explicit). I'd be fine with aligning on the other API though, of which it only seems like ErrorOr has operator*/operator->/get that would be shared (there doesn't seem to be any other non-Error related API on ErrorOr). Given the use of Optional, they are already kind of aligned there. I suppose to make them truly aligned, we'd need to drop various methods inherited from Optional.

[dblaikie]

llvm/include/llvm/Support/LogicalResult.h

96

Mostly the boolean conversion I think should be consistent between them - both or neither. It'd be pretty awkward if we have lots of code that does:

if (ErrorOr<T> T = func())

(which we do)
and then FailureOr can't be used in a similar way - that'll be pretty jarring for developers to have to handle these two things so fundamentally differently. I think this usage is pretty important & it'd be a loss to break all that ErrorOr usage - so I hope there's some way to align these while preserving such usage, but that ultimately (I think) boils down to at least an explicit conversion to bool. Which would mean we're at an impass.

[rriddle]

llvm/include/llvm/Support/LogicalResult.h

96

The point of the LogicalResult stuff is to not have boolean conversions. If the requirement for moving into LLVM Support is to have them, I suppose we shouldn't pull any of this into LLVM.

[dblaikie]

llvm/include/llvm/Support/LogicalResult.h

96

For FailureOr in particular, though - what're the risks of explicit conversion to bool that the absence is intended to mitigate?

[rriddle]

llvm/include/llvm/Support/LogicalResult.h

96

We don't want to allow things like:

FailureOr<Foo> someMethod();

...

if (someMethod()) {
}
if (!someMethod()) {
}

[ezhulenev]

llvm/include/llvm/Support/LogicalResult.h

96

Indeed it's the whole purpose of LogicalResult: a thing that is not implicitly convertible to bool. Of course returning a type instead of a bool is better, because the semantics of boolean conversion is defined in one place, but that was not the reason why original LogicalResult was added, Error or ErrorOr would work just fine.

[dblaikie]

llvm/include/llvm/Support/LogicalResult.h

96

Ah, Error/ErrorOr sort of avoid that problem because the error itself must be inspected, but that's a runtime failure (which still means if the error path is untested the boolean check is sufficient/the failure to handle the error is unchecked). We wouldn't even have that backstop with FailureOr if it weren't for the syntactic difference you're suggesting/have.

I'd feel less bad about this (& maybe even encourage Error/ErrorOr to move away from (even explicit) conversion to bool in favor of an explicit "success" check) if we were already using C++17 if-with-initializers https://www.tutorialspoint.com/cplusplus17-if-statement-with-initializer though that's still a bit awkward to write when the initializer is long & then after that you have to do the success check.

Are there particular cases where LogicalResult and FailureOr are intended to be used? Or is the intent/possibility that they become ubiquitous/replace all boolean success/failure returns in the LLVM project? If there's a narrow enough subset of cases we can say they're suitable for and others they aren't I'd be less worried about the awkward ergonomics of having to explicitly test success.

@lhames is out at the moment I think, but I'll be curious to hear his thoughts next week, hopefully.

[ezhulenev]

llvm/include/llvm/Support/LogicalResult.h

96

I'd say that every function that returns bool to signal success/failure should use LogicalResult, and every function that is happy with Error/ErrorOr should continue using them. LogicalResult is a huge productivity boost when you use not very familiar APIs, because you don't have to double check what is the semantics of the return booleans.

But I'm not familiar with LLVM code base to say if there are any concrete use cases that will benefit from it today.

[lhames]

llvm/include/llvm/Support/LogicalResult.h

25

LogicalResult seems like a misnomer -- isn't bool already a logical result?

If possible, I think you want a name that conveys that this is specifically about success/failure.

96

@lhames is out at the moment I think, but I'll be curious to hear his thoughts next week, hopefully.

I really like the idea of replacing bool with LogicalResult for fallible functions, since (even if you did allow boolean conversion) the return type tells you how to interpret its values.

The lack of boolean conversion is concerning though, especially on FailureOr. If we tried to harmonize all of these APIs (Optional, Error, Expected, FailureOr, ...) by removing implicit conversion from the existing utilities I think that it would add a lot of boilerplate around if checks (even if we do use if-with-initializers). If we don't harmonize the APIs then we're increasing the number of idioms that people need to be familiar with, and in that case it's not clear that the benefits would outweigh the costs.

I'm trying to think of a way that we could extend the succeeded and failed functions to make them applicable to Error and Expected in a way that would allow us to harmonize with FailureOr, but haven't come up with anything yet.

[ezhulenev]

Abandoning this change

llvm/include/llvm/Support/LogicalResult.h

 //===- LogicalResult.h - Utilities for handling success/failure -*- 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_SUPPORT_LOGICALRESULT_H
-#define MLIR_SUPPORT_LOGICALRESULT_H
+#ifndef LLVM_SUPPORT_LOGICALRESULT_H
+#define LLVM_SUPPORT_LOGICALRESULT_H
 
-#include "mlir/Support/LLVM.h"
 #include "llvm/ADT/Optional.h"
 
-namespace mlir {
+namespace llvm {
 
 /// This class represents an efficient way to signal success or failure. It
 /// should be preferred over the use of `bool` when appropriate, as it avoids
 /// all of the ambiguity that arises in interpreting a boolean result. This
 /// class is marked as NODISCARD to ensure that the result is processed. Users
 /// may explicitly discard a result by using `(void)`, e.g.
 /// `(void)functionThatReturnsALogicalResult();`. Given the intended nature of
 /// this class, it generally shouldn't be used as the result of functions that
 /// very frequently have the result ignored. This class is intended to be used
 /// in conjunction with the utility functions below.
 struct LLVM_NODISCARD LogicalResult {
 public:
   /// If isSuccess is true a `success` result is generated, otherwise a
   /// 'failure' result is generated.
   static LogicalResult success(bool isSuccess = true) {
     return LogicalResult(isSuccess);
   }
 
   /// If isFailure is true a `failure` result is generated, otherwise a

 
 /// Utility function that returns true if the provided LogicalResult corresponds
 /// to a failure value.
 inline bool failed(LogicalResult result) { return result.failed(); }
 
 /// This class provides support for representing a failure result, or a valid
 /// value of type `T`. This allows for integrating with LogicalResult, while
 /// also providing a value on the success path.
-template <typename T>
-class LLVM_NODISCARD FailureOr : public Optional<T> {
+template <typename T> class LLVM_NODISCARD FailureOr : public Optional<T> {
 public:
   /// Allow constructing from a LogicalResult. The result *must* be a failure.
   /// Success results should use a proper instance of type `T`.
   FailureOr(LogicalResult result) {
     assert(failed(result) &&
            "success should be constructed with an instance of 'T'");
   }
   FailureOr() : FailureOr(failure()) {}
   FailureOr(T &&y) : Optional<T>(std::forward<T>(y)) {}
   FailureOr(const T &y) : Optional<T>(y) {}
   template <typename U,
             std::enable_if_t<std::is_constructible<T, U>::value> * = nullptr>
   FailureOr(const FailureOr<U> &other)
       : Optional<T>(failed(other) ? Optional<T>() : Optional<T>(*other)) {}
 
   operator LogicalResult() const { return success(this->has_value()); }
 
 private:
   /// Hide the bool conversion as it easily creates confusion.
   using Optional<T>::operator bool;
   using Optional<T>::has_value;
 };
 
-/// This class represents success/failure for parsing-like operations that find
-/// it important to chain together failable operations with `||`.  This is an
-/// extended version of `LogicalResult` that allows for explicit conversion to
-/// bool.
-///
-/// This class should not be used for general error handling cases - we prefer
-/// to keep the logic explicit with the `succeeded`/`failed` predicates.
-/// However, traditional monadic-style parsing logic can sometimes get
-/// swallowed up in boilerplate without this, so we provide this for narrow
-/// cases where it is important.
-///
-class LLVM_NODISCARD ParseResult : public LogicalResult {
-public:
-  ParseResult(LogicalResult result = success()) : LogicalResult(result) {}
-
-  /// Failure is true in a boolean context.
-  explicit operator bool() const { return failed(); }
-};
-
-} // namespace mlir
+} // namespace llvm
 
-#endif // MLIR_SUPPORT_LOGICALRESULT_H
+#endif // LLVM_SUPPORT_LOGICALRESULT_H

mlir/include/mlir/Conversion/AffineToStandard/AffineToStandard.h

 //===- AffineToStandard.h - Convert Affine to Standard dialect --*- 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_CONVERSION_AFFINETOSTANDARD_AFFINETOSTANDARD_H
 #define MLIR_CONVERSION_AFFINETOSTANDARD_AFFINETOSTANDARD_H
 
 #include "mlir/Support/LLVM.h"
 
 namespace mlir {
 class AffineForOp;
 class Location;
-struct LogicalResult;
 class OpBuilder;
 class Pass;
 class RewritePattern;
 class Value;
 class ValueRange;
 
 class RewritePatternSet;
 

mlir/include/mlir/Conversion/GPUCommon/GPUCommonPass.h

 class LLVMContext;
 class Module;
 } // namespace llvm
 
 namespace mlir {
 
 class LLVMTypeConverter;
 class Location;
-struct LogicalResult;
 class ModuleOp;
 class Operation;
 class RewritePatternSet;
 
 template <typename T>
 class OperationPass;
 
 namespace gpu {

mlir/include/mlir/Conversion/SCFToGPU/SCFToGPU.h

 //===- SCFToGPU.h - Convert loop nests to GPU kernels -----------*- 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_CONVERSION_SCFTOGPU_SCFTOGPU_H_
 #define MLIR_CONVERSION_SCFTOGPU_SCFTOGPU_H_
 
 #include "mlir/Support/LLVM.h"
 
 namespace mlir {
 class AffineForOp;
 class ConversionTarget;
-struct LogicalResult;
 class MLIRContext;
 class Value;
 class Operation;
 class RewritePatternSet;
 
 namespace scf {
 class ForOp;
 } // namespace scf

mlir/include/mlir/Dialect/Affine/Utils.h

 namespace func {
 class FuncOp;
 } // namespace func
 
 namespace memref {
 class AllocOp;
 } // namespace memref
 
-struct LogicalResult;
-
 using ReductionLoopMap = DenseMap<Operation *, SmallVector<LoopReduction, 2>>;
 
 /// Replaces a parallel affine.for op with a 1-d affine.parallel op. `forOp`'s
 /// body is taken by the affine.parallel op and the former is erased.
 /// (mlir::isLoopParallel can be used to detect a parallel affine.for op.) The
 /// reductions specified in `parallelReductions` are also parallelized.
 /// Parallelization will fail in the presence of loop iteration arguments that
 /// are not listed in `parallelReductions`.

mlir/include/mlir/Dialect/Bufferization/Transforms/OneShotModuleBufferize.h

 //===- OneShotModuleBufferize.h - Bufferization across Func. Boundaries ---===//
 //
 // 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_BUFFERIZATION_TRANSFORMS_ONESHOTMODULEBUFFERIZE_H
 #define MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_ONESHOTMODULEBUFFERIZE_H
 
+#include "mlir/Support/LLVM.h"
+
 namespace mlir {
 
-struct LogicalResult;
 class ModuleOp;
 
 namespace bufferization {
 class OneShotAnalysisState;
 struct OneShotBufferizationOptions;
 
 /// Analyze `moduleOp` and its nested ops. Bufferization decisions are stored in
 /// `state`.

mlir/include/mlir/Dialect/GPU/Transforms/ParallelLoopMapper.h

 
 #include "mlir/Dialect/GPU/IR/GPUDialect.h"
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace mlir {
 
 class AffineMap;
-struct LogicalResult;
 class Operation;
 class Region;
 
 } // namespace mlir
 
 namespace mlir {
 namespace scf {
 class ParallelOp;

mlir/include/mlir/Dialect/GPU/Transforms/Utils.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_GPU_TRANSFORMS_UTILS_H_
 #define MLIR_DIALECT_GPU_TRANSFORMS_UTILS_H_
 
 #include "mlir/Support/LLVM.h"
 
 namespace mlir {
-struct LogicalResult;
 class Operation;
 class Value;
 
 namespace gpu {
 class GPUFuncOp;
 class LaunchOp;
 } // namespace gpu
 

mlir/include/mlir/Dialect/SCF/Transforms/Transforms.h

 #include "mlir/Dialect/SCF/Utils/AffineCanonicalizationUtils.h"
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 
 namespace mlir {
 
 class AffineMap;
 class ConversionTarget;
-struct LogicalResult;
 class MLIRContext;
 class Region;
 class RewriterBase;
 class TypeConverter;
 class RewritePatternSet;
 class Operation;
 class Value;
 class ValueRange;

mlir/include/mlir/Dialect/SCF/Utils/AffineCanonicalizationUtils.h

 
 #ifndef MLIR_DIALECT_SCF_UTILS_AFFINECANONICALIZATIONUTILS_H_
 #define MLIR_DIALECT_SCF_UTILS_AFFINECANONICALIZATIONUTILS_H_
 
 #include "mlir/Support/LLVM.h"
 
 namespace mlir {
 class AffineMap;
-struct LogicalResult;
 class Operation;
 class OpFoldResult;
 class RewriterBase;
 class Value;
 class ValueRange;
 
 namespace scf {
 class IfOp;

mlir/include/mlir/ExecutionEngine/JitRunner.h

 // The translation can be customized by providing an MLIR to MLIR
 // transformation.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_EXECUTIONENGINE_JITRUNNER_H
 #define MLIR_EXECUTIONENGINE_JITRUNNER_H
 
+#include "mlir/Support/LLVM.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ExecutionEngine/Orc/Core.h"
 
 namespace llvm {
 class Module;
 class LLVMContext;
 
 namespace orc {
 class MangleAndInterner;
 } // namespace orc
 } // namespace llvm
 
 namespace mlir {
 
 class DialectRegistry;
 class ModuleOp;
-struct LogicalResult;
 
 struct JitRunnerConfig {
   /// MLIR transformer applied after parsing the input into MLIR IR and before
   /// passing the MLIR module to the ExecutionEngine.
   llvm::function_ref<LogicalResult(mlir::ModuleOp)> mlirTransformer = nullptr;
 
   /// A custom function that is passed to ExecutionEngine. It processes MLIR
   /// module and creates LLVM IR module.

mlir/include/mlir/IR/AffineMap.h

 
 namespace mlir {
 
 namespace detail {
 struct AffineMapStorage;
 } // namespace detail
 
 class Attribute;
-struct LogicalResult;
 class MLIRContext;
 
 /// A multi-dimensional affine map
 /// Affine map's are immutable like Type's, and they are uniqued.
 /// Eg: (d0, d1) -> (d0/128, d0 mod 128, d1)
 /// The names used (d0, d1) don't matter - it's the mathematical function that
 /// is unique to this affine map.
 class AffineMap {

mlir/include/mlir/IR/Diagnostics.h

 namespace llvm {
 class MemoryBuffer;
 class SMLoc;
 class SourceMgr;
 } // namespace llvm
 
 namespace mlir {
 class DiagnosticEngine;
-struct LogicalResult;
 class MLIRContext;
 class Operation;
 class OperationName;
 class OpPrintingFlags;
 class Type;
 class Value;
 
 namespace detail {

mlir/include/mlir/IR/ExtensibleDialect.h

 
 #ifndef MLIR_IR_EXTENSIBLEDIALECT_H
 #define MLIR_IR_EXTENSIBLEDIALECT_H
 
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/DialectInterface.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/OpDefinition.h"
+#include "mlir/Support/LLVM.h"
 #include "mlir/Support/TypeID.h"
 #include "llvm/ADT/StringMap.h"
 
 namespace mlir {
 class AsmParser;
 class AsmPrinter;
 class DynamicAttr;
 class DynamicType;
 class ExtensibleDialect;
 class MLIRContext;
 class OptionalParseResult;
-class ParseResult;
 
 namespace detail {
 struct DynamicAttrStorage;
 struct DynamicTypeStorage;
 } // namespace detail
 
 //===----------------------------------------------------------------------===//
 // Dynamic attribute

mlir/include/mlir/IR/OperationSupport.h

 #define MLIR_IR_OPERATIONSUPPORT_H
 
 #include "mlir/IR/BlockSupport.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/TypeRange.h"
 #include "mlir/IR/Types.h"
 #include "mlir/IR/Value.h"
+#include "mlir/Support/LLVM.h"
 #include "mlir/Support/InterfaceSupport.h"
 #include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 #include "llvm/Support/TrailingObjects.h"
 #include <memory>
 
 namespace llvm {

 class Operation;
 struct OperationState;
 class OpAsmParser;
 class OpAsmParserResult;
 class OpAsmPrinter;
 class OperandRange;
 class OperandRangeRange;
 class OpFoldResult;
-class ParseResult;
 class Pattern;
 class Region;
 class ResultRange;
 class RewritePattern;
 class RewritePatternSet;
 class Type;
 class Value;
 class ValueRange;

mlir/include/mlir/IR/Verifier.h

 //===- Verifier.h - Verifier analysis for MLIR structures -------*- 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_IR_VERIFIER_H
 #define MLIR_IR_VERIFIER_H
 
+#include "mlir/Support/LLVM.h"
+
 namespace mlir {
-struct LogicalResult;
 class Operation;
 
 /// Perform (potentially expensive) checks of invariants, used to detect
 /// compiler bugs, on this operation and any nested operations. On error, this
 /// reports the error through the MLIRContext and returns failure. If
 /// `verifyRecursively` is false, this assumes that nested operations have
 /// already been properly verified, and does not recursively invoke the verifier
 /// on nested operations.
 LogicalResult verify(Operation *op, bool verifyRecursively = true);
 
 } // namespace mlir
 
 #endif

mlir/include/mlir/Support/LLVM.h

 namespace llvm {
 // String types
 template <unsigned N>
 class SmallString;
 class StringRef;
 class StringLiteral;
 class Twine;
 
+// Logical result types.
+struct LogicalResult;
+template <typename T>
+class FailureOr;
+
 // Containers.
 template <typename T>
 class ArrayRef;
 class BitVector;
 namespace detail {
 template <typename KeyT, typename ValueT>
 struct DenseMapPair;
 } // namespace detail

 using llvm::isa_and_nonnull;
 
 // String types
 using llvm::SmallString;
 using llvm::StringLiteral;
 using llvm::StringRef;
 using llvm::Twine;
 
+// Logical result types.
+using llvm::FailureOr;
+using llvm::LogicalResult;
+
 // Container Related types
 //
 // Containers.
 using llvm::ArrayRef;
 using llvm::BitVector;
 template <typename T, typename Enable = void>
 using DenseMapInfo = llvm::DenseMapInfo<T, Enable>;
 template <typename KeyT, typename ValueT,

mlir/include/mlir/Support/LogicalResult.h

 //===- LogicalResult.h - Utilities for handling success/failure -*- 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_SUPPORT_LOGICALRESULT_H
 #define MLIR_SUPPORT_LOGICALRESULT_H
 
 #include "mlir/Support/LLVM.h"
-#include "llvm/ADT/Optional.h"
+#include "llvm/Support/LogicalResult.h"
 
 namespace mlir {
 
-/// This class represents an efficient way to signal success or failure. It
-/// should be preferred over the use of `bool` when appropriate, as it avoids
-/// all of the ambiguity that arises in interpreting a boolean result. This
-/// class is marked as NODISCARD to ensure that the result is processed. Users
-/// may explicitly discard a result by using `(void)`, e.g.
-/// `(void)functionThatReturnsALogicalResult();`. Given the intended nature of
-/// this class, it generally shouldn't be used as the result of functions that
-/// very frequently have the result ignored. This class is intended to be used
-/// in conjunction with the utility functions below.
-struct LLVM_NODISCARD LogicalResult {
-public:
-  /// If isSuccess is true a `success` result is generated, otherwise a
-  /// 'failure' result is generated.
-  static LogicalResult success(bool isSuccess = true) {
-    return LogicalResult(isSuccess);
-  }
-
-  /// If isFailure is true a `failure` result is generated, otherwise a
-  /// 'success' result is generated.
-  static LogicalResult failure(bool isFailure = true) {
-    return success(!isFailure);
-  }
-
-  /// Returns true if the provided LogicalResult corresponds to a success value.
-  bool succeeded() const { return isSuccess; }
-
-  /// Returns true if the provided LogicalResult corresponds to a failure value.
-  bool failed() const { return !succeeded(); }
-
-private:
-  LogicalResult(bool isSuccess) : isSuccess(isSuccess) {}
-
-  /// Boolean indicating if this is a success result, if false this is a
-  /// failure result.
-  bool isSuccess;
-};
-
-/// Utility function to generate a LogicalResult. If isSuccess is true a
-/// `success` result is generated, otherwise a 'failure' result is generated.
-inline LogicalResult success(bool isSuccess = true) {
-  return LogicalResult::success(isSuccess);
-}
-
-/// Utility function to generate a LogicalResult. If isFailure is true a
-/// `failure` result is generated, otherwise a 'success' result is generated.
-inline LogicalResult failure(bool isFailure = true) {
-  return LogicalResult::failure(isFailure);
-}
-
-/// Utility function that returns true if the provided LogicalResult corresponds
-/// to a success value.
-inline bool succeeded(LogicalResult result) { return result.succeeded(); }
-
-/// Utility function that returns true if the provided LogicalResult corresponds
-/// to a failure value.
-inline bool failed(LogicalResult result) { return result.failed(); }
-
-/// This class provides support for representing a failure result, or a valid
-/// value of type `T`. This allows for integrating with LogicalResult, while
-/// also providing a value on the success path.
-template <typename T>
-class LLVM_NODISCARD FailureOr : public Optional<T> {
-public:
-  /// Allow constructing from a LogicalResult. The result *must* be a failure.
-  /// Success results should use a proper instance of type `T`.
-  FailureOr(LogicalResult result) {
-    assert(failed(result) &&
-           "success should be constructed with an instance of 'T'");
-  }
-  FailureOr() : FailureOr(failure()) {}
-  FailureOr(T &&y) : Optional<T>(std::forward<T>(y)) {}
-  FailureOr(const T &y) : Optional<T>(y) {}
-  template <typename U,
-            std::enable_if_t<std::is_constructible<T, U>::value> * = nullptr>
-  FailureOr(const FailureOr<U> &other)
-      : Optional<T>(failed(other) ? Optional<T>() : Optional<T>(*other)) {}
-
-  operator LogicalResult() const { return success(this->has_value()); }
-
-private:
-  /// Hide the bool conversion as it easily creates confusion.
-  using Optional<T>::operator bool;
-  using Optional<T>::has_value;
-};
+using llvm::failed;
+using llvm::failure;
+using llvm::succeeded;
+using llvm::success;
 
 /// This class represents success/failure for parsing-like operations that find
 /// it important to chain together failable operations with `||`.  This is an
 /// extended version of `LogicalResult` that allows for explicit conversion to
 /// bool.
 ///
 /// This class should not be used for general error handling cases - we prefer
 /// to keep the logic explicit with the `succeeded`/`failed` predicates.

mlir/include/mlir/Support/ToolUtilities.h

 #include "llvm/ADT/STLExtras.h"
 #include <memory>
 
 namespace llvm {
 class MemoryBuffer;
 } // namespace llvm
 
 namespace mlir {
-struct LogicalResult;
 
 using ChunkBufferHandler = function_ref<LogicalResult(
     std::unique_ptr<llvm::MemoryBuffer> chunkBuffer, raw_ostream &os)>;
 
 /// Splits the specified buffer on a marker (`// -----`), processes each chunk
 /// independently according to the normal `processChunkBuffer` logic, and writes
 /// all results to `os`.
 ///

mlir/include/mlir/Target/SPIRV/Serialization.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TARGET_SPIRV_SERIALIZATION_H
 #define MLIR_TARGET_SPIRV_SERIALIZATION_H
 
 #include "mlir/Support/LLVM.h"
 
 namespace mlir {
-struct LogicalResult;
 class MLIRContext;
 
 namespace spirv {
 class ModuleOp;
 
 struct SerializationOptions {
   /// Whether to emit `OpName` instructions for SPIR-V symbol ops.
   bool emitSymbolName = true;

mlir/include/mlir/Tools/mlir-lsp-server/MlirLspServerMain.h

 //===- MlirLspServerMain.h - MLIR Language Server main ----------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Main entry function for mlir-lsp-server for when built as standalone binary.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TOOLS_MLIR_LSP_SERVER_MLIRLSPSERVERMAIN_H
 #define MLIR_TOOLS_MLIR_LSP_SERVER_MLIRLSPSERVERMAIN_H
 
+#include "mlir/Support/LLVM.h"
+
 namespace mlir {
 class DialectRegistry;
-struct LogicalResult;
 
 /// Implementation for tools like `mlir-lsp-server`.
 /// - registry should contain all the dialects that can be parsed in source IR
 /// passed to the server.
 LogicalResult MlirLspServerMain(int argc, char **argv,
                                 DialectRegistry &registry);
 
 } // namespace mlir
 
 #endif // MLIR_TOOLS_MLIR_LSP_SERVER_MLIRLSPSERVERMAIN_H

mlir/include/mlir/Tools/mlir-pdll-lsp-server/MlirPdllLspServerMain.h

 //===- MlirPdllLspServerMain.h - MLIR PDLL Language Server main -*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Main entry function for mlir-pdll-lsp-server for when built as standalone
 // binary.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TOOLS_MLIR_PDLL_LSP_SERVER_MLIRPDLLLSPSERVERMAIN_H
 #define MLIR_TOOLS_MLIR_PDLL_LSP_SERVER_MLIRPDLLLSPSERVERMAIN_H
 
+#include "mlir/Support/LLVM.h"
+
 namespace mlir {
-struct LogicalResult;
 
 /// Implementation for tools like `mlir-pdll-lsp-server`.
 LogicalResult MlirPdllLspServerMain(int argc, char **argv);
 
 } // namespace mlir
 
 #endif // MLIR_TOOLS_MLIR_PDLL_LSP_SERVER_MLIRPDLLLSPSERVERMAIN_H

mlir/include/mlir/Tools/mlir-translate/Translation.h

 //===- Translation.h - Translation registry ---------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Registry for user-provided translations.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TOOLS_MLIRTRANSLATE_TRANSLATION_H
 #define MLIR_TOOLS_MLIRTRANSLATE_TRANSLATION_H
 
+#include "mlir/Support/LLVM.h"
 #include "llvm/Support/CommandLine.h"
 
 namespace llvm {
 class MemoryBuffer;
 class SourceMgr;
 class StringRef;
 } // namespace llvm
 
 namespace mlir {
 class DialectRegistry;
-struct LogicalResult;
 class MLIRContext;
 class ModuleOp;
 template <typename OpTy>
 class OwningOpRef;
 
 /// Interface of the function that translates the sources managed by `sourceMgr`
 /// to MLIR. The source manager has at least one buffer. The implementation
 /// should create a new MLIR ModuleOp in the given context and return a pointer

mlir/include/mlir/Tools/tblgen-lsp-server/TableGenLspServerMain.h

 //===- TableGenLSPServerMain.h - TableGen Language Server main --*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Main entry function for tblgen-lsp-server when built as standalone binary.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TOOLS_TBLGENLSPSERVER_TABLEGENLSPSERVERMAIN_H
 #define MLIR_TOOLS_TBLGENLSPSERVER_TABLEGENLSPSERVERMAIN_H
 
+#include "mlir/Support/LLVM.h"
+
 namespace mlir {
-struct LogicalResult;
 
 /// Implementation for tools like `tblgen-lsp-server`.
 LogicalResult TableGenLspServerMain(int argc, char **argv);
 
 } // namespace mlir
 
 #endif // MLIR_TOOLS_TBLGENLSPSERVER_TABLEGENLSPSERVERMAIN_H

mlir/include/mlir/Transforms/LocationSnapshot.h

 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/StringRef.h"
 
 #include <memory>
 
 namespace mlir {
 class Location;
-struct LogicalResult;
 class Operation;
 class OpPrintingFlags;
 class Pass;
 
 /// This function generates new locations from the given IR by snapshotting the
 /// IR to the given stream, and using the printed locations within that stream.
 /// The generated locations replace the current operation locations.
 void generateLocationsFromIR(raw_ostream &os, StringRef fileName, Operation *op,

mlir/lib/Tools/PDLL/Parser/Lexer.h

 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/SMLoc.h"
 
 namespace llvm {
 class SourceMgr;
 } // namespace llvm
 
 namespace mlir {
-struct LogicalResult;
 
 namespace pdll {
 class CodeCompleteContext;
 
 namespace ast {
 class DiagnosticEngine;
 } // namespace ast
 

mlir/lib/Tools/lsp-server-support/Protocol.h

 #include "llvm/Support/raw_ostream.h"
 #include <bitset>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 namespace mlir {
-struct LogicalResult;
 
 namespace lsp {
 
 enum class ErrorCode {
   // Defined by JSON RPC.
   ParseError = -32700,
   InvalidRequest = -32600,
   MethodNotFound = -32601,

mlir/lib/Tools/mlir-lsp-server/LSPServer.h

 //===- LSPServer.h - MLIR LSP Server ----------------------------*- 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 LIB_MLIR_TOOLS_MLIRLSPSERVER_LSPSERVER_H
 #define LIB_MLIR_TOOLS_MLIRLSPSERVER_LSPSERVER_H
 
 #include <memory>
 
+#include "mlir/Support/LLVM.h"
+
 namespace mlir {
-struct LogicalResult;
 
 namespace lsp {
 class JSONTransport;
 class MLIRServer;
 
 /// Run the main loop of the LSP server using the given MLIR server and
 /// transport.
 LogicalResult runMlirLSPServer(MLIRServer &server, JSONTransport &transport);
 } // namespace lsp
 } // namespace mlir
 
 #endif // LIB_MLIR_TOOLS_MLIRLSPSERVER_LSPSERVER_H

mlir/lib/Tools/mlir-pdll-lsp-server/LSPServer.h

 //===- LSPServer.h - PDLL LSP Server ----------------------------*- 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 LIB_MLIR_TOOLS_MLIRPDLLLSPSERVER_LSPSERVER_H
 #define LIB_MLIR_TOOLS_MLIRPDLLLSPSERVER_LSPSERVER_H
 
 #include <memory>
 
+#include "mlir/Support/LLVM.h"
+
 namespace mlir {
-struct LogicalResult;
 
 namespace lsp {
 class JSONTransport;
 class PDLLServer;
 
 /// Run the main loop of the LSP server using the given PDLL server and
 /// transport.
 LogicalResult runPdllLSPServer(PDLLServer &server, JSONTransport &transport);
 
 } // namespace lsp
 } // namespace mlir
 
 #endif // LIB_MLIR_TOOLS_MLIRPDLLLSPSERVER_LSPSERVER_H

mlir/lib/Tools/tblgen-lsp-server/LSPServer.h

 //===- LSPServer.h - TableGen LSP Server ------------------------*- 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 LIB_MLIR_TOOLS_TBLGENLSPSERVER_LSPSERVER_H
 #define LIB_MLIR_TOOLS_TBLGENLSPSERVER_LSPSERVER_H
 
 #include <memory>
 
+#include "mlir/Support/LLVM.h"
+
 namespace mlir {
-struct LogicalResult;
 
 namespace lsp {
 class JSONTransport;
 class TableGenServer;
 
 /// Run the main loop of the LSP server using the given TableGen server and
 /// transport.
 LogicalResult runTableGenLSPServer(TableGenServer &server,
                                    JSONTransport &transport);
 
 } // namespace lsp
 } // namespace mlir
 
 #endif // LIB_MLIR_TOOLS_TBLGENLSPSERVER_LSPSERVER_H

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

deps = [
         ":BufferizationDialect",
         ":BufferizationPassIncGen",
         ":ControlFlowInterfaces",
         ":FuncDialect",
         ":IR",
         ":LoopLikeInterface",
         ":MemRefDialect",
         ":Pass",
+        ":Support",
         ":TensorDialect",
         ":Transforms",
         "//llvm:Support",
     ],
 )
 
 cc_library(
     name = "BufferizationToMemRef",