[libcxx-commits] [libcxx] 67c43d8 - [libc++] [test_iterators] Make all ADL base() functions into hidden friends. NFCI.

[Arthur O'Dwyer via libcxx-commits]

Author: Arthur O'Dwyer
Date: 2021-12-08T16:41:01-05:00
New Revision: 67c43d87cd53fdbd75dea6da8dbbd0762357864a

URL: https://github.com/llvm/llvm-project/commit/67c43d87cd53fdbd75dea6da8dbbd0762357864a
DIFF: https://github.com/llvm/llvm-project/commit/67c43d87cd53fdbd75dea6da8dbbd0762357864a.diff

LOG: [libc++] [test_iterators] Make all ADL base() functions into hidden friends. NFCI.

This follows up on my addition of base(cpp20_input_iterator) in D115177,
making all the ADL base() functions consistent.
Also align cpp20_input_iterator with the other test iterators' style.

Reviewed as part of D115272.

Added: 
    

Modified: 
    libcxx/test/support/test_iterators.h

Removed: 
    


################################################################################
diff  --git a/libcxx/test/support/test_iterators.h b/libcxx/test/support/test_iterators.h
index ef699642cb950..a6ca62833bfdb 100644
--- a/libcxx/test/support/test_iterators.h
+++ b/libcxx/test/support/test_iterators.h
@@ -42,6 +42,8 @@ class output_iterator
     TEST_CONSTEXPR_CXX14 output_iterator operator++(int)
         {output_iterator tmp(*this); ++(*this); return tmp;}
 
+    friend TEST_CONSTEXPR It base(const output_iterator& i) { return i.it_; }
+
     template <class T>
     void operator,(T const &) = delete;
 };
@@ -81,6 +83,8 @@ class cpp17_input_iterator
     friend TEST_CONSTEXPR_CXX14 bool operator!=(const cpp17_input_iterator& x, const cpp17_input_iterator& y)
         {return !(x == y);}
 
+    friend TEST_CONSTEXPR It base(const cpp17_input_iterator& i) { return i.it_; }
+
     template <class T>
     void operator,(T const &) = delete;
 };
@@ -129,6 +133,8 @@ class forward_iterator
     friend TEST_CONSTEXPR_CXX14 bool operator!=(const forward_iterator& x, const forward_iterator& y)
         {return !(x == y);}
 
+    friend TEST_CONSTEXPR It base(const forward_iterator& i) { return i.it_; }
+
     template <class T>
     void operator,(T const &) = delete;
 };
@@ -229,6 +235,8 @@ class bidirectional_iterator
     TEST_CONSTEXPR_CXX14 bidirectional_iterator operator--(int)
         {bidirectional_iterator tmp(*this); --(*this); return tmp;}
 
+    friend TEST_CONSTEXPR It base(const bidirectional_iterator& i) { return i.it_; }
+
     template <class T>
     void operator,(T const &) = delete;
 };
@@ -289,6 +297,8 @@ class random_access_iterator
 
     TEST_CONSTEXPR_CXX14 reference operator[](
diff erence_type n) const {return it_[n];}
 
+    friend TEST_CONSTEXPR It base(const random_access_iterator& i) { return i.it_; }
+
     template <class T>
     void operator,(T const &) = delete;
 };
@@ -419,32 +429,14 @@ class contiguous_iterator
         return x.base() != y.base();
     }
 
+    friend TEST_CONSTEXPR It base(const contiguous_iterator& i) { return i.it_; }
+
     template <class T>
     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(); }
-
-template <class Iter>
-TEST_CONSTEXPR_CXX14 Iter base(forward_iterator<Iter> i) { return i.base(); }
-
-template <class Iter>
-TEST_CONSTEXPR_CXX14 Iter base(bidirectional_iterator<Iter> i) { return i.base(); }
-
-template <class Iter>
-TEST_CONSTEXPR_CXX14 Iter base(random_access_iterator<Iter> i) { return i.base(); }
-
-#if TEST_STD_VER > 17
-template <class Iter>
-TEST_CONSTEXPR_CXX14 Iter base(contiguous_iterator<Iter> i) { return i.base(); }
-#endif
-
-template <class Iter>    // everything else
+template <class Iter> // ADL base() for everything else (including pointers)
 TEST_CONSTEXPR_CXX14 Iter base(Iter i) { return i; }
 
 template <typename T>
@@ -628,42 +620,30 @@ struct NonThrowingIterator {
 
 #ifdef TEST_SUPPORTS_RANGES
 
-template <class I>
-struct cpp20_input_iterator {
-    using value_type = std::iter_value_t<I>;
-    using 
diff erence_type = std::iter_
diff erence_t<I>;
-    using iterator_concept = std::input_iterator_tag;
+template <class It>
+class cpp20_input_iterator
+{
+    It it_;
 
-    cpp20_input_iterator() = delete;
+public:
+    using value_type = std::iter_value_t<It>;
+    using 
diff erence_type = std::iter_
diff erence_t<It>;
+    using iterator_concept = std::input_iterator_tag;
 
+    constexpr explicit cpp20_input_iterator(It it) : it_(it) {}
     cpp20_input_iterator(cpp20_input_iterator&&) = default;
     cpp20_input_iterator& operator=(cpp20_input_iterator&&) = default;
+    constexpr decltype(auto) operator*() const { return *it_; }
+    constexpr cpp20_input_iterator& operator++() { ++it_; return *this; }
+    constexpr void operator++(int) { ++it_; }
 
-    cpp20_input_iterator(cpp20_input_iterator const&) = delete;
-    cpp20_input_iterator& operator=(cpp20_input_iterator const&) = delete;
+    constexpr const It& base() const& { return it_; }
+    constexpr It base() && { return std::move(it_); }
 
-    explicit constexpr cpp20_input_iterator(I base) : base_(std::move(base)) {}
-
-    constexpr decltype(auto) operator*() const { return *base_; }
-
-    constexpr cpp20_input_iterator& operator++() {
-        ++base_;
-        return *this;
-    }
-
-    constexpr void operator++(int) { ++base_; }
-
-    constexpr const I& base() const& { return base_; }
-
-    constexpr I base() && { return std::move(base_); }
-
-    friend constexpr I base(const cpp20_input_iterator& i) { return i.base_; }
+    friend constexpr It base(const cpp20_input_iterator& i) { return i.it_; }
 
     template <class T>
     void operator,(T const &) = delete;
-
-private:
-    I base_ = I();
 };
 
 template <std::input_or_output_iterator I>
@@ -960,15 +940,15 @@ class three_way_contiguous_iterator
 
     constexpr reference operator[](
diff erence_type n) const {return it_[n];}
 
-    template <class T>
-    void operator,(T const &) = delete;
-
     friend constexpr
     
diff erence_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;
+
+    template <class T>
+    void operator,(T const &) = delete;
 };
 
 #endif // TEST_STD_VER > 17 && defined(__cpp_lib_concepts)