[libc++][test] Use = delete over DELETE_FUNCTION. NFC.

[jloser]

Summary

Some tests repeat the definition of DELETE_FUNCTION macro locally.
However, it's not even requred to guard against in the C++03 case since
Clang supports = delete; in C++03 mode. A warning is issued but
libc++ tests run with -Wno-c++11-extensions, so this isn't an issue.
Since we don't support other compilers in C++03 mode, = delete; is
always available for use. As such, inline all calls of DELETE_FUNCTION
to use = delete;.

[jloser]

Fix commit message

[jloser]

Use DELETE_FUNCTION in test_allocator.h

[jloser]

Remove extra private section in limited_allocator since we use DELETE_FUNCTION now.

[jloser]

[NFC] More cleanup in limited_allocator

[• Quuxplusone]

LGTM, but, have you tried just inlining = delete; in all these places? I believe Clang supports it in C++03 mode, and we don't care about other compilers in C++03 mode.

[jloser]

Inline = delete; for all usages of DELETE_FUNCTION

[jloser]

In D111148#3042824, @Quuxplusone wrote:

LGTM, but, have you tried just inlining = delete; in all these places? I believe Clang supports it in C++03 mode, and we don't care about other compilers in C++03 mode.

Just tried inlining = delete; everywhere. We'll see if BuildKite is happy! It seems you're right that Clang supports it in C++03 mode. A warning is issued, but the libc++ tests run with -Wno-c++11-extensions, so we should be OK. Small example at https://godbolt.org/z/KvYKMqWfz

[ldionne]

LGTM if CI is happy.

libcxx/test/libcxx/iterators/contiguous_iterators.pass.cpp

 #if TEST_STD_VER >= 17
 #include <string_view>
 #endif
 
 #if TEST_STD_VER >= 20
 #include <span>
 #endif
 
-#if TEST_STD_VER >= 11
-#define DELETE_FUNCTION = delete
-#else
-#define DELETE_FUNCTION
-#endif
-
 class T;  // incomplete
 
 class my_input_iterator
 {
     struct tag : std::input_iterator_tag {};
     typedef my_input_iterator Self;
     int *state_;
 public:

libcxx/test/std/utilities/memory/storage.iterator/raw_storage_iterator.pass.cpp

 
 #include <memory>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include <MoveOnly.h>
 
-#if TEST_STD_VER >= 11
-#define DELETE_FUNCTION = delete
-#else
-#define DELETE_FUNCTION
-#endif
-
 int A_constructed = 0;
 
 struct A
 {
     int data_;
 public:
     explicit A(int i) : data_(i) {++A_constructed;}
 

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared.pass.cpp

 #include <memory>
 #include <new>
 #include <cstdlib>
 #include <cassert>
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
-#if TEST_STD_VER >= 11
-#define DELETE_FUNCTION = delete
-#else
-#define DELETE_FUNCTION
-#endif
-
 int new_count = 0;
 
 struct A
 {
     static int count;
 
     A(int i, char c) : int_(i), char_(c) {++count;}
     A(const A& a)

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp

 // template<class T, class... Args> shared_ptr<T> make_shared(Args&&... args);
 
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 #include "count_new.h"
 
-#if TEST_STD_VER >= 11
-#define DELETE_FUNCTION = delete
-#else
-#define DELETE_FUNCTION
-#endif
-
 struct A
 {
     static int count;
 
     A(int i, char c) : int_(i), char_(c) {++count;}
     A(const A& a)
         : int_(a.int_), char_(a.char_)
         {++count;}

libcxx/test/support/test_allocator.h

public:
 
     limited_allocator(limited_allocator const& other) : handle_(other.handle_) {}
 
     template <class U>
     explicit limited_allocator(limited_allocator<U, N> const& other)
         : handle_(other.handle_) {}
 
 private:
-    limited_allocator& operator=(const limited_allocator&);// = delete;
+    limited_allocator& operator=(const limited_allocator&) DELETE_FUNCTION;
 
 public:
     pointer allocate(size_type n) { return handle_->template allocate<T>(n); }
     void deallocate(pointer p, size_type n) { handle_->deallocate(p, n); }
     size_type max_size() const {return N;}
 
     BuffT* getHandle() const { return handle_.get(); }
 };

libcxx/test/support/test_iterators.h

 
 #include <cassert>
 #include <iterator>
 #include <stdexcept>
 #include <utility>
 
 #include "test_macros.h"
 
-#if TEST_STD_VER >= 11
-#define DELETE_FUNCTION = delete
-#else
-#define DELETE_FUNCTION
-#endif
-
 template <class It>
 class output_iterator
 {
     It it_;
 
     template <class U> friend class output_iterator;
 public:
     typedef          std::output_iterator_tag                  iterator_category;
difference_type operator-(const three_way_contiguous_iterator& x, const three_way_contiguous_iterator& y) {
         return x.base() - y.base();
     }
 
     friend auto operator<=>(const three_way_contiguous_iterator&, const three_way_contiguous_iterator&) = default;
 };
 
 #endif // TEST_STD_VER > 17 && defined(__cpp_lib_concepts)
 
-#undef DELETE_FUNCTION
-
 #endif // SUPPORT_TEST_ITERATORS_H

libcxx/test/support/test_macros.h

 #endif
 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 #define TEST_SUPPORTS_RANGES
 #endif
 
 #define TEST_IGNORE_NODISCARD (void)
 
+#if TEST_STD_VER >= 11
+#define DELETE_FUNCTION = delete
+#else
+#define DELETE_FUNCTION
+#endif
+
 namespace test_macros_detail {
 template <class T, class U>
 struct is_same { enum { value = 0};} ;
 template <class T>
 struct is_same<T, T> { enum {value = 1}; };
 } // namespace test_macros_detail
 
 #define ASSERT_SAME_TYPE(...) \