TypedError for recoverable error handling

[lhames]

Summary

This patch adds the TypedError scheme that was initially posted on llvm-dev as an [RFC] in early February. It is largely unchanged from the original version, but adds unit tests and preliminary documentation in the programmers manual.

[lhames]

As described in the original RFC (see "Error handling in LLVM libraries." on the llvm-dev mailing list), this patch adds support for an error-handling system tentatively named TypedError. This scheme can be thought of as a hybrid between error returns an exceptions: Errors in the scheme are explicitly represented as return types in the API (like error codes), but error values are structured, user-defined types, similar to c++ exceptions.

The motivation and details of the scheme can be read in the original RFC, my expectation is that this thread will focus on the implementation details.

[dblaikie]

unittests/Support/TypedErrorTest.cpp

247 ↗

(On Diff #49536)

Oh, right, one of the things I was going to suggest is to see if you could make this less indented - since it'll involve potetnially multiple lambdas like this. If the API looked like this instead, the clang-tidy indent would be much less:

Oh, maybe not. Seems there's a special case for a /single/ lambda, like this:

catchAllTypedErrors(std::move(E), [&](std::unique_ptr<CustomError> CE) {
  ...
});

But I can't seem to tickle that formatting to cascade into multiple such lambdas... /maybe/ worth talking to the clang-tidy folks to see if there's a formatting (eg: when any number of trailing arguments are lambdas, to format it like this:

catchAllTypedErrors(std::move(E), [&](std::unique_ptr<CustomSubError> SE) {
  CustomErrorInfo2 = SE->getInfo();
  CustomErrorExtraInfo = SE->getExtraInfo();
  return TypedError();
}, [&](std::unique_ptr<CustomError> CE) {
  // Assert that the CustomError instance above is handled before the
  // CustomSubError - joinTypedErrors should preserve error ordering.
  if (CustomErrorInfo2 != 0)
    abort();
  CustomErrorInfo1 = CE->getInfo();
  return TypedError();
});

& we could try to figure out some way to not need the handleTypedError wrapper.. which might be nice even if we don't get the formatting improvement (less boilerplate is always a win)

[resistor]

Hi Lang,

I want to ask what I feel is an important high-level question here: how does this approach differ, fundamentally, from exceptions, and why should we go down the route of building our own error handling scheme rather than “just” adopting exceptions?

To answer my own question, my impression is that your proposed scheme is functionally similar to exceptions, with the major deviation of being opt-in rather than opt-out. While opt-in is intellectually appealing at first glance, I’m not convinced that it is actually the best solution to some of the problems at play here. In particular, an opt-in scheme will require threading the error-handling type system through many layers of generic and/or boilerplate code in order to allow various callbacks in target backends to report errors properly.

As a concrete example, every backend under the sun has some degree of implicit contract between the backend and the frontend regarding supported IR constructs. This can be as “simple” as ABI lowering and intrinsic names for a typical CPU target, but can be far more complex for targets with non-traditional execution models. In either case, it seems very desirable for the target in the abstract, and instruction selection in particular, to be able to report violations of this contract via the error reporting mechanism. However, to do some in the context of SelectionDAG or FastISel (and I see no particular reason why GlobalISel will be particularly different) would require threading error checking through vast swaths of code both in the instruction selection infrastructure and in the callbacks for the targets themselves. Moreover, instruction selection tends to be a performance sensitive component of the compiler, which argues in favor of exceptions which are, at least notionally, zero-cost.

I’m not claiming here to have a global optimally solution to the problem, and I emphatically do want to see LLVM be better behaved about error handling in general. But it’s not clear to me exactly where the right cost/benefit tradeoff lies in terms of error handling technologies.

—Owen

[lhames]

Gentle ping.

[mehdi_amini]

That's a great patch overall! I enjoyed reading it :)

Please see comments below.

docs/ProgrammersManual.rst

304

Don't you get warning for default with fully-covered switch in this case?

373

make_typed_error is a bit "long" (the "..." here will almost always lead to wrapping (bad for vertical space efficiency).
What about:

return TypedError<FloatingPointError>(...)

The same remark applies to all the API that repeat "TypedError" everywhere (catchTypedError, etc.). Can we at least drop the "typed" part where possible?

include/llvm/Support/TypedError.h

148 ↗

(On Diff #49536)

Could this ctor be expressed in terms of the move assignment operator?

355 ↗

(On Diff #49536)

s/pubilc/public

359 ↗

(On Diff #49536)

I like reading the handle<MyError>(...) but won't it be actually handle<MyError>(...)?

496 ↗

(On Diff #49536)

s/cla/class/

499 ↗

(On Diff #49536)

I assumed you almost copy/pasted the ErrorOr implementation right? Some weirdness here and there but it has been pretty well tested so...

537 ↗

(On Diff #49536)

What do you mean?

554 ↗

(On Diff #49536)

The error storage never needs deletion?
Is it handled differently somehow?

642 ↗

(On Diff #49536)

Doc.

[lhames]

docs/ProgrammersManual.rst

373

So far I've heard general enthusiasm (and no objections) to renaming this class and the utilities to just "Error". I'll re-work the patch - that should cut down on this boilerplate a little.

include/llvm/Support/TypedError.h

148 ↗

(On Diff #49536)

Yes it could. I'll fix that up.

355 ↗

(On Diff #49536)

Good catch.

359 ↗

(On Diff #49536)

I don't follow the question?

If you mean that this syntax is a bit verbose - I agree. I'll see if I can improve this.

499 ↗

(On Diff #49536)

I did. :)

537 ↗

(On Diff #49536)

This comment was copied over from ErrorOr - I think it's stale. I'll get rid of it.

554 ↗

(On Diff #49536)

Oops. This is an omission. ErrorOr doesn't need to delete its error storage because it's just a std::error_code, but TypedErrorOr does. I'll fix that up.

[mehdi_amini]

include/llvm/Support/TypedError.h

359 ↗

(On Diff #49536)

The question was terrible (bad copy/paste). Let me phrase it again:

The doxygen says handle<MyError>(...), but from what I can understand the function prototype below does not match and the code would be handleTypedError<MyError>(...)`.
I like the former more :)

[lhames]

Big readability update:

(1) Main classes / utilities renamed from TypedError -> Error.
(2) Added ErrorHandlerTraits machinery to deduce handler type for handler RTTI checks. This removes the need to wrap handlers in a 'handleTypedError<T>' call.
(3) Rename catch* to handle*.

The new handler idiom is:

handleErrors(std::move(E),
  [](const CustomErrType &EI) {
    // ...
  },
  [](const CustomErrType2 &EI) {
    //...
  },
  ...);

Otherwise the scheme is unchanged from the original patch.

[dblaikie]

docs/ProgrammersManual.rst

419

Indentation

include/llvm/Support/Error.h

350–380

Where's all this get used? Didn't immediately spot any test cases related to member function error handlers.

448–462

Can this not be implemented with a lambda like other handlers? (something about the "appliesTo" functionality?)

617–618

That feels a tad heavyweight & perhaps nicer to do with just a couple of named functions, but I'm not wedded to the notion.

unittests/Support/ErrorTest.cpp

149

Might be worth having a consumeError that takes a non-const ref (lvalue ref) so you don't have to add the std::move. Just to make the tests a bit more terse. Seems easy/handy enough.

182

Is it worth testing named handlers separately from function objects? Is there anything special going on in the implementation that would make these cases different?

258–273

Probably worth bringing this sort of formatting to the attention of djasper and the clang-format folks, see if we can do anything better here

262

why are the error handlers returning errors? (maybe I'll figure this out before I finish reviewing the patch...)

So I see from the docs this is for dynamically unhandled errors - do you have a use case in mind for that already? Could we defer adding it until we do? Might it be worth allowing void returning handlers for the common case of a handler that won't dynamically fail to handle the error?

269–270

Presumably these two lines should be an EXPECT_ or ASSERT_ style macro, rather than an anonymous abort()?

280–288

what's going on witmh the indentation and brace matching here?

321

Test case might be easier to follow if the value returned was not itself another error (to demonstrate that it's entirely independent - maybe a string or unique_ptr<int> if you want a move-only thing, etc)

383–386

You can just roll the contents of the lambda into the EXPECT_DEATH:

EXPECT_DEATH({ Expected<int> A = make_error<CustomError>(42); }, ... );

[lhames]

include/llvm/Support/Error.h

350–380

Lambdas. :)

The six empty specializations are for (in order)

[](ErrT&) mutable { ... }
[](ErrT&) { ... }
[](const ErrT&) mutable { ... }
[](const ErrT&) { ... }
[](std::unique_ptr<ErrT>) mutable { ... }
[](std::unique_ptr<ErrT>) { ... }

I think 90% of lambdas will be of the form 'const ErrT&', and another 9% will be 'std::unique_ptr<ErrT>' (which is useful when you want to modify and "re-throw" an error).

The other combinations - mutable versions of the above, plus the non-const reference versions, were just signatures that I felt would be useful for debugging handlers or error types by adding counters.

448–462

Indeed it can - this is a hangover from the earlier design. I'll remove it.

617–618

This was just yanked over from ErrorOr. I'm not wedded to it either, but it's battle-tested, Since getting the corner cases right for this may be tricky I'd rather change it post-commit once this code has been hammered on a bit.

unittests/Support/ErrorTest.cpp

149

Sounds reasonable. I'll add that.

182

Named handlers are function pointers, whereas lambdas are member functions. These tests are exercising different ErrorHandlerTraits specializations.

258–273

This is actually clang-format output, and I think it gets it right here.

Very short lambdas may get put on the same line, which looks odd - I could suggest that they specialize that.

262

Basically enabling "rethrow"-like functionality. It applies in all the same cases that re-throw would be used.

I think I could add extra ErrorHandlerTraits specializations to detect void handlers and automatically return "Error::success()" into the handleErrors machinery.

269–270

I wasn't sure about how gtest would handle nesting an EXPECT call inside another EXPECT. I'll give it a shot and if nothing explodes I'm happy to switch it over.

280–288

clang-format. :)

Time to file a bug I guess.

321

I'm not sure I follow that.

Error handlers can only return Error (or, if I implement the extension described earlier, void).

383–386

Will do.

[lhames]

Updated with suggested changes from Dave. Most importantly - error handlers can now have 'void' return type, which is equivalent to returning success.

[dblaikie]

Looking pretty good. Tried applying the patch - death tests that check for the specific text of the assertion are not portable as you've written them, because different platforms describe the assertion differently ("Assertion failed: "x"" versus "Assertion x failed"). Maybe just look for the text message you've passed to the assertion, rather than any flavor text around it. Though even that's not /whole/y reliable, of course (up to the implementation what it puts in that message) - but may work on the platforms we care about.

I think the ErrorHandlerTraits + test cases might be able to be simplified/reduced by implementing some more general and orthogonal constructs. If we had a trait for "arguments to a callable" (as is described here: http://stackoverflow.com/questions/21465394/accept-any-kind-of-callable-and-also-know-argument-type ) and then just used std::result_of, we could probably get away from this code having to worry about members V non-members, etc. Might be able to do the unique_ptr versus ref variants just with overloading & decltype to get the return type... it's a bit hand wavy, I realize, but happy to work through it in more detail if you like.

include/llvm/Support/Error.h

493

Drop this?

506

Drop the return here?

unittests/Support/ErrorTest.cpp

291

Drop this?

302

And this?

[mehdi_amini]

unittests/Support/ErrorTest.cpp

407

How does it work with assertions disabled? (alternatively: where is this identified as "requires: assert"?)

To avoid the issue reported by David, you might roll your own "assert" so that you control the exact printed message?

[lhames]

Updated patch should be in shortly.

include/llvm/Support/Error.h

493

Yep.

506

Also yep.

unittests/Support/ErrorTest.cpp

291

Yep.

302

Yep.

407

I'm updating the Error class to disable the 'Checked' bit in Release mode, so I'll wrap all these tests with #ifndef NDEBUG.

[lhames]

Disable the 'Checked' bit on Error in release mode, update death unit-tests accordingly.

Also tidy up some handlers in the unit-test, and fix a test that was relying on implementation specific assertion output.

[lhames]

I think the ErrorHandlerTraits + test cases might be able to be simplified/reduced by implementing some more general and orthogonal constructs. If we had a trait for "arguments to a callable" (as is described here: http://stackoverflow.com/questions/21465394/accept-any-kind-of-callable-and-also-know-argument-type ) and then just used std::result_of, we could probably get away from this code having to worry about members V non-members, etc. Might be able to do the unique_ptr versus ref variants just with overloading & decltype to get the return type... it's a bit hand wavy, I realize, but happy to work through it in more detail if you like.

I think factoring out the argument-matching stuff into a general callable_traits class would be useful, and I'm happy to do it, . I need to do something like that anyway for some improvements I want to make to the RPC API. That said, I think we can do that post commit - I want to take some time to think about the right way to do it, and I don't want to block the people who are waiting for this Error support to land.

[lhames]

Accepted by Dave in mailing list correspondence.

[lhames]

Committed in r263609.

docs/ProgrammersManual.rst

 when defining a function which should be able to efficiently accept concatenated
 strings.
 
+.. _error_apis:
+
+Error handling
+--------------
+
+Proper error handling helps us identify bugs in our code, and helps end-users
+understand errors in their tool usage. Errors fall into two broad categories:
+*programmatic* and *recoverable*, with different strategies for handling and
+reporting.
+
+Programmatic Errors
+^^^^^^^^^^^^^^^^^^^
+
+Programmatic errors are violations of program invariants or API contracts, and
+represent bugs within the program itself. Our aim is to document invariants, and
+to abort quickly at the point of failure (providing some basic diagnostic) when
+invariants are broken at runtime.
+
+The fundamental tools for handling programmatic errors are assertions and the
+llvm_unreachable function. Assertions are used to express invariant conditions,
+and should include a message describing the invariant:
+
+.. code-block:: c++
+
+  assert(isPhysReg(R) && "All virt regs should have been allocated already.");
+
+The llvm_unreachable function can be used to document areas of control flow
+that should never be entered if the program invariants hold:
+
+.. code-block:: c++
+
+  enum { Foo, Bar, Baz } X = foo();
+
+  switch (X) {
+    case Foo: /* Handle Foo */; break;
+    case Bar: /* Handle Bar */; break;
+    default:
+      llvm_unreachable("X should be Foo or Bar here");
+  }
+
+Recoverable Errors
+^^^^^^^^^^^^^^^^^^
+
+Recoverable errors represent an error in the program's environment, for example
+a resource failure (a missing file, a dropped network connection, etc.), or
+malformed input. These errors should be detected and communicated to a level of
+the program where they can be handled appropriately. Handling the error may be
+as simple as reporting the issue to the user, or it may involve attempts at
+recovery.
+
+Recoverable errors are modeled using LLVM's ``Error`` scheme. This scheme
+represents errors using function return values, similar to classic C integer
+error codes, or C++'s ``std::error_code``. However, the ``Error`` class is
+actually a lightweight wrapper for user-defined error types, allowing arbitrary
+information to be attached to describe the error. This is similar to the way C++
+exceptions allow throwing of user-defined types.
+
+Success values are created by calling ``Error::success()``:
+
+.. code-block:: c++
+
+  Error foo() {
+    // Do something.
+    // Return success.
+    return Error::success();
+  }
+
+Success values are very cheap to construct and return - they have minimal
+impact on program performance.
+
+Failure values are constructed using ``make_error<T>``, where ``T`` is any class
+that inherits from the ErrorInfo utility:
+
+.. code-block:: c++
+
+  class MyError : public ErrorInfo<MyError> {
+  public:
+    MyError(std::string Msg) : Msg(Msg) {}
+    void log(OStream &OS) const override { OS << "MyError - " << Msg; }
+  private:
+    std::string Msg;
+  };
+
+  Error bar() {
+    if (checkErrorCondition)
+      return make_error<MyError>("Error condition detected");
+
+    // No error - proceed with bar.
+
+    // Return success value.
+    return Error::success();
+  }
+
+For functions that can fail but need to return a value the ``Expected<T>``
+utility can be used. Values of this type can be constructed with either a
+``T``, or a ``Error``. Values are implicitly convertible to boolean: true
+for success, false for error. If success, the ``T`` value can be accessed via
+the dereference operator. If failure, the ``Error`` value can be extracted
+using the ``takeError()`` method:
+
+.. code-block:: c++
+
+  Expected<float> parseAndSquareRoot(IStream &IS) {
+    float f;
+    OS >> f;
+    if (f < 0)
+      return make_error<FloatingPointError>(...);
+    return sqrt(f);
+  }
+
+  Error foo(IStream &IS) {
+    if (auto SqrtOrErr = parseAndSquartRoot(IS)) {
+      float Sqrt = *SqrtOrErr;
+      // ...
+    } else
+      return SqrtOrErr.takeError();
+  }
+
+All Error instances, whether success or failure, must be either checked or
+moved from (via std::move or a return) before they are destructed. Accidentally
+discarding an unchecked error will cause a program abort at the point where the
+unchecked value's destructor is run, making it easy to identify and fix
+violations of this rule.
+
+Success values are considered checked once they have been tested (by invoking
+the boolean conversion operator):
+
+.. code-block:: c++
+
+  if (auto Err = canFail(...))
+    return Err; // Failure value - move error to caller.
+
+  // Safe to continue: Err was checked.
+
+In contrast, the following code will always cause an abort, regardless of the
+return value of ``foo``:
+
+.. code-block:: c++
+
+    canFail();
+    // Program will always abort here, even if canFail() returns Success, since
+    // the value is not checked.
+
+Failure values are considered checked once a handler for the error type has
+been activated:
+
+.. code-block:: c++
+
+  auto Err = canFail(...);
+  if (auto Err2 =
+       handleErrors(std::move(Err),
+         [](std::unique_ptr<MyError> M) {
+           // Try to handle 'M'. If successful, return a success value from
+           // the handler.
+           if (tryToHandle(M))
+             return Error::success();
+
+           // We failed to handle 'M' - return it from the handler.
+           // This value will be passed back from catchErrors and
+           // wind up in Err2, where it will be returned from this function.
+           return Error(std::move(M));
+         })))
+    return Err2;
+
+
 .. _function_apis:
 
+More information on Error and its related utilities can be found in the
+Error.h header file.
+
 Passing functions and other callable objects
 --------------------------------------------
 

include/llvm/Support/Error.h

+//===----- llvm/Support/Error.h - Recoverable error handling ----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines an API used to report recoverable errors.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_ERROR_H
+#define LLVM_SUPPORT_ERROR_H
+
+#include "llvm/ADT/PointerIntPair.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/raw_ostream.h"
+#include <vector>
+
+namespace llvm {
+
+class Error;
+class ErrorList;
+
+/// Base class for error info classes. Do not extend this directly: Extend
+/// the ErrorInfo template subclass instead.
+class ErrorInfoBase {
+public:
+  virtual ~ErrorInfoBase() {}
+
+  /// Print an error message to an output stream.
+  virtual void log(raw_ostream &OS) const = 0;
+
+  // Check whether this instance is a subclass of the class identified by
+  // ClassID.
+  virtual bool isA(const void *const ClassID) const {
+    return ClassID == classID();
+  }
+
+  // Check whether this instance is a subclass of ErrorInfoT.
+  template <typename ErrorInfoT> bool isA() const {
+    return isA(ErrorInfoT::classID());
+  }
+
+  // Returns the class ID for this type.
+  static const void *classID() { return &ID; }
+
+private:
+  virtual void anchor();
+  static char ID;
+};
+
+/// Lightweight error class with error context and mandatory checking.
+///
+/// Instances of this class wrap a ErrorInfoBase pointer. Failure states
+/// are represented by setting the pointer to a ErrorInfoBase subclass
+/// instance containing information describing the failure. Success is
+/// represented by a null pointer value.
+///
+/// Instances of Error also contains a 'Checked' flag, which must be set
+/// before the destructor is called, otherwise the destructor will trigger a
+/// runtime error. This enforces at runtime the requirement that all Error
+/// instances be checked or returned to the caller.
+///
+/// There are two ways to set the checked flag, depending on what state the
+/// Error instance is in. For Error instances indicating success, it
+/// is sufficient to invoke the boolean conversion operator. E.g.:
+///
+///   Error foo(<...>);
+///
+///   if (auto E = foo(<...>))
+///     return E; // <- Return E if it is in the error state.
+///   // We have verified that E was in the success state. It can now be safely
+///   // destroyed.
+///
+/// A success value *can not* be dropped. For example, just calling 'foo(<...>)'
+/// without testing the return value will raise a runtime error, even if foo
+/// returns success.
+///
+/// For Error instances representing failure, you must use the either the
+/// handleErrors or handleAllErrors function with a typed handler. E.g.:
+///
+///   class MyErrorInfo : public ErrorInfo<MyErrorInfo> {
+///     // Custom error info.
+///   };
+///
+///   Error foo(<...>) { return make_error<MyErrorInfo>(...); }
+///
+///   auto E = foo(<...>); // <- foo returns failure with MyErrorInfo.
+///   auto NewE =
+///     checkErrors(E,
+///       [](const MyErrorInfo &M) {
+///         // Deal with the error.
+///       },
+///       [](std::unique_ptr<OtherError> M) -> Error {
+///         if (canHandle(*M)) {
+///           // handle error.
+///           return Error::success();
+///         }
+///         // Couldn't handle this error instance. Pass it up the stack.
+///         return Error(std::move(M));
+///       );
+///   // Note - we must check or return NewE in case any of the handlers
+///   // returned a new error.
+///
+/// The handleAllErrors function is identical to handleErrors, except
+/// that it has a void return type, and requires all errors to be handled and
+/// no new errors be returned. It prevents errors (assuming they can all be
+/// handled) from having to be bubbled all the way to the top-level.
+///
+/// *All* Error instances must be checked before destruction, even if
+/// they're moved-assigned or constructed from Success values that have already
+/// been checked. This enforces checking through all levels of the call stack.
+class Error {
+
+  // ErrorList needs to be able to yank ErrorInfoBase pointers out of this
+  // class to add to the error list.
+  friend class ErrorList;
+
+  // handleErrors needs to be able to set the Checked flag.
+  template <typename... HandlerTs>
+  friend Error handleErrors(Error E, HandlerTs &&... Handlers);
+
+public:
+  /// Create a success value. Prefer using 'Error::success()' for readability
+  /// where possible.
+  Error() {
+    setPtr(nullptr);
+    setChecked(false);
+  }
+
+  /// Create a success value. This is equivalent to calling the default
+  /// constructor, but should be preferred for readability where possible.
+  static Error success() { return Error(); }
+
+  // Errors are not copy-constructable.
+  Error(const Error &Other) = delete;
+
+  /// Move-construct an error value. The newly constructed error is considered
+  /// unchecked, even if the source error had been checked. The original error
+  /// becomes a checked Success value, regardless of its original state.
+  Error(Error &&Other) {
+    setChecked(true);
+    *this = std::move(Other);
+  }
+
+  /// Create an error value. Prefer using the 'make_error' function, but
+  /// this constructor can be useful when "re-throwing" errors from handlers.
+  Error(std::unique_ptr<ErrorInfoBase> Payload) {
+    setPtr(Payload.release());
+    setChecked(false);
+  }
+
+  // Errors are not copy-assignable.
+  Error &operator=(const Error &Other) = delete;
+
+  /// Move-assign an error value. The current error must represent success, you
+  /// you cannot overwrite an unhandled error. The current error is then
+  /// considered unchecked. The source error becomes a checked success value,
+  /// regardless of its original state.
+  Error &operator=(Error &&Other) {
+    // Move assignment shouldn't drop an existing error, but we won't complain
+    // about overwriting success.
+    assertIsChecked();
+    setPtr(Other.getPtr());
+
+    // This Error is unchecked, even if the source error was checked.
+    setChecked(false);
+
+    // Null out Other's payload and set its checked bit.
+    Other.setPtr(nullptr);
+    Other.setChecked(true);
+
+    return *this;
+  }
+
+  /// Destroy a Error. Fails with a call to abort() if the error is
+  /// unchecked.
+  ~Error() {
+    assertIsChecked();
+    delete getPtr();
+  }
+
+  /// Bool conversion. Returns true if this Error is in a failure state,
+  /// and false if it is in an accept state. If the error is in a Success state
+  /// it will be considered checked.
+  explicit operator bool() {
+    setChecked(getPtr() == nullptr);
+    return getPtr() != nullptr;
+  }
+
+  /// Check whether one error is a subclass of another.
+  template <typename ErrT> bool isA() const {
+    return getPtr()->isA(ErrT::classID());
+  }
+
+private:
+  void assertIsChecked() {
+#ifndef NDEBUG
+    if (!getChecked() || getPtr()) {
+      dbgs() << "Program aborted due to an unhandled Error:\n";
+      if (getPtr())
+        getPtr()->log(dbgs());
+      else
+        dbgs()
+            << "Error value was Success. (Note: Success values must still be "
+               "checked prior to being destroyed).\n";
+      abort();
+    }
+#endif
+  }
+
+  ErrorInfoBase *getPtr() const {
+#ifndef NDEBUG
+    return PayloadAndCheckedBit.getPointer();
+#else
+    return Payload;
+#endif
+  }
+
+  void setPtr(ErrorInfoBase *EI) {
+#ifndef NDEBUG
+    PayloadAndCheckedBit.setPointer(EI);
+#else
+    Payload = EI;
+#endif
+  }
+
+  bool getChecked() const {
+#ifndef NDEBUG
+    return PayloadAndCheckedBit.getInt();
+#else
+    return true;
+#endif
+  }
+
+  void setChecked(bool V) {
+#ifndef NDEBUG
+    PayloadAndCheckedBit.setInt(V);
+#endif
+  }
+
+  std::unique_ptr<ErrorInfoBase> takePayload() {
+    std::unique_ptr<ErrorInfoBase> Tmp(getPtr());
+    setPtr(nullptr);
+    setChecked(true);
+    return Tmp;
+  }
+
+#ifndef NDEBUG
+  PointerIntPair<ErrorInfoBase *, 1> PayloadAndCheckedBit;
+#else
+  ErrorInfoBase *Payload;
+#endif
+};
+
+/// Make a Error instance representing failure using the given error info
+/// type.
+template <typename ErrT, typename... ArgTs> Error make_error(ArgTs &&... Args) {
+  return Error(llvm::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
+}
+
+/// Base class for user error types. Users should declare their error types
+/// like:
+///
+/// class MyError : public ErrorInfo<MyError> {
+///   ....
+/// };
+///
+/// This class provides an implementation of the ErrorInfoBase::kind
+/// method, which is used by the Error RTTI system.
+template <typename ThisErrT, typename ParentErrT = ErrorInfoBase>
+class ErrorInfo : public ParentErrT {
+public:
+  bool isA(const void *const ClassID) const override {
+    return ClassID == classID() || ParentErrT::isA(ClassID);
+  }
+
+  static const void *classID() { return &ID; }
+
+private:
+  static char ID;
+};
+
+template <typename MyErrT, typename ParentErrT>
+char ErrorInfo<MyErrT, ParentErrT>::ID = 0;
+
+/// Special ErrorInfo subclass representing a list of ErrorInfos.
+/// Instances of this class are constructed by joinError.
+class ErrorList final : public ErrorInfo<ErrorList> {
+
+  // handleErrors needs to be able to iterate the payload list of an
+  // ErrorList.
+  template <typename... HandlerTs>
+  friend Error handleErrors(Error E, HandlerTs &&... Handlers);
+
+  // joinErrors is implemented in terms of join.
+  friend Error joinErrors(Error, Error);
+
+public:
+  void log(raw_ostream &OS) const override {
+    OS << "Multiple errors:\n";
+    for (auto &ErrPayload : Payloads) {
+      ErrPayload->log(OS);
+      OS << "\n";
+    }
+  }
+
+private:
+  ErrorList(std::unique_ptr<ErrorInfoBase> Payload1,
+            std::unique_ptr<ErrorInfoBase> Payload2) {
+    assert(!Payload1->isA<ErrorList>() && !Payload2->isA<ErrorList>() &&
+           "ErrorList constructor payloads should be singleton errors");
+    Payloads.push_back(std::move(Payload1));
+    Payloads.push_back(std::move(Payload2));
+  }
+
+  static Error join(Error E1, Error E2) {
+    if (!E1)
+      return E2;
+    if (!E2)
+      return E1;
+    if (E1.isA<ErrorList>()) {
+      auto &E1List = static_cast<ErrorList &>(*E1.getPtr());
+      if (E2.isA<ErrorList>()) {
+        auto &E2List = static_cast<ErrorList &>(*E2.getPtr());
+        for (auto &Payload : E2List.Payloads)
+          E1List.Payloads.push_back(std::move(Payload));
+      } else
+        E1List.Payloads.push_back(E2.takePayload());
+
+      return E1;
+    }
+    if (E2.isA<ErrorList>()) {
+      auto &E2List = static_cast<ErrorList &>(*E2.getPtr());
+      E2List.Payloads.insert(E2List.Payloads.begin(), E1.takePayload());
+      return E2;
+    }
+    return Error(std::unique_ptr<ErrorList>(
+        new ErrorList(E1.takePayload(), E2.takePayload())));
+  }
+
+  std::vector<std::unique_ptr<ErrorInfoBase>> Payloads;
+};
+
+/// Concatenate errors. The resulting Error is unchecked, and contains the
+/// ErrorInfo(s), if any, contained in E1, followed by the
+/// ErrorInfo(s), if any, contained in E2.
+inline Error joinErrors(Error E1, Error E2) {
+  return ErrorList::join(std::move(E1), std::move(E2));
+}
+
+/// Helper for testing applicability of, and applying, handlers for
+/// ErrorInfo types.
+template <typename HandlerT>
+class ErrorHandlerTraits
+    : public ErrorHandlerTraits<decltype(
+          &std::remove_reference<HandlerT>::type::operator())> {};
+
+// Specialization functions of the form 'Error (const ErrT&)'.
+template <typename ErrT> class ErrorHandlerTraits<Error (&)(ErrT &)> {
+public:
+  static bool appliesTo(const ErrorInfoBase &E) {
+    return E.template isA<ErrT>();
+  }
+
+  template <typename HandlerT>
+  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
+    assert(appliesTo(*E) && "Applying incorrect handler");
+    return H(static_cast<ErrT &>(*E));
+  }
+};
+
+// Specialization functions of the form 'void (const ErrT&)'.
+template <typename ErrT> class ErrorHandlerTraits<void (&)(ErrT &)> {
+public:
+  static bool appliesTo(const ErrorInfoBase &E) {
+    return E.template isA<ErrT>();
+  }
+
+  template <typename HandlerT>
+  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
+    assert(appliesTo(*E) && "Applying incorrect handler");
+    H(static_cast<ErrT &>(*E));
+    return Error::success();
+  }
+};
+
+/// Specialization for functions of the form 'Error (std::unique_ptr<ErrT>)'.
+template <typename ErrT>
+class ErrorHandlerTraits<Error (&)(std::unique_ptr<ErrT>)> {
+public:
+  static bool appliesTo(const ErrorInfoBase &E) {
+    return E.template isA<ErrT>();
+  }
+
+  template <typename HandlerT>
+  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
+    assert(appliesTo(*E) && "Applying incorrect handler");
+    std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
+    return H(std::move(SubE));
+  }
+};
+
+/// Specialization for functions of the form 'Error (std::unique_ptr<ErrT>)'.
+template <typename ErrT>
+class ErrorHandlerTraits<void (&)(std::unique_ptr<ErrT>)> {
+public:
+  static bool appliesTo(const ErrorInfoBase &E) {
+    return E.template isA<ErrT>();
+  }
+
+  template <typename HandlerT>
+  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
+    assert(appliesTo(*E) && "Applying incorrect handler");
+    std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
+    H(std::move(SubE));
+    return Error::success();
+  }
+};
+
+// Specialization for member functions of the form 'RetT (const ErrT&)'.
+template <typename C, typename RetT, typename ErrT>
+class ErrorHandlerTraits<RetT (C::*)(ErrT &)>
+    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
+
+// Specialization for member functions of the form 'RetT (const ErrT&) const'.
+template <typename C, typename RetT, typename ErrT>
+class ErrorHandlerTraits<RetT (C::*)(ErrT &) const>
+    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
+
+// Specialization for member functions of the form 'RetT (const ErrT&)'.
+template <typename C, typename RetT, typename ErrT>
+class ErrorHandlerTraits<RetT (C::*)(const ErrT &)>
+    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
+
+// Specialization for member functions of the form 'RetT (const ErrT&) const'.
+template <typename C, typename RetT, typename ErrT>
+class ErrorHandlerTraits<RetT (C::*)(const ErrT &) const>
+    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
+
+/// Specialization for member functions of the form
+/// 'RetT (std::unique_ptr<ErrT>) const'.
+template <typename C, typename RetT, typename ErrT>
+class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>)>
+    : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
+
+/// Specialization for member functions of the form
+/// 'RetT (std::unique_ptr<ErrT>) const'.
+template <typename C, typename RetT, typename ErrT>
+class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>) const>
+    : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
+
+inline Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload) {
+  return Error(std::move(Payload));
+}
+
+template <typename HandlerT, typename... HandlerTs>
+Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload,
+                      HandlerT &&Handler, HandlerTs &&... Handlers) {
+  if (ErrorHandlerTraits<HandlerT>::appliesTo(*Payload))
+    return ErrorHandlerTraits<HandlerT>::apply(std::forward<HandlerT>(Handler),
+                                               std::move(Payload));
+  return handleErrorImpl(std::move(Payload),
+                         std::forward<HandlerTs>(Handlers)...);
+}
+
+/// Pass the ErrorInfo(s) contained in E to their respective handlers. Any
+/// unhandled errors (or Errors returned by handlers) are re-concatenated and
+/// returned.
+/// Because this function returns an error, its result must also be checked
+/// or returned. If you intend to handle all errors use handleAllErrors
+/// (which returns void, and will abort() on unhandled errors) instead.
+template <typename... HandlerTs>
+Error handleErrors(Error E, HandlerTs &&... Hs) {
+  if (!E)
+    return Error::success();
+
+  std::unique_ptr<ErrorInfoBase> Payload = E.takePayload();
+
+  if (Payload->isA<ErrorList>()) {
+    ErrorList &List = static_cast<ErrorList &>(*Payload);
+    Error R;
+    for (auto &P : List.Payloads)
+      R = ErrorList::join(
+          std::move(R),
+          handleErrorImpl(std::move(P), std::forward<HandlerTs>(Hs)...));
+    return R;
+  }
+
+  return handleErrorImpl(std::move(Payload), std::forward<HandlerTs>(Hs)...);
+}
+
+/// Behaves the same as handleErrors, except that it requires that all
+/// errors be handled by the given handlers. If any unhandled error remains
+/// after the handlers have run, abort() will be called.
+template <typename... HandlerTs>
+void handleAllErrors(Error E, HandlerTs &&... Handlers) {
+  auto F = handleErrors(std::move(E), std::forward<HandlerTs>(Handlers)...);
+  // Cast 'F' to bool to set the 'Checked' flag if it's a success value:
+  (void)!F;
+}
+
+/// Check that E is a non-error, then drop it.
+inline void handleAllErrors(Error E) {
+  // Cast 'E' to a bool to set the 'Checked' flag if it's a success value:
+  (void)!E;
+}
+
+/// Log all errors (if any) in E to OS. If there are any errors, ErrorBanner
+/// will be printed before the first one is logged. A newline will be printed
+/// after each error.
+///
+/// This is useful in the base level of your program to allow clean termination
+/// (allowing clean deallocation of resources, etc.), while reporting error
+/// information to the user.
+template <typename... HandlerTs>
+void logAllUnhandledErrors(Error E, raw_ostream &OS, std::string ErrorBanner) {
+  if (!E)
+    return;
+  OS << ErrorBanner;
+  handleAllErrors(std::move(E), [&](const ErrorInfoBase &EI) {
+    EI.log(OS);
+    OS << "\n";
+  });
+}
+
+/// Consume a Error without doing anything. This method should be used
+/// only where an error can be considered a reasonable and expected return
+/// value.
+///
+/// Uses of this method are potentially indicative of design problems: If it's
+/// legitimate to do nothing while processing an "error", the error-producer
+/// might be more clearly refactored to return an Optional<T>.
+inline void consumeError(Error Err) {
+  handleAllErrors(std::move(Err), [](const ErrorInfoBase &) {});
+}
+
+/// Tagged union holding either a T or a Error.
+///
+/// This class parallels ErrorOr, but replaces error_code with Error. Since
+/// Error cannot be copied, this class replaces getError() with
+/// takeError(). It also adds an bool errorIsA<ErrT>() method for testing the
+/// error class type.
+template <class T> class Expected {
+  template <class OtherT> friend class Expected;
+  static const bool isRef = std::is_reference<T>::value;
+  typedef ReferenceStorage<typename std::remove_reference<T>::type> wrap;
+
+public:
+  typedef typename std::conditional<isRef, wrap, T>::type storage_type;
+
+private:
+  typedef typename std::remove_reference<T>::type &reference;
+  typedef const typename std::remove_reference<T>::type &const_reference;
+  typedef typename std::remove_reference<T>::type *pointer;
+  typedef const typename std::remove_reference<T>::type *const_pointer;
+
+public:
+  /// Create an Expected<T> error value from the given Error.
+  Expected(Error Err) : HasError(true) {
+    assert(Err && "Cannot create Expected from Error success value.");
+    new (getErrorStorage()) Error(std::move(Err));
+  }
+
+  /// Create an Expected<T> success value from the given OtherT value, which
+  /// must be convertible to T.
+  template <typename OtherT>
+  Expected(OtherT &&Val,
+           typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
+               * = nullptr)
+      : HasError(false) {
+    new (getStorage()) storage_type(std::move(Val));
+  }
+
+  /// Move construct an Expected<T> value.
+  Expected(Expected &&Other) { moveConstruct(std::move(Other)); }
+
+  /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
+  /// must be convertible to T.
+  template <class OtherT>
+  Expected(Expected<OtherT> &&Other,
+           typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
+               * = nullptr) {
+    moveConstruct(std::move(Other));
+  }
+
+  /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
+  /// isn't convertible to T.
+  template <class OtherT>
+  explicit Expected(
+      Expected<OtherT> &&Other,
+      typename std::enable_if<!std::is_convertible<OtherT, T>::value>::type * =
+          nullptr) {
+    moveConstruct(std::move(Other));
+  }
+
+  /// Move-assign from another Expected<T>.
+  Expected &operator=(Expected &&Other) {
+    moveAssign(std::move(Other));
+    return *this;
+  }
+
+  /// Destroy an Expected<T>.
+  ~Expected() {
+    if (!HasError)
+      getStorage()->~storage_type();
+    else
+      getErrorStorage()->~Error();
+  }
+
+  /// \brief Return false if there is an error.
+  explicit operator bool() const { return !HasError; }
+
+  /// \brief Returns a reference to the stored T value.
+  reference get() { return *getStorage(); }
+
+  /// \brief Returns a const reference to the stored T value.
+  const_reference get() const { return const_cast<Expected<T> *>(this)->get(); }
+
+  /// \brief Check that this Expected<T> is an error of type ErrT.
+  template <typename ErrT> bool errorIsA() const {
+    return HasError && getErrorStorage()->template isA<ErrT>();
+  }
+
+  /// \brief Take ownership of the stored error.
+  /// After calling this the Expected<T> is in an indeterminate state that can
+  /// only be safely destructed. No further calls (beside the destructor) should
+  /// be made on the Expected<T> vaule.
+  Error takeError() {
+    return HasError ? std::move(*getErrorStorage()) : Error();
+  }
+
+  /// \brief Returns a pointer to the stored T value.
+  pointer operator->() { return toPointer(getStorage()); }
+
+  /// \brief Returns a const pointer to the stored T value.
+  const_pointer operator->() const { return toPointer(getStorage()); }
+
+  /// \brief Returns a reference to the stored T value.
+  reference operator*() { return *getStorage(); }
+
+  /// \brief Returns a const reference to the stored T value.
+  const_reference operator*() const { return *getStorage(); }
+
+private:
+  template <class T1>
+  static bool compareThisIfSameType(const T1 &a, const T1 &b) {
+    return &a == &b;
+  }
+
+  template <class T1, class T2>
+  static bool compareThisIfSameType(const T1 &a, const T2 &b) {
+    return false;
+  }
+
+  template <class OtherT> void moveConstruct(Expected<OtherT> &&Other) {
+    if (!Other.HasError) {
+      // Get the other value.
+      HasError = false;
+      new (getStorage()) storage_type(std::move(*Other.getStorage()));
+    } else {
+      // Get other's error.
+      HasError = true;
+      new (getErrorStorage()) Error(Other.takeError());
+    }
+  }
+
+  template <class OtherT> void moveAssign(Expected<OtherT> &&Other) {
+    if (compareThisIfSameType(*this, Other))
+      return;
+
+    this->~Expected();
+    new (this) Expected(std::move(Other));
+  }
+
+  pointer toPointer(pointer Val) { return Val; }
+
+  const_pointer toPointer(const_pointer Val) const { return Val; }
+
+  pointer toPointer(wrap *Val) { return &Val->get(); }
+
+  const_pointer toPointer(const wrap *Val) const { return &Val->get(); }
+
+  storage_type *getStorage() {
+    assert(!HasError && "Cannot get value when an error exists!");
+    return reinterpret_cast<storage_type *>(TStorage.buffer);
+  }
+
+  const storage_type *getStorage() const {
+    assert(!HasError && "Cannot get value when an error exists!");
+    return reinterpret_cast<const storage_type *>(TStorage.buffer);
+  }
+
+  Error *getErrorStorage() {
+    assert(HasError && "Cannot get error when a value exists!");
+    return reinterpret_cast<Error *>(ErrorStorage.buffer);
+  }
+
+  union {
+    AlignedCharArrayUnion<storage_type> TStorage;
+    AlignedCharArrayUnion<Error> ErrorStorage;
+  };
+  bool HasError : 1;
+};
+
+/// This class wraps a std::error_code in a Error.
+///
+/// This is useful if you're writing an interface that returns a Error
+/// (or Expected) and you want to call code that still returns
+/// std::error_codes.
+class ECError : public ErrorInfo<ECError> {
+public:
+  ECError() = default;
+  ECError(std::error_code EC) : EC(EC) {}
+  std::error_code getErrorCode() const { return EC; }
+  void log(raw_ostream &OS) const override { OS << EC.message(); }
+
+protected:
+  std::error_code EC;
+};
+
+/// Helper for converting an std::error_code to a Error.
+inline Error errorCodeToError(std::error_code EC) {
+  if (!EC)
+    return Error::success();
+  return make_error<ECError>(EC);
+}
+
+/// Helper for converting an ECError to a std::error_code.
+///
+/// This method requires that Err be Error() or an ECError, otherwise it
+/// will trigger a call to abort().
+inline std::error_code errorToErrorCode(Error Err) {
+  std::error_code EC;
+  handleAllErrors(std::move(Err),
+                  [&](const ECError &ECE) { EC = ECE.getErrorCode(); });
+  return EC;
+}
+
+} // namespace llvm
+
+#endif // LLVM_SUPPORT_ERROR_H

lib/Support/ErrorHandling.cpp

 #include "llvm/Config/config.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Errc.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/MutexGuard.h"

   remove_fatal_error_handler();
 }
 
+void ErrorInfoBase::anchor() {}
+char ErrorInfoBase::ID = 0;
+
 #ifdef LLVM_ON_WIN32
 
 #include <winerror.h>

unittests/Support/CMakeLists.txt

   DwarfTest.cpp
   EndianStreamTest.cpp
   EndianTest.cpp
+  ErrorTest.cpp
   ErrorOrTest.cpp
   FileOutputBufferTest.cpp
   IteratorTest.cpp

unittests/Support/ErrorTest.cpp

+//===----- unittests/ErrorTest.cpp - Error.h tests ------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/Error.h"
+#include "llvm/Support/Errc.h"
+#include "gtest/gtest.h"
+#include <memory>
+
+using namespace llvm;
+
+namespace {
+
+// Test:
+//
+// Constructing success.
+//   - Silent acceptance of tested success.
+//   - Programmatic error on untested success.
+//
+// Custom error class.
+//   - Creation of a custom error class with a default base class.
+//   - Handling of a custom error class with a default base class.
+//   - Handler type deduction.
+//   - Failure to handle a custom error class.
+//   - Isa testing of a custom error class.
+//
+//   - Creation of a custom error class with a custom base class.
+//   - Handling of a custom error class with a default base class.
+//   - Correct shadowing of handlers.
+//
+// Utility functions:
+//   - join_errors to defer errors.
+//   - consume_error to consume a "safe" error without any output.
+//   - handleAllUnhandledErrors to assert that all errors are handled.
+//   - logAllUnhandledErrors to log errors to a stream.
+//
+// Expected tests:
+//   - Expected<T> with T.
+//   - Expected<T> with Error.
+//   - Failure to handle an Expected<T> in failure mode.
+//   - Error extraction (Expected -> Error).
+//
+// std::error_code:
+//   - std::error_code to Error in success mode.
+//   - std::error_code to Error (ECError) in failure mode.
+//   - Error to std::error_code in success mode.
+//   - Error (ECError) to std::error_code in failure mode.
+
+// Custom error class with a default base class and some random 'info' attached.
+class CustomError : public ErrorInfo<CustomError> {
+public:
+  // Create an error with some info attached.
+  CustomError(int Info) : Info(Info) {}
+
+  // Get the info attached to this error.
+  int getInfo() const { return Info; }
+
+  // Log this error to a stream.
+  void log(raw_ostream &OS) const override {
+    OS << "CustomError { " << getInfo() << "}";
+  }
+
+protected:
+  // This error is subclassed below, but we can't use inheriting constructors
+  // yet, so we can't propagate the constructors through ErrorInfo. Instead
+  // we have to have a default constructor and have the subclass initialize all
+  // fields.
+  CustomError() : Info(0) {}
+
+  int Info;
+};
+
+// Custom error class with a custom base class and some additional random
+// 'info'.
+class CustomSubError : public ErrorInfo<CustomSubError, CustomError> {
+public:
+  // Create a sub-error with some info attached.
+  CustomSubError(int Info, int ExtraInfo) : ExtraInfo(ExtraInfo) {
+    this->Info = Info;
+  }
+
+  // Get the extra info attached to this error.
+  int getExtraInfo() const { return ExtraInfo; }
+
+  // Log this error to a stream.
+  void log(raw_ostream &OS) const override {
+    OS << "CustomSubError { " << getInfo() << ", " << getExtraInfo() << "}";
+  }
+
+protected:
+  int ExtraInfo;
+};
+
+// Verify that success values that are checked (i.e. cast to 'bool') are
+// destructed without error, and that unchecked success values cause an
+// abort.
+TEST(Error, CheckSuccess) {
+  // Test checked success.
+  {
+    Error E;
+    EXPECT_FALSE(E) << "Unexpected error while testing Error 'Success'";
+  }
+
+// Test unchecked success.
+// Test runs in debug mode only.
+#ifndef NDEBUG
+  {
+    auto DropUncheckedSuccess = []() { Error E; };
+    EXPECT_DEATH(DropUncheckedSuccess(),
+                 "Program aborted due to an unhandled Error:")
+        << "Unchecked Error Succes value did not cause abort()";
+  }
+#endif
+}
+
+static Error handleCustomError(const CustomError &CE) { return Error(); }
+
+static void handleCustomErrorVoid(const CustomError &CE) {}
+
+static Error handleCustomErrorUP(std::unique_ptr<CustomError> CE) {
+  return Error();
+}
+
+static void handleCustomErrorUPVoid(std::unique_ptr<CustomError> CE) {}
+
+// Verify creation and handling of custom error classes.
+TEST(Error, CheckCustomErrors) {
+// Check that we abort on unhandled failure cases. (Force conversion to bool
+// to make sure that we don't accidentally treat checked errors as handled).
+// Test runs in debug mode only.
+#ifndef NDEBUG
+  {
+    auto DropUnhandledError = []() {
+      Error E = make_error<CustomError>(42);
+      (void)!E;
+    };
+    EXPECT_DEATH(DropUnhandledError(),
+                 "Program aborted due to an unhandled Error:")
+        << "Unhandled Error failure value did not cause abort()";
+  }
+#endif
+
+  // Check 'isA' handling.
+  {
+    Error E = make_error<CustomError>(1);
+    Error F = make_error<CustomSubError>(1, 2);
+
+    EXPECT_TRUE(E.isA<CustomError>());
+    EXPECT_FALSE(E.isA<CustomSubError>());
+    EXPECT_TRUE(F.isA<CustomError>());
+    EXPECT_TRUE(F.isA<CustomSubError>());
+
+    consumeError(std::move(E));
+    consumeError(std::move(F));
+  }
+
+  // Check that we can handle a custom error.
+  {
+    int CaughtErrorInfo = 0;
+    handleAllErrors(make_error<CustomError>(42), [&](const CustomError &CE) {
+      CaughtErrorInfo = CE.getInfo();
+    });
+
+    EXPECT_TRUE(CaughtErrorInfo == 42)
+        << "Wrong result from CustomError handler";
+  }
+
+  // Check that handler type deduction also works for handlers
+  // of the following types:
+  // void (const Err&)
+  // Error (const Err&) mutable
+  // void (const Err&) mutable
+  // Error (Err&)
+  // void (Err&)
+  // Error (Err&) mutable
+  // void (Err&) mutable
+  // Error (unique_ptr<Err>)
+  // void (unique_ptr<Err>)
+  // Error (unique_ptr<Err>) mutable
+  // void (unique_ptr<Err>) mutable
+
+  handleAllErrors(make_error<CustomError>(42), [](const CustomError &CE) {});
+
+  handleAllErrors(
+      make_error<CustomError>(42),
+      [](const CustomError &CE) mutable { return Error::success(); });
+
+  handleAllErrors(make_error<CustomError>(42),
+                  [](const CustomError &CE) mutable {});
+
+  handleAllErrors(make_error<CustomError>(42),
+                  [](CustomError &CE) { return Error::success(); });
+
+  handleAllErrors(make_error<CustomError>(42), [](CustomError &CE) {});
+
+  handleAllErrors(make_error<CustomError>(42),
+                  [](CustomError &CE) mutable { return Error::success(); });
+
+  handleAllErrors(make_error<CustomError>(42), [](CustomError &CE) mutable {});
+
+  handleAllErrors(
+      make_error<CustomError>(42),
+      [](std::unique_ptr<CustomError> CE) { return Error::success(); });
+
+  handleAllErrors(make_error<CustomError>(42),
+                  [](std::unique_ptr<CustomError> CE) {});
+
+  handleAllErrors(
+      make_error<CustomError>(42),
+      [](std::unique_ptr<CustomError> CE) mutable { return Error::success(); });
+
+  handleAllErrors(make_error<CustomError>(42),
+                  [](std::unique_ptr<CustomError> CE) mutable {});
+
+  // Check that named handlers of type 'Error (const Err&)' work.
+  handleAllErrors(make_error<CustomError>(42), handleCustomError);
+
+  // Check that named handlers of type 'void (const Err&)' work.
+  handleAllErrors(make_error<CustomError>(42), handleCustomErrorVoid);
+
+  // Check that named handlers of type 'Error (std::unique_ptr<Err>)' work.
+  handleAllErrors(make_error<CustomError>(42), handleCustomErrorUP);
+
+  // Check that named handlers of type 'Error (std::unique_ptr<Err>)' work.
+  handleAllErrors(make_error<CustomError>(42), handleCustomErrorUPVoid);
+
+  // Check that we can handle a custom error with a custom base class.
+  {
+    int CaughtErrorInfo = 0;
+    int CaughtErrorExtraInfo = 0;
+    handleAllErrors(make_error<CustomSubError>(42, 7),
+                    [&](const CustomSubError &SE) {
+                      CaughtErrorInfo = SE.getInfo();
+                      CaughtErrorExtraInfo = SE.getExtraInfo();
+                    });
+
+    EXPECT_TRUE(CaughtErrorInfo == 42 && CaughtErrorExtraInfo == 7)
+        << "Wrong result from CustomSubError handler";
+  }
+
+  // Check that we trigger only the first handler that applies.
+  {
+    int DummyInfo = 0;
+    int CaughtErrorInfo = 0;
+    int CaughtErrorExtraInfo = 0;
+
+    handleAllErrors(make_error<CustomSubError>(42, 7),
+                    [&](const CustomSubError &SE) {
+                      CaughtErrorInfo = SE.getInfo();
+                      CaughtErrorExtraInfo = SE.getExtraInfo();
+                    },
+                    [&](const CustomError &CE) { DummyInfo = CE.getInfo(); });
+
+    EXPECT_TRUE(CaughtErrorInfo == 42 && CaughtErrorExtraInfo == 7 &&
+                DummyInfo == 0)
+        << "Activated the wrong Error handler(s)";
+  }
+
+  // Check that general handlers shadow specific ones.
+  {
+    int CaughtErrorInfo = 0;
+    int DummyInfo = 0;
+    int DummyExtraInfo = 0;
+
+    handleAllErrors(
+        make_error<CustomSubError>(42, 7),
+        [&](const CustomError &CE) { CaughtErrorInfo = CE.getInfo(); },
+        [&](const CustomSubError &SE) {
+          DummyInfo = SE.getInfo();
+          DummyExtraInfo = SE.getExtraInfo();
+        });
+
+    EXPECT_TRUE(CaughtErrorInfo = 42 && DummyInfo == 0 && DummyExtraInfo == 0)
+        << "General Error handler did not shadow specific handler";
+  }
+}
+
+// Test utility functions.
+TEST(Error, CheckErrorUtilities) {
+
+  // Test joinErrors
+  {
+    int CustomErrorInfo1 = 0;
+    int CustomErrorInfo2 = 0;
+    int CustomErrorExtraInfo = 0;
+    Error E = joinErrors(make_error<CustomError>(7),
+                         make_error<CustomSubError>(42, 7));
+
+    handleAllErrors(std::move(E),
+                    [&](const CustomSubError &SE) {
+                      CustomErrorInfo2 = SE.getInfo();
+                      CustomErrorExtraInfo = SE.getExtraInfo();
+                    },
+                    [&](const CustomError &CE) {
+                      // Assert that the CustomError instance above is handled
+                      // before the
+                      // CustomSubError - joinErrors should preserve error
+                      // ordering.
+                      EXPECT_EQ(CustomErrorInfo2, 0)
+                          << "CustomErrorInfo2 should be 0 here. "
+                             "joinErrors failed to preserve ordering.\n";
+                      CustomErrorInfo1 = CE.getInfo();
+                    });
+
+    EXPECT_TRUE(CustomErrorInfo1 == 7 && CustomErrorInfo2 == 42 &&
+                CustomErrorExtraInfo == 7)
+        << "Failed handling compound Error.";
+  }
+
+  // Test consumeError for both success and error cases.
+  {
+    Error E;
+    consumeError(std::move(E));
+  }
+  {
+    Error E = make_error<CustomError>(7);
+    consumeError(std::move(E));
+  }
+
+// Test that handleAllUnhandledErrors crashes if an error is not caught.
+// Test runs in debug mode only.
+#ifndef NDEBUG
+  {
+    auto FailToHandle = []() {
+      handleAllErrors(make_error<CustomError>(7),
+                      [&](const CustomSubError &SE) {
+                        errs() << "This should never be called";
+                        exit(1);
+                      });
+    };
+
+    EXPECT_DEATH(FailToHandle(), "Program aborted due to an unhandled Error:")
+        << "Unhandled Error in handleAllErrors call did not cause an "
+           "abort()";
+  }
+#endif
+
+// Test that handleAllUnhandledErrors crashes if an error is returned from a
+// handler.
+// Test runs in debug mode only.
+#ifndef NDEBUG
+  {
+    auto ReturnErrorFromHandler = []() {
+      handleAllErrors(make_error<CustomError>(7),
+                      [&](std::unique_ptr<CustomSubError> SE) {
+                        return Error(std::move(SE));
+                      });
+    };
+
+    EXPECT_DEATH(ReturnErrorFromHandler(),
+                 "Program aborted due to an unhandled Error:")
+        << " Error returned from handler in handleAllErrors call did not "
+           "cause abort()";
+  }
+#endif
+
+  // Test that we can return values from handleErrors.
+  {
+    int ErrorInfo = 0;
+
+    Error E = handleErrors(
+        make_error<CustomError>(7),
+        [&](std::unique_ptr<CustomError> CE) { return Error(std::move(CE)); });
+
+    handleAllErrors(std::move(E),
+                    [&](const CustomError &CE) { ErrorInfo = CE.getInfo(); });
+
+    EXPECT_EQ(ErrorInfo, 7)
+        << "Failed to handle Error returned from handleErrors.";
+  }
+}
+
+// Test Expected behavior.
+TEST(Error, CheckExpected) {
+
+  // Check that non-errors convert to 'true'.
+  {
+    Expected<int> A = 7;
+    EXPECT_TRUE(!!A)
+        << "Expected with non-error value doesn't convert to 'true'";
+  }
+
+  // Check that non-error values are accessible via operator*.
+  {
+    Expected<int> A = 7;
+    EXPECT_EQ(*A, 7) << "Incorrect Expected non-error value";
+  }
+
+  // Check that errors convert to 'false'.
+  {
+    Expected<int> A = make_error<CustomError>(42);
+    EXPECT_FALSE(!!A) << "Expected with error value doesn't convert to 'false'";
+    consumeError(A.takeError());
+  }
+
+  // Check that error values are accessible via takeError().
+  {
+    Expected<int> A = make_error<CustomError>(42);
+    Error E = A.takeError();
+    EXPECT_TRUE(E.isA<CustomError>()) << "Incorrect Expected error value";
+    consumeError(std::move(E));
+  }
+
+// Check that an Expected instance with an error value doesn't allow access to
+// operator*.
+// Test runs in debug mode only.
+#ifndef NDEBUG
+  {
+    Expected<int> A = make_error<CustomError>(42);
+    EXPECT_DEATH(*A, "\\(!HasError && \"Cannot get value "
+                     "when an error exists!\"\\)")
+        << "Incorrect Expected error value";
+    consumeError(A.takeError());
+  }
+#endif
+
+// Check that an Expected instance with an error triggers an abort if
+// unhandled.
+// Test runs in debug mode only.
+#ifndef NDEBUG
+  EXPECT_DEATH({ Expected<int> A = make_error<CustomError>(42); },
+               "Program aborted due to an unhandled Error:")
+      << "Unchecked Expected<T> failure value did not cause an abort()";
+#endif
+
+  // Test covariance of Expected.
+  {
+    class B {};
+    class D : public B {};
+
+    Expected<B *> A1(Expected<D *>(nullptr));
+    A1 = Expected<D *>(nullptr);
+
+    Expected<std::unique_ptr<B>> A2(Expected<std::unique_ptr<D>>(nullptr));
+    A2 = Expected<std::unique_ptr<D>>(nullptr);
+  }
+}
+
+TEST(Error, ECError) {
+
+  // Round-trip a success value to check that it converts correctly.
+  EXPECT_EQ(errorToErrorCode(errorCodeToError(std::error_code())),
+            std::error_code())
+      << "std::error_code() should round-trip via Error conversions";
+
+  // Round-trip an error value to check that it converts correctly.
+  EXPECT_EQ(errorToErrorCode(errorCodeToError(errc::invalid_argument)),
+            errc::invalid_argument)
+      << "std::error_code error value should round-trip via Error "
+         "conversions";
+}
+
+} // end anon namespace