Fix make_from_tuple when given a tuple containing rvalues

[zoecarver]

Summary

This patch attempts to fix 41643 by providing two __make_from_tuple_impl overloads. I am not sure if this is the best way to implement this (and I especially don't love __is_rvalue_tuple) so I am waiting to update tuple_cat (and possibly others) until this patch gets a green-light.

[jloser]

include/tuple

1386

Do we need specializations for volatile too?

[zoecarver]

include/tuple

1386

Yes, I will add that. There must be a better way to do this...

[EricWF]

As mentioned on llvm.org/PR41643, this isn't a bug in libc++. We implement the standard as specified, and we can't change the required behavior of <tuple> without also changing the standard.

This change cannot proceed.

include/tuple

 inline _LIBCPP_INLINE_VISIBILITY
 constexpr decltype(auto) apply(_Fn && __f, _Tuple && __t)
 _LIBCPP_NOEXCEPT_RETURN(
     _VSTD::__apply_tuple_impl(
         _VSTD::forward<_Fn>(__f), _VSTD::forward<_Tuple>(__t),
         typename __make_tuple_indices<tuple_size_v<remove_reference_t<_Tuple>>>::type{})
 )
 
+template<class>
+struct __is_rvalue_tuple : false_type { };
+
+template<class..._Ts>
+struct __is_rvalue_tuple<tuple<_Ts&&...>> : true_type { };
+
+template<class..._Ts>
+struct __is_rvalue_tuple<tuple<_Ts&&...> &> : true_type { };
+
+template<class..._Ts>
+struct __is_rvalue_tuple<const tuple<_Ts&&...>> : true_type { };
+
+template<class..._Ts>
+struct __is_rvalue_tuple<const tuple<_Ts&&...> &> : true_type { };
+
 template <class _Tp, class _Tuple, size_t... _Idx>
-inline _LIBCPP_INLINE_VISIBILITY
-constexpr _Tp __make_from_tuple_impl(_Tuple&& __t, __tuple_indices<_Idx...>)
+inline _LIBCPP_INLINE_VISIBILITY constexpr
+typename enable_if<__is_rvalue_tuple<_Tuple>::value, _Tp>::type
+__make_from_tuple_impl(_Tuple&& __t, __tuple_indices<_Idx...>)
+_LIBCPP_NOEXCEPT_RETURN(
+    _Tp(_VSTD::move(_VSTD::get<_Idx>(_VSTD::forward<_Tuple>(__t)))...)
+)
+
+template <class _Tp, class _Tuple, size_t... _Idx>
+inline _LIBCPP_INLINE_VISIBILITY constexpr
+typename enable_if<!__is_rvalue_tuple<_Tuple>::value, _Tp>::type
+__make_from_tuple_impl(_Tuple&& __t, __tuple_indices<_Idx...>)
 _LIBCPP_NOEXCEPT_RETURN(
     _Tp(_VSTD::get<_Idx>(_VSTD::forward<_Tuple>(__t))...)
 )
 
 template <class _Tp, class _Tuple>
 inline _LIBCPP_INLINE_VISIBILITY
 constexpr _Tp make_from_tuple(_Tuple&& __t)
 _LIBCPP_NOEXCEPT_RETURN(
-    _VSTD::__make_from_tuple_impl<_Tp>(_VSTD::forward<_Tuple>(__t),
+    __make_from_tuple_impl<_Tp>(_VSTD::forward<_Tuple>(__t),
         typename __make_tuple_indices<tuple_size_v<remove_reference_t<_Tuple>>>::type{})
 )
 
 #undef _LIBCPP_NOEXCEPT_RETURN
 
 #endif // _LIBCPP_STD_VER > 14
 
 #endif // !defined(_LIBCPP_CXX03_LANG)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_TUPLE

test/std/utilities/tuple/tuple.tuple/tuple.apply/make_from_tuple.pass.cpp

// test with array<T, I>
         using Tup = std::array<int, 3>;
         Tup tup = {42, 101, -1};
         Tup const& ctup = tup;
         assert((do_forwarding_test<int&, int&, int&>(tup)));
         assert((do_forwarding_test<int const&, int const&, int const&>(ctup)));
         assert((do_forwarding_test<int&&, int&&, int&&>(std::move(tup))));
         assert((do_forwarding_test<int const&&, int const&&, int const&&>(std::move(ctup))));
     }
+    // test with pair<T&&, T&&>
+    {
+        using Tup = std::tuple<int&&, int&&>;
+        int x = 42;
+        Tup tup(std::move(x), std::move(x));
+        assert((do_forwarding_test<int&&, int&&>(tup)));
+    }
 }
 
 void test_noexcept() {
     struct NothrowMoveable {
       NothrowMoveable() = default;
       NothrowMoveable(NothrowMoveable const&) {}
       NothrowMoveable(NothrowMoveable&&) noexcept {}
     };

 }
 
 int main(int, char**)
 {
     test_constexpr_construction();
     test_perfect_forwarding();
     test_noexcept();
 
     return 0;
 }