Author: ericwf
Date: Sun Jul 24 23:32:07 2016
New Revision: 276605
URL: http://llvm.org/viewvc/llvm-project?rev=276605&view=rev
Log:
Implement the std::pair parts of "Improving pair and tuple". Completes N4387.
Added:
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second_cxx03.pass.cpp
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V_cxx03.pass.cpp
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/not_constexpr_cxx11.fail.cpp
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/special_member_generation_test.pass.cpp
libcxx/trunk/test/support/archetypes.hpp
Modified:
libcxx/trunk/include/__tuple
libcxx/trunk/include/tuple
libcxx/trunk/include/utility
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/U_V.pass.cpp
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
libcxx/trunk/www/cxx1z_status.html
Modified: libcxx/trunk/include/__tuple
URL:
http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/__tuple?rev=276605&r1=276604&r2=276605&view=diff
==============================================================================
--- libcxx/trunk/include/__tuple (original)
+++ libcxx/trunk/include/__tuple Sun Jul 24 23:32:07 2016
@@ -146,6 +146,12 @@ template <class ..._Tp> class _LIBCPP_TY
template <class... _Tp> struct __tuple_like<tuple<_Tp...> > : true_type {};
+template <class ..._Tp>
+class _LIBCPP_TYPE_VIS_ONLY tuple_size<tuple<_Tp...> >
+ : public integral_constant<size_t, sizeof...(_Tp)>
+{
+};
+
template <size_t _Ip, class ..._Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
typename tuple_element<_Ip, tuple<_Tp...> >::type&
@@ -431,8 +437,48 @@ struct __tuple_assignable<_Tp, _Up, true
>
{};
+
+template <size_t _Ip, class ..._Tp>
+class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, tuple<_Tp...> >
+{
+public:
+ typedef typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;
+};
+
+#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
+ >;
+
+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; }
+ template <class ...>
+ static constexpr bool __enable_assign() { return false; }
+};
+#endif
+
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TUPLE
Modified: libcxx/trunk/include/tuple
URL:
http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/tuple?rev=276605&r1=276604&r2=276605&view=diff
==============================================================================
--- libcxx/trunk/include/tuple (original)
+++ libcxx/trunk/include/tuple Sun Jul 24 23:32:07 2016
@@ -150,27 +150,6 @@ _LIBCPP_BEGIN_NAMESPACE_STD
#ifndef _LIBCPP_HAS_NO_VARIADICS
-// tuple_size
-
-template <class ..._Tp>
-class _LIBCPP_TYPE_VIS_ONLY tuple_size<tuple<_Tp...> >
- : public integral_constant<size_t, sizeof...(_Tp)>
-{
-};
-
-// tuple_element
-
-template <size_t _Ip, class ..._Tp>
-class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, tuple<_Tp...> >
-{
-public:
- typedef typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;
-};
-
-#if _LIBCPP_STD_VER > 11
-template <size_t _Ip, class ..._Tp>
-using tuple_element_t = typename tuple_element <_Ip, _Tp...>::type;
-#endif
// __tuple_leaf
@@ -489,27 +468,7 @@ struct __tuple_impl<__tuple_indices<_Ind
}
};
-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
- >;
-
-
-struct _LIBCPP_TYPE_VIS __check_tuple_constructor_fail {
- template <class ...>
- static constexpr bool __enable_explicit() { return false; }
- template <class ...>
- static constexpr bool __enable_implicit() { return false; }
-};
template <class ..._Tp>
class _LIBCPP_TYPE_VIS_ONLY tuple
@@ -532,6 +491,11 @@ class _LIBCPP_TYPE_VIS_ONLY tuple
struct _CheckArgsConstructor<true, _Dummy>
{
template <class ..._Args>
+ static constexpr bool __enable_default() {
+ return __all<is_default_constructible<_Args>::value...>::value;
+ }
+
+ template <class ..._Args>
static constexpr bool __enable_explicit() {
return
__tuple_constructible<
@@ -641,7 +605,7 @@ class _LIBCPP_TYPE_VIS_ONLY tuple
public:
template <bool _Dummy = true, class = typename enable_if<
- __all<__dependent_type<is_default_constructible<_Tp>,
_Dummy>::value...>::value
+ _CheckArgsConstructor<_Dummy>::template __enable_default<_Tp...>()
>::type>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR tuple()
@@ -1362,6 +1326,9 @@ template <class ..._Tp, class _Alloc>
struct _LIBCPP_TYPE_VIS_ONLY uses_allocator<tuple<_Tp...>, _Alloc>
: true_type {};
+#endif // _LIBCPP_HAS_NO_VARIADICS
+
+#ifndef _LIBCPP_CXX03_LANG
template <class _T1, class _T2>
template <class... _Args1, class... _Args2, size_t ..._I1, size_t ..._I2>
inline _LIBCPP_INLINE_VISIBILITY
@@ -1372,8 +1339,7 @@ pair<_T1, _T2>::pair(piecewise_construct
second(_VSTD::forward<_Args2>(_VSTD::get<_I2>(__second_args))...)
{
}
-
-#endif // _LIBCPP_HAS_NO_VARIADICS
+#endif // _LIBCPP_CXX03_LANG
#if _LIBCPP_STD_VER > 14
template <class _Tp>
Modified: libcxx/trunk/include/utility
URL:
http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/utility?rev=276605&r1=276604&r2=276605&view=diff
==============================================================================
--- libcxx/trunk/include/utility (original)
+++ libcxx/trunk/include/utility Sun Jul 24 23:32:07 2016
@@ -291,6 +291,7 @@ extern const piecewise_construct_t piece
constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
#endif
+
template <class _T1, class _T2>
struct _LIBCPP_TYPE_VIS_ONLY pair
{
@@ -300,28 +301,6 @@ struct _LIBCPP_TYPE_VIS_ONLY pair
_T1 first;
_T2 second;
-#ifndef _LIBCPP_HAS_NO_DEFAULT_FUNCTION_TEMPLATE_ARGS
- template <bool _Dummy = true, class = typename enable_if<
- __dependent_type<is_default_constructible<_T1>, _Dummy>::value &&
- __dependent_type<is_default_constructible<_T2>, _Dummy>::value
- >::type>
-#endif
- _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR pair() : first(), second() {}
-
- _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
- pair(const _T1& __x, const _T2& __y)
- : first(__x), second(__y) {}
-
- template<class _U1, class _U2>
- _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
- pair(const pair<_U1, _U2>& __p
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
- ,typename enable_if<is_convertible<const _U1&, _T1>::value &&
- is_convertible<const _U2&,
_T2>::value>::type* = 0
-#endif
- )
- : first(__p.first), second(__p.second) {}
-
#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
_LIBCPP_INLINE_VISIBILITY
pair(const pair& __p)
@@ -348,23 +327,172 @@ struct _LIBCPP_TYPE_VIS_ONLY pair
// Use the implicitly declared copy constructor in C++03
#endif
-#if !defined(_LIBCPP_CXX03_LANG)
- typedef typename conditional<
- is_copy_assignable<_T1>::value
- && is_copy_assignable<_T2>::value,
- pair, __nat
- >::type _CopyAssignT;
- typedef typename conditional<
- is_move_assignable<_T1>::value
- && is_move_assignable<_T2>::value,
- pair, __nat
- >::type _MoveAssignT;
+#ifdef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ pair() : first(), second() {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ pair(_T1 const& __t1, _T2 const& __t2) : first(__t1), second(__t2) {}
+
+ template <class _U1, class _U2>
+ _LIBCPP_INLINE_VISIBILITY
+ pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ pair& operator=(pair const& __p) {
+ first = __p.first;
+ second = __p.second;
+ return *this;
+ }
#else
- typedef pair _CopyAssignT;
-#endif
+ template <bool _Val>
+ using _EnableB = typename enable_if<_Val, bool>::type;
+
+ struct _CheckArgs {
+ template <class _U1, class _U2>
+ static constexpr bool __enable_default() {
+ return is_default_constructible<_U1>::value
+ && is_default_constructible<_U2>::value;
+ }
+
+ template <class _U1, class _U2>
+ static constexpr bool __enable_explicit() {
+ return is_constructible<first_type, _U1>::value
+ && is_constructible<second_type, _U2>::value
+ && (!is_convertible<_U1, first_type>::value
+ || !is_convertible<_U2, second_type>::value);
+ }
+
+ template <class _U1, class _U2>
+ static constexpr bool __enable_implicit() {
+ return is_constructible<first_type, _U1>::value
+ && is_constructible<second_type, _U2>::value
+ && is_convertible<_U1, first_type>::value
+ && is_convertible<_U2, second_type>::value;
+ }
+ };
+
+ template <bool _MaybeEnable>
+ using _CheckArgsDep = typename conditional<
+ _MaybeEnable, _CheckArgs, __check_tuple_constructor_fail>::type;
+
+ struct _CheckTupleLikeConstructor {
+ template <class _Tuple>
+ static constexpr bool __enable_implicit() {
+ return __tuple_convertible<_Tuple, pair>::value;
+ }
+
+ template <class _Tuple>
+ static constexpr bool __enable_explicit() {
+ return __tuple_constructible<_Tuple, pair>::value
+ && !__tuple_convertible<_Tuple, pair>::value;
+ }
+
+ template <class _Tuple>
+ static constexpr bool __enable_assign() {
+ return __tuple_assignable<_Tuple, pair>::value;
+ }
+ };
+
+ template <class _Tuple>
+ using _CheckTLC = typename conditional<
+ __tuple_like_with_size<_Tuple, 2>::value
+ && !is_same<typename decay<_Tuple>::type, pair>::value,
+ _CheckTupleLikeConstructor,
+ __check_tuple_constructor_fail
+ >::type;
+
+ template<bool _Dummy = true, _EnableB<
+ _CheckArgsDep<_Dummy>::template __enable_default<_T1, _T2>()
+ > = false>
+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
+ pair() : first(), second() {}
+
+ template <bool _Dummy = true, _EnableB<
+ _CheckArgsDep<_Dummy>::template __enable_explicit<_T1 const&, _T2
const&>()
+ > = false>
+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+ explicit pair(_T1 const& __t1, _T2 const& __t2)
+ : first(__t1), second(__t2) {}
+
+ template<bool _Dummy = true, _EnableB<
+ _CheckArgsDep<_Dummy>::template __enable_implicit<_T1 const&, _T2
const&>()
+ > = false>
+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+ pair(_T1 const& __t1, _T2 const& __t2)
+ : first(__t1), second(__t2) {}
+
+ template<class _U1, class _U2, _EnableB<
+ _CheckArgs::template __enable_explicit<_U1, _U2>()
+ > = false>
+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+ explicit pair(_U1&& __u1, _U2&& __u2)
+ : first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2))
{}
+
+ template<class _U1, class _U2, _EnableB<
+ _CheckArgs::template __enable_implicit<_U1, _U2>()
+ > = false>
+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+ pair(_U1&& __u1, _U2&& __u2)
+ : first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2))
{}
+
+ template<class _U1, class _U2, _EnableB<
+ _CheckArgs::template __enable_explicit<_U1 const&, _U2 const&>()
+ > = false>
+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+ explicit pair(pair<_U1, _U2> const& __p)
+ : first(__p.first), second(__p.second) {}
+
+ template<class _U1, class _U2, _EnableB<
+ _CheckArgs::template __enable_implicit<_U1 const&, _U2 const&>()
+ > = false>
+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+ pair(pair<_U1, _U2> const& __p)
+ : first(__p.first), second(__p.second) {}
+
+ template<class _U1, class _U2, _EnableB<
+ _CheckArgs::template __enable_explicit<_U1, _U2>()
+ > = false>
+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+ explicit pair(pair<_U1, _U2>&&__p)
+ : first(_VSTD::forward<_U1>(__p.first)),
second(_VSTD::forward<_U2>(__p.second)) {}
+
+ template<class _U1, class _U2, _EnableB<
+ _CheckArgs::template __enable_implicit<_U1, _U2>()
+ > = false>
+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+ pair(pair<_U1, _U2>&& __p)
+ : first(_VSTD::forward<_U1>(__p.first)),
second(_VSTD::forward<_U2>(__p.second)) {}
+
+ template<class _Tuple, _EnableB<
+ _CheckTLC<_Tuple>::template __enable_explicit<_Tuple>()
+ > = false>
+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+ explicit pair(_Tuple&& __p)
+ : first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))),
+ second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {}
+
+ template<class _Tuple, _EnableB<
+ _CheckTLC<_Tuple>::template __enable_implicit<_Tuple>()
+ > = false>
+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+ pair(_Tuple&& __p)
+ : first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))),
+ second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {}
+
+ template <class... _Args1, class... _Args2>
+ _LIBCPP_INLINE_VISIBILITY
+ pair(piecewise_construct_t __pc,
+ tuple<_Args1...> __first_args, tuple<_Args2...> __second_args)
+ : pair(__pc, __first_args, __second_args,
+ typename __make_tuple_indices<sizeof...(_Args1)>::type(),
+ typename __make_tuple_indices<sizeof...(_Args2) >::type()) {}
_LIBCPP_INLINE_VISIBILITY
- pair& operator=(_CopyAssignT const& __p)
+ pair& operator=(typename conditional<
+ is_copy_assignable<first_type>::value &&
+ is_copy_assignable<second_type>::value,
+ pair, __nat>::type const& __p)
_NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value &&
is_nothrow_copy_assignable<second_type>::value)
{
@@ -373,9 +501,11 @@ struct _LIBCPP_TYPE_VIS_ONLY pair
return *this;
}
-#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY
- pair& operator=(_MoveAssignT&& __p)
+ pair& operator=(typename conditional<
+ is_move_assignable<first_type>::value &&
+ is_move_assignable<second_type>::value,
+ pair, __nat>::type&& __p)
_NOEXCEPT_(is_nothrow_move_assignable<first_type>::value &&
is_nothrow_move_assignable<second_type>::value)
{
@@ -383,68 +513,18 @@ struct _LIBCPP_TYPE_VIS_ONLY pair
second = _VSTD::forward<second_type>(__p.second);
return *this;
}
-#endif
-
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
- template <class _U1, class _U2,
- class = typename enable_if<is_convertible<_U1,
first_type>::value &&
- is_convertible<_U2,
second_type>::value>::type>
- _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
- pair(_U1&& __u1, _U2&& __u2)
- : first(_VSTD::forward<_U1>(__u1)),
- second(_VSTD::forward<_U2>(__u2))
- {}
-
- template<class _U1, class _U2>
- _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
- pair(pair<_U1, _U2>&& __p,
- typename enable_if<is_convertible<_U1, _T1>::value &&
- is_convertible<_U2, _T2>::value>::type* =
0)
- : first(_VSTD::forward<_U1>(__p.first)),
- second(_VSTD::forward<_U2>(__p.second)) {}
+ template <class _Tuple, _EnableB<
+ _CheckTLC<_Tuple>::template __enable_assign()
+ > = false>
+ _LIBCPP_INLINE_VISIBILITY
+ pair& operator=(_Tuple&& __p) {
+ first = _VSTD::get<0>(_VSTD::forward<_Tuple>(__p));
+ second = _VSTD::get<1>(_VSTD::forward<_Tuple>(__p));
+ return *this;
+ }
+#endif
-
-#ifndef _LIBCPP_HAS_NO_VARIADICS
- template<class _Tuple,
- class = typename enable_if<__tuple_convertible<_Tuple,
pair>::value>::type>
- _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
- pair(_Tuple&& __p)
- : first(_VSTD::forward<typename tuple_element<0,
- typename
__make_tuple_types<_Tuple>::type>::type>(_VSTD::get<0>(__p))),
- second(_VSTD::forward<typename tuple_element<1,
- typename
__make_tuple_types<_Tuple>::type>::type>(_VSTD::get<1>(__p)))
- {}
-
-
-
- template <class... _Args1, class... _Args2>
- _LIBCPP_INLINE_VISIBILITY
- pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args,
- tuple<_Args2...> __second_args)
- : pair(__pc, __first_args, __second_args,
- typename __make_tuple_indices<sizeof...(_Args1)>::type(),
- typename __make_tuple_indices<sizeof...(_Args2) >::type())
- {}
-
- template <class _Tuple,
- class = typename enable_if<!is_same<typename
decay<_Tuple>::type, pair>::value && __tuple_assignable<_Tuple,
pair>::value>::type>
- _LIBCPP_INLINE_VISIBILITY
- pair&
- operator=(_Tuple&& __p)
- {
- typedef typename __make_tuple_types<_Tuple>::type _TupleRef;
- typedef typename tuple_element<0, _TupleRef>::type _U0;
- typedef typename tuple_element<1, _TupleRef>::type _U1;
- first = _VSTD::forward<_U0>(_VSTD::get<0>(__p));
- second = _VSTD::forward<_U1>(_VSTD::get<1>(__p));
- return *this;
- }
-
-#endif // _LIBCPP_HAS_NO_VARIADICS
-
-#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
void
swap(pair& __p) _NOEXCEPT_(__is_nothrow_swappable<first_type>::value &&
@@ -456,13 +536,13 @@ struct _LIBCPP_TYPE_VIS_ONLY pair
}
private:
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+#ifndef _LIBCPP_CXX03_LANG
template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
_LIBCPP_INLINE_VISIBILITY
pair(piecewise_construct_t,
tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
__tuple_indices<_I1...>, __tuple_indices<_I2...>);
-#endif // _LIBCPP_HAS_NO_VARIADICS
+#endif
};
template <class _T1, class _T2>
Modified: libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/U_V.pass.cpp
URL:
http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/U_V.pass.cpp?rev=276605&r1=276604&r2=276605&view=diff
==============================================================================
--- libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/U_V.pass.cpp
(original)
+++ libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/U_V.pass.cpp Sun
Jul 24 23:32:07 2016
@@ -7,24 +7,93 @@
//
//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03
+
// <utility>
// template <class T1, class T2> struct pair
// template<class U, class V> pair(U&& x, V&& y);
+
#include <utility>
#include <memory>
#include <cassert>
+#include "archetypes.hpp"
+#include "test_convertible.hpp"
+
+template <class T1, class T1Arg,
+ bool CanCopy = true, bool CanConvert = CanCopy>
+void test_sfinae() {
+ using P1 = std::pair<T1, int>;
+ using P2 = std::pair<int, T1>;
+ using T2 = int const&;
+ static_assert(std::is_constructible<P1, T1Arg, T2>::value == CanCopy, "");
+ static_assert(test_convertible<P1, T1Arg, T2>() == CanConvert, "");
+ static_assert(std::is_constructible<P2, T2, T1Arg>::value == CanCopy,
"");
+ static_assert(test_convertible<P2, T2, T1Arg>() == CanConvert, "");
+}
+
+struct ExplicitT {
+ constexpr explicit ExplicitT(int x) : value(x) {}
+ int value;
+};
+
+struct ImplicitT {
+ constexpr ImplicitT(int x) : value(x) {}
+ int value;
+};
+
+
int main()
{
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
typedef std::pair<std::unique_ptr<int>, short*> P;
P p(std::unique_ptr<int>(new int(3)), nullptr);
assert(*p.first == 3);
assert(p.second == nullptr);
}
-#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+ {
+ // Test non-const lvalue and rvalue types
+ test_sfinae<AllCtors, AllCtors&>();
+ test_sfinae<AllCtors, AllCtors&&>();
+ test_sfinae<ExplicitAllCtors, ExplicitAllCtors&, true, false>();
+ test_sfinae<ExplicitAllCtors, ExplicitAllCtors&&, true, false>();
+ test_sfinae<CopyOnly, CopyOnly&>();
+ test_sfinae<CopyOnly, CopyOnly&&>();
+ test_sfinae<ExplicitCopyOnly, ExplicitCopyOnly&, true, false>();
+ test_sfinae<ExplicitCopyOnly, ExplicitCopyOnly&&, true, false>();
+ test_sfinae<MoveOnly, MoveOnly&, false>();
+ test_sfinae<MoveOnly, MoveOnly&&>();
+ test_sfinae<ExplicitMoveOnly, ExplicitMoveOnly&, false>();
+ test_sfinae<ExplicitMoveOnly, ExplicitMoveOnly&&, true, false>();
+ test_sfinae<NonCopyable, NonCopyable&, false>();
+ test_sfinae<NonCopyable, NonCopyable&&, false>();
+ test_sfinae<ExplicitNonCopyable, ExplicitNonCopyable&, false>();
+ test_sfinae<ExplicitNonCopyable, ExplicitNonCopyable&&, false>();
+ }
+ {
+ // Test converting types
+ test_sfinae<ConvertingType, int&>();
+ test_sfinae<ConvertingType, const int&>();
+ test_sfinae<ConvertingType, int&&>();
+ test_sfinae<ConvertingType, const int&&>();
+ test_sfinae<ExplicitConvertingType, int&, true, false>();
+ test_sfinae<ExplicitConvertingType, const int&, true, false>();
+ test_sfinae<ExplicitConvertingType, int&&, true, false>();
+ test_sfinae<ExplicitConvertingType, const int&&, true, false>();
+ }
+#if TEST_STD_VER > 11
+ { // explicit constexpr test
+ constexpr std::pair<ExplicitT, ExplicitT> p(42, 43);
+ static_assert(p.first.value == 42, "");
+ static_assert(p.second.value == 43, "");
+ }
+ { // implicit constexpr test
+ constexpr std::pair<ImplicitT, ImplicitT> p = {42, 43};
+ static_assert(p.first.value == 42, "");
+ static_assert(p.second.value == 43, "");
+ }
+#endif
}
Modified:
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp
URL:
http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp?rev=276605&r1=276604&r2=276605&view=diff
==============================================================================
---
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp
(original)
+++
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second.pass.cpp
Sun Jul 24 23:32:07 2016
@@ -7,6 +7,8 @@
//
//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03
+
// <utility>
// template <class T1, class T2> struct pair
@@ -16,25 +18,33 @@
#include <utility>
#include <cassert>
-class A
-{
- int data_;
-public:
- A(int data) : data_(data) {}
+#include "archetypes.hpp"
+#include "test_convertible.hpp"
- bool operator==(const A& a) const {return data_ == a.data_;}
+struct ExplicitT {
+ constexpr explicit ExplicitT(int x) : value(x) {}
+ constexpr explicit ExplicitT(ExplicitT const& o) : value(o.value) {}
+ int value;
};
-#if _LIBCPP_STD_VER > 11
-class AC
-{
- int data_;
-public:
- constexpr AC(int data) : data_(data) {}
-
- constexpr bool operator==(const AC& a) const {return data_ == a.data_;}
+struct ImplicitT {
+ constexpr ImplicitT(int x) : value(x) {}
+ constexpr ImplicitT(ImplicitT const& o) : value(o.value) {}
+ int value;
};
-#endif
+
+template <class T1,
+ bool CanCopy = true, bool CanConvert = CanCopy>
+void test_sfinae() {
+ using P1 = std::pair<T1, int>;
+ using P2 = std::pair<int, T1>;
+ using T1Arg = T1 const&;
+ using T2 = int const&;
+ static_assert(std::is_constructible<P1, T1Arg, T2>::value == CanCopy, "");
+ static_assert(test_convertible<P1, T1Arg, T2>() == CanConvert, "");
+ static_assert(std::is_constructible<P2, T2, T1Arg>::value == CanCopy,
"");
+ static_assert(test_convertible<P2, T2, T1Arg>() == CanConvert, "");
+}
int main()
{
@@ -45,13 +55,22 @@ int main()
assert(p.second == nullptr);
}
{
- typedef std::pair<A, int> P;
+ typedef std::pair<ImplicitT, int> P;
P p(1, 2);
- assert(p.first == A(1));
+ assert(p.first.value == 1);
assert(p.second == 2);
}
-
-#if _LIBCPP_STD_VER > 11
+ {
+ test_sfinae<AllCtors>();
+ test_sfinae<ExplicitAllCtors, true, false>();
+ test_sfinae<CopyOnly>();
+ test_sfinae<ExplicitCopyOnly, true, false>();
+ test_sfinae<MoveOnly, false>();
+ test_sfinae<ExplicitMoveOnly, false>();
+ test_sfinae<NonCopyable, false>();
+ test_sfinae<ExplicitNonCopyable, false>();
+ }
+#if TEST_STD_VER > 11
{
typedef std::pair<float, short*> P;
constexpr P p(3.5f, 0);
@@ -59,10 +78,20 @@ int main()
static_assert(p.second == nullptr, "");
}
{
- typedef std::pair<AC, int> P;
- constexpr P p(1, 2);
- static_assert(p.first == AC(1), "");
- static_assert(p.second == 2, "");
+ using P = std::pair<ExplicitT, int>;
+ constexpr ExplicitT e(42);
+ constexpr int x = 10;
+ constexpr P p(e, x);
+ static_assert(p.first.value == 42, "");
+ static_assert(p.second == 10, "");
+ }
+ {
+ using P = std::pair<ImplicitT, int>;
+ constexpr ImplicitT e(42);
+ constexpr int x = 10;
+ constexpr P p = {e, x};
+ static_assert(p.first.value == 42, "");
+ static_assert(p.second == 10, "");
}
#endif
}
Added:
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second_cxx03.pass.cpp
URL:
http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second_cxx03.pass.cpp?rev=276605&view=auto
==============================================================================
---
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second_cxx03.pass.cpp
(added)
+++
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/const_first_const_second_cxx03.pass.cpp
Sun Jul 24 23:32:07 2016
@@ -0,0 +1,42 @@
+//===----------------------------------------------------------------------===//
+//
+// 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.
+//
+//===----------------------------------------------------------------------===//
+
+// <utility>
+
+// template <class T1, class T2> struct pair
+
+// pair(const T1& x, const T2& y);
+
+#include <utility>
+#include <cassert>
+
+class A
+{
+ int data_;
+public:
+ A(int data) : data_(data) {}
+
+ bool operator==(const A& a) const {return data_ == a.data_;}
+};
+
+int main()
+{
+ {
+ typedef std::pair<float, short*> P;
+ P p(3.5f, 0);
+ assert(p.first == 3.5f);
+ assert(p.second == nullptr);
+ }
+ {
+ typedef std::pair<A, int> P;
+ P p(1, 2);
+ assert(p.first == A(1));
+ assert(p.second == 2);
+ }
+}
Modified:
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
URL:
http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp?rev=276605&r1=276604&r2=276605&view=diff
==============================================================================
---
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
(original)
+++
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
Sun Jul 24 23:32:07 2016
@@ -7,27 +7,151 @@
//
//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03
+
// <utility>
// template <class T1, class T2> struct pair
-// template <class U, class V> pair(const pair<U, V>& p);
+// template <class U, class V> EXPLICIT constexpr pair(const pair<U, V>& p);
#include <utility>
#include <cassert>
+#include "archetypes.hpp"
+#include "test_convertible.hpp"
+
+template <class T1, class U1,
+ bool CanCopy = true, bool CanConvert = CanCopy>
+void test_pair_const()
+{
+ using P1 = std::pair<T1, int>;
+ using P2 = std::pair<int, T1>;
+ using UP1 = std::pair<U1, int> const&;
+ using UP2 = std::pair<int, U1> const&;
+ static_assert(std::is_constructible<P1, UP1>::value == CanCopy, "");
+ static_assert(test_convertible<P1, UP1>() == CanConvert, "");
+ static_assert(std::is_constructible<P2, UP2>::value == CanCopy, "");
+ static_assert(test_convertible<P2, UP2>() == CanConvert, "");
+}
+
+template <class T, class U>
+struct DPair : public std::pair<T, U> {
+ using Base = std::pair<T, U>;
+ using Base::Base;
+};
+
+struct ExplicitT {
+ constexpr explicit ExplicitT(int x) : value(x) {}
+ constexpr explicit ExplicitT(ExplicitT const& o) : value(o.value) {}
+ int value;
+};
+
+struct ImplicitT {
+ constexpr ImplicitT(int x) : value(x) {}
+ constexpr ImplicitT(ImplicitT const& o) : value(o.value) {}
+ int value;
+};
+
int main()
{
{
typedef std::pair<int, short> P1;
typedef std::pair<double, long> P2;
- P1 p1(3, 4);
- P2 p2 = p1;
+ const P1 p1(3, 4);
+ const P2 p2 = p1;
assert(p2.first == 3);
assert(p2.second == 4);
}
+ {
+ // We allow derived types to use this constructor
+ using P1 = DPair<long, long>;
+ using P2 = std::pair<int, int>;
+ P1 p1(42, 101);
+ P2 p2(p1);
+ assert(p2.first == 42);
+ assert(p2.second = 101);
+ }
+ {
+ test_pair_const<AllCtors, AllCtors>(); // copy construction
+ test_pair_const<AllCtors, AllCtors&>();
+ test_pair_const<AllCtors, AllCtors&&>();
+ test_pair_const<AllCtors, const AllCtors&>();
+ test_pair_const<AllCtors, const AllCtors&&>();
+
+ test_pair_const<ExplicitAllCtors, ExplicitAllCtors>(); // copy
construction
+ test_pair_const<ExplicitAllCtors, ExplicitAllCtors&, true, false>();
+ test_pair_const<ExplicitAllCtors, ExplicitAllCtors&&, true, false>();
+ test_pair_const<ExplicitAllCtors, const ExplicitAllCtors&, true,
false>();
+ test_pair_const<ExplicitAllCtors, const ExplicitAllCtors&&, true,
false>();
+
+ test_pair_const<MoveOnly, MoveOnly, false>(); // copy construction
+ test_pair_const<MoveOnly, MoveOnly&, false>();
+ test_pair_const<MoveOnly, MoveOnly&&, false>();
+
+ test_pair_const<ExplicitMoveOnly, ExplicitMoveOnly, false>(); // copy
construction
+ test_pair_const<ExplicitMoveOnly, ExplicitMoveOnly&, false>();
+ test_pair_const<ExplicitMoveOnly, ExplicitMoveOnly&&, false>();
+
+ test_pair_const<CopyOnly, CopyOnly>();
+ test_pair_const<CopyOnly, CopyOnly&>();
+ test_pair_const<CopyOnly, CopyOnly&&>();
+
+ test_pair_const<ExplicitCopyOnly, ExplicitCopyOnly>();
+ test_pair_const<ExplicitCopyOnly, ExplicitCopyOnly&, true, false>();
+ test_pair_const<ExplicitCopyOnly, ExplicitCopyOnly&&, true, false>();
+
+ test_pair_const<NonCopyable, NonCopyable, false>();
+ test_pair_const<NonCopyable, NonCopyable&, false>();
+ test_pair_const<NonCopyable, NonCopyable&&, false>();
+ test_pair_const<NonCopyable, const NonCopyable&, false>();
+ test_pair_const<NonCopyable, const NonCopyable&&, false>();
+ }
-#if _LIBCPP_STD_VER > 11
+ { // Test construction of references
+ test_pair_const<NonCopyable&, NonCopyable&>();
+ test_pair_const<NonCopyable&, NonCopyable&&>();
+ test_pair_const<NonCopyable&, NonCopyable const&, false>();
+ test_pair_const<NonCopyable const&, NonCopyable&&>();
+ test_pair_const<NonCopyable&&, NonCopyable&&, false>();
+
+ test_pair_const<ConvertingType&, int, false>();
+ test_pair_const<ExplicitConvertingType&, int, false>();
+ // Unfortunately the below conversions are allowed and create dangling
+ // references.
+ //test_pair_const<ConvertingType&&, int>();
+ //test_pair_const<ConvertingType const&, int>();
+ //test_pair_const<ConvertingType const&&, int>();
+ // But these are not because the converting constructor is explicit.
+ test_pair_const<ExplicitConvertingType&&, int, false>();
+ test_pair_const<ExplicitConvertingType const&, int, false>();
+ test_pair_const<ExplicitConvertingType const&&, int, false>();
+
+ }
+ {
+ test_pair_const<AllCtors, int, false>();
+ test_pair_const<ExplicitAllCtors, int, false>();
+ test_pair_const<ConvertingType, int>();
+ test_pair_const<ExplicitConvertingType, int, true, false>();
+
+ test_pair_const<ConvertingType, int>();
+ test_pair_const<ConvertingType, ConvertingType>();
+ test_pair_const<ConvertingType, ConvertingType const&>();
+ test_pair_const<ConvertingType, ConvertingType&>();
+ test_pair_const<ConvertingType, ConvertingType&&>();
+
+ test_pair_const<ExplicitConvertingType, int, true, false>();
+ test_pair_const<ExplicitConvertingType, int&, true, false>();
+ test_pair_const<ExplicitConvertingType, const int&, true, false>();
+ test_pair_const<ExplicitConvertingType, int&&, true, false>();
+ test_pair_const<ExplicitConvertingType, const int&&, true, false>();
+
+ test_pair_const<ExplicitConvertingType, ExplicitConvertingType>();
+ test_pair_const<ExplicitConvertingType, ExplicitConvertingType const&,
true, false>();
+ test_pair_const<ExplicitConvertingType, ExplicitConvertingType&, true,
false>();
+ test_pair_const<ExplicitConvertingType, ExplicitConvertingType&&,
true, false>();
+ }
+#if TEST_STD_VER > 11
{
typedef std::pair<int, short> P1;
typedef std::pair<double, long> P2;
@@ -36,5 +160,21 @@ int main()
static_assert(p2.first == 3, "");
static_assert(p2.second == 4, "");
}
+ {
+ using P1 = std::pair<int, int>;
+ using P2 = std::pair<ExplicitT, ExplicitT>;
+ constexpr P1 p1(42, 101);
+ constexpr P2 p2(p1);
+ static_assert(p2.first.value == 42, "");
+ static_assert(p2.second.value == 101, "");
+ }
+ {
+ using P1 = std::pair<int, int>;
+ using P2 = std::pair<ImplicitT, ImplicitT>;
+ constexpr P1 p1(42, 101);
+ constexpr P2 p2 = p1;
+ static_assert(p2.first.value == 42, "");
+ static_assert(p2.second.value == 101, "");
+ }
#endif
}
Added:
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V_cxx03.pass.cpp
URL:
http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V_cxx03.pass.cpp?rev=276605&view=auto
==============================================================================
---
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V_cxx03.pass.cpp
(added)
+++
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V_cxx03.pass.cpp
Sun Jul 24 23:32:07 2016
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+// 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.
+//
+//===----------------------------------------------------------------------===//
+
+// <utility>
+
+// template <class T1, class T2> struct pair
+
+// template <class U, class V> pair(const pair<U, V>& p);
+
+#include <utility>
+#include <cassert>
+
+int main()
+{
+ {
+ typedef std::pair<int, short> P1;
+ typedef std::pair<double, long> P2;
+ const P1 p1(3, 4);
+ const P2 p2 = p1;
+ assert(p2.first == 3);
+ assert(p2.second == 4);
+ }
+}
Modified:
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp
URL:
http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp?rev=276605&r1=276604&r2=276605&view=diff
==============================================================================
--- libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp
(original)
+++ libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/default.pass.cpp
Sun Jul 24 23:32:07 2016
@@ -27,14 +27,15 @@
#include <cassert>
#include "test_macros.h"
+#include "archetypes.hpp"
int main()
{
{
- typedef std::pair<float, short*> P;
- P p;
- assert(p.first == 0.0f);
- assert(p.second == nullptr);
+ typedef std::pair<float, short*> P;
+ P p;
+ assert(p.first == 0.0f);
+ assert(p.second == nullptr);
}
#if TEST_STD_VER >= 11
{
@@ -43,5 +44,11 @@ int main()
static_assert(p.first == 0.0f, "");
static_assert(p.second == nullptr, "");
}
+ {
+ using P = std::pair<int, NoDefault>;
+ static_assert(!std::is_default_constructible<P>::value, "");
+ using P2 = std::pair<NoDefault, int>;
+ static_assert(!std::is_default_constructible<P>::value, "");
+ }
#endif
}
Added:
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/not_constexpr_cxx11.fail.cpp
URL:
http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/not_constexpr_cxx11.fail.cpp?rev=276605&view=auto
==============================================================================
---
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/not_constexpr_cxx11.fail.cpp
(added)
+++
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/not_constexpr_cxx11.fail.cpp
Sun Jul 24 23:32:07 2016
@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+// 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.
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: c++11
+
+// <utility>
+
+// Test that only the default constructor is constexpr in C++11
+
+#include <utility>
+#include <cassert>
+
+struct ExplicitT {
+ constexpr explicit ExplicitT(int x) : value(x) {}
+ constexpr explicit ExplicitT(ExplicitT const& o) : value(o.value) {}
+ int value;
+};
+
+struct ImplicitT {
+ constexpr ImplicitT(int x) : value(x) {}
+ constexpr ImplicitT(ImplicitT const& o) : value(o.value) {}
+ int value;
+};
+
+int main()
+{
+ {
+ using P = std::pair<int, int>;
+ constexpr int x = 42;
+ constexpr P default_p{};
+ constexpr P copy_p(default_p);
+ constexpr P const_U_V(x, x); // expected-error {{must be initialized
by a constant expression}}
+ constexpr P U_V(42, 101); // expected-error {{must be initialized by a
constant expression}}
+ }
+ {
+ using P = std::pair<ExplicitT, ExplicitT>;
+ constexpr std::pair<int, int> other;
+ constexpr ExplicitT e(99);
+ constexpr P const_U_V(e, e); // expected-error {{must be initialized
by a constant expression}}
+ constexpr P U_V(42, 101); // expected-error {{must be initialized by a
constant expression}}
+ constexpr P pair_U_V(other); // expected-error {{must be initialized
by a constant expression}}
+ }
+ {
+ using P = std::pair<ImplicitT, ImplicitT>;
+ constexpr std::pair<int, int> other;
+ constexpr ImplicitT i = 99;
+ constexpr P const_U_V = {i, i}; // expected-error {{must be
initialized by a constant expression}}
+ constexpr P U_V = {42, 101}; // expected-error {{must be initialized
by a constant expression}}
+ constexpr P pair_U_V = other; // expected-error {{must be initialized
by a constant expression}}
+ }
+}
Modified:
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
URL:
http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp?rev=276605&r1=276604&r2=276605&view=diff
==============================================================================
---
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
(original)
+++
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
Sun Jul 24 23:32:07 2016
@@ -7,6 +7,8 @@
//
//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03
+
// <utility>
// template <class T1, class T2> struct pair
@@ -17,6 +19,23 @@
#include <memory>
#include <cassert>
+#include "archetypes.hpp"
+#include "test_convertible.hpp"
+
+template <class T1, class U1,
+ bool CanCopy = true, bool CanConvert = CanCopy>
+void test_pair_rv()
+{
+ using P1 = std::pair<T1, int>;
+ using P2 = std::pair<int, T1>;
+ using UP1 = std::pair<U1, int>&&;
+ using UP2 = std::pair<int, U1>&&;
+ static_assert(std::is_constructible<P1, UP1>::value == CanCopy, "");
+ static_assert(test_convertible<P1, UP1>() == CanConvert, "");
+ static_assert(std::is_constructible<P2, UP2>::value == CanCopy, "");
+ static_assert(test_convertible<P2, UP2>() == CanConvert, "");
+}
+
struct Base
{
virtual ~Base() {}
@@ -27,9 +46,25 @@ struct Derived
{
};
+
+template <class T, class U>
+struct DPair : public std::pair<T, U> {
+ using Base = std::pair<T, U>;
+ using Base::Base;
+};
+
+struct ExplicitT {
+ constexpr explicit ExplicitT(int x) : value(x) {}
+ int value;
+};
+
+struct ImplicitT {
+ constexpr ImplicitT(int x) : value(x) {}
+ int value;
+};
+
int main()
{
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
typedef std::pair<std::unique_ptr<Derived>, short> P1;
typedef std::pair<std::unique_ptr<Base>, long> P2;
@@ -38,5 +73,104 @@ int main()
assert(p2.first == nullptr);
assert(p2.second == 4);
}
-#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+ {
+ // We allow derived types to use this constructor
+ using P1 = DPair<long, long>;
+ using P2 = std::pair<int, int>;
+ P1 p1(42, 101);
+ P2 p2(std::move(p1));
+ assert(p2.first == 42);
+ assert(p2.second = 101);
+ }
+ {
+ test_pair_rv<AllCtors, AllCtors>();
+ test_pair_rv<AllCtors, AllCtors&>();
+ test_pair_rv<AllCtors, AllCtors&&>();
+ test_pair_rv<AllCtors, const AllCtors&>();
+ test_pair_rv<AllCtors, const AllCtors&&>();
+
+ test_pair_rv<ExplicitAllCtors, ExplicitAllCtors>();
+ test_pair_rv<ExplicitAllCtors, ExplicitAllCtors&, true, false>();
+ test_pair_rv<ExplicitAllCtors, ExplicitAllCtors&&, true, false>();
+ test_pair_rv<ExplicitAllCtors, const ExplicitAllCtors&, true, false>();
+ test_pair_rv<ExplicitAllCtors, const ExplicitAllCtors&&, true,
false>();
+
+ test_pair_rv<MoveOnly, MoveOnly>();
+ test_pair_rv<MoveOnly, MoveOnly&, false>();
+ test_pair_rv<MoveOnly, MoveOnly&&>();
+
+ test_pair_rv<ExplicitMoveOnly, ExplicitMoveOnly>(); // copy
construction
+ test_pair_rv<ExplicitMoveOnly, ExplicitMoveOnly&, false>();
+ test_pair_rv<ExplicitMoveOnly, ExplicitMoveOnly&&, true, false>();
+
+ test_pair_rv<CopyOnly, CopyOnly>();
+ test_pair_rv<CopyOnly, CopyOnly&>();
+ test_pair_rv<CopyOnly, CopyOnly&&>();
+
+ test_pair_rv<ExplicitCopyOnly, ExplicitCopyOnly>();
+ test_pair_rv<ExplicitCopyOnly, ExplicitCopyOnly&, true, false>();
+ test_pair_rv<ExplicitCopyOnly, ExplicitCopyOnly&&, true, false>();
+
+ test_pair_rv<NonCopyable, NonCopyable, false>();
+ test_pair_rv<NonCopyable, NonCopyable&, false>();
+ test_pair_rv<NonCopyable, NonCopyable&&, false>();
+ test_pair_rv<NonCopyable, const NonCopyable&, false>();
+ test_pair_rv<NonCopyable, const NonCopyable&&, false>();
+ }
+ { // Test construction of references
+ test_pair_rv<NonCopyable&, NonCopyable&>();
+ test_pair_rv<NonCopyable&, NonCopyable&&>();
+ test_pair_rv<NonCopyable&, NonCopyable const&, false>();
+ test_pair_rv<NonCopyable const&, NonCopyable&&>();
+ test_pair_rv<NonCopyable&&, NonCopyable&&>();
+
+ test_pair_rv<ConvertingType&, int, false>();
+ test_pair_rv<ExplicitConvertingType&, int, false>();
+ // Unfortunately the below conversions are allowed and create dangling
+ // references.
+ //test_pair_rv<ConvertingType&&, int>();
+ //test_pair_rv<ConvertingType const&, int>();
+ //test_pair_rv<ConvertingType const&&, int>();
+ // But these are not because the converting constructor is explicit.
+ test_pair_rv<ExplicitConvertingType&&, int, false>();
+ test_pair_rv<ExplicitConvertingType const&, int, false>();
+ test_pair_rv<ExplicitConvertingType const&&, int, false>();
+ }
+ {
+ test_pair_rv<AllCtors, int, false>();
+ test_pair_rv<ExplicitAllCtors, int, false>();
+ test_pair_rv<ConvertingType, int>();
+ test_pair_rv<ExplicitConvertingType, int, true, false>();
+
+ test_pair_rv<ConvertingType, int>();
+ test_pair_rv<ConvertingType, ConvertingType>();
+ test_pair_rv<ConvertingType, ConvertingType const&>();
+ test_pair_rv<ConvertingType, ConvertingType&>();
+ test_pair_rv<ConvertingType, ConvertingType&&>();
+
+ test_pair_rv<ExplicitConvertingType, int, true, false>();
+ test_pair_rv<ExplicitConvertingType, int&, true, false>();
+ test_pair_rv<ExplicitConvertingType, const int&, true, false>();
+ test_pair_rv<ExplicitConvertingType, int&&, true, false>();
+ test_pair_rv<ExplicitConvertingType, const int&&, true, false>();
+
+ test_pair_rv<ExplicitConvertingType, ExplicitConvertingType>();
+ test_pair_rv<ExplicitConvertingType, ExplicitConvertingType const&,
true, false>();
+ test_pair_rv<ExplicitConvertingType, ExplicitConvertingType&, true,
false>();
+ test_pair_rv<ExplicitConvertingType, ExplicitConvertingType&&, true,
false>();
+ }
+#if TEST_STD_VER > 11
+ { // explicit constexpr test
+ constexpr std::pair<int, int> p1(42, 43);
+ constexpr std::pair<ExplicitT, ExplicitT> p2(std::move(p1));
+ static_assert(p2.first.value == 42, "");
+ static_assert(p2.second.value == 43, "");
+ }
+ { // implicit constexpr test
+ constexpr std::pair<int, int> p1(42, 43);
+ constexpr std::pair<ImplicitT, ImplicitT> p2 = std::move(p1);
+ static_assert(p2.first.value == 42, "");
+ static_assert(p2.second.value == 43, "");
+ }
+#endif
}
Added:
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/special_member_generation_test.pass.cpp
URL:
http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/special_member_generation_test.pass.cpp?rev=276605&view=auto
==============================================================================
---
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/special_member_generation_test.pass.cpp
(added)
+++
libcxx/trunk/test/std/utilities/utility/pairs/pairs.pair/special_member_generation_test.pass.cpp
Sun Jul 24 23:32:07 2016
@@ -0,0 +1,126 @@
+//===----------------------------------------------------------------------===//
+//
+// 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <utility>
+
+// template <class T, class U> struct pair;
+
+// pair(pair const&) = default;
+// pair(pair &&) = default;
+// pair& operator=(pair const&);
+// pair& operator=(pair&&);
+
+// Test that the copy/move constructors and assignment operators are
+// correctly defined or deleted based on the properties of `T` and `U`.
+
+#include <cassert>
+#include <string>
+#include <tuple>
+
+#include "archetypes.hpp"
+
+namespace ConstructorTest {
+
+template <class T1, bool CanCopy = true, bool CanMove = CanCopy> void test() {
+ using P1 = std::pair<T1, int>;
+ using P2 = std::pair<int, T1>;
+ static_assert(std::is_copy_constructible<P1>::value == CanCopy);
+ static_assert(std::is_move_constructible<P1>::value == CanMove);
+ static_assert(std::is_copy_constructible<P2>::value == CanCopy);
+ static_assert(std::is_move_constructible<P2>::value == CanMove);
+};
+
+} // namespace ConstructorTest
+
+void test_constructors_exist() {
+ using namespace ConstructorTest;
+ {
+ test<int>();
+ test<int &>();
+ test<int &&, false, true>();
+ test<const int>();
+ test<const int &>();
+ test<const int &&, false, true>();
+ }
+ {
+ test<Copyable>();
+ test<Copyable &>();
+ test<Copyable &&, false, true>();
+ }
+ {
+ test<NonCopyable, false>();
+ test<NonCopyable &, true>();
+ test<NonCopyable &&, false, true>();
+ }
+ {
+ // Even though CopyOnly has an explicitly deleted move constructor
+ // pair's move constructor is only implicitly deleted and therefore
+ // it doesn't participate in overload resolution.
+ test<CopyOnly, true, true>();
+ test<CopyOnly &, true>();
+ test<CopyOnly &&, false, true>();
+ }
+ {
+ test<MoveOnly, false, true>();
+ test<MoveOnly &, true>();
+ test<MoveOnly &&, false, true>();
+ }
+}
+
+namespace AssignmentOperatorTest {
+
+template <class T1, bool CanCopy = true, bool CanMove = CanCopy> void test() {
+ using P1 = std::pair<T1, int>;
+ using P2 = std::pair<int, T1>;
+ static_assert(std::is_copy_assignable<P1>::value == CanCopy);
+ static_assert(std::is_move_assignable<P1>::value == CanMove);
+ static_assert(std::is_copy_assignable<P2>::value == CanCopy);
+ static_assert(std::is_move_assignable<P2>::value == CanMove);
+};
+
+} // namespace AssignmentOperatorTest
+
+void test_assignment_operator_exists() {
+ using namespace AssignmentOperatorTest;
+ {
+ test<int>();
+ test<int &>();
+ test<int &&>();
+ test<const int, false>();
+ test<const int &, false>();
+ test<const int &&, false>();
+ }
+ {
+ test<Copyable>();
+ test<Copyable &>();
+ test<Copyable &&>();
+ }
+ {
+ test<NonCopyable, false>();
+ test<NonCopyable &, false>();
+ test<NonCopyable &&, false>();
+ }
+ {
+ test<CopyOnly, true>();
+ test<CopyOnly &, true>();
+ test<CopyOnly &&, true>();
+ }
+ {
+ test<MoveOnly, false, true>();
+ test<MoveOnly &, false, false>();
+ test<MoveOnly &&, false, true>();
+ }
+}
+
+int main() {
+ test_constructors_exist();
+ test_assignment_operator_exists();
+}
Added: libcxx/trunk/test/support/archetypes.hpp
URL:
http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/support/archetypes.hpp?rev=276605&view=auto
==============================================================================
--- libcxx/trunk/test/support/archetypes.hpp (added)
+++ libcxx/trunk/test/support/archetypes.hpp Sun Jul 24 23:32:07 2016
@@ -0,0 +1,110 @@
+#ifndef TEST_SUPPORT_ARCHETYPES_HPP
+#define TEST_SUPPORT_ARCHETYPES_HPP
+
+#include "test_macros.h"
+
+#if TEST_STD_VER >= 11
+
+struct NoDefault {
+ NoDefault() = delete;
+};
+
+// Implicit copy/move types
+
+struct AllCtors {
+ AllCtors() = default;
+ AllCtors(AllCtors const&) = default;
+ AllCtors(AllCtors &&) = default;
+ AllCtors& operator=(AllCtors const&) = default;
+ AllCtors& operator=(AllCtors &&) = default;
+};
+
+struct Copyable {
+ Copyable() = default;
+ Copyable(Copyable const &) = default;
+ Copyable &operator=(Copyable const &) = default;
+};
+
+struct CopyOnly {
+ CopyOnly() = default;
+ CopyOnly(CopyOnly const &) = default;
+ CopyOnly &operator=(CopyOnly const &) = default;
+ CopyOnly(CopyOnly &&) = delete;
+ CopyOnly &operator=(CopyOnly &&) = delete;
+};
+
+struct NonCopyable {
+ NonCopyable() = default;
+ NonCopyable(NonCopyable const &) = delete;
+ NonCopyable &operator=(NonCopyable const &) = delete;
+};
+
+struct MoveOnly {
+ MoveOnly() = default;
+ MoveOnly(MoveOnly &&) = default;
+ MoveOnly &operator=(MoveOnly &&) = default;
+};
+
+struct ConvertingType {
+ ConvertingType() = default;
+ ConvertingType(ConvertingType const&) = default;
+ ConvertingType(ConvertingType &&) = default;
+ ConvertingType& operator=(ConvertingType const&) = default;
+ ConvertingType& operator=(ConvertingType &&) = default;
+ template <class ...Args>
+ ConvertingType(Args&&...) {}
+ template <class Arg>
+ ConvertingType& operator=(Arg&&) { return *this; }
+};
+
+struct ExplicitConvertingType {
+ ExplicitConvertingType() = default;
+ explicit ExplicitConvertingType(ExplicitConvertingType const&) = default;
+ explicit ExplicitConvertingType(ExplicitConvertingType &&) = default;
+ ExplicitConvertingType& operator=(ExplicitConvertingType const&) = default;
+ ExplicitConvertingType& operator=(ExplicitConvertingType &&) = default;
+ template <class ...Args>
+ explicit ExplicitConvertingType(Args&&...) {}
+ template <class Arg>
+ ExplicitConvertingType& operator=(Arg&&) { return *this; }
+};
+
+// Explicit copy/move types
+
+struct ExplicitAllCtors {
+ explicit ExplicitAllCtors() = default;
+ explicit ExplicitAllCtors(ExplicitAllCtors const&) = default;
+ explicit ExplicitAllCtors(ExplicitAllCtors &&) = default;
+ ExplicitAllCtors& operator=(ExplicitAllCtors const&) = default;
+ ExplicitAllCtors& operator=(ExplicitAllCtors &&) = default;
+};
+
+struct ExplicitCopyable {
+ explicit ExplicitCopyable() = default;
+ explicit ExplicitCopyable(ExplicitCopyable const &) = default;
+ ExplicitCopyable &operator=(ExplicitCopyable const &) = default;
+};
+
+struct ExplicitCopyOnly {
+ explicit ExplicitCopyOnly() = default;
+ explicit ExplicitCopyOnly(ExplicitCopyOnly const &) = default;
+ ExplicitCopyOnly &operator=(ExplicitCopyOnly const &) = default;
+ explicit ExplicitCopyOnly(ExplicitCopyOnly &&) = delete;
+ ExplicitCopyOnly &operator=(ExplicitCopyOnly &&) = delete;
+};
+
+struct ExplicitNonCopyable {
+ explicit ExplicitNonCopyable() = default;
+ explicit ExplicitNonCopyable(ExplicitNonCopyable const &) = delete;
+ ExplicitNonCopyable &operator=(ExplicitNonCopyable const &) = delete;
+};
+
+struct ExplicitMoveOnly {
+ explicit ExplicitMoveOnly() = default;
+ explicit ExplicitMoveOnly(ExplicitMoveOnly &&) = default;
+ ExplicitMoveOnly &operator=(ExplicitMoveOnly &&) = default;
+};
+
+#endif // TEST_STD_VER >= 11
+
+#endif // TEST_SUPPORT_ARCHETYPES_HPP
Modified: libcxx/trunk/www/cxx1z_status.html
URL:
http://llvm.org/viewvc/llvm-project/libcxx/trunk/www/cxx1z_status.html?rev=276605&r1=276604&r2=276605&view=diff
==============================================================================
--- libcxx/trunk/www/cxx1z_status.html (original)
+++ libcxx/trunk/www/cxx1z_status.html Sun Jul 24 23:32:07 2016
@@ -64,7 +64,7 @@
<tr><td><a
href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4284";>N4284</a></td><td>LWG</td></td><td>Contiguous
Iterators.</td><td>Urbana</td><td>Complete</td><td>3.6</td></tr>
<tr><td><a
href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4285";>N4285</a></td><td>CWG</td></td><td>Cleanup
for exception-specification and
throw-expression.</td><td>Urbana</td><td></td><td></td></tr>
<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
- <tr><td><a
href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4387";>N4387</a></td><td>LWG</td></td><td>improving
pair and tuple</td><td>Lenexa</td><td></td><td></td></tr>
+ <tr><td><a
href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4387";>N4387</a></td><td>LWG</td></td><td>improving
pair and tuple</td><td>Lenexa</td><td>Complete</td><td>4.0</td></tr>
<tr><td><a
href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4389";>N4389</a></td><td>LWG</td></td><td>bool_constant</td><td>Lenexa</td><td>Complete</td><td>3.7</td></tr>
<tr><td><a
href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4508";>N4508</a></td><td>LWG</td></td><td>shared_mutex
for C++17</td><td>Lenexa</td><td>Complete</td><td>3.7</td></tr>
<tr><td><a
href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4366";>N4366</a></td><td>LWG</td></td><td>LWG
2228 missing SFINAE rule</td><td>Lenexa</td><td>Complete</td><td>3.1</td></tr>
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
