[libc++] Remove some obsolete _LIBCPP_CXX03_LANG

[• Quuxplusone]

Summary

Based on this comment from D103753.

We don't pretend to implement a "C++03 library"; no libc++ user should
ever be relying on the fact that e.g. `emplace_back` does NOT exist.

We support GCC only with `-std=c++11` and later.

We support Clang in `-std=c++03` mode, but Clang supports rvalue references,
defaulted member functions, NSDMIs, and variadic templates all as extensions
to C++03.

Conclusion: Several instances of _LIBCPP_CXX03_LANG are unnecessary.

However, it's still true that in `-std=c++03` mode we're not allowed to use
- `std::initializer_list`
- braces around member-initializers
- the `constexpr` or `noexcept` keywords

And I don't think we want to turn on user-visible move constructors;
e.g. today in `-std=c++03` mode,

    std::vector<T> v(1);
    auto w = std::move(v);

visibly calls T's copy ctor.
I think it would be reckless to change that, at least in this particular patch.

[ldionne]

Thanks for the cleanup.

[• Quuxplusone]

Rebase; ready to land on Monday if nobody shouts "stop!" before then.

[ldionne]

Thinking about this some more, I believe we need to figure out what to do with the tests. As it stands, this patch doesn't modify the tests at all, which means that the C++11 functionality that will be enabled in C++03 by this patch will never get tested.

One way to go would be to change some UNSUPPORTED: c++03 to UNSUPPORTED: c++03 && !libc++ to acknowledge that we're supporting this in libc++ as an extension.

[• Quuxplusone]

@ldionne: My impression is that your testing concern applies:

• YES to things like vector::emplace_back
• NO to the changes in <bitset>
• MAYBE to things like vector::push_back(value_type&&)

I think the precedent here is std/utilities/utility/forward/move.pass.cpp — libc++ supports std::move in C++03 as an extension, so our tests for std::move do not say UNSUPPORTED: c++03. Instead, they say nothing: the test is simply supported in all modes. I can go through the tests for these facilities and remove UNSUPPORTED: c++03 where I see it; for example, in std/containers//sequences/deque/deque.modifiers/emplace_back.pass.cpp.

It doesn't make sense to add UNSUPPORTED: c++03 && !libc++ to new code; this is the libc++ test suite, and we do not run it on any other "C++03" libraries. Any other library tested with this test suite should be C++11-or-later already.

I'll also split out the "implementation" changes, that don't have any effects on libcxx/test/, into a separate commit/PR.

[ldionne]

Please make sure we test things like vector::emplace_back and vector::push_back(value_type&&) in the test suite (i.e. we remove any UNSUPPORTED: c++03 annotations).

libcxx/include/__memory/shared_ptr.h

shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d,
     : __ptr_(__p)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
         typedef __shared_ptr_pointer<_Yp*, _Dp, _AllocT > _CntrlBlk;
-#ifndef _LIBCPP_CXX03_LANG
         __cntrl_ = new _CntrlBlk(__p, _VSTD::move(__d), _AllocT());
-#else
-        __cntrl_ = new _CntrlBlk(__p, __d, _AllocT());
-#endif // not _LIBCPP_CXX03_LANG
         __enable_weak_this(__p, __p);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         __d(__p);
         throw;
     }
 #endif // _LIBCPP_NO_EXCEPTIONS
 }
 
 template<class _Tp>
 template<class _Dp>
 shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d)
     : __ptr_(nullptr)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         typedef typename __shared_ptr_default_allocator<_Tp>::type _AllocT;
         typedef __shared_ptr_pointer<nullptr_t, _Dp, _AllocT > _CntrlBlk;
-#ifndef _LIBCPP_CXX03_LANG
         __cntrl_ = new _CntrlBlk(__p, _VSTD::move(__d), _AllocT());
-#else
-        __cntrl_ = new _CntrlBlk(__p, __d, _AllocT());
-#endif // not _LIBCPP_CXX03_LANG
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         __d(__p);
         throw;
     }
 #endif // _LIBCPP_NO_EXCEPTIONS
#ifndef _LIBCPP_NO_EXCEPTIONS
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         typedef __shared_ptr_pointer<_Yp*, _Dp, _Alloc> _CntrlBlk;
         typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
         typedef __allocator_destructor<_A2> _D2;
         _A2 __a2(__a);
         unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
         ::new ((void*)_VSTD::addressof(*__hold2.get()))
-#ifndef _LIBCPP_CXX03_LANG
             _CntrlBlk(__p, _VSTD::move(__d), __a);
-#else
-            _CntrlBlk(__p, __d, __a);
-#endif // not _LIBCPP_CXX03_LANG
         __cntrl_ = _VSTD::addressof(*__hold2.release());
         __enable_weak_this(__p, __p);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         __d(__p);
         throw;
#ifndef _LIBCPP_NO_EXCEPTIONS
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         typedef __shared_ptr_pointer<nullptr_t, _Dp, _Alloc> _CntrlBlk;
         typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
         typedef __allocator_destructor<_A2> _D2;
         _A2 __a2(__a);
         unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
         ::new ((void*)_VSTD::addressof(*__hold2.get()))
-#ifndef _LIBCPP_CXX03_LANG
             _CntrlBlk(__p, _VSTD::move(__d), __a);
-#else
-            _CntrlBlk(__p, __d, __a);
-#endif // not _LIBCPP_CXX03_LANG
         __cntrl_ = _VSTD::addressof(*__hold2.release());
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         __d(__p);
         throw;
     }

libcxx/include/bitset

protected:
     static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
 
     friend class __bit_reference<__bitset>;
     friend class __bit_const_reference<__bitset>;
     friend class __bit_iterator<__bitset, false>;
     friend class __bit_iterator<__bitset, true>;
     friend struct __bit_array<__bitset>;
 
-    __storage_type __first_[_N_words];
+    __storage_type __first_[_N_words] = {};
 
     typedef __bit_reference<__bitset>                  reference;
     typedef __bit_const_reference<__bitset>            const_reference;
     typedef __bit_iterator<__bitset, false>            iterator;
     typedef __bit_iterator<__bitset, true>             const_iterator;
 
     _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR __bitset() _NOEXCEPT;
+    _LIBCPP_CONSTEXPR __bitset() _NOEXCEPT {}
     _LIBCPP_INLINE_VISIBILITY
     explicit _LIBCPP_CONSTEXPR __bitset(unsigned long long __v) _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY reference __make_ref(size_t __pos) _NOEXCEPT
         {return reference(__first_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR const_reference __make_ref(size_t __pos) const _NOEXCEPT
         {return const_reference(__first_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
     _LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t __pos) _NOEXCEPT
#endif // _LIBCPP_CXX03_LANG
     unsigned long long to_ullong(false_type) const;
     _LIBCPP_INLINE_VISIBILITY
     unsigned long long to_ullong(true_type) const;
     _LIBCPP_INLINE_VISIBILITY
     unsigned long long to_ullong(true_type, false_type) const;
     unsigned long long to_ullong(true_type, true_type) const;
 };
 
-template <size_t _N_words, size_t _Size>
-inline
-_LIBCPP_CONSTEXPR
-__bitset<_N_words, _Size>::__bitset() _NOEXCEPT
-#ifndef _LIBCPP_CXX03_LANG
-    : __first_{0}
-#endif
-{
-#ifdef _LIBCPP_CXX03_LANG
-    _VSTD::fill_n(__first_, _N_words, __storage_type(0));
-#endif
-}
-
 #ifdef _LIBCPP_CXX03_LANG
 
 template <size_t _N_words, size_t _Size>
 void
 __bitset<_N_words, _Size>::__init(unsigned long long __v, false_type) _NOEXCEPT
 {
     __storage_type __t[sizeof(unsigned long long) / sizeof(__storage_type)];
     size_t __sz = _Size;

libcxx/include/deque

     _LIBCPP_INLINE_VISIBILITY
     __deque_base()
         _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
     _LIBCPP_INLINE_VISIBILITY
     explicit __deque_base(const allocator_type& __a);
 public:
     ~__deque_base();
 
-#ifndef _LIBCPP_CXX03_LANG
     __deque_base(__deque_base&& __c)
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
     __deque_base(__deque_base&& __c, const allocator_type& __a);
-#endif // _LIBCPP_CXX03_LANG
 
     void swap(__deque_base& __c)
 #if _LIBCPP_STD_VER >= 14
         _NOEXCEPT;
 #else
         _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
                     __is_nothrow_swappable<allocator_type>::value);
 #endif

 {
     clear();
     typename __map::iterator __i = __map_.begin();
     typename __map::iterator __e = __map_.end();
     for (; __i != __e; ++__i)
         __alloc_traits::deallocate(__alloc(), *__i, __block_size);
 }
 
-#ifndef _LIBCPP_CXX03_LANG
-
 template <class _Tp, class _Allocator>
 __deque_base<_Tp, _Allocator>::__deque_base(__deque_base&& __c)
     _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
     : __map_(_VSTD::move(__c.__map_)),
       __start_(_VSTD::move(__c.__start_)),
       __size_(_VSTD::move(__c.__size_))
 {
     __c.__start_ = 0;

     else
     {
         __map_.clear();
         __start_ = 0;
         size() = 0;
     }
 }
 
-#endif // _LIBCPP_CXX03_LANG
-
 template <class _Tp, class _Allocator>
 void
 __deque_base<_Tp, _Allocator>::swap(__deque_base& __c)
 #if _LIBCPP_STD_VER >= 14
         _NOEXCEPT
 #else
         _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
                     __is_nothrow_swappable<allocator_type>::value)

     _LIBCPP_INLINE_VISIBILITY
     reference back() _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     const_reference back() const _NOEXCEPT;
 
     // 23.2.2.3 modifiers:
     void push_front(const value_type& __v);
     void push_back(const value_type& __v);
-#ifndef _LIBCPP_CXX03_LANG
 #if _LIBCPP_STD_VER > 14
     template <class... _Args> reference emplace_front(_Args&&... __args);
     template <class... _Args> reference emplace_back (_Args&&... __args);
 #else
     template <class... _Args> void      emplace_front(_Args&&... __args);
     template <class... _Args> void      emplace_back (_Args&&... __args);
 #endif
     template <class... _Args> iterator emplace(const_iterator __p, _Args&&... __args);
 
     void push_front(value_type&& __v);
     void push_back(value_type&& __v);
     iterator insert(const_iterator __p, value_type&& __v);
 
+#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator __p, initializer_list<value_type> __il)
         {return insert(__p, __il.begin(), __il.end());}
 #endif // _LIBCPP_CXX03_LANG
     iterator insert(const_iterator __p, const value_type& __v);
     iterator insert(const_iterator __p, size_type __n, const value_type& __v);
     template <class _InputIter>
         iterator insert(const_iterator __p, _InputIter __f, _InputIter __l,

         _NOEXCEPT_(__alloc_traits::propagate_on_container_move_assignment::value &&
                    is_nothrow_move_assignable<allocator_type>::value)
 {
     __move_assign(__c, integral_constant<bool,
           __alloc_traits::propagate_on_container_move_assignment::value>());
     return *this;
 }
 
+#endif // _LIBCPP_CXX03_LANG
+
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::__move_assign(deque& __c, false_type)
 {
     if (__base::__alloc() != __c.__alloc())
     {
         typedef move_iterator<iterator> _Ip;
         assign(_Ip(__c.begin()), _Ip(__c.end()));
     }
     else
         __move_assign(__c, true_type());
 }
 
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::__move_assign(deque& __c, true_type)
     _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
 {
     clear();
     shrink_to_fit();
     __base::__move_assign(__c);
 }
 
-#endif // _LIBCPP_CXX03_LANG
-
 template <class _Tp, class _Allocator>
 template <class _InputIter>
 void
 deque<_Tp, _Allocator>::assign(_InputIter __f, _InputIter __l,
                                typename enable_if<__is_cpp17_input_iterator<_InputIter>::value &&
                                                  !__is_cpp17_random_access_iterator<_InputIter>::value>::type*)
 {
     iterator __i = __base::begin();

     if (__front_spare() == 0)
         __add_front_capacity();
     // __front_spare() >= 1
     __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), __v);
     --__base::__start_;
     ++__base::size();
 }
 
-#ifndef _LIBCPP_CXX03_LANG
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::push_back(value_type&& __v)
 {
     allocator_type& __a = __base::__alloc();
     if (__back_spare() == 0)
         __add_back_capacity();
     // __back_spare() >= 1

             if (__de > 1)
                 __e = _VSTD::move_backward(__e - __de, __em1, __e);
             *--__e = _VSTD::move(__tmp.get());
         }
     }
     return __base::begin() + __pos;
 }
 
-#endif // _LIBCPP_CXX03_LANG
-
-
 template <class _Tp, class _Allocator>
 typename deque<_Tp, _Allocator>::iterator
 deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v)
 {
     size_type __pos = __p - __base::begin();
     size_type __to_end = __base::size() - __pos;
     allocator_type& __a = __base::__alloc();
     if (__pos < __to_end)

 template <class _Tp, class _Allocator>
 template <class _InpIter>
 void
 deque<_Tp, _Allocator>::__append(_InpIter __f, _InpIter __l,
                                  typename enable_if<__is_cpp17_input_iterator<_InpIter>::value &&
                                                    !__is_cpp17_forward_iterator<_InpIter>::value>::type*)
 {
     for (; __f != __l; ++__f)
-#ifdef _LIBCPP_CXX03_LANG
-        push_back(*__f);
-#else
         emplace_back(*__f);
-#endif
 }
 
 template <class _Tp, class _Allocator>
 template <class _ForIter>
 void
 deque<_Tp, _Allocator>::__append(_ForIter __f, _ForIter __l,
                                  typename enable_if<__is_cpp17_forward_iterator<_ForIter>::value>::type*)
 {

libcxx/include/forward_list

__forward_list_base()
         _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
         : __before_begin_(__begin_node(), __default_init_tag()) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit __forward_list_base(const allocator_type& __a)
         : __before_begin_(__begin_node(), __node_allocator(__a)) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit __forward_list_base(const __node_allocator& __a)
         : __before_begin_(__begin_node(), __a) {}
-#ifndef _LIBCPP_CXX03_LANG
+
 public:
     _LIBCPP_INLINE_VISIBILITY
     __forward_list_base(__forward_list_base&& __x)
         _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value);
     _LIBCPP_INLINE_VISIBILITY
     __forward_list_base(__forward_list_base&& __x, const allocator_type& __a);
-#endif // _LIBCPP_CXX03_LANG
-
-private:
-    __forward_list_base(const __forward_list_base&);
-    __forward_list_base& operator=(const __forward_list_base&);
-
-public:
     ~__forward_list_base();
 
 protected:
     _LIBCPP_INLINE_VISIBILITY
     void __copy_assign_alloc(const __forward_list_base& __x)
         {__copy_assign_alloc(__x, integral_constant<bool,
               __node_traits::propagate_on_container_copy_assignment::value>());}
 
private:
     void __move_assign_alloc(__forward_list_base&, false_type) _NOEXCEPT
         {}
     _LIBCPP_INLINE_VISIBILITY
     void __move_assign_alloc(__forward_list_base& __x, true_type)
         _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value)
         {__alloc() = _VSTD::move(__x.__alloc());}
 };
 
-#ifndef _LIBCPP_CXX03_LANG
-
 template <class _Tp, class _Alloc>
 inline
 __forward_list_base<_Tp, _Alloc>::__forward_list_base(__forward_list_base&& __x)
         _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value)
     : __before_begin_(_VSTD::move(__x.__before_begin_))
 {
     __x.__before_begin()->__next_ = nullptr;
 }
 
 template <class _Tp, class _Alloc>
 inline
 __forward_list_base<_Tp, _Alloc>::__forward_list_base(__forward_list_base&& __x,
                                                       const allocator_type& __a)
     : __before_begin_(__begin_node(), __node_allocator(__a))
 {
     if (__alloc() == __x.__alloc())
     {
         __before_begin()->__next_ = __x.__before_begin()->__next_;
         __x.__before_begin()->__next_ = nullptr;
     }
 }
 
-#endif // _LIBCPP_CXX03_LANG
-
 template <class _Tp, class _Alloc>
 __forward_list_base<_Tp, _Alloc>::~__forward_list_base()
 {
     clear();
 }
 
 template <class _Tp, class _Alloc>
 inline
size_type max_size() const _NOEXCEPT {
             numeric_limits<difference_type>::max());
     }
 
     _LIBCPP_INLINE_VISIBILITY
     reference       front()       {return base::__before_begin()->__next_->__value_;}
     _LIBCPP_INLINE_VISIBILITY
     const_reference front() const {return base::__before_begin()->__next_->__value_;}
 
-#ifndef _LIBCPP_CXX03_LANG
 #if _LIBCPP_STD_VER > 14
     template <class... _Args> reference emplace_front(_Args&&... __args);
 #else
     template <class... _Args> void      emplace_front(_Args&&... __args);
 #endif
     void push_front(value_type&& __v);
-#endif // _LIBCPP_CXX03_LANG
     void push_front(const value_type& __v);
 
     void pop_front();
 
-#ifndef _LIBCPP_CXX03_LANG
     template <class... _Args>
         iterator emplace_after(const_iterator __p, _Args&&... __args);
 
     iterator insert_after(const_iterator __p, value_type&& __v);
+#ifndef _LIBCPP_CXX03_LANG
     iterator insert_after(const_iterator __p, initializer_list<value_type> __il)
         {return insert_after(__p, __il.begin(), __il.end());}
 #endif // _LIBCPP_CXX03_LANG
     iterator insert_after(const_iterator __p, const value_type& __v);
     iterator insert_after(const_iterator __p, size_type __n, const value_type& __v);
     template <class _InputIterator>
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if
#endif
     void splice_after(const_iterator __p, forward_list& __x, const_iterator __i);
     void splice_after(const_iterator __p, forward_list& __x,
                       const_iterator __f, const_iterator __l);
     __remove_return_type remove(const value_type& __v);
     template <class _Predicate> __remove_return_type remove_if(_Predicate __pred);
     _LIBCPP_INLINE_VISIBILITY
     __remove_return_type unique() {return unique(__equal_to<value_type>());}
     template <class _BinaryPredicate> __remove_return_type unique(_BinaryPredicate __binary_pred);
-#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     void merge(forward_list&& __x) {merge(__x, __less<value_type>());}
     template <class _Compare>
         _LIBCPP_INLINE_VISIBILITY
         void merge(forward_list&& __x, _Compare __comp)
         {merge(__x, _VSTD::move(__comp));}
-#endif // _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     void merge(forward_list& __x) {merge(__x, __less<value_type>());}
     template <class _Compare> void merge(forward_list& __x, _Compare __comp);
     _LIBCPP_INLINE_VISIBILITY
     void sort() {sort(__less<value_type>());}
     template <class _Compare> _LIBCPP_INLINE_VISIBILITY void sort(_Compare __comp);
     void reverse() _NOEXCEPT;
 
 private:
 
-#ifndef _LIBCPP_CXX03_LANG
     void __move_assign(forward_list& __x, true_type)
         _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
     void __move_assign(forward_list& __x, false_type);
-#endif // _LIBCPP_CXX03_LANG
 
     template <class _Compare>
         static
         __node_pointer
         __merge(__node_pointer __f1, __node_pointer __f2, _Compare& __comp);
 
     template <class _Compare>
         static
for (; __j != __e && __n > 0; --__n, ++__i, ++__j)
         *__j = __v;
     if (__j == __e)
         insert_after(__i, __n, __v);
     else
         erase_after(__i, __e);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
-
 template <class _Tp, class _Alloc>
 inline
 void
 forward_list<_Tp, _Alloc>::assign(initializer_list<value_type> __il)
 {
     assign(__il.begin(), __il.end());
 }
+#endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Alloc>
 template <class... _Args>
 #if _LIBCPP_STD_VER > 14
 typename forward_list<_Tp, _Alloc>::reference
 #else
 void
 #endif
forward_list<_Tp, _Alloc>::push_front(value_type&& __v)
     __node_allocator& __a = base::__alloc();
     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
     __node_traits::construct(__a, _VSTD::addressof(__h->__value_), _VSTD::move(__v));
     __h->__next_ = base::__before_begin()->__next_;
     base::__before_begin()->__next_ = __h.release();
 }
 
-#endif // _LIBCPP_CXX03_LANG
-
 template <class _Tp, class _Alloc>
 void
 forward_list<_Tp, _Alloc>::push_front(const value_type& __v)
 {
     __node_allocator& __a = base::__alloc();
     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
     __node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
     __h->__next_ = base::__before_begin()->__next_;
     base::__before_begin()->__next_ = __h.release();
 }
 
 template <class _Tp, class _Alloc>
 void
 forward_list<_Tp, _Alloc>::pop_front()
 {
     __node_allocator& __a = base::__alloc();
     __node_pointer __p = base::__before_begin()->__next_;
     base::__before_begin()->__next_ = __p->__next_;
     __node_traits::destroy(__a, _VSTD::addressof(__p->__value_));
     __node_traits::deallocate(__a, __p, 1);
 }
 
-#ifndef _LIBCPP_CXX03_LANG
-
 template <class _Tp, class _Alloc>
 template <class... _Args>
 typename forward_list<_Tp, _Alloc>::iterator
 forward_list<_Tp, _Alloc>::emplace_after(const_iterator __p, _Args&&... __args)
 {
     __begin_node_pointer const __r = __p.__get_begin();
     __node_allocator& __a = base::__alloc();
     typedef __allocator_destructor<__node_allocator> _Dp;
forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, value_type&& __v)
     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
     __node_traits::construct(__a, _VSTD::addressof(__h->__value_), _VSTD::move(__v));
     __h->__next_ = __r->__next_;
     __r->__next_ = __h.release();
     return iterator(__r->__next_);
 }
 
-#endif // _LIBCPP_CXX03_LANG
-
 template <class _Tp, class _Alloc>
 typename forward_list<_Tp, _Alloc>::iterator
 forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, const value_type& __v)
 {
     __begin_node_pointer const __r = __p.__get_begin();
     __node_allocator& __a = base::__alloc();
     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));

libcxx/include/list

protected:
 
     _LIBCPP_INLINE_VISIBILITY
     __list_imp()
         _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value);
     _LIBCPP_INLINE_VISIBILITY
     __list_imp(const allocator_type& __a);
     _LIBCPP_INLINE_VISIBILITY
     __list_imp(const __node_allocator& __a);
-#ifndef _LIBCPP_CXX03_LANG
     __list_imp(__node_allocator&& __a) _NOEXCEPT;
-#endif
     ~__list_imp();
     void clear() _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT {return __sz() == 0;}
 
     _LIBCPP_INLINE_VISIBILITY
     iterator begin() _NOEXCEPT
     {
__list_imp<_Tp, _Alloc>::__list_imp(const allocator_type& __a)
     : __size_alloc_(0, __node_allocator(__a))
 {
 }
 
 template <class _Tp, class _Alloc>
 inline __list_imp<_Tp, _Alloc>::__list_imp(const __node_allocator& __a)
     : __size_alloc_(0, __a) {}
 
-#ifndef _LIBCPP_CXX03_LANG
 template <class _Tp, class _Alloc>
 inline __list_imp<_Tp, _Alloc>::__list_imp(__node_allocator&& __a) _NOEXCEPT
     : __size_alloc_(0, _VSTD::move(__a)) {}
-#endif
 
 template <class _Tp, class _Alloc>
 __list_imp<_Tp, _Alloc>::~__list_imp() {
   clear();
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->__erase_c(this);
 #endif
 }
#endif // _LIBCPP_CXX03_LANG
     }
     _LIBCPP_INLINE_VISIBILITY
     const_reference back() const
     {
         _LIBCPP_ASSERT(!empty(), "list::back called on empty list");
         return base::__end_.__prev_->__as_node()->__value_;
     }
 
-#ifndef _LIBCPP_CXX03_LANG
     void push_front(value_type&& __x);
     void push_back(value_type&& __x);
 
     template <class... _Args>
 #if _LIBCPP_STD_VER > 14
        reference emplace_front(_Args&&... __args);
 #else
        void      emplace_front(_Args&&... __args);
 #endif
     template <class... _Args>
 #if _LIBCPP_STD_VER > 14
         reference emplace_back(_Args&&... __args);
 #else
        void       emplace_back(_Args&&... __args);
 #endif
     template <class... _Args>
         iterator emplace(const_iterator __p, _Args&&... __args);
 
     iterator insert(const_iterator __p, value_type&& __x);
 
+#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator __p, initializer_list<value_type> __il)
         {return insert(__p, __il.begin(), __il.end());}
 #endif // _LIBCPP_CXX03_LANG
 
     void push_front(const value_type& __x);
     void push_back(const value_type& __x);
 
-#ifndef _LIBCPP_CXX03_LANG
     template <class _Arg>
     _LIBCPP_INLINE_VISIBILITY
     void __emplace_back(_Arg&& __arg) { emplace_back(_VSTD::forward<_Arg>(__arg)); }
-#else
-    _LIBCPP_INLINE_VISIBILITY
-    void __emplace_back(value_type const& __arg) { push_back(__arg); }
-#endif
 
     iterator insert(const_iterator __p, const value_type& __x);
     iterator insert(const_iterator __p, size_type __n, const value_type& __x);
     template <class _InpIter>
         iterator insert(const_iterator __p, _InpIter __f, _InpIter __l,
              typename enable_if<__is_cpp17_input_iterator<_InpIter>::value>::type* = 0);
 
     _LIBCPP_INLINE_VISIBILITY
#endif
 
     iterator erase(const_iterator __p);
     iterator erase(const_iterator __f, const_iterator __l);
 
     void resize(size_type __n);
     void resize(size_type __n, const value_type& __x);
 
     void splice(const_iterator __p, list& __c);
-#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     void splice(const_iterator __p, list&& __c) {splice(__p, __c);}
     _LIBCPP_INLINE_VISIBILITY
     void splice(const_iterator __p, list&& __c, const_iterator __i)
         {splice(__p, __c, __i);}
     _LIBCPP_INLINE_VISIBILITY
     void splice(const_iterator __p, list&& __c, const_iterator __f, const_iterator __l)
         {splice(__p, __c, __f, __l);}
-#endif
     void splice(const_iterator __p, list& __c, const_iterator __i);
     void splice(const_iterator __p, list& __c, const_iterator __f, const_iterator __l);
 
     __remove_return_type remove(const value_type& __x);
     template <class _Pred> __remove_return_type remove_if(_Pred __pred);
     _LIBCPP_INLINE_VISIBILITY
     __remove_return_type unique() { return unique(__equal_to<value_type>()); }
     template <class _BinaryPred>
         __remove_return_type unique(_BinaryPred __binary_pred);
     _LIBCPP_INLINE_VISIBILITY
     void merge(list& __c);
-#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     void merge(list&& __c) {merge(__c);}
 
     template <class _Comp>
     _LIBCPP_INLINE_VISIBILITY
         void merge(list&& __c, _Comp __comp) {merge(__c, __comp);}
-#endif
     template <class _Comp>
         void merge(list& __c, _Comp __comp);
 
     _LIBCPP_INLINE_VISIBILITY
     void sort();
     template <class _Comp>
         _LIBCPP_INLINE_VISIBILITY
         void sort(_Comp __comp);

 
 template <class _Tp, class _Alloc>
 list<_Tp, _Alloc>::list(size_type __n)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->__insert_c(this);
 #endif
     for (; __n > 0; --__n)
-#ifndef _LIBCPP_CXX03_LANG
         emplace_back();
-#else
-        push_back(value_type());
-#endif
 }
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp, class _Alloc>
 list<_Tp, _Alloc>::list(size_type __n, const allocator_type& __a) : base(__a)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     __get_db()->__insert_c(this);
list<_Tp, _Alloc>::push_back(const value_type& __x)
     __node_allocator& __na = base::__node_alloc();
     __hold_pointer __hold = __allocate_node(__na);
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
     __link_nodes_at_back(__hold.get()->__as_link(), __hold.get()->__as_link());
     ++base::__sz();
     __hold.release();
 }
 
-#ifndef _LIBCPP_CXX03_LANG
-
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::push_front(value_type&& __x)
 {
     __node_allocator& __na = base::__node_alloc();
     __hold_pointer __hold = __allocate_node(__na);
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x));
     __link_nodes_at_front(__hold.get()->__as_link(), __hold.get()->__as_link());
#endif
     __hold.release();
 #if _LIBCPP_DEBUG_LEVEL == 2
     return iterator(__nl, this);
 #else
     return iterator(__nl);
 #endif
 }
 
-#endif // _LIBCPP_CXX03_LANG
-
 template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::pop_front()
 {
     _LIBCPP_ASSERT(!empty(), "list::pop_front() called with empty list");
     __node_allocator& __na = base::__node_alloc();
     __link_pointer __n = base::__end_.__next_;
     base::__unlink_nodes(__n, __n);

libcxx/include/set

#endif // _LIBCPP_CXX03_LANG
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT {return __tree_.size() == 0;}
     _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT {return __tree_.size();}
     _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const _NOEXCEPT {return __tree_.max_size();}
 
     // modifiers:
-#ifndef _LIBCPP_CXX03_LANG
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         pair<iterator, bool> emplace(_Args&&... __args)
             {return __tree_.__emplace_unique(_VSTD::forward<_Args>(__args)...);}
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         iterator emplace_hint(const_iterator __p, _Args&&... __args)
             {return __tree_.__emplace_hint_unique(__p, _VSTD::forward<_Args>(__args)...);}
-#endif // _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
     pair<iterator,bool> insert(const value_type& __v)
         {return __tree_.__insert_unique(__v);}
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator __p, const value_type& __v)
         {return __tree_.__insert_unique(__p, __v);}
 
     template <class _InputIterator>
         _LIBCPP_INLINE_VISIBILITY
         void insert(_InputIterator __f, _InputIterator __l)
         {
             for (const_iterator __e = cend(); __f != __l; ++__f)
                 __tree_.__insert_unique(__e, *__f);
         }
 
-#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     pair<iterator,bool> insert(value_type&& __v)
         {return __tree_.__insert_unique(_VSTD::move(__v));}
 
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator __p, value_type&& __v)
         {return __tree_.__insert_unique(__p, _VSTD::move(__v));}
 
+#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     void insert(initializer_list<value_type> __il)
         {insert(__il.begin(), __il.end());}
 #endif // _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
     iterator  erase(const_iterator __p) {return __tree_.erase(__p);}
     _LIBCPP_INLINE_VISIBILITY
#endif // _LIBCPP_CXX03_LANG
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT {return __tree_.size() == 0;}
     _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT {return __tree_.size();}
     _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const _NOEXCEPT {return __tree_.max_size();}
 
     // modifiers:
-#ifndef _LIBCPP_CXX03_LANG
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         iterator emplace(_Args&&... __args)
             {return __tree_.__emplace_multi(_VSTD::forward<_Args>(__args)...);}
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         iterator emplace_hint(const_iterator __p, _Args&&... __args)
             {return __tree_.__emplace_hint_multi(__p, _VSTD::forward<_Args>(__args)...);}
-#endif // _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const value_type& __v)
         {return __tree_.__insert_multi(__v);}
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator __p, const value_type& __v)
         {return __tree_.__insert_multi(__p, __v);}
 
     template <class _InputIterator>
         _LIBCPP_INLINE_VISIBILITY
         void insert(_InputIterator __f, _InputIterator __l)
         {
             for (const_iterator __e = cend(); __f != __l; ++__f)
                 __tree_.__insert_multi(__e, *__f);
         }
 
-#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(value_type&& __v)
         {return __tree_.__insert_multi(_VSTD::move(__v));}
 
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator __p, value_type&& __v)
         {return __tree_.__insert_multi(__p, _VSTD::move(__v));}
 
+#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     void insert(initializer_list<value_type> __il)
         {insert(__il.begin(), __il.end());}
 #endif // _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
     iterator  erase(const_iterator __p) {return __tree_.erase(__p);}
     _LIBCPP_INLINE_VISIBILITY

libcxx/include/vector

protected:
     _LIBCPP_INLINE_VISIBILITY
     const pointer& __end_cap() const _NOEXCEPT
         {return __end_cap_.first();}
 
     _LIBCPP_INLINE_VISIBILITY
     __vector_base()
         _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
     _LIBCPP_INLINE_VISIBILITY __vector_base(const allocator_type& __a);
-#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY __vector_base(allocator_type&& __a) _NOEXCEPT;
-#endif
     ~__vector_base();
 
     _LIBCPP_INLINE_VISIBILITY
     void clear() _NOEXCEPT {__destruct_at_end(__begin_);}
     _LIBCPP_INLINE_VISIBILITY
     size_type capacity() const _NOEXCEPT
         {return static_cast<size_type>(__end_cap() - __begin_);}
 

 inline _LIBCPP_INLINE_VISIBILITY
 __vector_base<_Tp, _Allocator>::__vector_base(const allocator_type& __a)
     : __begin_(nullptr),
       __end_(nullptr),
       __end_cap_(nullptr, __a)
 {
 }
 
-#ifndef _LIBCPP_CXX03_LANG
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 __vector_base<_Tp, _Allocator>::__vector_base(allocator_type&& __a) _NOEXCEPT
     : __begin_(nullptr),
       __end_(nullptr),
       __end_cap_(nullptr, _VSTD::move(__a)) {}
-#endif
 
 template <class _Tp, class _Allocator>
 __vector_base<_Tp, _Allocator>::~__vector_base()
 {
     if (__begin_ != nullptr)
     {
         clear();
         __alloc_traits::deallocate(__alloc(), __begin_, capacity());
#endif
 
     _LIBCPP_INLINE_VISIBILITY
     value_type*       data() _NOEXCEPT
         {return _VSTD::__to_address(this->__begin_);}
     _LIBCPP_INLINE_VISIBILITY
     const value_type* data() const _NOEXCEPT
         {return _VSTD::__to_address(this->__begin_);}
 
-#ifdef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    void __emplace_back(const value_type& __x) { push_back(__x); }
-#else
     template <class _Arg>
     _LIBCPP_INLINE_VISIBILITY
     void __emplace_back(_Arg&& __arg) {
       emplace_back(_VSTD::forward<_Arg>(__arg));
     }
-#endif
 
     _LIBCPP_INLINE_VISIBILITY void push_back(const_reference __x);
-
-#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY void push_back(value_type&& __x);
 
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
 #if _LIBCPP_STD_VER > 14
         reference emplace_back(_Args&&... __args);
 #else
         void      emplace_back(_Args&&... __args);
 #endif
-#endif // !_LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
     void pop_back();
 
     iterator insert(const_iterator __position, const_reference __x);
 
-#ifndef _LIBCPP_CXX03_LANG
     iterator insert(const_iterator __position, value_type&& __x);
     template <class... _Args>
         iterator emplace(const_iterator __position, _Args&&... __args);
-#endif // !_LIBCPP_CXX03_LANG
 
     iterator insert(const_iterator __position, size_type __n, const_reference __x);
     template <class _InputIterator>
         typename enable_if
         <
              __is_cpp17_input_iterator  <_InputIterator>::value &&
             !__is_cpp17_forward_iterator<_InputIterator>::value &&
             is_constructible<
private:
     void __destruct_at_end(pointer __new_last) _NOEXCEPT
     {
         __invalidate_iterators_past(__new_last);
         size_type __old_size = size();
         __base::__destruct_at_end(__new_last);
         __annotate_shrink(__old_size);
     }
 
-#ifndef _LIBCPP_CXX03_LANG
     template <class _Up>
     _LIBCPP_INLINE_VISIBILITY
     inline void __push_back_slow_path(_Up&& __x);
 
     template <class... _Args>
     _LIBCPP_INLINE_VISIBILITY
     inline void __emplace_back_slow_path(_Args&&... __args);
-#else
-    template <class _Up>
-    _LIBCPP_INLINE_VISIBILITY
-    inline void __push_back_slow_path(_Up& __x);
-#endif
 
     // The following functions are no-ops outside of AddressSanitizer mode.
     // We call annotatations only for the default Allocator because other allocators
     // may not meet the AddressSanitizer alignment constraints.
     // See the documentation for __sanitizer_annotate_contiguous_container for more details.
 #ifndef _LIBCPP_HAS_NO_ASAN
     void __annotate_contiguous_container(const void *__beg, const void *__end,
                                          const void *__old_mid,
#ifndef _LIBCPP_NO_EXCEPTIONS
         }
 #endif // _LIBCPP_NO_EXCEPTIONS
     }
 }
 
 template <class _Tp, class _Allocator>
 template <class _Up>
 void
-#ifndef _LIBCPP_CXX03_LANG
 vector<_Tp, _Allocator>::__push_back_slow_path(_Up&& __x)
-#else
-vector<_Tp, _Allocator>::__push_back_slow_path(_Up& __x)
-#endif
 {
     allocator_type& __a = this->__alloc();
     __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), size(), __a);
     // __v.push_back(_VSTD::forward<_Up>(__x));
     __alloc_traits::construct(__a, _VSTD::__to_address(__v.__end_), _VSTD::forward<_Up>(__x));
     __v.__end_++;
     __swap_out_circular_buffer(__v);
 }
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 vector<_Tp, _Allocator>::push_back(const_reference __x)
 {
     if (this->__end_ != this->__end_cap())
     {
         __construct_one_at_end(__x);
     }
     else
         __push_back_slow_path(__x);
 }
 
-#ifndef _LIBCPP_CXX03_LANG
-
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 vector<_Tp, _Allocator>::push_back(value_type&& __x)
 {
     if (this->__end_ < this->__end_cap())
     {
         __construct_one_at_end(_VSTD::move(__x));
vector<_Tp, _Allocator>::emplace_back(_Args&&... __args)
     }
     else
         __emplace_back_slow_path(_VSTD::forward<_Args>(__args)...);
 #if _LIBCPP_STD_VER > 14
     return this->back();
 #endif
 }
 
-#endif // !_LIBCPP_CXX03_LANG
-
 template <class _Tp, class _Allocator>
 inline
 void
 vector<_Tp, _Allocator>::pop_back()
 {
     _LIBCPP_ASSERT(!empty(), "vector::pop_back called on an empty vector");
     this->__destruct_at_end(this->__end_ - 1);
 }
else
         allocator_type& __a = this->__alloc();
         __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a);
         __v.push_back(__x);
         __p = __swap_out_circular_buffer(__v, __p);
     }
     return __make_iter(__p);
 }
 
-#ifndef _LIBCPP_CXX03_LANG
-
 template <class _Tp, class _Allocator>
 typename vector<_Tp, _Allocator>::iterator
 vector<_Tp, _Allocator>::insert(const_iterator __position, value_type&& __x)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this,
         "vector::insert(iterator, x) called with an iterator not"
         " referring to this vector");
else
         allocator_type& __a = this->__alloc();
         __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a);
         __v.emplace_back(_VSTD::forward<_Args>(__args)...);
         __p = __swap_out_circular_buffer(__v, __p);
     }
     return __make_iter(__p);
 }
 
-#endif // !_LIBCPP_CXX03_LANG
-
 template <class _Tp, class _Allocator>
 typename vector<_Tp, _Allocator>::iterator
 vector<_Tp, _Allocator>::insert(const_iterator __position, size_type __n, const_reference __x)
 {
 #if _LIBCPP_DEBUG_LEVEL == 2
     _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this,
         "vector::insert(iterator, n, x) called with an iterator not"
         " referring to this vector");