[libc++] Enable rvalue overloads for pair in C++03

[philnik]

Summary

We require rvalue support anyways, so let's use it.

[huixie90]

libcxx/include/__utility/pair.h

424–445

I guess this somehow changed the c++ 03 behaviour. it used to make copies on 1. function parameters 2. constructor initialisers
Now it only make the copy inside constructors. Is it ok to make this change?

[ldionne]

libcxx/include/__utility/pair.h

424–445

I was going to say this:

I don't think it is, actually, because in C++03 make_pair is explicitly specified like

template< class T1, class T2 >
std::pair<T1,T2> make_pair( T1 t, T2 u );

IMO the rest of these changes are OK, but this one does changes our C++03 API (which one day we will deprecate if my dreams become reality).

---

But then, @philnik reminded me that libc++ was originally built to implement the C++11 standard even on top of a C++03 compiler, and that is actually one of the things we tell users. In other words, we never really faithfully implement C++03 anyways. For example, we provide all kinds of things like std::shared_ptr in C++03 mode, and those are all C++11 features.

So yeah, I think it's fine to drop this. And it only reinforces my desire to get a discussion started on deprecating C++03 support entirely.

486

This one is definitely good. std::get(pair) was added in C++11/14 depending on the overloads, and we probably only did that before rvalue references as a C++03 extension in Clang.

libcxx/test/std/utilities/utility/pairs/pairs.spec/non_member_swap.pass.cpp

3

Side comment, but we do seem to have quite a few files that haven't moved to the new license. You could make a NFC with those without review if you want.

[philnik]

• Try to fix CI

[philnik]

• Next try

libcxx/include/__utility/pair.h

 #endif
 {
     typedef _T1 first_type;
     typedef _T2 second_type;
 
     _T1 first;
     _T2 second;
 
-#if !defined(_LIBCPP_CXX03_LANG)
     pair(pair const&) = default;
     pair(pair&&) = default;
-#else
-  // Use the implicitly declared copy constructor in C++03
-#endif
 
 #ifdef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     pair() : first(), second() {}
 
     _LIBCPP_INLINE_VISIBILITY
     pair(_T1 const& __t1, _T2 const& __t2) : first(__t1), second(__t2) {}
 

 >::type
 swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
                      _NOEXCEPT_((__is_nothrow_swappable<_T1>::value &&
                                  __is_nothrow_swappable<_T2>::value))
 {
     __x.swap(__y);
 }
 
-#ifndef _LIBCPP_CXX03_LANG
-
 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
 pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type>
 make_pair(_T1&& __t1, _T2&& __t2)
 {
     return pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type>
                (_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2));
 }
 
-#else  // _LIBCPP_CXX03_LANG
-
-template <class _T1, class _T2>
-inline _LIBCPP_INLINE_VISIBILITY
-pair<_T1,_T2>
-make_pair(_T1 __x, _T2 __y)
-{
-    return pair<_T1, _T2>(__x, __y);
-}
-
-#endif // _LIBCPP_CXX03_LANG
-
 template <class _T1, class _T2>
   struct _LIBCPP_TEMPLATE_VIS tuple_size<pair<_T1, _T2> >
     : public integral_constant<size_t, 2> {};
 
 template <size_t _Ip, class _T1, class _T2>
 struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, pair<_T1, _T2> >
 {
     static_assert(_Ip < 2, "Index out of bounds in std::tuple_element<std::pair<T1, T2>>");
struct __get_pair<0>
     get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
 
     template <class _T1, class _T2>
     static
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
     const _T1&
     get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
 
-#ifndef _LIBCPP_CXX03_LANG
     template <class _T1, class _T2>
     static
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
     _T1&&
     get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T1>(__p.first);}
 
     template <class _T1, class _T2>
     static
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
     const _T1&&
     get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<const _T1>(__p.first);}
-#endif // _LIBCPP_CXX03_LANG
 };
 
 template <>
 struct __get_pair<1>
 {
     template <class _T1, class _T2>
     static
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
     _T2&
     get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
 
     template <class _T1, class _T2>
     static
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
     const _T2&
     get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
 
-#ifndef _LIBCPP_CXX03_LANG
     template <class _T1, class _T2>
     static
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
     _T2&&
     get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T2>(__p.second);}
 
     template <class _T1, class _T2>
     static
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
     const _T2&&
     get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<const _T2>(__p.second);}
-#endif // _LIBCPP_CXX03_LANG
 };
 
 template <size_t _Ip, class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
 typename tuple_element<_Ip, pair<_T1, _T2> >::type&
 get(pair<_T1, _T2>& __p) _NOEXCEPT
 {
     return __get_pair<_Ip>::get(__p);
 }
 
 template <size_t _Ip, class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
 const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
 get(const pair<_T1, _T2>& __p) _NOEXCEPT
 {
     return __get_pair<_Ip>::get(__p);
 }
 
-#ifndef _LIBCPP_CXX03_LANG
 template <size_t _Ip, class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
 typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
 get(pair<_T1, _T2>&& __p) _NOEXCEPT
 {
     return __get_pair<_Ip>::get(_VSTD::move(__p));
 }
 
 template <size_t _Ip, class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
 const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
 get(const pair<_T1, _T2>&& __p) _NOEXCEPT
 {
     return __get_pair<_Ip>::get(_VSTD::move(__p));
 }
-#endif // _LIBCPP_CXX03_LANG
 
 #if _LIBCPP_STD_VER > 11
 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY
 constexpr _T1 & get(pair<_T1, _T2>& __p) _NOEXCEPT
 {
     return __get_pair<0>::get(__p);
 }

 
 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY
 constexpr _T1 const && get(pair<_T2, _T1> const&& __p) _NOEXCEPT
 {
     return __get_pair<1>::get(_VSTD::move(__p));
 }
 
-#endif
+#endif // _LIBCPP_STD_VER > 11
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___UTILITY_PAIR_H

libcxx/test/std/utilities/utility/pairs/pair.astuple/get_const_rv.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <utility>
 
 // template <class T1, class T2> struct pair
 
 // template<size_t I, class T1, class T2>
 //     const typename tuple_element<I, std::pair<T1, T2> >::type&&
 //     get(const pair<T1, T2>&&);
 
-// UNSUPPORTED: c++03
+// UNSUPPORTED: c++03 && !stdlib=libc++
 
 #include <utility>
 #include <memory>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
+#if TEST_STD_VER >= 11
     typedef std::pair<std::unique_ptr<int>, short> P;
     const P p(std::unique_ptr<int>(new int(3)), static_cast<short>(4));
     static_assert(std::is_same<const std::unique_ptr<int>&&, decltype(std::get<0>(std::move(p)))>::value, "");
     static_assert(noexcept(std::get<0>(std::move(p))), "");
     const std::unique_ptr<int>&& ptr = std::get<0>(std::move(p));
     assert(*ptr == 3);
+#endif
     }
 
     {
     int x = 42;
     int const y = 43;
     std::pair<int&, int const&> const p(x, y);
     static_assert(std::is_same<int&, decltype(std::get<0>(std::move(p)))>::value, "");
-    static_assert(noexcept(std::get<0>(std::move(p))), "");
     static_assert(std::is_same<int const&, decltype(std::get<1>(std::move(p)))>::value, "");
+#if TEST_STD_VER >= 11
+    static_assert(noexcept(std::get<0>(std::move(p))), "");
     static_assert(noexcept(std::get<1>(std::move(p))), "");
+#endif
     }
 
     {
+#if TEST_STD_VER >= 11
     int x = 42;
     int const y = 43;
     std::pair<int&&, int const&&> const p(std::move(x), std::move(y));
     static_assert(std::is_same<int&&, decltype(std::get<0>(std::move(p)))>::value, "");
     static_assert(noexcept(std::get<0>(std::move(p))), "");
     static_assert(std::is_same<int const&&, decltype(std::get<1>(std::move(p)))>::value, "");
     static_assert(noexcept(std::get<1>(std::move(p))), "");
+#endif
     }
 
 #if TEST_STD_VER > 11
     {
     typedef std::pair<int, short> P;
     constexpr const P p1(3, static_cast<short>(4));
     static_assert(std::get<0>(std::move(p1)) == 3, "");
     static_assert(std::get<1>(std::move(p1)) == 4, "");
     }
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/utility/pairs/pairs.spec/comparison.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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <utility>
 
 // template <class T1, class T2> struct pair
 
 // template <class T1, class T2> bool operator==(const pair<T1,T2>&, const pair<T1,T2>&);

libcxx/test/std/utilities/utility/pairs/pairs.spec/make_pair.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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <utility>
 
 // template <class T1, class T2> pair<V1, V2> make_pair(T1&&, T2&&);
 
 #include <utility>

libcxx/test/std/utilities/utility/pairs/pairs.spec/non_member_swap.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.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <utility>
 
 // template <class T1, class T2> struct pair
 
 // template <class T1, class T2> void swap(pair<T1, T2>& x, pair<T1, T2>& y);