[libc++] Remove a few unneeded _LIBCPP_CXX03_LANG ifdefs

[• Quuxplusone]

LGTM except for the unique_ptr parts.

libcxx/include/__memory/unique_ptr.h

261–264

This one is different — it's #ifdef, not #ifndef. Either leave this file alone, or dig into it a bit more to see whether we can just remove the whole block.

484–487

Ditto.

libcxx/include/type_traits

1289–1292

Consider deferring this one to a later PR where you also update all the call-sites to use __uncvref_t<T> instead of __uncvref<T>::type. Not mandatory, but worth considering.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp

31

(After removing the non-NFC unique_ptr diffs, this test diff should also go away.)

[ldionne]

LGTM once CI passes, but I agree with the std::unique_ptr bits.

[• Quuxplusone]

libcxx/include/type_traits

1835

Based on the weirdness of the test failure in https://reviews.llvm.org/harbormaster/unit/view/2687268/ , I don't think you should do this diff either.

Looks to me like maybe Clang's C++03 mode doesn't let you do sizeof(foo()) unless foo()'s return type is destructible. We could probably fix this most simply by just not deleting ~__nat() in any mode, but that's a majorly scary patch that should go in its own PR and be carefully audited for all the users of __nat. (Off the top of my head I don't know why __nat deletes anything — I think it should just be a plain old tag type — but, as always, I assume there is a reason, which means we need to go find out what that reason is.)

[philnik]

• Address comments

[• Quuxplusone]

LGTM if CI is green. Thanks!

libcxx/include/atomic

2439

Nit: I'd remove this blank line.

libcxx/include/__debug

 struct _LIBCPP_TYPE_VIS __c_node;
 
 struct _LIBCPP_TYPE_VIS __i_node
 {
     void* __i_;
     __i_node* __next_;
     __c_node* __c_;
 
-#ifndef _LIBCPP_CXX03_LANG
     __i_node(const __i_node&) = delete;
     __i_node& operator=(const __i_node&) = delete;
-#else
-private:
-    __i_node(const __i_node&);
-    __i_node& operator=(const __i_node&);
-public:
-#endif
+
     _LIBCPP_INLINE_VISIBILITY
     __i_node(void* __i, __i_node* __next, __c_node* __c)
         : __i_(__i), __next_(__next), __c_(__c) {}
     ~__i_node();
 };
 
 struct _LIBCPP_TYPE_VIS __c_node
 {
     void* __c_;
     __c_node* __next_;
     __i_node** beg_;
     __i_node** end_;
     __i_node** cap_;
 
-#ifndef _LIBCPP_CXX03_LANG
     __c_node(const __c_node&) = delete;
     __c_node& operator=(const __c_node&) = delete;
-#else
-private:
-    __c_node(const __c_node&);
-    __c_node& operator=(const __c_node&);
-public:
-#endif
+
     _LIBCPP_INLINE_VISIBILITY
     __c_node(void* __c, __c_node* __next)
         : __c_(__c), __next_(__next), beg_(nullptr), end_(nullptr), cap_(nullptr) {}
     virtual ~__c_node();
 
     virtual bool __dereferenceable(const void*) const = 0;
     virtual bool __decrementable(const void*) const = 0;
     virtual bool __addable(const void*, ptrdiff_t) const = 0;
class _LIBCPP_TYPE_VIS __libcpp_db
     __c_node** __cend_;
     size_t   __csz_;
     __i_node** __ibeg_;
     __i_node** __iend_;
     size_t   __isz_;
 
     __libcpp_db();
 public:
-#ifndef _LIBCPP_CXX03_LANG
     __libcpp_db(const __libcpp_db&) = delete;
     __libcpp_db& operator=(const __libcpp_db&) = delete;
-#else
-private:
-    __libcpp_db(const __libcpp_db&);
-    __libcpp_db& operator=(const __libcpp_db&);
-public:
-#endif
+
     ~__libcpp_db();
 
     class __db_c_iterator;
     class __db_c_const_iterator;
     class __db_i_iterator;
     class __db_i_const_iterator;
 
     __db_c_const_iterator __c_end() const;

libcxx/include/__iterator/reverse_access.h

 #include <initializer_list>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if !defined(_LIBCPP_CXX03_LANG)
-
 #if _LIBCPP_STD_VER > 11
 
 template <class _Tp, size_t _Np>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 reverse_iterator<_Tp*> rbegin(_Tp (&__array)[_Np])
 {
     return reverse_iterator<_Tp*>(__array + _Np);
 }

 
 template <class _Cp>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 auto crend(const _Cp& __c) -> decltype(_VSTD::rend(__c))
 {
     return _VSTD::rend(__c);
 }
 
-#endif
-
-#endif // !defined(_LIBCPP_CXX03_LANG)
+#endif // _LIBCPP_STD_VER > 11
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_REVERSE_ACCESS_H

libcxx/include/__memory/unique_ptr.h

_LIBCPP_INLINE_VISIBILITY
                              is_same<_Dp, default_delete<_Tp> >::value,
                          unique_ptr&>::type
       operator=(auto_ptr<_Up> __p) {
     reset(__p.release());
     return *this;
   }
 #endif
 
-#ifdef _LIBCPP_CXX03_LANG
   unique_ptr(unique_ptr const&) = delete;
   unique_ptr& operator=(unique_ptr const&) = delete;
-#endif
 
 
   _LIBCPP_INLINE_VISIBILITY
   ~unique_ptr() { reset(); }
 
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr& operator=(nullptr_t) _NOEXCEPT {
     reset();
public:
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr&
   operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT {
     reset(__u.release());
     __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter());
     return *this;
   }
 
-#ifdef _LIBCPP_CXX03_LANG
   unique_ptr(unique_ptr const&) = delete;
   unique_ptr& operator=(unique_ptr const&) = delete;
-#endif
-
 public:
   _LIBCPP_INLINE_VISIBILITY
   ~unique_ptr() { reset(); }
 
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr& operator=(nullptr_t) _NOEXCEPT {
     reset();
     return *this;

libcxx/include/atomic

 #else
     _LIBCPP_INLINE_VISIBILITY
     __atomic_base() _NOEXCEPT = default;
 #endif
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
     __atomic_base(_Tp __d) _NOEXCEPT : __a_(__d) {}
 
-#ifndef _LIBCPP_CXX03_LANG
     __atomic_base(const __atomic_base&) = delete;
-#else
-private:
-    _LIBCPP_INLINE_VISIBILITY
-    __atomic_base(const __atomic_base&);
-#endif
 };
 
 #if defined(__cpp_lib_atomic_is_always_lock_free)
 template <class _Tp, bool __b>
 _LIBCPP_CONSTEXPR bool __atomic_base<_Tp, __b>::is_always_lock_free;
 #endif
 
 // atomic<Integral>

 #else
     _LIBCPP_INLINE_VISIBILITY
     atomic_flag() _NOEXCEPT = default;
 #endif
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
     atomic_flag(bool __b) _NOEXCEPT : __a_(__b) {} // EXTENSION
 
-#ifndef _LIBCPP_CXX03_LANG
     atomic_flag(const atomic_flag&) = delete;
     atomic_flag& operator=(const atomic_flag&) = delete;
     atomic_flag& operator=(const atomic_flag&) volatile = delete;
-#else
-private:
-    _LIBCPP_INLINE_VISIBILITY
-    atomic_flag(const atomic_flag&);
-    _LIBCPP_INLINE_VISIBILITY
-    atomic_flag& operator=(const atomic_flag&);
-    _LIBCPP_INLINE_VISIBILITY
-    atomic_flag& operator=(const atomic_flag&) volatile;
-#endif
+
 } atomic_flag;
 
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 atomic_flag_test(const volatile atomic_flag* __o) _NOEXCEPT
 {
     return __o->test();

libcxx/include/type_traits

struct __uncvref  {
     typedef _LIBCPP_NODEBUG typename remove_cv<typename remove_reference<_Tp>::type>::type type;
 };
 
 template <class _Tp>
 struct __unconstref {
     typedef _LIBCPP_NODEBUG typename remove_const<typename remove_reference<_Tp>::type>::type type;
 };
 
-#ifndef _LIBCPP_CXX03_LANG
 template <class _Tp>
 using __uncvref_t _LIBCPP_NODEBUG = typename __uncvref<_Tp>::type;
-#endif
 
 // __is_same_uncvref
 
 template <class _Tp, class _Up>
 struct __is_same_uncvref : _IsSame<typename __uncvref<_Tp>::type,
                                    typename __uncvref<_Up>::type> {};
 
 #if _LIBCPP_STD_VER > 17

 struct __type_list
 {
     typedef _Hp _Head;
     typedef _Tp _Tail;
 };
 
 struct __nat
 {
-#ifndef _LIBCPP_CXX03_LANG
     __nat() = delete;
     __nat(const __nat&) = delete;
     __nat& operator=(const __nat&) = delete;
     ~__nat() = delete;
-#endif
 };
 
 template <class _Tp>
 struct __align_type
 {
     static const size_t value = _LIBCPP_PREFERRED_ALIGNOF(_Tp);
     typedef _Tp type;
 };
 

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp

void test_bad_index() {
     std::tuple<> t0;
     TEST_IGNORE_NODISCARD std::get<char*>(t0); // expected-node {{requested here}}
         // expected-error@tuple:* 1 {{type not in empty type list}}
 }
 
 void test_bad_return_type() {
     typedef std::unique_ptr<int> upint;
     std::tuple<upint> t;
-    upint p = std::get<upint>(t); // expected-error{{deleted copy constructor}}
+    upint p = std::get<upint>(t); // expected-error{{call to deleted constructor}}
 }
 
 int main(int, char**)
 {
     test_bad_index();
     test_bad_return_type();
 
   return 0;
 }