[libcxx] Fix tuple construction/assignment from types derived from tuple/pair/array.

[EricWF]

Summary

The standard requires tuple have the following constructors:

tuple(tuple<OtherTypes...> const&);
tuple(tuple<OtherTypes...> &&);
tuple(pair<T1, T2> const&);
tuple(pair<T1, T2> &&);
tuple(array<T, N> const&);
tuple(array<T, N> &&);

However libc++ implements these as a single constructor with the signature:

template <class TupleLike, enable_if_t<__is_tuple_like<TupleLike>::value>>
tuple(TupleLike&&);

This causes the constructor to reject types derived from tuple-like types; Unlike if we had all of the concrete overloads, because they cause the derived->base conversion in the signature.

This patch fixes this issue by detecting derived types and the tuple-like base they are derived from. It does this by creating an overloaded function with signatures for each of tuple/pair/array and checking if the possibly derived type can convert to any of them.

This patch fixes PR17550

This patch

[EricWF]

Cleanup a couple of issues.

[EricWF]

Fix comments.

[mpark]

include/tuple

568

indentation?

871

indentation?

906

s/_Deducer/_Deduced/

907

s/_QualTupleBase/_TupBase/

915–916

A general comment about using the base in noexcept condition. I remember for variant we wanted to express it directly rather than delegating it to the "base". Does that also apply here?

918

Here and elsewhere, why do we bother with base_.operator=(...); as opposed to just base_ = ...;?

[EricWF]

Address review comments.

@mpark any other concerns/comments?

[EricWF]

Accepting revision. @mpark mentioned that this was good to go offline. Ignore the inline comment about base.operator=, phab won't let me delete it.

include/tuple

884

This should be fixed

915–916

Yes. probably. but this is existing code. I'll fix that in another patch. Plus it's really hard to state this noexcept directly since you need to expand the input argument into its tuple-types.

918

I think the reason for not using base_ = ... is because that can select different conversion sequences IIRC.

include/__tuple

 #if _LIBCPP_STD_VER > 11
 template <size_t _Ip, class ..._Tp>
 using tuple_element_t = typename tuple_element <_Ip, _Tp...>::type;
 #endif
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
 #ifndef _LIBCPP_CXX03_LANG
-template <bool _IsTuple, class _SizeTrait, size_t _Expected>
-struct __tuple_like_with_size_imp : false_type {};
 
-template <class _SizeTrait, size_t _Expected>
-struct __tuple_like_with_size_imp<true, _SizeTrait, _Expected>
-    : integral_constant<bool, _SizeTrait::value == _Expected> {};
-
-template <class _Tuple, size_t _ExpectedSize,
-          class _RawTuple = typename __uncvref<_Tuple>::type>
-using __tuple_like_with_size = __tuple_like_with_size_imp<
-                                   __tuple_like<_RawTuple>::value,
-                                   tuple_size<_RawTuple>, _ExpectedSize
-                              >;
+template <class _Tp, size_t _TSize, bool _Good = true>
+struct __lookup_result {
+  using type = _Tp;
+  static constexpr bool _Success = _Good;
+  static constexpr size_t _Size = _TSize;
+};
+using __lookup_failure = __lookup_result<void, (size_t)-1, false>;
+
+template <class ..._Args>
+auto __deduce_tuple_type_ovl(tuple<_Args...>&)
+    -> __lookup_result<tuple<_Args...>, sizeof...(_Args)>;
+
+template <class _T1, class _T2>
+auto __deduce_tuple_type_ovl(pair<_T1, _T2>&)
+    -> __lookup_result<pair<_T1, _T2>, 2>;
+
+template <class _Tp, size_t _Size>
+auto __deduce_tuple_type_ovl(array<_Tp, _Size>&)
+  -> __lookup_result<array<_Tp, _Size>, _Size>;
+
+template <class _Tp>
+auto __deduce_tuple_type_imp(int)
+  -> decltype(__deduce_tuple_type_ovl(_VSTD::declval<__uncvref_t<_Tp>&>()));
+template <class> __lookup_failure __deduce_tuple_type_imp(...);
+
+// __deduce_tuple_like - Given a type determine if it is, or is derived from,
+//   a tuple-like type. This trait is used to support constructing and assigning
+//   to std::tuple from user-types derived from a tuple-like type.
+template <class _TupleLike,
+    class _Result = decltype(__deduce_tuple_type_imp<_TupleLike>(0)),
+    bool _Good = _Result::_Success>
+struct __deduce_tuple_like {
+  static_assert(_Good, "incorrect specialization choosen");
+  static constexpr bool _Success = true;
+  static constexpr size_t _Size = _Result::_Size;
+  using _RawType = typename _Result::type;
+  using _QualType =
+    typename __propagate_value_category<_TupleLike>::template __apply<_RawType>;
+};
+
+template <class _TupleLike, class _Result>
+struct __deduce_tuple_like<_TupleLike, _Result, /*_Good=*/false> {
+  static constexpr bool _Success = false;
+  static constexpr size_t _Size = (size_t)-1;
+};
+
+template <class _TupleLike, size_t _ExpectedSize,
+          class _Deduced = __deduce_tuple_like<_TupleLike>>
+using __tuple_like_with_size = integral_constant<bool,
+    _Deduced::_Success && _Deduced::_Size == _ExpectedSize>;
 
 struct _LIBCPP_TYPE_VIS __check_tuple_constructor_fail {
     template <class ...>
     static constexpr bool __enable_default() { return false; }
     template <class ...>
     static constexpr bool __enable_explicit() { return false; }
     template <class ...>
     static constexpr bool __enable_implicit() { return false; }

include/tuple

template <bool _MaybeEnable,
               class _Dummy = void>
     struct _CheckTupleLikeConstructor : __check_tuple_constructor_fail {};
 
     template <class _Dummy>
     struct _CheckTupleLikeConstructor<true, false, _Dummy>
     {
         template <class _Tuple>
         static constexpr bool __enable_implicit() {
-            return __tuple_convertible<_Tuple, tuple>::value;
+            using _Deduced = __deduce_tuple_like<_Tuple>;
+            using _QualType = typename _Deduced::_QualType;
+            static_assert(__tuple_like<typename _Deduced::_RawType>::value, "");
+            return __tuple_convertible<_QualType, tuple>::value;
         }
 
         template <class _Tuple>
         static constexpr bool __enable_explicit() {
-            return __tuple_constructible<_Tuple, tuple>::value
-               && !__tuple_convertible<_Tuple, tuple>::value;
+            using _Deduced = __deduce_tuple_like<_Tuple>;
+            using _QualType = typename _Deduced::_QualType;
+            static_assert(__tuple_like<typename _Deduced::_RawType>::value, "");
+            return __tuple_constructible<_QualType, tuple>::value
+               && !__tuple_convertible<_QualType, tuple>::value;
         }
     };
 
     template <class _Dummy>
     struct _CheckTupleLikeConstructor<true, true, _Dummy>
     {
         // This trait is used to disable the tuple-like constructor when
         // the UTypes... constructor should be selected instead.
template <class _Alloc, class ..._Up,
             : base_(allocator_arg_t(), __a,
                     typename __make_tuple_indices<sizeof...(_Up)>::type(),
                     typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
                     typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
                     typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
                     _VSTD::forward<_Up>(__u)...) {}
 
     template <class _Tuple,
+              class _Deduced = __deduce_tuple_like<_Tuple>,
+              class _TupBase = typename _Deduced::_QualType,
               typename enable_if
                       <
                          _CheckTupleLikeConstructor<
-                             __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
-                             && !_PackExpandsToThisTuple<_Tuple>::value
-                         >::template __enable_implicit<_Tuple>(),
+                            _Deduced::_Size == sizeof...(_Tp)
+                             && !_PackExpandsToThisTuple<_TupBase>::value
+                         >::template __enable_implicit<_TupBase>(),
                          bool
                       >::type = false
              >
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
-        tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<base, _Tuple>::value))
-            : base_(_VSTD::forward<_Tuple>(__t)) {}
+        tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<base, _TupBase>::value))
+            : base_(_VSTD::forward<_TupBase>(__t)) {}
 
     template <class _Tuple,
+              class _Deduced = __deduce_tuple_like<_Tuple>,
+              class _TupBase = typename _Deduced::_QualType,
               typename enable_if
                       <
                          _CheckTupleLikeConstructor<
-                             __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
-                             && !_PackExpandsToThisTuple<_Tuple>::value
-                         >::template __enable_explicit<_Tuple>(),
+                              _Deduced::_Size == sizeof...(_Tp)
+                             && !_PackExpandsToThisTuple<_TupBase>::value
+                         >::template __enable_explicit<_TupBase>(),
                          bool
                       >::type = false
              >
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         explicit
-        tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<base, _Tuple>::value))
-            : base_(_VSTD::forward<_Tuple>(__t)) {}
+        tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<base, _TupBase>::value))
+            : base_(_VSTD::forward<_TupBase>(__t)) {}
 
     template <class _Alloc, class _Tuple,
+              class _Deduced = __deduce_tuple_like<_Tuple>,
+              class _TupBase = typename _Deduced::_QualType,
               typename enable_if
                       <
                          _CheckTupleLikeConstructor<
-                             __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
-                         >::template __enable_implicit<_Tuple>(),
+                             _Deduced::_Size == sizeof...(_Tp)
+                         >::template __enable_implicit<_TupBase>(),
                          bool
                       >::type = false
              >
         _LIBCPP_INLINE_VISIBILITY
         tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
-            : base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
+            : base_(allocator_arg_t(), __a, _VSTD::forward<_TupBase>(__t)) {}
 
     template <class _Alloc, class _Tuple,
+              class _Deduced = __deduce_tuple_like<_Tuple>,
+              class _TupBase = typename _Deduced::_QualType,
               typename enable_if
                       <
                          _CheckTupleLikeConstructor<
-                             __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
-                         >::template __enable_explicit<_Tuple>(),
+                             _Deduced::_Size == sizeof...(_Tp)
+                         >::template __enable_explicit<_TupBase>(),
                          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)) {}
+            : base_(allocator_arg_t(), __a, _VSTD::forward<_TupBase>(__t)) {}
 
     using _CanCopyAssign = __all<is_copy_assignable<_Tp>::value...>;
     using _CanMoveAssign = __all<is_move_assignable<_Tp>::value...>;
 
     _LIBCPP_INLINE_VISIBILITY
-    tuple& operator=(typename conditional<_CanCopyAssign::value, tuple, __nat>::type const& __t)
+    tuple& operator=(typename conditional<_CanCopyAssign::value, tuple const&, __nat>::type const& __t)
         _NOEXCEPT_((__all<is_nothrow_copy_assignable<_Tp>::value...>::value))
     {
         base_.operator=(__t.base_);
         return *this;
     }
 
     _LIBCPP_INLINE_VISIBILITY
     tuple& operator=(typename conditional<_CanMoveAssign::value, tuple, __nat>::type&& __t)
         _NOEXCEPT_((__all<is_nothrow_move_assignable<_Tp>::value...>::value))
     {
         base_.operator=(static_cast<base&&>(__t.base_));
         return *this;
     }
 
     template <class _Tuple,
+              class _Deduced = __deduce_tuple_like<_Tuple>,
+              class _TupBase = typename _Deduced::_QualType,
               class = typename enable_if
                       <
-                         __tuple_assignable<_Tuple, tuple>::value
+                         __tuple_assignable<_TupBase, tuple>::value
                       >::type
              >
         _LIBCPP_INLINE_VISIBILITY
         tuple&
-        operator=(_Tuple&& __t) _NOEXCEPT_((is_nothrow_assignable<base&, _Tuple>::value))
+        operator=(_Tuple&& __t)
+          _NOEXCEPT_((is_nothrow_assignable<base&, _TupBase>::value))
         {
-            base_.operator=(_VSTD::forward<_Tuple>(__t));
+            base_.operator=(_VSTD::forward<_TupBase>(__t));
             return *this;
         }
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
         {base_.swap(__t.base_);}
 };
 

include/type_traits

 // This specialization returns __extract_key_fail_tag for non-map containers
 // because _Key == _ContainerValueTy
 template <class _ValTy, class _Key, class _RawValTy>
 struct __can_extract_map_key<_ValTy, _Key, _Key, _RawValTy>
     : false_type {};
 
 #endif
 
+#ifndef _LIBCPP_CXX03_LANG
+
+// __propagate_value_category -- A utility for detecting the value category
+// of a given type and applying that value-category to another type.
+// For example applying the cv-ref quals of a derived type to form the
+// correctly cv-qualified base type.
+template <class _FromType>
+struct __propagate_value_category {
+  template <class _ToType> struct __checked_apply {
+    static_assert(!is_reference<_ToType>::value, "must be unqualified");
+    static_assert(!is_const<_ToType>::value
+               && !is_volatile<_ToType>::value, "must be unqualified");
+    using type = _ToType;
+  };
+  template <class _ToType>
+  using __apply = typename __checked_apply<_ToType>::type;
+};
+
+template <class _FromType>
+struct __propagate_value_category<_FromType&> {
+  template <class _ToType>
+  using __apply = typename add_lvalue_reference<
+    typename __propagate_value_category<_FromType>::template __apply<_ToType>
+  >::type;
+};
+
+template <class _FromType>
+struct __propagate_value_category<_FromType&&> {
+  template <class _ToType>
+  using __apply = typename add_rvalue_reference<
+    typename __propagate_value_category<_FromType>::template __apply<_ToType>
+  >::type;
+};
+
+template <class _FromType>
+struct __propagate_value_category<_FromType const> {
+  template <class _ToType>
+  using __apply = typename add_const<
+    typename __propagate_value_category<_FromType>::template __apply<_ToType>
+  >::type;
+};
+
+template <class _FromType>
+struct __propagate_value_category<_FromType volatile> {
+  template <class _ToType>
+  using __apply = typename add_volatile<
+    typename __propagate_value_category<_FromType>::template __apply<_ToType>
+  >::type;
+};
+
+template <class _FromType>
+struct __propagate_value_category<_FromType const volatile> {
+  template <class _ToType>
+  using __apply = typename add_cv<
+    typename __propagate_value_category<_FromType>::template __apply<_ToType>
+  >::type;
+};
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_TYPE_TRAITS

test/std/utilities/tuple/tuple.tuple/tuple.assign/derived_from_tuple_like.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template <class... UTypes>
+//   tuple& operator=(const tuple<UTypes...>& u);
+
+// UNSUPPORTED: c++98, 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(42, 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(42, 101);
+    t = ValueCategoryCast<VC>(d);
+    assert(std::get<0>(t) == 42);
+    assert(std::get<1>(t).checkAssign(101, VC));
+  }
+  reset();
+  {
+    DerivedFromTup<std::array<int, 2>> d = {{{42, 101}}};
+    t = ValueCategoryCast<VC>(d);
+    assert(std::get<0>(t) == 42);
+    assert(std::get<1>(t).checkAssign(101, VC));
+  }
+}
+
+int main() {
+    do_derived_assign_test<VC_LVal | VC_Const>();
+    do_derived_assign_test<VC_RVal>();
+#if defined(_LIBCPP_VERSION)
+    // Non-const copy assign and const move assign are libc++ extensions.
+    do_derived_assign_test<VC_LVal>();
+    do_derived_assign_test<VC_RVal | VC_Const>();
+#endif
+}

test/std/utilities/tuple/tuple.tuple/tuple.cnstr/derived_from_tuple_like.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template <class... UTypes>
+//   tuple& operator=(const tuple<UTypes...>& u);
+
+// UNSUPPORTED: c++98, c++03
+
+#include <tuple>
+#include <array>
+#include <string>
+#include <utility>
+#include <cassert>
+
+#include "propagate_value_category.hpp"
+
+template <bool Explicit = false>
+struct TracksIntQuals {
+  TracksIntQuals() : value(-1), value_category(VC_None), assigned(false) {}
+
+  template <
+      class Tp,
+      typename std::enable_if<Explicit &&
+                                  !std::is_same<typename std::decay<Tp>::type,
+                                                TracksIntQuals>::value,
+                              bool>::type = false>
+  explicit TracksIntQuals(Tp &&x)
+      : value(x), value_category(getValueCategory<Tp &&>()), assigned(false) {
+    static_assert(std::is_same<UnCVRef<Tp>, int>::value, "");
+  }
+
+  template <
+      class Tp,
+      typename std::enable_if<!Explicit &&
+                                  !std::is_same<typename std::decay<Tp>::type,
+                                                TracksIntQuals>::value,
+                              bool>::type = false>
+  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_construct_test() {
+  using Tup1 = std::tuple<long, TracksIntQuals</*Explicit*/ false>>;
+  {
+    DerivedFromTup<std::tuple<int, int>> d(42, 101);
+    Tup1 t = ValueCategoryCast<VC>(d);
+    assert(std::get<0>(t) == 42);
+    assert(std::get<1>(t).checkConstruct(101, VC));
+  }
+  {
+    DerivedFromTup<std::pair<int, int>> d(42, 101);
+    Tup1 t = ValueCategoryCast<VC>(d);
+    assert(std::get<0>(t) == 42);
+    assert(std::get<1>(t).checkConstruct(101, VC));
+  }
+  {
+    DerivedFromTup<std::array<int, 2>> d = {{{42, 101}}};
+    Tup1 t = ValueCategoryCast<VC>(d);
+    assert(std::get<0>(t) == 42);
+    assert(std::get<1>(t).checkConstruct(101, VC));
+  }
+
+  using Tup2 = std::tuple<long, TracksIntQuals</*Explicit*/ true>>;
+  {
+    using D = DerivedFromTup<std::tuple<int, int>>;
+    static_assert(!std::is_convertible<ApplyValueCategoryT<VC, D>, Tup2>::value,
+                  "");
+    D d(42, 101);
+    Tup2 t(ValueCategoryCast<VC>(d));
+    assert(std::get<0>(t) == 42);
+    assert(std::get<1>(t).checkConstruct(101, VC));
+  }
+  {
+    using D = DerivedFromTup<std::pair<int, int>>;
+    static_assert(!std::is_convertible<ApplyValueCategoryT<VC, D>, Tup2>::value,
+                  "");
+    D d(42, 101);
+    Tup2 t(ValueCategoryCast<VC>(d));
+    assert(std::get<0>(t) == 42);
+    assert(std::get<1>(t).checkConstruct(101, VC));
+  }
+  {
+    using D = DerivedFromTup<std::array<int, 2>>;
+    static_assert(!std::is_convertible<ApplyValueCategoryT<VC, D>, Tup2>::value,
+                  "");
+    D d = {{{42, 101}}};
+    Tup2 t(ValueCategoryCast<VC>(d));
+    assert(std::get<0>(t) == 42);
+    assert(std::get<1>(t).checkConstruct(101, VC));
+  }
+}
+
+int main() {
+  do_derived_construct_test<VC_LVal | VC_Const>();
+  do_derived_construct_test<VC_RVal>();
+#if defined(_LIBCPP_VERSION)
+  // Supporting non-const copy and const move are libc++ extensions
+  do_derived_construct_test<VC_LVal>();
+  do_derived_construct_test<VC_RVal | VC_Const>();
+#endif
+}

test/support/propagate_value_category.hpp

+#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