[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;}
 
     A(const A& a) : data_(a.data_)  {++A_constructed;}
     ~A() {--A_constructed; data_ = 0;}
 
     bool operator==(int i) const {return data_ == i;}
-    A* operator& () DELETE_FUNCTION;
+    A* operator& () = delete;
 };
 
 int main(int, char**)
 {
     {
     typedef A S;
     typedef std::aligned_storage<3*sizeof(S), std::alignment_of<S>::value>::type
             Storage;

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)
         : int_(a.int_), char_(a.char_)
         {++count;}
     ~A() {--count;}
 
     int get_int() const {return int_;}
     char get_char() const {return char_;}
 
-    A* operator& () DELETE_FUNCTION;
+    A* operator& () = delete;
 private:
     int int_;
     char char_;
 };
 
 int A::count = 0;
 
 struct Zero

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;}
     ~A() {--count;}
 
     int get_int() const {return int_;}
     char get_char() const {return char_;}
 
-    A* operator& () DELETE_FUNCTION;
+    A* operator& () = delete;
 
 private:
     int int_;
     char char_;
 };
 
 int A::count = 0;
 

libcxx/test/support/test_allocator.h

public:
     limited_allocator() : handle_(new BuffT) {}
 
     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;
 
-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(); }
 };
 
 template <class T, class U, std::size_t N>

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;
public:
 
     TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
 
     TEST_CONSTEXPR_CXX14 output_iterator& operator++() {++it_; return *this;}
     TEST_CONSTEXPR_CXX14 output_iterator operator++(int)
         {output_iterator tmp(*this); ++(*this); return tmp;}
 
     template <class T>
-    void operator,(T const &) DELETE_FUNCTION;
+    void operator,(T const &) = delete;
 };
 
 // This is the Cpp17InputIterator requirement as described in Table 87 ([input.iterators]),
 // formerly known as InputIterator prior to C++20.
 template <class It, class ItTraits = It>
 class cpp17_input_iterator
 {
     typedef std::iterator_traits<ItTraits> Traits;
TEST_CONSTEXPR_CXX14 cpp17_input_iterator operator++(int)
         {cpp17_input_iterator tmp(*this); ++(*this); return tmp;}
 
     friend TEST_CONSTEXPR_CXX14 bool operator==(const cpp17_input_iterator& x, const cpp17_input_iterator& y)
         {return x.it_ == y.it_;}
     friend TEST_CONSTEXPR_CXX14 bool operator!=(const cpp17_input_iterator& x, const cpp17_input_iterator& y)
         {return !(x == y);}
 
     template <class T>
-    void operator,(T const &) DELETE_FUNCTION;
+    void operator,(T const &) = delete;
 };
 
 template <class T, class TV, class U, class UV>
 bool operator==(const cpp17_input_iterator<T, TV>& x, const cpp17_input_iterator<U, UV>& y)
 {
     return x.base() == y.base();
 }
 
TEST_CONSTEXPR_CXX14 forward_iterator operator++(int)
         {forward_iterator tmp(*this); ++(*this); return tmp;}
 
     friend TEST_CONSTEXPR_CXX14 bool operator==(const forward_iterator& x, const forward_iterator& y)
         {return x.it_ == y.it_;}
     friend TEST_CONSTEXPR_CXX14 bool operator!=(const forward_iterator& x, const forward_iterator& y)
         {return !(x == y);}
 
     template <class T>
-    void operator,(T const &) DELETE_FUNCTION;
+    void operator,(T const &) = delete;
 };
 
 template <class T, class U>
 TEST_CONSTEXPR_CXX14
 bool operator==(const forward_iterator<T>& x, const forward_iterator<U>& y)
 {
     return x.base() == y.base();
 }
TEST_CONSTEXPR_CXX14 non_default_constructible_iterator operator++(int)
         {non_default_constructible_iterator tmp(*this); ++(*this); return tmp;}
 
     friend TEST_CONSTEXPR_CXX14 bool operator==(const non_default_constructible_iterator& x, const non_default_constructible_iterator& y)
         {return x.it_ == y.it_;}
     friend TEST_CONSTEXPR_CXX14 bool operator!=(const non_default_constructible_iterator& x, const non_default_constructible_iterator& y)
         {return !(x == y);}
 
     template <class T>
-    void operator,(T const &) DELETE_FUNCTION;
+    void operator,(T const &) = delete;
 };
 
 template <class T, class U>
 TEST_CONSTEXPR_CXX14
 bool operator==(const non_default_constructible_iterator<T>& x, const non_default_constructible_iterator<U>& y)
 {
     return x.base() == y.base();
 }
public:
     TEST_CONSTEXPR_CXX14 bidirectional_iterator operator++(int)
         {bidirectional_iterator tmp(*this); ++(*this); return tmp;}
 
     TEST_CONSTEXPR_CXX14 bidirectional_iterator& operator--() {--it_; return *this;}
     TEST_CONSTEXPR_CXX14 bidirectional_iterator operator--(int)
         {bidirectional_iterator tmp(*this); --(*this); return tmp;}
 
     template <class T>
-    void operator,(T const &) DELETE_FUNCTION;
+    void operator,(T const &) = delete;
 };
 
 template <class T, class U>
 TEST_CONSTEXPR_CXX14
 bool operator==(const bidirectional_iterator<T>& x, const bidirectional_iterator<U>& y)
 {
     return x.base() == y.base();
 }
friend TEST_CONSTEXPR_CXX14 random_access_iterator operator+(difference_type n, random_access_iterator x)
         {x += n; return x;}
     TEST_CONSTEXPR_CXX14 random_access_iterator& operator-=(difference_type n) {return *this += -n;}
     TEST_CONSTEXPR_CXX14 random_access_iterator operator-(difference_type n) const
         {random_access_iterator tmp(*this); tmp -= n; return tmp;}
 
     TEST_CONSTEXPR_CXX14 reference operator[](difference_type n) const {return it_[n];}
 
     template <class T>
-    void operator,(T const &) DELETE_FUNCTION;
+    void operator,(T const &) = delete;
 };
 
 template <class T, class U>
 TEST_CONSTEXPR_CXX14
 bool operator==(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
 {
     return x.base() == y.base();
 }
difference_type operator==(const contiguous_iterator& x, const contiguous_iterator& y) {
         return x.base() == y.base();
     }
     friend TEST_CONSTEXPR_CXX14
     difference_type operator!=(const contiguous_iterator& x, const contiguous_iterator& y) {
         return x.base() != y.base();
     }
 
     template <class T>
-    void operator,(T const &) DELETE_FUNCTION;
+    void operator,(T const &) = delete;
 };
 #endif
 
 template <class Iter>
 TEST_CONSTEXPR_CXX14 Iter base(output_iterator<Iter> i) { return i.base(); }
 
 template <class Iter>
 TEST_CONSTEXPR_CXX14 Iter base(cpp17_input_iterator<Iter> i) { return i.base(); }
#endif
         return a.current_ == b.current_;
     }
 
     friend bool operator!=(const ThrowingIterator& a, const ThrowingIterator& b) {
         return !(a == b);
     }
 
     template <class T2>
-    void operator,(T2 const &) DELETE_FUNCTION;
+    void operator,(T2 const &) = delete;
 
 private:
     const T* begin_;
     const T* end_;
     const T* current_;
     ThrowingAction action_;
     mutable int index_;
 };
friend bool operator==(const NonThrowingIterator& a, const NonThrowingIterator& b) TEST_NOEXCEPT {
         return a.current_ == b.current_;
     }
 
     friend bool operator!=(const NonThrowingIterator& a, const NonThrowingIterator& b) TEST_NOEXCEPT {
         return !(a == b);
     }
 
     template <class T2>
-    void operator,(T2 const &) DELETE_FUNCTION;
+    void operator,(T2 const &) = delete;
 
 private:
     const T *begin_;
     const T *end_;
     const T *current_;
 };
 
 #ifdef TEST_SUPPORTS_RANGES
struct cpp20_input_iterator {
 
     constexpr void operator++(int) { ++base_; }
 
     constexpr const I& base() const& { return base_; }
 
     constexpr I base() && { return std::move(base_); }
 
     template <class T>
-    void operator,(T const &) DELETE_FUNCTION;
+    void operator,(T const &) = delete;
 
 private:
     I base_ = I();
 };
 
 template <std::input_or_output_iterator I>
 struct iterator_concept {
     using type = std::output_iterator_tag;
public:
 
     friend constexpr bool operator>=(stride_counting_iterator const& x, stride_counting_iterator const& y)
         requires std::random_access_iterator<I>
     {
         return !(x < y);
     }
 
     template <class T>
-    void operator,(T const &) DELETE_FUNCTION;
+    void operator,(T const &) = delete;
 
 private:
     I base_;
     difference_type stride_count_ = 0;
     difference_type stride_displacement_ = 0;
 };
 
 template<class T, class U>
public:
     constexpr auto operator+(difference_type n) const {auto tmp = *this; tmp += n; return tmp;}
     friend constexpr auto operator+(difference_type n, three_way_contiguous_iterator x) {x += n; return x;}
     constexpr three_way_contiguous_iterator& operator-=(difference_type n) {return *this += -n;}
     constexpr auto operator-(difference_type n) const {auto tmp = *this; tmp -= n; return tmp;}
 
     constexpr reference operator[](difference_type n) const {return it_[n];}
 
     template <class T>
-    void operator,(T const &) DELETE_FUNCTION;
+    void operator,(T const &) = delete;
 
     friend constexpr
     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