[libcxx] Fix tuple construction/assignment from types derived from tuple/pair/array.
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]( https://llvm.org/bugs/show_bug.cgi?id=17550)
This patch
Reviewers: mclow.lists, K-ballo, mpark, EricWF
Subscribers: cfe-commits
Differential Revision: https://reviews.llvm.org/D27606
llvm-svn: 289727
Cr-Mirrored-From: sso://chromium.googlesource.com/_direct/external/github.com/llvm/llvm-project
Cr-Mirrored-Commit: f8136d08c6b1e1d7b922d12b202736f38e21f33c
diff --git a/include/__tuple b/include/__tuple
index 775d734..8e6d2bd 100644
--- a/include/__tuple
+++ b/include/__tuple
@@ -453,19 +453,57 @@
#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 _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 _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 ..._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 ...>
diff --git a/include/tuple b/include/tuple
index 553d8e5..c9146fd 100644
--- a/include/tuple
+++ b/include/tuple
@@ -555,13 +555,19 @@
{
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;
}
};
@@ -814,66 +820,74 @@
_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_);
@@ -889,16 +903,19 @@
}
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;
}
diff --git a/include/type_traits b/include/type_traits
index fbfc9d3..c2b90ea 100644
--- a/include/type_traits
+++ b/include/type_traits
@@ -4696,6 +4696,65 @@
#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