[Support] raw_ostream << Error&& and formatv(..., Error&&) consume the Error.

[sammccall]

Summary

This makes <<, to_string, and formatv behave like the current llvm::toString (in Error.h).

Because of this, we can unify the behavior of llvm::toString with
llvm::to_string, and deprecate the former.

This patch is an alternative to D49013, I think I prefer this one.

(Currently the strings aren't exactly the same for no good reason. Deprecating toString may not be the right thing to do. Not sure the tests are organized right. I'm flexible on any of these details)

[sammccall]

Remove some noise

[sammccall]

As pointed out on D49013, this doesn't work for formatv, as the behavior is different when printing 0/1/2 times.

This approach could still be used to merge toString/to_string if that's desirable.

include/llvm/Support/Error.h

 ///
 /// 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.
 void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner);
 
 /// Write all error messages (if any) in E to a string. The newline character
 /// is used to separate error messages.
+/// DEPRECATED: prefer llvm::to_string(E) from ScopedPrinter.h
 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) {
   handleAllErrors(std::move(Err), [](const ErrorInfoBase &) {});
 }
 
+/// Sending an rvalue error to a raw_ostream prints its message and consumes it.
+inline raw_ostream &operator<<(raw_ostream &OS, Error &&E) {
+  OS << static_cast<const Error &>(E);
+  consumeError(std::move(E));
+  return OS;
+}
+
 /// Helper for converting an Error to a bool.
 ///
 /// This method returns true if Err is in an error state, or false if it is
 /// in a success state.  Puts Err in a checked state in both cases (unlike
 /// Error::operator bool(), which only does this for success states).
 inline bool errorToBool(Error Err) {
   bool IsError = static_cast<bool>(Err);
   if (IsError)

include/llvm/Support/FormatVariadicDetails.h

 template <typename T>
 class stream_operator_format_adapter : public format_adapter {
   T Item;
 
 public:
   explicit stream_operator_format_adapter(T &&Item)
       : Item(std::forward<T>(Item)) {}
 
-  void format(llvm::raw_ostream &S, StringRef Options) override { S << Item; }
+  void format(llvm::raw_ostream &S, StringRef Options) override {
+    S << std::forward<T>(Item);
+  }
 };
 
 template <typename T> class missing_format_adapter;
 
 // Test if format_provider<T> is defined on T and contains a member function
 // with the signature:
 //   static void format(const T&, raw_stream &, StringRef);
 //

include/llvm/Support/ScopedPrinter.h

struct HexNumber {
   HexNumber(unsigned long Value) : Value(Value) {}
   HexNumber(unsigned long long Value) : Value(Value) {}
   uint64_t Value;
 };
 
 raw_ostream &operator<<(raw_ostream &OS, const HexNumber &Value);
 const std::string to_hexString(uint64_t Value, bool UpperCase = true);
 
-template <class T> const std::string to_string(const T &Value) {
+template <class T> const std::string to_string(T &&Value) {
   std::string number;
   llvm::raw_string_ostream stream(number);
-  stream << Value;
+  stream << std::forward<T>(Value);
   return stream.str();
 }
 
 class ScopedPrinter {
 public:
   ScopedPrinter(raw_ostream &OS) : OS(OS), IndentLevel(0) {}
 
   void flush() { OS.flush(); }

lib/Support/FormatVariadic.cpp

formatv_object_base::parseFormatString(StringRef Fmt) {
   ReplacementItem I;
   while (!Fmt.empty()) {
     std::tie(I, Fmt) = splitLiteralAndReplacement(Fmt);
     if (I.Type != ReplacementType::Empty)
       Replacements.push_back(I);
   }
   return Replacements;
 }
+

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/ADT/Twine.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest-spi.h"
 #include "gtest/gtest.h"
 #include <memory>
 
 using namespace llvm;
 
 namespace {
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);
+  EXPECT_EQ(to_string(Error::success()), "success");
 
-  Error E1 = make_error<CustomError>(0);
-  EXPECT_EQ(toString(std::move(E1)).compare("CustomError {0}"), 0);
+  Error E1A = make_error<CustomError>(0), E1B = make_error<CustomError>(0);
+  EXPECT_EQ(to_string(E1A), "CustomError {0}");
+  EXPECT_EQ(toString(std::move(E1A)).compare("CustomError {0}"), 0);
+  EXPECT_EQ(to_string(std::move(E1B)).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))
+  Error E3A =
+            joinErrors(make_error<CustomError>(0), make_error<CustomError>(1)),
+        E3B =
+            joinErrors(make_error<CustomError>(0), make_error<CustomError>(1));
+  EXPECT_EQ(toString(std::move(E3A))
                 .compare("CustomError {0}\n"
                          "CustomError {1}"),
             0);
+  EXPECT_EQ(to_string(std::move(E3B)),
+            "Multiple errors:\nCustomError {0}\nCustomError {1}\n");
 }
 
 TEST(Error, Stream) {
   {
     Error OK = Error::success();
     std::string Buf;
     llvm::raw_string_ostream S(Buf);
     S << OK;

unittests/Support/FormatVariadicTest.cpp

 //===- FormatVariadicTest.cpp - Unit tests for string formatting ----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/FormatAdapters.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 // Compile-time tests templates in the detail namespace.
 namespace {
 struct Format : public FormatAdapter<int> {

 namespace adl {
 struct X {};
 raw_ostream &operator<<(raw_ostream &OS, const X &) { return OS << "X"; }
 } // namespace adl
 TEST(FormatVariadicTest, FormatStreamable) {
   adl::X X;
   EXPECT_EQ("X", formatv("{0}", X).str());
 }
+
+TEST(FormatVariadicTest, FormatError) {
+  auto E1 = make_error<StringError>("X", inconvertibleErrorCode());
+  EXPECT_EQ("X", formatv("{0}", E1).str());
+  EXPECT_TRUE(E1.isA<StringError>()); // not consumed
+  EXPECT_EQ("X", formatv("{0}", std::move(E1)).str());
+  EXPECT_FALSE(E1.isA<StringError>()); // consumed
+}