[Support] Make support types more easily printable.

[sammccall]

Summary

formatv() can now print objects with a operator<< accepting raw_ostream.
This covers a bunch of new types, and avoids needing a dependency between formatv and the type when no special formatting options are needed.
(Maybe formatv deliberately doesn't do this today?)

Error's new operator<< is the first way to print an error without consuming it, which allows it to work with formatv.

[sammccall]

Simplify approach, just allow printing anything with operator<< as a fallback.
This reduces coupling and makes more types printable (proved useful/necessary for clangd logging refactor).

[sammccall]

Remove noisy changes, add Error test.

[zturner]

unittests/Support/ErrorTest.cpp

733 ↗

(On Diff #154255)

Is the space supposed to be before the 0?

[sammccall]

unittests/Support/ErrorTest.cpp

733 ↗

(On Diff #154255)

Hmm, this was in the existing test helpers but it just looks like a typo. Fixed in various places.

include/llvm/Support/Error.h

#endif
 
   std::unique_ptr<ErrorInfoBase> takePayload() {
     std::unique_ptr<ErrorInfoBase> Tmp(getPtr());
     setPtr(nullptr);
     setChecked(true);
     return Tmp;
   }
 
+  friend raw_ostream &operator<<(raw_ostream &OS, const Error &E) {
+    if (auto P = E.getPtr())
+      P->log(OS);
+    else
+      OS << "success";
+    return OS;
+  }
+
   ErrorInfoBase *Payload = nullptr;
 };
 
 /// Subclass of Error for the sole purpose of identifying the success path in
 /// the type system. This allows to catch invalid conversion to Expected<T> at
 /// compile time.
 class ErrorSuccess : public Error {};
 

include/llvm/Support/FormatProviders.h

while (Begin != End) {
       Stream << Sep;
       auto Adapter =
           detail::build_format_adapter(std::forward<reference>(*Begin));
       Adapter.format(Stream, ArgStyle);
       ++Begin;
     }
   }
 };
-}
+
+} // namespace llvm
 
 #endif

include/llvm/Support/FormatVariadic.h

 //
 //   1. If the parameter is of class type, and inherits from format_adapter,
 //      Then format() is invoked on it to produce the formatted output.  The
 //      implementation should write the formatted text into `Stream`.
 //   2. If there is a suitable template specialization of format_provider<>
 //      for type T containing a method whose signature is:
 //      void format(const T &Obj, raw_ostream &Stream, StringRef Options)
 //      Then this method is invoked as described in Step 1.
+//   3. If an appropriate operator<< for raw_ostream exists, it will be used.
+//      For this to work, (raw_ostream& << const T&) must return raw_ostream&.
 //
 // If a match cannot be found through either of the above methods, a compiler
 // error is generated.
 //
 // ===Invalid Format String Handling===
 //
 // In the case of a format string which does not match the grammar described
 // above, the output is undefined.  With asserts enabled, LLVM will trigger an
 // assertion.  Otherwise, it will try to do something reasonable, but in general
 // the details of what that is are undefined.
 //
 template <typename... Ts>
 inline auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object<decltype(
     std::make_tuple(detail::build_format_adapter(std::forward<Ts>(Vals))...))> {
   using ParamTuple = decltype(
       std::make_tuple(detail::build_format_adapter(std::forward<Ts>(Vals))...));
   return formatv_object<ParamTuple>(
       Fmt,
       std::make_tuple(detail::build_format_adapter(std::forward<Ts>(Vals))...));
 }
 
-// Allow a formatv_object to be formatted (no options supported).
-template <typename T> struct format_provider<formatv_object<T>> {
-  static void format(const formatv_object<T> &V, raw_ostream &OS, StringRef) {
-    OS << V;
-  }
-};
-
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_FORMATVARIADIC_H

include/llvm/Support/FormatVariadicDetails.h

 public:
   explicit provider_format_adapter(T &&Item) : Item(std::forward<T>(Item)) {}
 
   void format(llvm::raw_ostream &S, StringRef Options) override {
     format_provider<typename std::decay<T>::type>::format(Item, S, Options);
   }
 };
 
+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; }
+};
+
 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);
 //
 template <class T> class has_FormatProvider {
 public:
   using Decayed = typename std::decay<T>::type;
   typedef void (*Signature_format)(const Decayed &, llvm::raw_ostream &,
                                    StringRef);
 
   template <typename U>
   static char test(SameType<Signature_format, &U::format> *);
 
   template <typename U> static double test(...);
 
   static bool const value =
       (sizeof(test<llvm::format_provider<Decayed>>(nullptr)) == 1);
 };
 
+// Test if raw_ostream& << T -> raw_ostream& is findable via ADL.
+template <class T> class has_StreamOperator {
+public:
+  using ConstRefT = const typename std::decay<T>::type &;
+
+  template <typename U>
+  static char test(typename std::enable_if<
+                   std::is_same<decltype(std::declval<llvm::raw_ostream &>()
+                                         << std::declval<U>()),
+                                llvm::raw_ostream &>::value,
+                   int *>::type);
+
+  template <typename U> static double test(...);
+
+  static bool const value = (sizeof(test<ConstRefT>(nullptr)) == 1);
+};
+
 // Simple template that decides whether a type T should use the member-function
 // based format() invocation.
 template <typename T>
 struct uses_format_member
     : public std::integral_constant<
           bool,
           std::is_base_of<format_adapter,
                           typename std::remove_reference<T>::type>::value> {};
 
 // Simple template that decides whether a type T should use the format_provider
 // based format() invocation.  The member function takes priority, so this test
 // will only be true if there is not ALSO a format member.
 template <typename T>
 struct uses_format_provider
     : public std::integral_constant<
           bool, !uses_format_member<T>::value && has_FormatProvider<T>::value> {
 };
 
+// Simple template that decides whether a type T should use the operator<<
+// based format() invocation.  This takes last priority.
+template <typename T>
+struct uses_stream_operator
+    : public std::integral_constant<bool, !uses_format_member<T>::value &&
+                                              !uses_format_provider<T>::value &&
+                                              has_StreamOperator<T>::value> {};
+
 // Simple template that decides whether a type T has neither a member-function
 // nor format_provider based implementation that it can use.  Mostly used so
 // that the compiler spits out a nice diagnostic when a type with no format
 // implementation can be located.
 template <typename T>
 struct uses_missing_provider
-    : public std::integral_constant<bool,
-                                    !uses_format_member<T>::value &&
-                                        !uses_format_provider<T>::value> {};
+    : public std::integral_constant<bool, !uses_format_member<T>::value &&
+                                              !uses_format_provider<T>::value &&
+                                              !uses_stream_operator<T>::value> {
+};
 
 template <typename T>
 typename std::enable_if<uses_format_member<T>::value, T>::type
 build_format_adapter(T &&Item) {
   return std::forward<T>(Item);
 }
 
 template <typename T>
 typename std::enable_if<uses_format_provider<T>::value,
                         provider_format_adapter<T>>::type
 build_format_adapter(T &&Item) {
   return provider_format_adapter<T>(std::forward<T>(Item));
 }
 
 template <typename T>
+typename std::enable_if<uses_stream_operator<T>::value,
+                        stream_operator_format_adapter<T>>::type
+build_format_adapter(T &&Item) {
+  return stream_operator_format_adapter<T>(std::forward<T>(Item));
+}
+
+template <typename T>
 typename std::enable_if<uses_missing_provider<T>::value,
                         missing_format_adapter<T>>::type
 build_format_adapter(T &&Item) {
   return missing_format_adapter<T>();
 }
 }
 }
 
 #endif

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> {
TEST(FormatVariadicTest, FormatAdapter) {
   // EXPECT_EQ("Format", formatv("{0}", cvar).str());
 }
 
 TEST(FormatVariadicTest, FormatFormatvObject) {
   EXPECT_EQ("Format", formatv("F{0}t", formatv("o{0}a", "rm")).str());
   EXPECT_EQ("[   ! ]", formatv("[{0,+5}]", formatv("{0,-2}", "!")).str());
 }
 
+TEST(FormatVariadicTest, FormatError) {
+  Error Bad = make_error<StringError>("oh no!", inconvertibleErrorCode());
+  Error OK = Error::success();
+  EXPECT_EQ("oh no!", formatv("{0}", Bad).str());
+  EXPECT_EQ("success", formatv("{0}", OK).str());
+  // formatv takes a const Error&, and does not consume it.
+  consumeError(std::move(Bad));
+  consumeError(std::move(OK));
+}
+
 namespace {
 struct Recorder {
   int Copied = 0, Moved = 0;
   Recorder() = default;
   Recorder(const Recorder &Copy) : Copied(1 + Copy.Copied), Moved(Copy.Moved) {}
   Recorder(const Recorder &&Move)
       : Copied(Move.Copied), Moved(1 + Move.Moved) {}
 };

 TEST(FormatVariadicTest, CopiesAndMoves) {
   Recorder R;
   EXPECT_EQ("0C 0M", formatv("{0}", R).str());
   EXPECT_EQ("0C 3M", formatv("{0}", std::move(R)).str());
   EXPECT_EQ("0C 3M", formatv("{0}", Recorder()).str());
   EXPECT_EQ(0, R.Copied);
   EXPECT_EQ(0, R.Moved);
 }
+
+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());
+}