rvalue stream operators (1203 and 2534)

[zoecarver]

Summary

This patch fixes issues 1203 and 2534. 1203 hasn't been adopted by the standard but was already partially supported. I think it is better to fully support it (which cannot break existing code) rather than remove partial support of it which will remove functionality people may rely on.

[zoecarver]

• update status

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

1

I didn't include a test like this for ostream because I didn't think it would be meaningful (I can if you want though).

[zoecarver]

This may have slipped through the cracks — ping (but no rush).

[mclow.lists]

test/std/input.output/iostream.format/input.streams/istream.rvalue/ios_base_operator_overload_resolution.fail.cpp

32

Instead of std::move(is), you could just use std::istringstream()

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

42

Why A and B here? What's the point of having two different types?
And do A and B have stream insertion operations?

[zoecarver]

• fix based on review

[zoecarver]

Does this look good? I would like to get it committed :)

[zoecarver]

Another ping (@mclow.lists)

[zoecarver]

Resolved by c90dee1 and D96885.

include/istream

 #endif  // _LIBCPP_NO_EXCEPTIONS
         __is.setstate(__state);
     }
     return __is;
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
-template <class _CharT, class _Traits, class _Tp>
+template <class _Stream, class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp&& __x)
+typename enable_if
+<
+    (__has_in_stream_op<_Stream&,  _Tp& >::value ||
+     __has_in_stream_op<_Stream&,  _Tp&&>::value) &&
+    is_base_of<ios_base, _Stream>::value,
+    _Stream&&
+>::type
+operator>>(_Stream&& __is, _Tp&& __x)
 {
     __is >> _VSTD::forward<_Tp>(__x);
-    return __is;
+    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>

include/ostream

 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Stream, class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    !is_lvalue_reference<_Stream>::value &&
+    (__has_out_stream_op<_Stream&,  _Tp&>::value ||
+     __has_out_stream_op<_Stream&&, _Tp&>::value) &&
     is_base_of<ios_base, _Stream>::value,
     _Stream&&
 >::type
 operator<<(_Stream&& __os, const _Tp& __x)
 {
     __os << __x;
     return _VSTD::move(__os);
 }

include/type_traits

 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_lvalue_reference_v
     = is_lvalue_reference<_Tp>::value;
 
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_rvalue_reference_v
     = is_rvalue_reference<_Tp>::value;
 #endif
+
 // is_union
 
 #if __has_feature(is_union) || defined(_LIBCPP_COMPILER_GCC)
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_union
     : public integral_constant<bool, __is_union(_Tp)> {};
 
 #else

 
 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_BUILTIN_IS_CONSTANT_EVALUATED)
 _LIBCPP_INLINE_VISIBILITY
 inline constexpr bool is_constant_evaluated() noexcept {
   return __builtin_is_constant_evaluated();
 }
 #endif
 
+#ifndef _LIBCPP_CXX03_LANG
+// __has_stream_op
+
+template<class _Tp, class _Up>
+struct __has_out_stream_op
+{
+  template<class _T1, class _U1>
+  static auto test(int) -> decltype(declval<_T1>() << declval<_U1>());
+
+  template<class, class>
+  static auto test(...) -> false_type;
+
+  static constexpr bool value = !is_same<false_type, decltype(test<_Tp, _Up>(0))>::value;
+};
+
+template<class _Tp, class _Up>
+struct __has_in_stream_op
+{
+  template<class _T1, class _U1>
+  static auto test(int) -> decltype(declval<_T1>() >> declval<_U1>());
+
+  template<class, class>
+  static auto test(...) -> false_type;
+
+  static constexpr bool value = !is_same<false_type, decltype(test<_Tp, _Up>(0))>::value;
+};
+
+#endif  // _LIBCPP_CXX03_LANG
+
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
 // std::byte
 namespace std  // purposefully not versioned
 {
 template <class _Integer>
   constexpr typename enable_if<is_integral_v<_Integer>, byte>::type &

test/std/input.output/iostream.format/input.streams/istream.rvalue/ios_base_operator_overload_resolution.fail.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++98, c++03
+
+// <istream>
+
+// template <class charT, class traits = char_traits<charT> >
+//   class basic_istream;
+
+// template <class charT, class traits, class T>
+//   basic_ostream<charT, traits>&
+//   operator>>(basic_istream<charT, traits>&& os, const T& x);
+
+// LWG: 2534 and 1203
+
+#include <sstream>
+
+#include "test_macros.h"
+
+struct A {};
+
+int main(int, char**)
+{
+    std::istringstream is;
+    std::move(is) >> A{}; // expected-error-re {{invalid operands to binary expression {{.*}}}}
+
+    return 0;
+}

test/std/input.output/iostream.format/input.streams/istream.rvalue/perfect_forwarding.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++98, c++03
+
+// <istream>
+
+// template <class charT, class traits, class T>
+//   basic_istream<charT, traits>&
+//   operator>>(basic_istream<charT, traits>&& is, T&& x);
+
+#include <istream>
+#include <sstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct A{};
+struct B{};
+
+bool rval = false;
+bool lval = false;
+
+void operator>>(std::istream&, A&&){ rval = true; }
+void operator>>(std::istream&, B& ){ lval = true; }
+
+int main(int, char**)
+{
+    {
+        std::istringstream ss;
+        std::move(ss) >> A{};
+        assert(rval);
+    }
+    {
+        std::istringstream ss;
+        B b;
+        std::move(ss) >> b;
+        assert(lval);
+    }
+
+    return 0;
+}

test/std/input.output/iostream.format/output.streams/ostream.rvalue/ios_base_operator_overload_resolution.fail.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++98, c++03
+
+// <ostream>
+
+// template <class charT, class traits = char_traits<charT> >
+//   class basic_ostream;
+
+// template <class charT, class traits, class T>
+//   basic_ostream<charT, traits>&
+//   operator<<(basic_ostream<charT, traits>&& os, const T& x);
+
+// LWG: 2534 and 1203
+
+#include <sstream>
+
+#include "test_macros.h"
+
+struct A {};
+
+int main(int, char**)
+{
+    std::stringstream os;
+    std::move(os) << A{}; // expected-error-re {{invalid operands to binary expression {{.*}}}}
+
+    return 0;
+}