Eliminate _LIBCPP_EQUAL_DELETE in favor of `=delete`. NFC.

[• Quuxplusone]

Summary

All supported compilers have supported =delete as an extension in C++03 mode for many years at this point.

[ldionne]

I think there are similar simplifications we can make to the test suite.

[• Quuxplusone]

In D109942#3009825, @ldionne wrote:

I think there are similar simplifications we can make to the test suite.

I didn't immediately see anything related to =delete in the tests. They may have been dealt with already, I guess.

For the record: I do see a similar macro _LIBCPP_DEFAULT in <__config>, but it is not as mechanical to remove, because its semantics are "Make things defaulted (possibly trivial) in C++11, non-defaulted (non-trivial) in C++03." And it is used only in atomic, std::allocator (where ISTR we have needed discussions to avoid exactly that kind of ABI break), and error_category (where it is guarded by some dylib-related stuff that is beyond me). So I am not planning a followup patch to remove _LIBCPP_DEFAULT, myself.

[ldionne]

In D109942#3009886, @Quuxplusone wrote:

In D109942#3009825, @ldionne wrote:

I think there are similar simplifications we can make to the test suite.

I didn't immediately see anything related to =delete in the tests. They may have been dealt with already, I guess.

For the record: I do see a similar macro _LIBCPP_DEFAULT in <__config>, but it is not as mechanical to remove, because its semantics are "Make things defaulted (possibly trivial) in C++11, non-defaulted (non-trivial) in C++03." And it is used only in atomic, std::allocator (where ISTR we have needed discussions to avoid exactly that kind of ABI break), and error_category (where it is guarded by some dylib-related stuff that is beyond me). So I am not planning a followup patch to remove _LIBCPP_DEFAULT, myself.

Yeah, I was mistaking it with the = default machinery in the test suite. Thanks!

libcxx/include/__config

 #endif
 
 #ifdef _LIBCPP_CXX03_LANG
 #  define _LIBCPP_DEFAULT {}
 #else
 #  define _LIBCPP_DEFAULT = default;
 #endif
 
-#ifdef _LIBCPP_CXX03_LANG
-#  define _LIBCPP_EQUAL_DELETE
-#else
-#  define _LIBCPP_EQUAL_DELETE = delete
-#endif
-
 #ifdef __GNUC__
 #  define _LIBCPP_NOALIAS __attribute__((__malloc__))
 #else
 #  define _LIBCPP_NOALIAS
 #endif
 
 #if __has_attribute(using_if_exists)
 # define _LIBCPP_USING_IF_EXISTS __attribute__((using_if_exists))

libcxx/include/__mutex_base

public:
 
     _LIBCPP_NODISCARD_EXT _LIBCPP_INLINE_VISIBILITY
     lock_guard(mutex_type& __m, adopt_lock_t) _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m))
         : __m_(__m) {}
     _LIBCPP_INLINE_VISIBILITY
     ~lock_guard() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) {__m_.unlock();}
 
 private:
-    lock_guard(lock_guard const&) _LIBCPP_EQUAL_DELETE;
-    lock_guard& operator=(lock_guard const&) _LIBCPP_EQUAL_DELETE;
+    lock_guard(lock_guard const&) = delete;
+    lock_guard& operator=(lock_guard const&) = delete;
 };
 
 template <class _Mutex>
 class _LIBCPP_TEMPLATE_VIS unique_lock
 {
 public:
     typedef _Mutex mutex_type;
 

libcxx/include/__tree

public:
     pointer __parent_unsafe() const { return static_cast<pointer>(__parent_);}
 
     _LIBCPP_INLINE_VISIBILITY
     void __set_parent(pointer __p) {
         __parent_ = static_cast<__parent_pointer>(__p);
     }
 
 private:
-  ~__tree_node_base() _LIBCPP_EQUAL_DELETE;
-  __tree_node_base(__tree_node_base const&) _LIBCPP_EQUAL_DELETE;
-  __tree_node_base& operator=(__tree_node_base const&) _LIBCPP_EQUAL_DELETE;
+  ~__tree_node_base() = delete;
+  __tree_node_base(__tree_node_base const&) = delete;
+  __tree_node_base& operator=(__tree_node_base const&) = delete;
 };
 
 template <class _Tp, class _VoidPtr>
 class _LIBCPP_STANDALONE_DEBUG __tree_node
     : public __tree_node_base<_VoidPtr>
 {
 public:
     typedef _Tp __node_value_type;
 
     __node_value_type __value_;
 
 private:
-  ~__tree_node() _LIBCPP_EQUAL_DELETE;
-  __tree_node(__tree_node const&) _LIBCPP_EQUAL_DELETE;
-  __tree_node& operator=(__tree_node const&) _LIBCPP_EQUAL_DELETE;
+  ~__tree_node() = delete;
+  __tree_node(__tree_node const&) = delete;
+  __tree_node& operator=(__tree_node const&) = delete;
 };
 
 
 template <class _Allocator>
 class __tree_node_destructor
 {
     typedef _Allocator                                      allocator_type;
     typedef allocator_traits<allocator_type>                __alloc_traits;

libcxx/include/map

#endif
     _LIBCPP_INLINE_VISIBILITY
     __value_type& operator=(_ValueTp&& __v)
     {
         __ref() = _VSTD::forward<_ValueTp>(__v);
         return *this;
     }
 
 private:
-    __value_type() _LIBCPP_EQUAL_DELETE;
-    ~__value_type() _LIBCPP_EQUAL_DELETE;
-    __value_type(const __value_type& __v) _LIBCPP_EQUAL_DELETE;
-    __value_type(__value_type&& __v) _LIBCPP_EQUAL_DELETE;
+    __value_type() = delete;
+    ~__value_type() = delete;
+    __value_type(const __value_type&) = delete;
+    __value_type(__value_type&&) = delete;
 };
 
 #else
 
 template <class _Key, class _Tp>
 struct __value_type
 {
     typedef _Key                                     key_type;