Implement LWG#1203 for raw_ostream

[csigg]

Summary

Implement LWG#1203 (https://cplusplus.github.io/LWG/issue1203) for raw_ostream like libc++ does for std::basic_ostream<...>.

Add a operator<< overload that takes an rvalue reference of a typed derived from raw_ostream, streams the value to it and returns the stream of the same type as the argument.

This allows free operator<< to work with rvalue reference raw_ostreams:
raw_ostream& operator<<(raw_ostream&, const SomeType& Value);
raw_os_ostream(std::cout) << SomeType();

It also allows using the derived type like:
auto Foo = (raw_string_ostream(buffer) << "foo").str();

[timshen]

llvm/include/llvm/Support/raw_ostream.h

361

std::is_lvalue_reference -> std::is_reference? The semantics is the same (since OStream can never by an rvalue reference), but the spelling is shorter.

[csigg]

Changed is_lvalue_reference to is_reference

[csigg]

Could someone please merge the latest revision?

(I'm not impatient. The phabricator docs suggests that I ask for this. This is my first PR to LLVM, let me know if I'm off.)

llvm/include/llvm/Support/raw_ostream.h

 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <string>
 #include <system_error>
+#include <type_traits>
 
 namespace llvm {
 
 class formatv_object_base;
 class format_object_base;
 class FormattedString;
 class FormattedNumber;
 class FormattedBytes;
private:
 
   /// Copy data into the buffer. Size must not be greater than the number of
   /// unused bytes in the buffer.
   void copy_to_buffer(const char *Ptr, size_t Size);
 
   virtual void anchor();
 };
 
+/// Call the appropriate insertion operator, given an rvalue reference to a
+/// raw_ostream object and return a stream of the same type as the argument.
+template <typename OStream, typename T>
+typename std::enable_if<!std::is_reference<OStream>::value &&
+                            std::is_base_of<raw_ostream, OStream>::value,
+                        OStream &&>::type
+operator<<(OStream &&OS, const T &Value) {
+  OS << Value;
+  return std::move(OS);
+}
+
 /// An abstract base class for streams implementations that also support a
 /// pwrite operation. This is useful for code that can mostly stream out data,
 /// but needs to patch in a header that needs to know the output size.
 class raw_pwrite_stream : public raw_ostream {
   virtual void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) = 0;
   void anchor() override;
 
 public:

llvm/unittests/Support/raw_ostream_test.cpp

 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
 template<typename T> std::string printToString(const T &Value) {
   std::string res;
-  llvm::raw_string_ostream(res) << Value;
-  return res;    
+  return (llvm::raw_string_ostream(res) << Value).str();
 }
 
 /// printToString - Print the given value to a stream which only has \arg
 /// BytesLeftInBuffer bytes left in the buffer. This is useful for testing edge
 /// cases in the buffer handling logic.
 template<typename T> std::string printToString(const T &Value,
                                                unsigned BytesLeftInBuffer) {
   // FIXME: This is relying on internal knowledge of how raw_ostream works to

 template<typename T> std::string printToStringUnbuffered(const T &Value) {
   std::string res;
   llvm::raw_string_ostream OS(res);
   OS.SetUnbuffered();
   OS << Value;
   return res;
 }
 
+struct X {};
+
+raw_ostream &operator<<(raw_ostream &OS, const X &) { return OS << 'X'; }
+
 TEST(raw_ostreamTest, Types_Buffered) {
   // Char
   EXPECT_EQ("c", printToString('c'));
 
   // String
   EXPECT_EQ("hello", printToString("hello"));
   EXPECT_EQ("hello", printToString(std::string("hello")));
 
TEST(raw_ostreamTest, Types_Buffered) {
   // void*
   EXPECT_EQ("0x0", printToString((void*) nullptr));
   EXPECT_EQ("0xbeef", printToString((void*) 0xbeefLL));
   EXPECT_EQ("0xdeadbeef", printToString((void*) 0xdeadbeefLL));
 
   // Min and max.
   EXPECT_EQ("18446744073709551615", printToString(UINT64_MAX));
   EXPECT_EQ("-9223372036854775808", printToString(INT64_MIN));
+
+  // X, checking free operator<<().
+  EXPECT_EQ("X", printToString(X{}));
 }
 
 TEST(raw_ostreamTest, Types_Unbuffered) {  
   // Char
   EXPECT_EQ("c", printToStringUnbuffered('c'));
 
   // String
   EXPECT_EQ("hello", printToStringUnbuffered("hello"));
TEST(raw_ostreamTest, Types_Unbuffered) {
   // void*
   EXPECT_EQ("0x0", printToStringUnbuffered((void*) nullptr));
   EXPECT_EQ("0xbeef", printToStringUnbuffered((void*) 0xbeefLL));
   EXPECT_EQ("0xdeadbeef", printToStringUnbuffered((void*) 0xdeadbeefLL));
 
   // Min and max.
   EXPECT_EQ("18446744073709551615", printToStringUnbuffered(UINT64_MAX));
   EXPECT_EQ("-9223372036854775808", printToStringUnbuffered(INT64_MIN));
+
+  // X, checking free operator<<().
+  EXPECT_EQ("X", printToString(X{}));
 }
 
 TEST(raw_ostreamTest, BufferEdge) {  
   EXPECT_EQ("1.20", printToString(format("%.2f", 1.2), 1));
   EXPECT_EQ("1.20", printToString(format("%.2f", 1.2), 2));
   EXPECT_EQ("1.20", printToString(format("%.2f", 1.2), 3));
   EXPECT_EQ("1.20", printToString(format("%.2f", 1.2), 4));
   EXPECT_EQ("1.20", printToString(format("%.2f", 1.2), 10));