[libc++] Enable the rvalue overloads of operator<< and operator>> even in C++03.

[• Quuxplusone]

Summary

Split out the second part of D104310: eliminating no-longer-needed uses of _LIBCPP_CXX03_LANG.

libcxx/include/istream

             }
         }
 #endif // _LIBCPP_NO_EXCEPTIONS
         __is.setstate(__state);
     }
     return __is;
 }
 
-#ifndef _LIBCPP_CXX03_LANG
-
 template <class _Stream, class _Tp, class = void>
 struct __is_istreamable : false_type { };
 
 template <class _Stream, class _Tp>
 struct __is_istreamable<_Stream, _Tp, decltype(
     declval<_Stream>() >> declval<_Tp>(), void()
 )> : true_type { };
 
 template <class _Stream, class _Tp, class = typename enable_if<
     _And<is_base_of<ios_base, _Stream>,
-         __is_istreamable<_Stream&, _Tp&&>>::value
+         __is_istreamable<_Stream&, _Tp&&> >::value
 >::type>
 _LIBCPP_INLINE_VISIBILITY
 _Stream&& operator>>(_Stream&& __is, _Tp&& __x)
 {
     __is >> _VSTD::forward<_Tp>(__x);
     return _VSTD::move(__is);
 }
 
-#endif // _LIBCPP_CXX03_LANG
-
 template <class _CharT, class _Traits>
 class _LIBCPP_TEMPLATE_VIS basic_iostream
     : public basic_istream<_CharT, _Traits>,
       public basic_ostream<_CharT, _Traits>
 {
 public:
     // types:
     typedef _CharT                         char_type;

libcxx/include/ostream

 inline
 basic_ostream<_CharT, _Traits>&
 flush(basic_ostream<_CharT, _Traits>& __os)
 {
     __os.flush();
     return __os;
 }
 
-#ifndef _LIBCPP_CXX03_LANG
-
 template <class _Stream, class _Tp, class = void>
 struct __is_ostreamable : false_type { };
 
 template <class _Stream, class _Tp>
 struct __is_ostreamable<_Stream, _Tp, decltype(
     declval<_Stream>() << declval<_Tp>(), void()
 )> : true_type { };
 
 template <class _Stream, class _Tp, class = typename enable_if<
     _And<is_base_of<ios_base, _Stream>,
-         __is_ostreamable<_Stream&, const _Tp&>>::value
+         __is_ostreamable<_Stream&, const _Tp&> >::value
 >::type>
 _LIBCPP_INLINE_VISIBILITY
 _Stream&& operator<<(_Stream&& __os, const _Tp& __x)
 {
     __os << __x;
     return _VSTD::move(__os);
 }
 
-#endif // _LIBCPP_CXX03_LANG
-
 template<class _CharT, class _Traits, class _Allocator>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
            const basic_string<_CharT, _Traits, _Allocator>& __str)
 {
     return _VSTD::__put_character_sequence(__os, __str.data(), __str.size());
 }
 

libcxx/test/std/input.output/iostream.format/input.streams/istream.rvalue/not_istreamable.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03
-
 // Make sure the rvalue overload of operator>> isn't part of the overload set
 // when the type is not input streamable from a lvalue stream.
 
 #include <istream>
 #include <utility>
 
 struct Foo { };
 
 using X = decltype(std::declval<std::istream>() >> std::declval<Foo&>()); // expected-error {{invalid operands to binary expression}}
 using Y = decltype(std::declval<std::istream>() >> std::declval<Foo>()); // expected-error {{invalid operands to binary expression}}

libcxx/test/std/input.output/iostream.format/input.streams/istream.rvalue/rvalue.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03
-
 // <istream>
 
 // template <class Stream, class T>
 // Stream&& operator>>(Stream&& is, T&& x);
 
 #include <istream>
 #include <sstream>
 #include <cassert>
int main(int, char**)
         std::wistream&& result = (std::move(is) >> i);
         assert(&result == &is);
         assert(i.value == 123);
     }
     {
         // test perfect forwarding
         assert(called == false);
         std::istringstream ss;
-        std::istringstream&& result = (std::move(ss) >> A{});
+        std::istringstream&& result = (std::move(ss) >> A());
         assert(&result == &ss);
         assert(called);
     }
 
     return 0;
 }

libcxx/test/std/input.output/iostream.format/output.streams/ostream.rvalue/not_ostreamable.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03
-
 // Make sure the rvalue overload of operator<< isn't part of the overload set
 // when the type is not output streamable into a lvalue stream.
 
 #include <ostream>
 #include <utility>
 
 struct Foo { };
 
 using X = decltype(std::declval<std::ostream>() << std::declval<Foo const&>()); // expected-error {{invalid operands to binary expression}}

libcxx/test/std/input.output/iostream.format/output.streams/ostream.rvalue/rvalue.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03
-
 // <ostream>
 
 // template <class Stream, class T>
 // Stream&& operator<<(Stream&& os, const T& x);
 
 #include <ostream>
 #include <cassert>