[libcxx] Fix __compressed_pair so it doesn't copy the argument multiple times

[EricWF]

Summary

__compressed_pair takes and passes it's constructor arguments by value. This causes arguments to be moved 3 times instead of once. This patch addresses that issue and fixes constexpr on the constructors.

A much better alternative to this patch is D27565, which is about 80% shorter than the current implementation but may be ABI breaking.

[EricWF]

Ideally I would like to re-write __compressed_pair so that it doesn't need 4 complete specializations but I'm not sure the change would be non-ABI breaking.

[loladiro]

I take it this supersedes D24372? I apologize for not getting around to commiting that yet, but if it does supersede that revision, we should probably keep the tests that we have there.

[EricWF]

Abandoning in favor of https://reviews.llvm.org/D27565

include/__hash_table

 {
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const hasher& __hf,
                                                        const key_equal& __eql,
                                                        const allocator_type& __a)
     : __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
-      __p1_(__node_allocator(__a)),
+      __p1_(__second_tag(), __node_allocator(__a)),
       __p2_(0, __hf),
       __p3_(1.0f, __eql)
 {
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const allocator_type& __a)
     : __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
-      __p1_(__node_allocator(__a)),
+      __p1_(__second_tag(), __node_allocator(__a)),
       __p2_(0),
       __p3_(1.0f)
 {
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const __hash_table& __u)
     : __bucket_list_(nullptr,
           __bucket_list_deleter(allocator_traits<__pointer_allocator>::
               select_on_container_copy_construction(
                   __u.__bucket_list_.get_deleter().__alloc()), 0)),
-      __p1_(allocator_traits<__node_allocator>::
+      __p1_(__second_tag(), allocator_traits<__node_allocator>::
           select_on_container_copy_construction(__u.__node_alloc())),
       __p2_(0, __u.hash_function()),
       __p3_(__u.__p3_)
 {
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const __hash_table& __u,
                                                        const allocator_type& __a)
     : __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
-      __p1_(__node_allocator(__a)),
+      __p1_(__second_tag(), __node_allocator(__a)),
       __p2_(0, __u.hash_function()),
       __p3_(__u.__p3_)
 {
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>

         __u.size() = 0;
     }
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u,
                                                        const allocator_type& __a)
     : __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
-      __p1_(__node_allocator(__a)),
+      __p1_(__second_tag(), __node_allocator(__a)),
       __p2_(0, _VSTD::move(__u.hash_function())),
       __p3_(_VSTD::move(__u.__p3_))
 {
     if (__a == allocator_type(__u.__node_alloc()))
     {
         __bucket_list_.reset(__u.__bucket_list_.release());
         __bucket_list_.get_deleter().size() = __u.__bucket_list_.get_deleter().size();
         __u.__bucket_list_.get_deleter().size() = 0;

include/memory

 #include <utility>
 #include <limits>
 #include <iterator>
 #include <__functional_base>
 #include <iosfwd>
 #include <tuple>
 #include <stdexcept>
 #include <cstring>
-
+#include <cassert>
 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 #  include <atomic>
 #endif
 
 #include <__undef_min_max>
 #include <__undef___deallocate>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

 struct __libcpp_compressed_pair_switch<_T1, _T2, false, true, true>    {enum {value = 3};};
 
 template <class _T1, class _T2>
 struct __libcpp_compressed_pair_switch<_T1, _T2, true, true, true>     {enum {value = 1};};
 
 template <class _T1, class _T2, unsigned = __libcpp_compressed_pair_switch<_T1, _T2>::value>
 class __libcpp_compressed_pair_imp;
 
+struct __first_tag {};
+struct __second_tag {};
+struct __args_tag {};
+
 template <class _T1, class _T2>
 class __libcpp_compressed_pair_imp<_T1, _T2, 0>
 {
 private:
     _T1 __first_;
     _T2 __second_;
 public:
     typedef _T1 _T1_param;
     typedef _T2 _T2_param;
 
     typedef typename remove_reference<_T1>::type& _T1_reference;
     typedef typename remove_reference<_T2>::type& _T2_reference;
 
     typedef const typename remove_reference<_T1>::type& _T1_const_reference;
     typedef const typename remove_reference<_T2>::type& _T2_const_reference;
 
-    _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() : __first_(), __second_() {}
-    _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1)
-        : __first_(_VSTD::forward<_T1_param>(__t1)), __second_() {}
-    _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2)
-        : __first_(), __second_(_VSTD::forward<_T2_param>(__t2)) {}
-    _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2)
-        : __first_(_VSTD::forward<_T1_param>(__t1)), __second_(_VSTD::forward<_T2_param>(__t2)) {}
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp() = default;
   
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+    template <class _Arg>
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr __libcpp_compressed_pair_imp(__first_tag, _Arg&& __a)
+        : __first_(std::forward<_Arg>(__a)), __second_() {}
+  
+    template <class _Arg>
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr __libcpp_compressed_pair_imp(__second_tag, _Arg&& __a)
+        : __first_(), __second_(std::forward<_Arg>(__a)) {}
+
+    template <class _U1, class _U2>
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr __libcpp_compressed_pair_imp(__args_tag, _U1&& __t1, _U2&& __t2)
+      : __first_(std::forward<_U1>(__t1)), __second_(std::forward<_U2>(__t2)) {}
 
     template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
-        _LIBCPP_INLINE_VISIBILITY
-        __libcpp_compressed_pair_imp(piecewise_construct_t __pc,
+    constexpr __libcpp_compressed_pair_imp(piecewise_construct_t __pc,
                                            tuple<_Args1...> __first_args,
                                            tuple<_Args2...> __second_args,
                                            __tuple_indices<_I1...>,
                                            __tuple_indices<_I2...>)
             : __first_(_VSTD::forward<_Args1>(_VSTD::get<_I1>(__first_args))...),
               __second_(_VSTD::forward<_Args2>(_VSTD::get<_I2>(__second_args))...)
             {}
+#else
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp() : __first_(), __second_() {}
     
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+    template <class _Arg>
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp(__first_tag, _Arg& __a)
+        : __first_(__a), __second_() {}
+
+    template <class _Arg>
+    _LIBCPP_INLINE_VISIBILITY 
+    __libcpp_compressed_pair_imp(__second_tag, _Arg& __a)
+        : __first_(), __second_(__a) {}
+
+    template <class _U1, class _U2>
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp(__args_tag, _U1& __t1, _U2& __t2)
+      : __first_(__t1), __second_(__t2) {}
+#endif  // _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY _T1_reference       first() _NOEXCEPT       {return __first_;}
     _LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return __first_;}
 
     _LIBCPP_INLINE_VISIBILITY _T2_reference       second() _NOEXCEPT       {return __second_;}
     _LIBCPP_INLINE_VISIBILITY _T2_const_reference second() const _NOEXCEPT {return __second_;}
 
     _LIBCPP_INLINE_VISIBILITY void swap(__libcpp_compressed_pair_imp& __x)
         _NOEXCEPT_(__is_nothrow_swappable<_T1>::value &&
                    __is_nothrow_swappable<_T2>::value)
     {
         using _VSTD::swap;
         swap(__first_, __x.__first_);
         swap(__second_, __x.__second_);
     }
 };
 
 template <class _T1, class _T2>
 class __libcpp_compressed_pair_imp<_T1, _T2, 1>
     : private _T1
 {
 private:
+  typedef _T1 __first_;
     _T2 __second_;
 public:
     typedef _T1 _T1_param;
     typedef _T2 _T2_param;
 
     typedef _T1&                                        _T1_reference;
     typedef typename remove_reference<_T2>::type& _T2_reference;
 
     typedef const _T1&                                        _T1_const_reference;
     typedef const typename remove_reference<_T2>::type& _T2_const_reference;
 
-    _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() : __second_() {}
-    _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1)
-        : _T1(_VSTD::forward<_T1_param>(__t1)), __second_() {}
-    _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2)
-        : __second_(_VSTD::forward<_T2_param>(__t2)) {}
-    _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2)
-        : _T1(_VSTD::forward<_T1_param>(__t1)), __second_(_VSTD::forward<_T2_param>(__t2)) {}
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp() = default;
+  
+    template <class _Arg>
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr __libcpp_compressed_pair_imp(__first_tag, _Arg&& __a)
+        : __first_(std::forward<_Arg>(__a)), __second_() {}
   
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+    template <class _Arg>
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr __libcpp_compressed_pair_imp(__second_tag, _Arg&& __a)
+        : __first_(), __second_(std::forward<_Arg>(__a)) {}
+
+    template <class _U1, class _U2>
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr __libcpp_compressed_pair_imp(__args_tag, _U1&& __t1, _U2&& __t2)
+      : __first_(std::forward<_U1>(__t1)), __second_(std::forward<_U2>(__t2)) {}
 
     template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
-        _LIBCPP_INLINE_VISIBILITY
-        __libcpp_compressed_pair_imp(piecewise_construct_t __pc,
+    constexpr __libcpp_compressed_pair_imp(piecewise_construct_t __pc,
                                            tuple<_Args1...> __first_args,
                                            tuple<_Args2...> __second_args,
                                            __tuple_indices<_I1...>,
                                            __tuple_indices<_I2...>)
-            : _T1(_VSTD::forward<_Args1>(_VSTD::get<_I1>(__first_args))...),
+            : __first_(_VSTD::forward<_Args1>(_VSTD::get<_I1>(__first_args))...),
               __second_(_VSTD::forward<_Args2>(_VSTD::get<_I2>(__second_args))...)
             {}
+#else
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp() : __first_(), __second_() {}
     
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+    template <class _Arg>
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp(__first_tag, _Arg& __a)
+        : __first_(__a), __second_() {}
+
+    template <class _Arg>
+    _LIBCPP_INLINE_VISIBILITY 
+    __libcpp_compressed_pair_imp(__second_tag, _Arg& __a)
+        : __first_(), __second_(__a) {}
+
+    template <class _U1, class _U2>
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp(__args_tag, _U1& __t1, _U2& __t2)
+      : __first_(__t1), __second_(__t2) {}
+#endif  // _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY _T1_reference       first() _NOEXCEPT       {return *this;}
     _LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return *this;}
 
     _LIBCPP_INLINE_VISIBILITY _T2_reference       second() _NOEXCEPT       {return __second_;}
     _LIBCPP_INLINE_VISIBILITY _T2_const_reference second() const _NOEXCEPT {return __second_;}
 
     _LIBCPP_INLINE_VISIBILITY void swap(__libcpp_compressed_pair_imp& __x)
         _NOEXCEPT_(__is_nothrow_swappable<_T1>::value &&
                    __is_nothrow_swappable<_T2>::value)
     {
         using _VSTD::swap;
         swap(__second_, __x.__second_);
     }
 };
 
 template <class _T1, class _T2>
 class __libcpp_compressed_pair_imp<_T1, _T2, 2>
     : private _T2
 {
 private:
     _T1 __first_;
+  typedef _T2 __second_;
 public:
     typedef _T1 _T1_param;
     typedef _T2 _T2_param;
 
     typedef typename remove_reference<_T1>::type& _T1_reference;
     typedef _T2&                                        _T2_reference;
 
     typedef const typename remove_reference<_T1>::type& _T1_const_reference;
     typedef const _T2&                                        _T2_const_reference;
 
-    _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() : __first_() {}
-    _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1)
-        : __first_(_VSTD::forward<_T1_param>(__t1)) {}
-    _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2)
-        : _T2(_VSTD::forward<_T2_param>(__t2)), __first_() {}
-    _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2)
-        _NOEXCEPT_(is_nothrow_move_constructible<_T1>::value &&
-                   is_nothrow_move_constructible<_T2>::value)
-        : _T2(_VSTD::forward<_T2_param>(__t2)), __first_(_VSTD::forward<_T1_param>(__t1)) {}
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp() = default;
+  
+    template <class _Arg>
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr __libcpp_compressed_pair_imp(__first_tag, _Arg&& __a)
+        : __second_(), __first_(std::forward<_Arg>(__a)) {}
   
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+    template <class _Arg>
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr __libcpp_compressed_pair_imp(__second_tag, _Arg&& __a)
+        : __second_(std::forward<_Arg>(__a)), __first_() {}
+
+    template <class _U1, class _U2>
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr __libcpp_compressed_pair_imp(__args_tag, _U1&& __t1, _U2&& __t2)
+      : __second_(std::forward<_U2>(__t2)), __first_(std::forward<_U1>(__t1)) {}
 
     template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
-        _LIBCPP_INLINE_VISIBILITY
-        __libcpp_compressed_pair_imp(piecewise_construct_t __pc,
+    constexpr __libcpp_compressed_pair_imp(piecewise_construct_t __pc,
                                            tuple<_Args1...> __first_args,
                                            tuple<_Args2...> __second_args,
                                            __tuple_indices<_I1...>,
                                            __tuple_indices<_I2...>)
-            : _T2(_VSTD::forward<_Args2>(_VSTD::get<_I2>(__second_args))...),
+            : __second_(_VSTD::forward<_Args2>(_VSTD::get<_I2>(__second_args))...),
               __first_(_VSTD::forward<_Args1>(_VSTD::get<_I1>(__first_args))...)
-              
             {}
+#else
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp() : __second_(), __first_() {}
+    
+    template <class _Arg>
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp(__first_tag, _Arg& __a)
+        : __second_(), __first_(__a) {}
+
+    template <class _Arg>
+    _LIBCPP_INLINE_VISIBILITY 
+    __libcpp_compressed_pair_imp(__second_tag, _Arg& __a)
+        : __second_(__a), __first_() {}
+
+    template <class _U1, class _U2>
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp(__args_tag, _U1& __t1, _U2& __t2)
+      : __second_(__t2), __first_(__t1) {}
+#endif  // _LIBCPP_CXX03_LANG
 
-#endif  // _LIBCPP_HAS_NO_VARIADICS
 
     _LIBCPP_INLINE_VISIBILITY _T1_reference       first() _NOEXCEPT       {return __first_;}
     _LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return __first_;}
 
     _LIBCPP_INLINE_VISIBILITY _T2_reference       second() _NOEXCEPT       {return *this;}
     _LIBCPP_INLINE_VISIBILITY _T2_const_reference second() const _NOEXCEPT {return *this;}
 
     _LIBCPP_INLINE_VISIBILITY void swap(__libcpp_compressed_pair_imp& __x)
         _NOEXCEPT_(__is_nothrow_swappable<_T1>::value &&
                    __is_nothrow_swappable<_T2>::value)
     {
         using _VSTD::swap;
         swap(__first_, __x.__first_);
     }
 };
 
 template <class _T1, class _T2>
 class __libcpp_compressed_pair_imp<_T1, _T2, 3>
     : private _T1,
       private _T2
 {
+private:
+  typedef _T1 __first_;
+  typedef _T2 __second_;
 public:
     typedef _T1 _T1_param;
     typedef _T2 _T2_param;
 
     typedef _T1& _T1_reference;
     typedef _T2& _T2_reference;
 
     typedef const _T1& _T1_const_reference;
     typedef const _T2& _T2_const_reference;
 
-    _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() {}
-    _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1)
-        : _T1(_VSTD::forward<_T1_param>(__t1)) {}
-    _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2)
-        : _T2(_VSTD::forward<_T2_param>(__t2)) {}
-    _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2)
-        : _T1(_VSTD::forward<_T1_param>(__t1)), _T2(_VSTD::forward<_T2_param>(__t2)) {}
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp() = default;
 
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+    template <class _Arg>
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr __libcpp_compressed_pair_imp(__first_tag, _Arg&& __a)
+        : __first_(std::forward<_Arg>(__a)), __second_() {}
+
+    template <class _Arg>
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr __libcpp_compressed_pair_imp(__second_tag, _Arg&& __a)
+        : __first_(), __second_(std::forward<_Arg>(__a)) {}
+
+    template <class _U1, class _U2>
+    _LIBCPP_INLINE_VISIBILITY
+    constexpr __libcpp_compressed_pair_imp(__args_tag, _U1&& __t1, _U2&& __t2)
+      : __first_(std::forward<_U1>(__t1)), __second_(std::forward<_U2>(__t2)) {}
 
     template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
-        _LIBCPP_INLINE_VISIBILITY
-        __libcpp_compressed_pair_imp(piecewise_construct_t __pc,
+    constexpr __libcpp_compressed_pair_imp(piecewise_construct_t __pc,
                                            tuple<_Args1...> __first_args,
                                            tuple<_Args2...> __second_args,
                                            __tuple_indices<_I1...>,
                                            __tuple_indices<_I2...>)
-            : _T1(_VSTD::forward<_Args1>(_VSTD::get<_I1>(__first_args))...),
-              _T2(_VSTD::forward<_Args2>(_VSTD::get<_I2>(__second_args))...)
+            : __first_(_VSTD::forward<_Args1>(_VSTD::get<_I1>(__first_args))...),
+              __second_(_VSTD::forward<_Args2>(_VSTD::get<_I2>(__second_args))...)
             {}
+#else
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp() : __first_(), __second_() {}
 
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+    template <class _Arg>
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp(__first_tag, _Arg& __a)
+        : __first_(__a), __second_() {}
+
+    template <class _Arg>
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp(__second_tag, _Arg& __a)
+        : __first_(), __second_(__a) {}
+
+    template <class _U1, class _U2>
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp(__args_tag, _U1& __t1, _U2& __t2)
+      : __first_(__t1), __second_(__t2) {}
+#endif  // _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY _T1_reference       first() _NOEXCEPT       {return *this;}
     _LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return *this;}
 
     _LIBCPP_INLINE_VISIBILITY _T2_reference       second() _NOEXCEPT       {return *this;}
     _LIBCPP_INLINE_VISIBILITY _T2_const_reference second() const _NOEXCEPT {return *this;}
 
     _LIBCPP_INLINE_VISIBILITY void swap(__libcpp_compressed_pair_imp&)
         _NOEXCEPT_(__is_nothrow_swappable<_T1>::value &&
                    __is_nothrow_swappable<_T2>::value)
     {
     }
 };
 
 template <class _T1, class _T2>
 class __compressed_pair
     : private __libcpp_compressed_pair_imp<_T1, _T2>
 {
     typedef __libcpp_compressed_pair_imp<_T1, _T2> base;
 public:
     typedef typename base::_T1_param _T1_param;
     typedef typename base::_T2_param _T2_param;
 
-    typedef typename base::_T1_reference _T1_reference;
-    typedef typename base::_T2_reference _T2_reference;
+#ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_INLINE_VISIBILITY
+  __compressed_pair() = default;
 
-    typedef typename base::_T1_const_reference _T1_const_reference;
-    typedef typename base::_T2_const_reference _T2_const_reference;
+  template <class _Tp, typename enable_if<
+      !is_same<typename decay<_Tp>::type, __compressed_pair>::value, bool>::type = true
+  >
+  _LIBCPP_INLINE_VISIBILITY
+  constexpr explicit __compressed_pair(_Tp&& __t)
+      : base(__first_tag(), std::forward<_Tp>(__t)) {  }
 
-    _LIBCPP_INLINE_VISIBILITY __compressed_pair() {}
-    _LIBCPP_INLINE_VISIBILITY explicit __compressed_pair(_T1_param __t1)
-        : base(_VSTD::forward<_T1_param>(__t1)) {}
-    _LIBCPP_INLINE_VISIBILITY explicit __compressed_pair(_T2_param __t2)
-        : base(_VSTD::forward<_T2_param>(__t2)) {}
-    _LIBCPP_INLINE_VISIBILITY __compressed_pair(_T1_param __t1, _T2_param __t2)
-        : base(_VSTD::forward<_T1_param>(__t1), _VSTD::forward<_T2_param>(__t2)) {}
+  template <class _Tp>
+  _LIBCPP_INLINE_VISIBILITY
+  constexpr __compressed_pair(__second_tag __tag, _Tp&& __t)
+      : base(__tag, std::forward<_Tp>(__t)) {}
 
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+  template <class _U1, class _U2>
+  _LIBCPP_INLINE_VISIBILITY
+  constexpr __compressed_pair(_U1&& __t1, _U2&& __t2)
+      : base(__args_tag{}, std::forward<_U1>(__t1), std::forward<_U2>(__t2)) {}
 
     template <class... _Args1, class... _Args2>
-        _LIBCPP_INLINE_VISIBILITY
-        __compressed_pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args,
-                                                      tuple<_Args2...> __second_args)
-            : base(__pc, _VSTD::move(__first_args), _VSTD::move(__second_args),
-                   typename __make_tuple_indices<sizeof...(_Args1)>::type(),
-                   typename __make_tuple_indices<sizeof...(_Args2) >::type())
-            {}
+    _LIBCPP_CONSTEXPR_AFTER_CXX14
 
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+#else
+  _LIBCPP_INLINE_VISIBILITY __compressed_pair() {}
 
-    _LIBCPP_INLINE_VISIBILITY _T1_reference       first() _NOEXCEPT       {return base::first();}
-    _LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return base::first();}
+    _LIBCPP_INLINE_VISIBILITY
+    explicit __compressed_pair(_T1_param __t1)
+        : base(__first_tag(), _VSTD::forward<_T1_param>(__t1)) {}
 
-    _LIBCPP_INLINE_VISIBILITY _T2_reference       second() _NOEXCEPT       {return base::second();}
-    _LIBCPP_INLINE_VISIBILITY _T2_const_reference second() const _NOEXCEPT {return base::second();}
+    _LIBCPP_INLINE_VISIBILITY
+    __compressed_pair(__second_tag __tag, _T2_param __t2)
+        : base(__tag, _VSTD::forward<_T2_param>(__t2)) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __compressed_pair(_T1_param __t1, _T2_param __t2)
+        : base(__args_tag(), _VSTD::forward<_T1_param>(__t1),
+                             _VSTD::forward<_T2_param>(__t2)) {}
+#endif
+    using base::first;
+    using base::second;
 
     _LIBCPP_INLINE_VISIBILITY void swap(__compressed_pair& __x)
         _NOEXCEPT_(__is_nothrow_swappable<_T1>::value &&
                    __is_nothrow_swappable<_T2>::value)
         {base::swap(__x);}
 };
 
 template <class _T1, class _T2>

 struct __same_or_less_cv_qualified<_Ptr1, _Ptr2, false>
     : false_type {};
 
 // default_delete
 
 template <class _Tp>
 struct _LIBCPP_TYPE_VIS_ONLY default_delete
 {
-#ifndef _LIBCPP_CXX03_LANG
+#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR default_delete() _NOEXCEPT = default;
 #else
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR default_delete() _NOEXCEPT {}
 #endif
     template <class _Up>
         _LIBCPP_INLINE_VISIBILITY default_delete(const default_delete<_Up>&,
              typename enable_if<is_convertible<_Up*, _Tp*>::value>::type* = 0) _NOEXCEPT {}
     _LIBCPP_INLINE_VISIBILITY void operator() (_Tp* __ptr) const _NOEXCEPT
         {
             static_assert(sizeof(_Tp) > 0, "default_delete can not delete incomplete type");
             static_assert(!is_void<_Tp>::value, "default_delete can not delete incomplete type");
             delete __ptr;
         }
 };
 
 template <class _Tp>
 struct _LIBCPP_TYPE_VIS_ONLY default_delete<_Tp[]>
 {
 public:
-#ifndef _LIBCPP_CXX03_LANG
+#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR default_delete() _NOEXCEPT = default;
 #else
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR default_delete() _NOEXCEPT {}
 #endif
     template <class _Up>
         _LIBCPP_INLINE_VISIBILITY default_delete(const default_delete<_Up[]>&,
              typename enable_if<__same_or_less_cv_qualified<_Up*, _Tp*>::value>::type* = 0) _NOEXCEPT {}
     template <class _Up>

include/string

 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const allocator_type& __a)
 #if _LIBCPP_STD_VER <= 14
         _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
 #else
         _NOEXCEPT
 #endif
-: __r_(__a)
+: __r_(__second_tag(), __a)
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
     __zero();
 }
 
 template <class _CharT, class _Traits, class _Allocator>

 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const value_type* __s, const allocator_type& __a)
-    : __r_(__a)
+    : __r_(__second_tag(), __a)
 {
     _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*, allocator) detected nullptr");
     __init(__s, traits_type::length(__s));
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const value_type* __s, size_type __n)
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n) detected nullptr");
     __init(__s, __n);
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const value_type* __s, size_type __n, const allocator_type& __a)
-    : __r_(__a)
+    : __r_(__second_tag(), __a)
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr");
     __init(__s, __n);
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str)
-    : __r_(__alloc_traits::select_on_container_copy_construction(__str.__alloc()))
+    : __r_(__second_tag(), __alloc_traits::select_on_container_copy_construction(__str.__alloc()))
 {
     if (!__str.__is_long())
         __r_.first().__r = __str.__r_.first().__r;
     else
         __init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, const allocator_type& __a)
-    : __r_(__a)
+    : __r_(__second_tag(), __a)
 {
     if (!__str.__is_long())
         __r_.first().__r = __str.__r_.first().__r;
     else
         __init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif

     if (__is_long())
         __get_db()->swap(this, &__str);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str, const allocator_type& __a)
-    : __r_(__a)
+    : __r_(__second_tag(), __a)
 {
     if (__str.__is_long() && __a != __str.__alloc()) // copy, not move
         __init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size());
     else
     {
         __r_.first().__r = __str.__r_.first().__r;
         __str.__zero();
     }

 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, value_type __c, const allocator_type& __a)
-    : __r_(__a)
+    : __r_(__second_tag(), __a)
 {
     __init(__n, __c);
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, size_type __pos, size_type __n,
                                                         const allocator_type& __a)
-    : __r_(__a)
+    : __r_(__second_tag(), __a)
 {
     size_type __str_sz = __str.size();
     if (__pos > __str_sz)
         this->__throw_out_of_range();
     __init(__str.data() + __pos, _VSTD::min(__n, __str_sz - __pos));
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, size_type __pos,
                                                         const allocator_type& __a)
-    : __r_(__a)
+    : __r_(__second_tag(), __a)
 {
     size_type __str_sz = __str.size();
     if (__pos > __str_sz)
         this->__throw_out_of_range();
     __init(__str.data() + __pos, __str_sz - __pos);
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(
              const _Tp& __t, size_type __pos, size_type __n, const allocator_type& __a,
        typename enable_if<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, void>::type *)
-    : __r_(__a)
+    : __r_(__second_tag(), __a)
 {
   __self_view __sv = __self_view(__t).substr(__pos, __n);
     __init(__sv.data(), __sv.size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif  
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(__self_view __sv)
 {
     __init(__sv.data(), __sv.size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(__self_view __sv, const allocator_type& __a)
-    : __r_(__a)
+    : __r_(__second_tag(), __a)
 {
     __init(__sv.data(), __sv.size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>

 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last,
                                                         const allocator_type& __a)
-    : __r_(__a)
+    : __r_(__second_tag(), __a)
 {
     __init(__first, __last);
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(initializer_list<value_type> __il)
 {
     __init(__il.begin(), __il.end());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(initializer_list<value_type> __il, const allocator_type& __a)
-    : __r_(__a)
+    : __r_(__second_tag(), __a)
 {
     __init(__il.begin(), __il.end());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS

test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/default01.fail.cpp

 // default unique_ptr ctor should require default Deleter ctor
 
 
 #include <memory>
 
 class Deleter
 {
     // expected-error@memory:* {{base class 'Deleter' has private default constructor}}
-    // expected-note@memory:* + {{in instantiation of member function}}
     Deleter() {} // expected-note {{implicitly declared private here}}
 
 public:
 
     Deleter(Deleter&) {}
     Deleter& operator=(Deleter&) { return *this; }
 
     void operator()(void*) const {}
 };
 
 int main()
 {
     std::unique_ptr<int[], Deleter> p;
 }