[Support] Add a free toString function for Error

[vsk]

Summary

1. Introduce a toString(Error) function which produces a error string.
2. Add a message() method to ErrorInfoBase with a sensible default implementation.

This should help reduce code duplication and simplify porting code which uses std::error_code.

[lhames]

Hrm. This particular plan sounded better in my head when we were discussing it earlier. My bad.

I like the idea of adding a message() method to ErrorInfoBase so that clients can write something like:

std::string Msg;
handle(std::move(Err),
  [&](ErrorInfoBase &E) {
    Msg = E.message();
  });

And I think it'd be useful to wrap all that up in a free function like 'toString', so that you could write:

std::string Msg = toString(std::move(Err));

However, unless there's a compelling reason not to, I think toString should consume the Error the same way logAllUnhandledErrors does.

The only reason I can think of not to consume the error (but still to log it) is for debugging output:

auto E = canFail(...);
DEBUG(OS << "canFail generated an error: " << toString(E) << "\n");
// ...
// Actually handle or return E.

If we want to support that idiom we should introduce non-consuming variants of both logAllUnhandled and toString for consistency.

[vsk]

Lang and I discusses this off-list and reached the conclusion that it makes more sense to have a *destructive* toString operation on ErrorInfoBase (not Error).

That's because: 1) the whole point of Error is to enforce centralized error handling, and 2) the Error class should just handle ownership -- we already use ErrorInfoBase for log so message really belongs there.

Lang's example of a use-case for a non-destructive toString method is interesting but I haven't run into such a use case in practice. So, we can defer that until it's needed.

[vsk]

• Address Lang's review feedback.

[lhames]

LGTM. Thanks Vedant. :)

include/llvm/Support/Error.h

     return getPtr() != nullptr;
   }
 
   /// Check whether one error is a subclass of another.
   template <typename ErrT> bool isA() const {
     return getPtr() && getPtr()->isA(ErrT::classID());
   }
 
+  /// Get the error message. Uses the log method on all contained instances of
+  /// ErrorInfoBase if this Error is in a failure state, and the empty string
+  /// if the error is in a Success state. This has the same effect on the
+  /// underlying Error as a bool conversion.
+  std::string message() {
+    this->operator bool();
+    std::string Msg;
+    if (getPtr()) {
+      raw_string_ostream OS(Msg);
+      getPtr()->log(OS);
+    }
+    return Msg;
+  }
+
 private:
   void assertIsChecked() {
 #ifndef NDEBUG
     if (!getChecked() || getPtr()) {
       dbgs() << "Program aborted due to an unhandled Error:\n";
       if (getPtr())
         getPtr()->log(dbgs());
       else

unittests/Support/ErrorTest.cpp

       expectedToErrorOr(
           errorOrToExpected(ErrorOr<int>(errc::invalid_argument)));
     EXPECT_EQ(Orig.getError(), RoundTripped.getError())
       << "ErrorOr<T> failure value should round-trip via Expected<T> "
          "conversions.";
   }
 }
 
+// Test that error messages work.
+TEST(Error, ErrorMessage) {
+  EXPECT_EQ(Error::success().message().compare(""), 0);
+
+  auto E = make_error<CustomError>(0);
+  EXPECT_EQ(E.message().compare("CustomError { 0}"), 0);
+  consumeError(std::move(E));
+}
+
 } // end anon namespace