[libc++] Fix tuple assignment from types derived from a tuple-like

[ldionne]

Summary

The implementation of tuple's constructors and assignment operators
currently diverges from the way the Standard specifies them, which leads
to subtle cases where the behavior is not as specified. In particular, a
class derived from a tuple-like type (e.g. pair) can't be assigned to a
tuple with corresponding members, when it should. This commit re-implements
the assignment operators (BUT NOT THE CONSTRUCTORS) in a way much closer
to the specification to get rid of this bug. Most of the tests have been
stolen from Eric's patch https://reviews.llvm.org/D27606.

As a fly-by improvement, tests for noexcept correctness have been added
to all overloads of operator=. We should tackle the same issue for the
tuple constructors in a future patch - I'm just trying to make progress
on fixing this long-standing bug.

PR17550
rdar://15837420

[ldionne]

Ping! It would be nice to land this in LLVM 8

[EricWF]

Our constructors still have the same bug,. Are you planning on fixing those as well? Doing so will require a metric butt-tonne of overloads.
If you're not planning on fixing the constructors, then can you explain why it's better that we're inconsistent?

Otherwises, this patch looks mostly OK. However, it makes a bunch of previously lazy SFINAE eager. Here are some tests:
https://gist.github.com/EricWF/88ceadf2bcdeef9f9d268b3a743dcd04

Is there a reason we can't use __tuple_assignable anymore?

[ldionne]

In D50106#1352469, @EricWF wrote:

Our constructors still have the same bug,. Are you planning on fixing those as well? Doing so will require a metric butt-tonne of overloads.
If you're not planning on fixing the constructors, then can you explain why it's better that we're inconsistent?

We should fix the constructors too, but one thing at a time. We should have the 18 constructors that are mandated by the Standard, I think.

Yes, I hate that.

Otherwises, this patch looks mostly OK. However, it makes a bunch of previously lazy SFINAE eager. Here are some tests:
https://gist.github.com/EricWF/88ceadf2bcdeef9f9d268b3a743dcd04

Good catch! Genuine question: In the Standard, we say in http://eel.is/c++draft/tuple.assign#10 (for tuple<Types...>::operator=(tuple<UTypes...> const&)):

Remarks: This operator shall not participate in overload resolution unless sizeof...(Types) == sizeof...(UTypes) and is_­assignable_­v<Ti&, Ui const&> is true for all i.

This makes me wonder whether short-circuiting is mandated by the Standard. It certainly is a good QOI property to have it, but it's not clear to me this is required. WDYT?

Is there a reason we can't use __tuple_assignable anymore?

We're not using __tuple_types, but there's no fundamental reason for that. I found it easier to have the logic inline. I do think we need to get back the short-circuiting behaviour that was there before (using your insanely clever SFINAE trick for left-to-right evaluation in a parameter pack expansion).

[ldionne]

Fix issues with the laziness of how we evaluate type traits

[ldionne]

Fix segfault on GCC and a few incorrect checks in the type traits.

I reduced the GCC segfault and it appears to have been fixed on GCC trunk, so
I won't be filing a bug report.

[• Quuxplusone]

libcxx/include/tuple

432

Your friendly neighborhood ADL hater says: _VSTD::__swallow plz
(and line 438)
(and maybe int() is a sillier-than-necessary way to write 0?)

891

Your friendly neighborhood ADL hater says: _VSTD:: plz
(and line 900)
(and line 931)
(and line 986)
(and line 1002)

[ldionne]

Fix build on GCC (or at least I think it should)

[ldionne]

Address Arthur's comments.

[ldionne]

Fix GCC issues. I swear I had done the same fix locally previously, but I must
have messed something up with Git or arc diff.

[• Quuxplusone]

Suggested some ways to improve test coverage, and continued bikeshedding on the SFINAE ;) but there's no reason to hold this up AFAIC.

libcxx/include/tuple

58

Since this already isn't mimicking the syntax of http://eel.is/c++draft/tuple.tuple#tuple.assign-1 , I think you should say

tuple& operator=(tuple&&) noexcept(is_nothrow_move_assignable_v<T> && ...);

but it definitely doesn't matter.

975

Perhaps in a followup patch: could we delineate exactly what code is part of this extension and put it all under an #if _LIBCPP_TUPLE_ARRAY_ASSIGNMENT or something, such that we could say "this is the exact extent of the extension code" and maybe even get customers to try compiling with -D_LIBCPP_TUPLE_ARRAY_ASSIGNMENT=0 to see what breaks?

I'm assuming that our goal here is to deprecate and remove this extension over time. But even if we support it forever, I think #if would be nicer than the //EXTENSION comments.

992

Nitpick: Sent you a Slack suggesting how to eliminate this class = void.

libcxx/test/libcxx/utilities/tuple/tuple.tuple/tuple.assign/const_array.pass.cpp

53 ↗

(On Diff #325039)

I would like to see this file combined with rvalue_array.pass.cpp, and also test the currently missing two value categories:

static_assert(std::is_nothrow_assignable<Tuple&, Array&>::value, "");
static_assert(std::is_nothrow_assignable<Tuple&, const Array&&>::value, "");

and also the negative cases:

static_assert(!std::is_assignable<Tuple&, std::array<long,2>&>::value, "");
static_assert(!std::is_assignable<Tuple&, std::array<long,2>&&>::value, "");
static_assert(!std::is_assignable<Tuple&, const std::array<long,2>&>::value, "");
static_assert(!std::is_assignable<Tuple&, const std::array<long,2>&&>::value, "");

static_assert(!std::is_assignable<Tuple&, std::array<long,4>&>::value, "");
static_assert(!std::is_assignable<Tuple&, std::array<long,4>&&>::value, "");
static_assert(!std::is_assignable<Tuple&, const std::array<long,4>&>::value, "");
static_assert(!std::is_assignable<Tuple&, const std::array<long,4>&&>::value, "");

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/const_pair.pass.cpp

52

Don't just test for lack-of-nothrow-assignability; test for assignability-but-maythrow:

static_assert(std::is_assignable<Tuple&, Pair const&>::value, "");
static_assert(!std::is_nothrow_assignable<Tuple&, Pair const&>::value, "");

And as above, I'd prefer to see tests for Pair& and Pair&& and const Pair&& as well.

[• Quuxplusone]

libcxx/include/tuple

971

Oh, late-breaking nit: I would prefer to see ... = static_cast<_Up1&&>(__pair.first); here, because _Up1 is not being deduced according to forwarding-reference rules, and thus shouldn't be "forwarded." Pragmatically I think forward<_Up1> ends up doing the right thing in all cases... but I don't think it's appropriate here. (Plus, we save one function template instantiation by omitting it!)

[ldionne]

Address Arthur's comments.

[ldionne]

I think we should be pretty much good to go now. Will let CI run just in case.

libcxx/include/tuple

971

It actually occurs to me that we should really be using _VSTD::move(__pair.first) since we're taking a rvalue reference to the pair as an argument. I'll change it to that, please LMK if you disagree.

975

The goal is to remove the extension shortly after.

992

Replied there. The short story is that I used class = void to workaround the GCC segfaults I was seeing on the bots.

[ldionne]

Rebase onto main.

libcxx/include/tuple

public:
     template <class Alloc, class... U>
         explicit(see-below) tuple(allocator_arg_t, const Alloc& a, tuple<U...>&&);
     template <class Alloc, class U1, class U2>
         explicit(see-below) tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
     template <class Alloc, class U1, class U2>
         explicit(see-below) tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);
 
     tuple& operator=(const tuple&);
-    tuple&
-        operator=(tuple&&) noexcept(AND(is_nothrow_move_assignable<T>::value ...));
+    tuple& operator=(tuple&&) noexcept(is_nothrow_move_assignable_v<T> && ...);
     template <class... U>
         tuple& operator=(const tuple<U...>&);
     template <class... U>
         tuple& operator=(tuple<U...>&&);
     template <class U1, class U2>
         tuple& operator=(const pair<U1, U2>&); // iff sizeof...(T) == 2
     template <class U1, class U2>
         tuple& operator=(pair<U1, U2>&&); // iff sizeof...(T) == 2
 
+    template<class U, size_t N>
+        tuple& operator=(array<U, N> const&) // iff sizeof...(T) == N, EXTENSION
+    template<class U, size_t N>
+        tuple& operator=(array<U, N>&&) // iff sizeof...(T) == N, EXTENSION
+
     void swap(tuple&) noexcept(AND(swap(declval<T&>(), declval<T&>())...));
 };
 
 template <class ...T>
 tuple(T...) -> tuple<T...>;                                         // since C++17
 template <class T1, class T2>
 tuple(pair<T1, T2>) -> tuple<T1, T2>;                               // since C++17
 template <class Alloc, class ...T>
template <class _Tp, class _Alloc>
         explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
             : __value_(_VSTD::forward<_Tp>(__t), __a)
         {static_assert(!is_reference<_Hp>::value,
            "Attempted to uses-allocator construct a reference element in a tuple");}
 
     __tuple_leaf(const __tuple_leaf& __t) = default;
     __tuple_leaf(__tuple_leaf&& __t) = default;
 
-    template <class _Tp>
-        _LIBCPP_INLINE_VISIBILITY
-        __tuple_leaf&
-        operator=(_Tp&& __t) _NOEXCEPT_((is_nothrow_assignable<_Hp&, _Tp>::value))
-        {
-            __value_ = _VSTD::forward<_Tp>(__t);
-            return *this;
-        }
-
     _LIBCPP_INLINE_VISIBILITY
     int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
     {
         _VSTD::swap(*this, __t);
         return 0;
     }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11       _Hp& get()       _NOEXCEPT {return __value_;}
public:
     template <class _Tp, class _Alloc>
         _LIBCPP_INLINE_VISIBILITY
         explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
             : _Hp(_VSTD::forward<_Tp>(__t), __a) {}
 
     __tuple_leaf(__tuple_leaf const &) = default;
     __tuple_leaf(__tuple_leaf &&) = default;
 
-    template <class _Tp>
-        _LIBCPP_INLINE_VISIBILITY
-        __tuple_leaf&
-        operator=(_Tp&& __t) _NOEXCEPT_((is_nothrow_assignable<_Hp&, _Tp>::value))
-        {
-            _Hp::operator=(_VSTD::forward<_Tp>(__t));
-            return *this;
-        }
-
     _LIBCPP_INLINE_VISIBILITY
     int
     swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
     {
         _VSTD::swap(*this, __t);
         return 0;
     }
 
template <class _Alloc, class _Tuple,
         _LIBCPP_INLINE_VISIBILITY
         __tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
             : __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx,
                                        typename __make_tuple_types<_Tuple>::type>::type>(), __a,
                                        _VSTD::forward<typename tuple_element<_Indx,
                                        typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
             {}
 
-    template <class _Tuple>
-        _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __tuple_assignable<_Tuple, tuple<_Tp...> >::value,
-            __tuple_impl&
-        >::type
-        operator=(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_assignable<_Tp&, typename tuple_element<_Indx,
-                                       typename __make_tuple_types<_Tuple>::type>::type>::value...>::value))
-        {
-            __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<typename tuple_element<_Indx,
-                                       typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...);
-            return *this;
-        }
-
     __tuple_impl(const __tuple_impl&) = default;
     __tuple_impl(__tuple_impl&&) = default;
 
     _LIBCPP_INLINE_VISIBILITY
-    __tuple_impl&
-    operator=(const __tuple_impl& __t) _NOEXCEPT_((__all<is_nothrow_copy_assignable<_Tp>::value...>::value))
+    void swap(__tuple_impl& __t)
+        _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
     {
-        __swallow(__tuple_leaf<_Indx, _Tp>::operator=(static_cast<const __tuple_leaf<_Indx, _Tp>&>(__t).get())...);
-        return *this;
+        _VSTD::__swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
     }
+};
 
-    _LIBCPP_INLINE_VISIBILITY
-    __tuple_impl&
-    operator=(__tuple_impl&& __t) _NOEXCEPT_((__all<is_nothrow_move_assignable<_Tp>::value...>::value))
-    {
-        __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<_Tp>(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t).get()))...);
-        return *this;
-    }
+template<class _Dest, class _Source, size_t ..._Np>
+void __memberwise_copy_assign(_Dest& __dest, _Source const& __source, __tuple_indices<_Np...>) {
+    _VSTD::__swallow(((_VSTD::get<_Np>(__dest) = _VSTD::get<_Np>(__source)), void(), 0)...);
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(__tuple_impl& __t)
-        _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
-    {
-        __swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
-    }
-};
-
-
+template<class _Dest, class _Source, class ..._Up, size_t ..._Np>
+void __memberwise_forward_assign(_Dest& __dest, _Source&& __source, __tuple_types<_Up...>, __tuple_indices<_Np...>) {
+    _VSTD::__swallow(((
+        _VSTD::get<_Np>(__dest) = _VSTD::forward<_Up>(_VSTD::get<_Np>(_VSTD::forward<_Source>(__source)))
+    ), void(), 0)...);
 
 template <class ..._Tp>
 class _LIBCPP_TEMPLATE_VIS tuple
 {
     typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> _BaseT;
 
     _BaseT __base_;
 
template <class _Alloc, class _Tuple,
                          bool
                       >::type = false
              >
         _LIBCPP_INLINE_VISIBILITY
         explicit
         tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
             : __base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
 
-    using _CanCopyAssign = __all<is_copy_assignable<_Tp>::value...>;
-    using _CanMoveAssign = __all<is_move_assignable<_Tp>::value...>;
+    // [tuple.assign]
+    _LIBCPP_INLINE_VISIBILITY
+    tuple& operator=(_If<_And<is_copy_assignable<_Tp>...>::value, tuple, __nat> const& __tuple)
+        _NOEXCEPT_((_And<is_nothrow_copy_assignable<_Tp>...>::value))
+    {
+        _VSTD::__memberwise_copy_assign(*this, __tuple,
+            typename __make_tuple_indices<sizeof...(_Tp)>::type());
+        return *this;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    tuple& operator=(_If<_And<is_move_assignable<_Tp>...>::value, tuple, __nat>&& __tuple)
+        _NOEXCEPT_((_And<is_nothrow_move_assignable<_Tp>...>::value))
+    {
+        _VSTD::__memberwise_forward_assign(*this, _VSTD::move(__tuple),
+            __tuple_types<_Tp...>(),
+            typename __make_tuple_indices<sizeof...(_Tp)>::type());
+        return *this;
+    }
 
+    template<class... _Up, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == sizeof...(_Up)>,
+            is_assignable<_Tp&, _Up const&>...
+        >::value
+    ,int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    tuple& operator=(typename conditional<_CanCopyAssign::value, tuple, __nat>::type const& __t)
-        _NOEXCEPT_((__all<is_nothrow_copy_assignable<_Tp>::value...>::value))
+    tuple& operator=(tuple<_Up...> const& __tuple)
+        _NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up const&>...>::value))
     {
-        __base_.operator=(__t.__base_);
+        _VSTD::__memberwise_copy_assign(*this, __tuple,
+            typename __make_tuple_indices<sizeof...(_Tp)>::type());
         return *this;
     }
 
+    template<class... _Up, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == sizeof...(_Up)>,
+            is_assignable<_Tp&, _Up>...
+        >::value
+    ,int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    tuple& operator=(typename conditional<_CanMoveAssign::value, tuple, __nat>::type&& __t)
-        _NOEXCEPT_((__all<is_nothrow_move_assignable<_Tp>::value...>::value))
+    tuple& operator=(tuple<_Up...>&& __tuple)
+        _NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up>...>::value))
     {
-        __base_.operator=(static_cast<_BaseT&&>(__t.__base_));
+        _VSTD::__memberwise_forward_assign(*this, _VSTD::move(__tuple),
+            __tuple_types<_Up...>(),
+            typename __make_tuple_indices<sizeof...(_Tp)>::type());
         return *this;
     }
 
-    template <class _Tuple,
-              class = typename enable_if
-                      <
-                         __tuple_assignable<_Tuple, tuple>::value
-                      >::type
-             >
-        _LIBCPP_INLINE_VISIBILITY
-        tuple&
-        operator=(_Tuple&& __t) _NOEXCEPT_((is_nothrow_assignable<_BaseT&, _Tuple>::value))
-        {
-            __base_.operator=(_VSTD::forward<_Tuple>(__t));
-            return *this;
-        }
+    template<class _Up1, class _Up2, class _Dep = true_type, _EnableIf<
+        _And<_Dep,
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            is_assignable<_FirstType<_Tp..., _Dep>&, _Up1 const&>,
+            is_assignable<_SecondType<_Tp..., _Dep>&, _Up2 const&>
+        >::value
+    ,int> = 0>
+    _LIBCPP_INLINE_VISIBILITY
+    tuple& operator=(pair<_Up1, _Up2> const& __pair)
+        _NOEXCEPT_((_And<
+            is_nothrow_assignable<_FirstType<_Tp...>&, _Up1 const&>,
+            is_nothrow_assignable<_SecondType<_Tp...>&, _Up2 const&>
+        >::value))
+    {
+        _VSTD::get<0>(*this) = __pair.first;
+        _VSTD::get<1>(*this) = __pair.second;
+        return *this;
+    }
+
+    template<class _Up1, class _Up2, class _Dep = true_type, _EnableIf<
+        _And<_Dep,
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            is_assignable<_FirstType<_Tp..., _Dep>&, _Up1>,
+            is_assignable<_SecondType<_Tp..., _Dep>&, _Up2>
+        >::value
+    ,int> = 0>
+    _LIBCPP_INLINE_VISIBILITY
+    tuple& operator=(pair<_Up1, _Up2>&& __pair)
+        _NOEXCEPT_((_And<
+            is_nothrow_assignable<_FirstType<_Tp...>&, _Up1>,
+            is_nothrow_assignable<_SecondType<_Tp...>&, _Up2>
+        >::value))
+    {
+        _VSTD::get<0>(*this) = _VSTD::move(__pair.first);
+        _VSTD::get<1>(*this) = _VSTD::move(__pair.second);
+        return *this;
+    }
+
+    // EXTENSION
+    template<class _Up, size_t _Np, class = _EnableIf<
+        _And<
+            _BoolConstant<_Np == sizeof...(_Tp)>,
+            is_assignable<_Tp&, _Up const&>...
+        >::value
+    > >
+    _LIBCPP_INLINE_VISIBILITY
+    tuple& operator=(array<_Up, _Np> const& __array)
+        _NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up const&>...>::value))
+    {
+        _VSTD::__memberwise_copy_assign(*this, __array,
+            typename __make_tuple_indices<sizeof...(_Tp)>::type());
+        return *this;
+    }
+
+    // EXTENSION
+    template<class _Up, size_t _Np, class = void, class = _EnableIf<
+        _And<
+            _BoolConstant<_Np == sizeof...(_Tp)>,
+            is_assignable<_Tp&, _Up>...
+        >::value
+    > >
+    tuple& operator=(array<_Up, _Np>&& __array)
+        _NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up>...>::value))
+        _VSTD::__memberwise_forward_assign(*this, _VSTD::move(__array),
+            __tuple_types<_If<true, _Up, _Tp>...>(),
+            typename __make_tuple_indices<sizeof...(_Tp)>::type());
 
+    // [tuple.swap]
     _LIBCPP_INLINE_VISIBILITY
     void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
         {__base_.swap(__t.__base_);}
 };
 
 template <>
 class _LIBCPP_TEMPLATE_VIS tuple<>
 {

libcxx/test/libcxx/utilities/tuple/tuple.tuple/tuple.assign/array.extension.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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// EXTENSION
+// template <class U, size_t N>
+//   tuple& operator=(const array<U, N>& u);
+//
+// template <class U, size_t N>
+//   tuple& operator=(array<U, N>&& u);
+
+// UNSUPPORTED: c++03
+
+#include <array>
+#include <cassert>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+
+template <class T>
+struct NothrowAssignableFrom {
+    NothrowAssignableFrom& operator=(T) noexcept { return *this; }
+};
+
+template <class T>
+struct PotentiallyThrowingAssignableFrom {
+    PotentiallyThrowingAssignableFrom& operator=(T) { return *this; }
+};
+
+int main(int, char**) {
+    // Tests for the array const& overload
+    {
+        std::array<long, 3> array = {1l, 2l, 3l};
+        std::tuple<int, int, int> tuple;
+        tuple = array;
+        assert(std::get<0>(tuple) == 1);
+        assert(std::get<1>(tuple) == 2);
+        assert(std::get<2>(tuple) == 3);
+    }
+    {
+        typedef std::tuple<NothrowAssignableFrom<int>> Tuple;
+        typedef std::array<int, 1> Array;
+        static_assert(std::is_nothrow_assignable<Tuple&, Array const&>::value, "");
+    }
+    {
+        typedef std::tuple<PotentiallyThrowingAssignableFrom<int>> Tuple;
+        typedef std::array<int, 1> Array;
+        static_assert(std::is_assignable<Tuple&, Array const&>::value, "");
+        static_assert(!std::is_nothrow_assignable<Tuple&, Array const&>::value, "");
+    }
+
+    // Tests for the array&& overload
+    {
+        std::array<long, 3> array = {1l, 2l, 3l};
+        std::tuple<int, int, int> tuple;
+        tuple = std::move(array);
+        assert(std::get<0>(tuple) == 1);
+        assert(std::get<1>(tuple) == 2);
+        assert(std::get<2>(tuple) == 3);
+    }
+    {
+        typedef std::tuple<NothrowAssignableFrom<int>> Tuple;
+        typedef std::array<int, 1> Array;
+        static_assert(std::is_nothrow_assignable<Tuple&, Array&&>::value, "");
+    }
+    {
+        typedef std::tuple<PotentiallyThrowingAssignableFrom<int>> Tuple;
+        typedef std::array<int, 1> Array;
+        static_assert(std::is_assignable<Tuple&, Array&&>::value, "");
+        static_assert(!std::is_nothrow_assignable<Tuple&, Array&&>::value, "");
+    }
+
+    // Test lvalue-refs and const rvalue-ref
+    {
+        typedef std::tuple<NothrowAssignableFrom<int>> Tuple;
+        typedef std::array<int, 1> Array;
+        static_assert(std::is_nothrow_assignable<Tuple&, Array&>::value, "");
+        static_assert(std::is_nothrow_assignable<Tuple&, const Array&&>::value, "");
+    }
+
+    {
+        typedef std::tuple<NothrowAssignableFrom<int>> Tuple;
+        static_assert(!std::is_assignable<Tuple&, std::array<long, 2>&>::value, "");
+        static_assert(!std::is_assignable<Tuple&, std::array<long, 2>&&>::value, "");
+        static_assert(!std::is_assignable<Tuple&, const std::array<long, 2>&>::value, "");
+        static_assert(!std::is_assignable<Tuple&, const std::array<long, 2>&&>::value, "");
+
+        static_assert(!std::is_assignable<Tuple&, std::array<long, 4>&>::value, "");
+        static_assert(!std::is_assignable<Tuple&, std::array<long, 4>&&>::value, "");
+        static_assert(!std::is_assignable<Tuple&, const std::array<long, 4>&>::value, "");
+        static_assert(!std::is_assignable<Tuple&, const std::array<long, 4>&&>::value, "");
+    }
+
+    return 0;
+}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/const_pair.pass.cpp

 
 // template <class... Types> class tuple;
 
 // template <class U1, class U2>
 //   tuple& operator=(const pair<U1, U2>& u);
 
 // UNSUPPORTED: c++03
 
+#include <cassert>
+#include <memory>
 #include <tuple>
+#include <type_traits>
 #include <utility>
-#include <memory>
-#include <cassert>
+
+struct NothrowCopyAssignable {
+    NothrowCopyAssignable& operator=(NothrowCopyAssignable const&) noexcept { return *this; }
+};
+struct PotentiallyThrowingCopyAssignable {
+    PotentiallyThrowingCopyAssignable& operator=(PotentiallyThrowingCopyAssignable const&) { return *this; }
+};
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::pair<long, char> T0;
         typedef std::tuple<long long, short> T1;
         T0 t0(2, 'a');
         T1 t1;
         t1 = t0;
         assert(std::get<0>(t1) == 2);
         assert(std::get<1>(t1) == short('a'));
     }
     {
         // test that the implicitly generated copy assignment operator
         // is properly deleted
         using T = std::tuple<int, int>;
         using P = std::tuple<std::unique_ptr<int>, std::unique_ptr<int>>;
         static_assert(!std::is_assignable<T, const P &>::value, "");
     }
+    {
+        typedef std::tuple<NothrowCopyAssignable, long> Tuple;
+        typedef std::pair<NothrowCopyAssignable, int> Pair;
+        static_assert(std::is_nothrow_assignable<Tuple&, Pair const&>::value, "");
+        static_assert(std::is_nothrow_assignable<Tuple&, Pair&>::value, "");
+        static_assert(std::is_nothrow_assignable<Tuple&, Pair const&&>::value, "");
+    }
+    {
+        typedef std::tuple<PotentiallyThrowingCopyAssignable, long> Tuple;
+        typedef std::pair<PotentiallyThrowingCopyAssignable, int> Pair;
+        static_assert(std::is_assignable<Tuple&, Pair const&>::value, "");
+        static_assert(!std::is_nothrow_assignable<Tuple&, Pair const&>::value, "");
+
+        static_assert(std::is_assignable<Tuple&, Pair&>::value, "");
+        static_assert(!std::is_nothrow_assignable<Tuple&, Pair&>::value, "");
+
+        static_assert(std::is_assignable<Tuple&, Pair const&&>::value, "");
+        static_assert(!std::is_nothrow_assignable<Tuple&, Pair const&&>::value, "");
+    }
 
     return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp

struct D
     explicit D(int i = 0) : B(i) {}
 };
 
 struct NonAssignable {
   NonAssignable& operator=(NonAssignable const&) = delete;
   NonAssignable& operator=(NonAssignable&&) = delete;
 };
 
+struct NothrowCopyAssignable
+{
+    NothrowCopyAssignable& operator=(NothrowCopyAssignable const&) noexcept { return *this; }
+};
+
+struct PotentiallyThrowingCopyAssignable
+{
+    PotentiallyThrowingCopyAssignable& operator=(PotentiallyThrowingCopyAssignable const&) { return *this; }
+};
+
 int main(int, char**)
 {
     {
         typedef std::tuple<long> T0;
         typedef std::tuple<long long> T1;
         T0 t0(2);
         T1 t1;
         t1 = t0;
int main(int, char**)
         assert(&std::get<0>(t) == &x);
     }
     {
       using T = std::tuple<int, NonAssignable>;
       using U = std::tuple<NonAssignable, int>;
       static_assert(!std::is_assignable<T, U const&>::value, "");
       static_assert(!std::is_assignable<U, T const&>::value, "");
     }
+    {
+        typedef std::tuple<NothrowCopyAssignable, long> T0;
+        typedef std::tuple<NothrowCopyAssignable, int> T1;
+        static_assert(std::is_nothrow_assignable<T0&, T1 const&>::value, "");
+    }
+    {
+        typedef std::tuple<PotentiallyThrowingCopyAssignable, long> T0;
+        typedef std::tuple<PotentiallyThrowingCopyAssignable, int> T1;
+        static_assert(!std::is_nothrow_assignable<T0&, T1 const&>::value, "");
+    }
 
     return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp

struct E {
   }
 };
 
 struct NonAssignable {
   NonAssignable& operator=(NonAssignable const&) = delete;
   NonAssignable& operator=(NonAssignable&&) = delete;
 };
 
+struct NothrowMoveAssignable
+{
+    NothrowMoveAssignable& operator=(NothrowMoveAssignable&&) noexcept { return *this; }
+};
+
+struct PotentiallyThrowingMoveAssignable
+{
+    PotentiallyThrowingMoveAssignable& operator=(PotentiallyThrowingMoveAssignable&&) { return *this; }
+};
+
 int main(int, char**)
 {
     {
         typedef std::tuple<long> T0;
         typedef std::tuple<long long> T1;
         T0 t0(2);
         T1 t1;
         t1 = std::move(t0);
int main(int, char**)
         assert(&std::get<0>(t) == &x);
     }
     {
       using T = std::tuple<int, NonAssignable>;
       using U = std::tuple<NonAssignable, int>;
       static_assert(!std::is_assignable<T, U&&>::value, "");
       static_assert(!std::is_assignable<U, T&&>::value, "");
     }
+    {
+        typedef std::tuple<NothrowMoveAssignable, long> T0;
+        typedef std::tuple<NothrowMoveAssignable, int> T1;
+        static_assert(std::is_nothrow_assignable<T0&, T1&&>::value, "");
+    }
+    {
+        typedef std::tuple<PotentiallyThrowingMoveAssignable, long> T0;
+        typedef std::tuple<PotentiallyThrowingMoveAssignable, int> T1;
+        static_assert(!std::is_nothrow_assignable<T0&, T1&&>::value, "");
+    }
 
     return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp

struct CopyAssignable {
   CopyAssignable& operator=(CopyAssignable const&) = default;
   CopyAssignable& operator=(CopyAssignable &&) = delete;
 };
 static_assert(std::is_copy_assignable<CopyAssignable>::value, "");
 struct MoveAssignable {
   MoveAssignable& operator=(MoveAssignable const&) = delete;
   MoveAssignable& operator=(MoveAssignable&&) = default;
 };
+struct NothrowCopyAssignable {
+  NothrowCopyAssignable& operator=(NothrowCopyAssignable const&) noexcept { return *this; }
+};
+struct PotentiallyThrowingCopyAssignable {
+  PotentiallyThrowingCopyAssignable& operator=(PotentiallyThrowingCopyAssignable const&) { return *this; }
+};
 
 struct CopyAssignableInt {
   CopyAssignableInt& operator=(int&) { return *this; }
 };
 
 int main(int, char**)
 {
     {
int main(int, char**)
       using P = std::pair<int, int>;
       static_assert(!std::is_assignable<T&, P const>::value, "");
     }
     {
       using T = std::tuple<int, MoveAssignable>;
       using P = std::pair<int, MoveAssignable>;
       static_assert(!std::is_assignable<T&, P&>::value, "");
     }
+    {
+        using T = std::tuple<NothrowCopyAssignable, int>;
+        static_assert(std::is_nothrow_copy_assignable<T>::value, "");
+    }
+    {
+        using T = std::tuple<PotentiallyThrowingCopyAssignable, int>;
+        static_assert(!std::is_nothrow_copy_assignable<T>::value, "");
+    }
 
     return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/derived_from_tuple_like.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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template <class... UTypes>
+//   tuple& operator=(const tuple<UTypes...>& u);
+
+// UNSUPPORTED: c++03
+
+#include <tuple>
+#include <array>
+#include <string>
+#include <utility>
+#include <cassert>
+
+#include "propagate_value_category.hpp"
+
+struct TracksIntQuals {
+  TracksIntQuals() : value(-1), value_category(VC_None), assigned(false) {}
+
+  template <class Tp,
+            class = typename std::enable_if<!std::is_same<
+                typename std::decay<Tp>::type, TracksIntQuals>::value>::type>
+  TracksIntQuals(Tp &&x)
+      : value(x), value_category(getValueCategory<Tp &&>()), assigned(false) {
+    static_assert(std::is_same<UnCVRef<Tp>, int>::value, "");
+  }
+
+  template <class Tp,
+            class = typename std::enable_if<!std::is_same<
+                typename std::decay<Tp>::type, TracksIntQuals>::value>::type>
+  TracksIntQuals &operator=(Tp &&x) {
+    static_assert(std::is_same<UnCVRef<Tp>, int>::value, "");
+    value = x;
+    value_category = getValueCategory<Tp &&>();
+    assigned = true;
+    return *this;
+  }
+
+  void reset() {
+    value = -1;
+    value_category = VC_None;
+    assigned = false;
+  }
+
+  bool checkConstruct(int expect, ValueCategory expect_vc) const {
+    return value != 1 && value == expect && value_category == expect_vc &&
+           assigned == false;
+  }
+
+  bool checkAssign(int expect, ValueCategory expect_vc) const {
+    return value != 1 && value == expect && value_category == expect_vc &&
+           assigned == true;
+  }
+
+  int value;
+  ValueCategory value_category;
+  bool assigned;
+};
+
+template <class Tup>
+struct DerivedFromTup : Tup {
+  using Tup::Tup;
+};
+
+template <ValueCategory VC>
+void do_derived_assign_test() {
+  using Tup1 = std::tuple<long, TracksIntQuals>;
+  Tup1 t;
+  auto reset = [&]() {
+    std::get<0>(t) = -1;
+    std::get<1>(t).reset();
+  };
+  {
+    DerivedFromTup<std::tuple<int, int>> d;
+    std::get<0>(d) = 42;
+    std::get<1>(d) = 101;
+
+    t = ValueCategoryCast<VC>(d);
+    assert(std::get<0>(t) == 42);
+    assert(std::get<1>(t).checkAssign(101, VC));
+  }
+  reset();
+  {
+    DerivedFromTup<std::pair<int, int>> d;
+    std::get<0>(d) = 42;
+    std::get<1>(d) = 101;
+
+    t = ValueCategoryCast<VC>(d);
+    assert(std::get<0>(t) == 42);
+    assert(std::get<1>(t).checkAssign(101, VC));
+  }
+  reset();
+  {
+#ifdef _LIBCPP_VERSION // assignment from std::array is a libc++ extension
+    DerivedFromTup<std::array<int, 2>> d;
+    std::get<0>(d) = 42;
+    std::get<1>(d) = 101;
+
+    t = ValueCategoryCast<VC>(d);
+    assert(std::get<0>(t) == 42);
+    assert(std::get<1>(t).checkAssign(101, VC));
+#endif
+  }
+}
+
+int main(int, char**) {
+    do_derived_assign_test<VC_LVal | VC_Const>();
+    do_derived_assign_test<VC_RVal>();
+
+    return 0;
+}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/laziness.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
+
+// This test ensures that std::tuple is lazy when it comes to checking whether
+// the elements it is assigned from can be used to assign to the types in
+// the tuple.
+
+#include <tuple>
+#include <array>
+
+template <bool Enable, class ...Class>
+constexpr typename std::enable_if<Enable, bool>::type BlowUp() {
+  static_assert(Enable && sizeof...(Class) != sizeof...(Class), "");
+  return true;
+}
+
+template<class T>
+struct Fail {
+  static_assert(sizeof(T) != sizeof(T), "");
+  using type = void;
+};
+
+struct NoAssign {
+  NoAssign() = default;
+  NoAssign(NoAssign const&) = default;
+  template <class T, class = typename std::enable_if<sizeof(T) != sizeof(T)>::type>
+  NoAssign& operator=(T) { return *this; }
+};
+
+template <int>
+struct DieOnAssign {
+  DieOnAssign() = default;
+  template <class T, class X = typename std::enable_if<!std::is_same<T, DieOnAssign>::value>::type,
+                     class = typename Fail<X>::type>
+  DieOnAssign& operator=(T) {
+    return *this;
+  }
+};
+
+void test_arity_checks() {
+  {
+    using T = std::tuple<int, DieOnAssign<0>, int>;
+    using P = std::pair<int, int>;
+    static_assert(!std::is_assignable<T&, P const&>::value, "");
+  }
+  {
+    using T = std::tuple<int, int, DieOnAssign<1> >;
+    using A = std::array<int, 1>;
+    static_assert(!std::is_assignable<T&, A const&>::value, "");
+  }
+}
+
+void test_assignability_checks() {
+  {
+    using T1 = std::tuple<int, NoAssign, DieOnAssign<2> >;
+    using T2 = std::tuple<long, long, long>;
+    static_assert(!std::is_assignable<T1&, T2 const&>::value, "");
+  }
+  {
+    using T1 = std::tuple<NoAssign, DieOnAssign<3> >;
+    using T2 = std::pair<long, double>;
+    static_assert(!std::is_assignable<T1&, T2 const&>::value, "");
+  }
+}
+
+int main(int, char**) {
+  test_arity_checks();
+  test_assignability_checks();
+  return 0;
+}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp

struct CopyAssignable {
   CopyAssignable& operator=(CopyAssignable const&) = default;
   CopyAssignable& operator=(CopyAssignable&&) = delete;
 };
 static_assert(std::is_copy_assignable<CopyAssignable>::value, "");
 struct MoveAssignable {
   MoveAssignable& operator=(MoveAssignable const&) = delete;
   MoveAssignable& operator=(MoveAssignable&&) = default;
 };
-
+struct NothrowMoveAssignable {
+  NothrowMoveAssignable& operator=(NothrowMoveAssignable&&) noexcept { return *this; }
+};
+struct PotentiallyThrowingMoveAssignable {
+  PotentiallyThrowingMoveAssignable& operator=(PotentiallyThrowingMoveAssignable&&) { return *this; }
+};
 
 struct CountAssign {
   static int copied;
   static int moved;
   static void reset() { copied = moved = 0; }
   CountAssign() = default;
   CountAssign& operator=(CountAssign const&) { ++copied; return *this; }
   CountAssign& operator=(CountAssign&&) { ++moved; return *this; }
 };
 int CountAssign::copied = 0;
 int CountAssign::moved = 0;
 
-
 int main(int, char**)
 {
     {
         typedef std::tuple<> T;
         T t0;
         T t;
         t = std::move(t0);
     }
int main(int, char**)
         assert(&std::get<1>(t) == &y);
     }
     {
         // test that the implicitly generated move assignment operator
         // is properly deleted
         using T = std::tuple<std::unique_ptr<int>>;
         static_assert(std::is_move_assignable<T>::value, "");
         static_assert(!std::is_copy_assignable<T>::value, "");
-
     }
     {
       using T = std::tuple<int, NonAssignable>;
       static_assert(!std::is_move_assignable<T>::value, "");
     }
     {
         using T = std::tuple<int, MoveAssignable>;
         static_assert(std::is_move_assignable<T>::value, "");
     }
     {
         // The move should decay to a copy.
         CountAssign::reset();
         using T = std::tuple<CountAssign, CopyAssignable>;
         static_assert(std::is_move_assignable<T>::value, "");
         T t1;
         T t2;
         t1 = std::move(t2);
         assert(CountAssign::copied == 1);
         assert(CountAssign::moved == 0);
     }
+    {
+        using T = std::tuple<int, NonAssignable>;
+        static_assert(!std::is_move_assignable<T>::value, "");
+    }
+    {
+        using T = std::tuple<int, MoveAssignable>;
+        static_assert(std::is_move_assignable<T>::value, "");
+    }
+    {
+        using T = std::tuple<NothrowMoveAssignable, int>;
+        static_assert(std::is_nothrow_move_assignable<T>::value, "");
+    }
+    {
+        using T = std::tuple<PotentiallyThrowingMoveAssignable, int>;
+        static_assert(!std::is_nothrow_move_assignable<T>::value, "");
+    }
 
     return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/move_pair.pass.cpp

 };
 
 struct D
     : B
 {
     explicit D(int i) : B(i) {}
 };
 
-struct NonMoveAssignable {
-  NonMoveAssignable& operator=(NonMoveAssignable const&) = default;
-  NonMoveAssignable& operator=(NonMoveAssignable&&) = delete;
+struct NonAssignable
+{
+  NonAssignable& operator=(NonAssignable const&) = delete;
+  NonAssignable& operator=(NonAssignable&&) = delete;
+};
+
+struct NothrowMoveAssignable
+{
+    NothrowMoveAssignable& operator=(NothrowMoveAssignable&&) noexcept { return *this; }
+};
+
+struct PotentiallyThrowingMoveAssignable
+{
+    PotentiallyThrowingMoveAssignable& operator=(PotentiallyThrowingMoveAssignable&&) { return *this; }
 };
 
 int main(int, char**)
 {
     {
         typedef std::pair<long, std::unique_ptr<D>> T0;
         typedef std::tuple<long long, std::unique_ptr<B>> T1;
         T0 t0(2, std::unique_ptr<D>(new D(3)));
         T1 t1;
         t1 = std::move(t0);
         assert(std::get<0>(t1) == 2);
         assert(std::get<1>(t1)->id_ == 3);
     }
     {
-      using T = std::tuple<int, NonMoveAssignable>;
-      using P = std::pair<int, NonMoveAssignable>;
+        using T = std::tuple<int, NonAssignable>;
+        using P = std::pair<int, NonAssignable>;
         static_assert(!std::is_assignable<T&, P&&>::value, "");
     }
     {
       using T = std::tuple<int, int, int>;
       using P = std::pair<int, int>;
       static_assert(!std::is_assignable<T&, P&&>::value, "");
     }
+    {
+        typedef std::tuple<NothrowMoveAssignable, long> Tuple;
+        typedef std::pair<NothrowMoveAssignable, int> Pair;
+        static_assert(std::is_nothrow_assignable<Tuple&, Pair&&>::value, "");
+        static_assert(!std::is_assignable<Tuple&, Pair const&&>::value, "");
+    }
+    {
+        typedef std::tuple<PotentiallyThrowingMoveAssignable, long> Tuple;
+        typedef std::pair<PotentiallyThrowingMoveAssignable, int> Pair;
+        static_assert(std::is_assignable<Tuple&, Pair&&>::value, "");
+        static_assert(!std::is_nothrow_assignable<Tuple&, Pair&&>::value, "");
+        static_assert(!std::is_assignable<Tuple&, Pair const&&>::value, "");
+    }
 
     return 0;
 }

libcxx/test/support/propagate_value_category.hpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TEST_SUPPORT_PROPAGATE_VALUE_CATEGORY
+#define TEST_SUPPORT_PROPAGATE_VALUE_CATEGORY
+
+#include "test_macros.h"
+#include <type_traits>
+
+#if TEST_STD_VER < 11
+#error this header may only be used in C++11
+#endif
+
+using UnderlyingVCType = unsigned;
+enum ValueCategory : UnderlyingVCType {
+  VC_None = 0,
+  VC_LVal = 1 << 0,
+  VC_RVal = 1 << 1,
+  VC_Const = 1 << 2,
+  VC_Volatile = 1 << 3,
+  VC_ConstVolatile = VC_Const | VC_Volatile
+};
+
+inline constexpr ValueCategory operator&(ValueCategory LHS, ValueCategory RHS) {
+  return ValueCategory(LHS & (UnderlyingVCType)RHS);
+}
+
+inline constexpr ValueCategory operator|(ValueCategory LHS, ValueCategory RHS) {
+  return ValueCategory(LHS | (UnderlyingVCType)RHS);
+}
+
+inline constexpr ValueCategory operator^(ValueCategory LHS, ValueCategory RHS) {
+  return ValueCategory(LHS ^ (UnderlyingVCType)RHS);
+}
+
+inline constexpr bool isValidValueCategory(ValueCategory VC) {
+  return (VC & (VC_LVal | VC_RVal)) != (VC_LVal | VC_RVal);
+}
+
+inline constexpr bool hasValueCategory(ValueCategory Arg, ValueCategory Key) {
+  return Arg == Key || ((Arg & Key) == Key);
+}
+
+template <class Tp>
+using UnCVRef =
+    typename std::remove_cv<typename std::remove_reference<Tp>::type>::type;
+
+template <class Tp>
+constexpr ValueCategory getReferenceQuals() {
+  return std::is_lvalue_reference<Tp>::value
+             ? VC_LVal
+             : (std::is_rvalue_reference<Tp>::value ? VC_RVal : VC_None);
+}
+static_assert(getReferenceQuals<int>() == VC_None, "");
+static_assert(getReferenceQuals<int &>() == VC_LVal, "");
+static_assert(getReferenceQuals<int &&>() == VC_RVal, "");
+
+template <class Tp>
+constexpr ValueCategory getCVQuals() {
+  using Vp = typename std::remove_reference<Tp>::type;
+  return std::is_const<Vp>::value && std::is_volatile<Vp>::value
+             ? VC_ConstVolatile
+             : (std::is_const<Vp>::value
+                    ? VC_Const
+                    : (std::is_volatile<Vp>::value ? VC_Volatile : VC_None));
+}
+static_assert(getCVQuals<int>() == VC_None, "");
+static_assert(getCVQuals<int const>() == VC_Const, "");
+static_assert(getCVQuals<int volatile>() == VC_Volatile, "");
+static_assert(getCVQuals<int const volatile>() == VC_ConstVolatile, "");
+static_assert(getCVQuals<int &>() == VC_None, "");
+static_assert(getCVQuals<int const &>() == VC_Const, "");
+
+template <class Tp>
+inline constexpr ValueCategory getValueCategory() {
+  return getReferenceQuals<Tp>() | getCVQuals<Tp>();
+}
+static_assert(getValueCategory<int>() == VC_None, "");
+static_assert(getValueCategory<int const &>() == (VC_LVal | VC_Const), "");
+static_assert(getValueCategory<int const volatile &&>() ==
+                  (VC_RVal | VC_ConstVolatile),
+              "");
+
+template <ValueCategory VC>
+struct ApplyValueCategory {
+private:
+  static_assert(isValidValueCategory(VC), "");
+
+  template <bool Pred, class Then, class Else>
+  using CondT = typename std::conditional<Pred, Then, Else>::type;
+
+public:
+  template <class Tp, class Vp = UnCVRef<Tp>>
+  using ApplyCVQuals = CondT<
+      hasValueCategory(VC, VC_ConstVolatile), typename std::add_cv<Vp>::type,
+      CondT<hasValueCategory(VC, VC_Const), typename std::add_const<Vp>::type,
+            CondT<hasValueCategory(VC, VC_Volatile),
+                  typename std::add_volatile<Vp>::type, Tp>>>;
+
+  template <class Tp, class Vp = typename std::remove_reference<Tp>::type>
+  using ApplyReferenceQuals =
+      CondT<hasValueCategory(VC, VC_LVal),
+            typename std::add_lvalue_reference<Vp>::type,
+            CondT<hasValueCategory(VC, VC_RVal),
+                  typename std::add_rvalue_reference<Vp>::type, Vp>>;
+
+  template <class Tp>
+  using Apply = ApplyReferenceQuals<ApplyCVQuals<UnCVRef<Tp>>>;
+
+  template <class Tp, bool Dummy = true,
+            typename std::enable_if<Dummy && (VC & VC_LVal), bool>::type = true>
+  static Apply<UnCVRef<Tp>> cast(Tp &&t) {
+    using ToType = Apply<UnCVRef<Tp>>;
+    return static_cast<ToType>(t);
+  }
+
+  template <class Tp, bool Dummy = true,
+            typename std::enable_if<Dummy && (VC & VC_RVal), bool>::type = true>
+  static Apply<UnCVRef<Tp>> cast(Tp &&t) {
+    using ToType = Apply<UnCVRef<Tp>>;
+    return static_cast<ToType>(std::move(t));
+  }
+
+  template <
+      class Tp, bool Dummy = true,
+      typename std::enable_if<Dummy && ((VC & (VC_LVal | VC_RVal)) == VC_None),
+                              bool>::type = true>
+  static Apply<UnCVRef<Tp>> cast(Tp &&t) {
+    return t;
+  }
+};
+
+template <ValueCategory VC, class Tp>
+using ApplyValueCategoryT = typename ApplyValueCategory<VC>::template Apply<Tp>;
+
+template <class Tp>
+using PropagateValueCategory = ApplyValueCategory<getValueCategory<Tp>()>;
+
+template <class Tp, class Up>
+using PropagateValueCategoryT =
+    typename ApplyValueCategory<getValueCategory<Tp>()>::template Apply<Up>;
+
+template <ValueCategory VC, class Tp>
+typename ApplyValueCategory<VC>::template Apply<Tp> ValueCategoryCast(Tp &&t) {
+  return ApplyValueCategory<VC>::cast(std::forward<Tp>(t));
+};
+
+#endif // TEST_SUPPORT_PROPAGATE_VALUE_CATEGORY