[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. :)

llvm/trunk/include/llvm/Support/Error.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_ERROR_H
 #define LLVM_SUPPORT_ERROR_H
 
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringExtras.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;
 
+  /// Return the error message as a string.
+  virtual std::string message() const {
+    std::string Msg;
+    raw_string_ostream OS(Msg);
+    log(OS);
+    return Msg;
+  }
+
   /// Convert this error to a std::error_code.
   ///
   /// This is a temporary crutch to enable interaction with code still
   /// using std::error_code. It will be removed in the future.
   virtual std::error_code convertToErrorCode() const = 0;
 
   // Check whether this instance is a subclass of the class identified by
   // ClassID.
if (!E)
     return;
   OS << ErrorBanner;
   handleAllErrors(std::move(E), [&](const ErrorInfoBase &EI) {
     EI.log(OS);
     OS << "\n";
   });
 }
 
+/// Write all error messages (if any) in E to a string. The newline character
+/// is used to separate error messages.
+inline std::string toString(Error E) {
+  SmallVector<std::string, 2> Errors;
+  handleAllErrors(std::move(E), [&Errors](const ErrorInfoBase &EI) {
+    Errors.push_back(EI.message());
+  });
+  return join(Errors.begin(), Errors.end(), "\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) {

llvm/trunk/unittests/Support/ErrorTest.cpp

auto RoundTripped =
       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(toString(Error::success()).compare(""), 0);
+
+  Error E1 = make_error<CustomError>(0);
+  EXPECT_EQ(toString(std::move(E1)).compare("CustomError { 0}"), 0);
+
+  Error E2 = make_error<CustomError>(0);
+  handleAllErrors(std::move(E2), [](const CustomError &CE) {
+    EXPECT_EQ(CE.message().compare("CustomError { 0}"), 0);
+  });
+
+  Error E3 = joinErrors(make_error<CustomError>(0), make_error<CustomError>(1));
+  EXPECT_EQ(toString(std::move(E3))
+                .compare("CustomError { 0}\n"
+                         "CustomError { 1}"),
+            0);
+}
+
 } // end anon namespace