[libc++] [ranges] ADL-proof ranges::iter_{swap,move}.

[• Quuxplusone]

Summary

As discovered in D117817, std::ranges::input_range<Holder<Incomplete>*[10]>
hard-errored before this patch. That's because input_range requires
iter_rvalue_reference_t, which requires iter_move, which was
not ADL-proofed.

Add ADL-proofing tests to all the range refinements.
output_range and common_range shouldn't be affected,
and all the others subsume input_range anyway, but we might as
well be thorough.

[• Quuxplusone]

Restore a (void) I'd removed; turns out it is needed in order to suppress a user-provided iter_swap's [[nodiscard]] attribute. (Fun.)
https://buildkite.com/llvm-project/libcxx-ci/builds/8158

[• Quuxplusone]

Rebase, and remove refactoring that doesn't affect this particular bug. Ping @ldionne!

libcxx/include/__iterator/iter_move.h

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
-namespace ranges::__iter_move {
+// [iterator.cust.move]
+
+namespace ranges {
+namespace __iter_move {
+
 void iter_move();
 
-template<class _Ip>
-concept __unqualified_iter_move = requires(_Ip&& __i) {
-    iter_move(_VSTD::forward<_Ip>(__i));
+template <class _Tp>
+concept __unqualified_iter_move =
+  __class_or_enum<remove_cvref_t<_Tp>> &&
+  requires (_Tp&& __t) {
+    iter_move(_VSTD::forward<_Tp>(__t));
+  };
+
+template <class _Tp>
+concept __operator_star =
+  !__unqualified_iter_move<_Tp> &&
+  requires (_Tp&& __t) {
+    *_VSTD::forward<_Tp>(__t);
   };
 
-// [iterator.cust.move]/1
-// The name ranges::iter_move denotes a customization point object.
-// The expression ranges::iter_move(E) for a subexpression E is
-// expression-equivalent to:
 struct __fn {
-  // [iterator.cust.move]/1.1
-  // iter_move(E), if E has class or enumeration type and iter_move(E) is a
-  // well-formed expression when treated as an unevaluated operand, [...]
-  template<class _Ip>
-    requires __class_or_enum<remove_cvref_t<_Ip>> && __unqualified_iter_move<_Ip>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator()(_Ip&& __i) const
-    noexcept(noexcept(iter_move(_VSTD::forward<_Ip>(__i))))
+  template <class _Tp>
+    requires __unqualified_iter_move<_Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr
+  decltype(auto) operator()(_Tp&& __t) const
+    noexcept(noexcept(iter_move(_VSTD::forward<_Tp>(__t))))
   {
-    return iter_move(_VSTD::forward<_Ip>(__i));
+    return iter_move(_VSTD::forward<_Tp>(__t));
   }
 
-  // [iterator.cust.move]/1.2
-  // Otherwise, if the expression *E is well-formed:
-  //  1.2.1 if *E is an lvalue, std::move(*E);
-  //  1.2.2 otherwise, *E.
-  template<class _Ip>
-    requires (!(__class_or_enum<remove_cvref_t<_Ip>> && __unqualified_iter_move<_Ip>)) &&
-    requires(_Ip&& __i) { *_VSTD::forward<_Ip>(__i); }
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator()(_Ip&& __i) const
-    noexcept(noexcept(*_VSTD::forward<_Ip>(__i)))
+  template <class _Tp>
+    requires __operator_star<_Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr
+  decltype(auto) operator()(_Tp&& __t) const
+    noexcept(noexcept(*_VSTD::forward<_Tp>(__t)))
   {
-    if constexpr (is_lvalue_reference_v<decltype(*_VSTD::forward<_Ip>(__i))>) {
-      return _VSTD::move(*_VSTD::forward<_Ip>(__i));
+    if constexpr (is_lvalue_reference_v<decltype(*_VSTD::forward<_Tp>(__t))>) {
+      return _VSTD::move(*_VSTD::forward<_Tp>(__t));
     } else {
-      return *_VSTD::forward<_Ip>(__i);
+      return *_VSTD::forward<_Tp>(__t);
     }
   }
-
-  // [iterator.cust.move]/1.3
-  // Otherwise, ranges::iter_move(E) is ill-formed.
 };
-} // namespace ranges::__iter_move
+} // namespace __iter_move
 
-namespace ranges::inline __cpo {
+inline namespace __cpo {
   inline constexpr auto iter_move = __iter_move::__fn{};
-}
+} // namespace __cpo
+} // namespace ranges
 
 template<__dereferenceable _Tp>
   requires requires(_Tp& __t) { { ranges::iter_move(__t) } -> __referenceable; }
 using iter_rvalue_reference_t = decltype(ranges::iter_move(declval<_Tp&>()));
 
 #endif // !_LIBCPP_HAS_NO_RANGES
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_ITER_MOVE_H

libcxx/include/__iterator/iter_swap.h

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
 namespace ranges {
 namespace __iter_swap {
+
   template<class _I1, class _I2>
   void iter_swap(_I1, _I2) = delete;
 
   template<class _T1, class _T2>
-  concept __unqualified_iter_swap = requires(_T1&& __x, _T2&& __y) {
+  concept __unqualified_iter_swap =
+    (__class_or_enum<remove_cvref_t<_T1>> || __class_or_enum<remove_cvref_t<_T2>>) &&
+    requires (_T1&& __x, _T2&& __y) {
       iter_swap(_VSTD::forward<_T1>(__x), _VSTD::forward<_T2>(__y));
     };
 
   template<class _T1, class _T2>
-  concept __readable_swappable =
-    indirectly_readable<_T1> && indirectly_readable<_T2> &&
+  concept __ranges_swappable =
+    !__unqualified_iter_swap<_T1, _T2> &&
+    indirectly_readable<_T1> &&
+    indirectly_readable<_T2> &&
     swappable_with<iter_reference_t<_T1>, iter_reference_t<_T2>>;
 
+  template<class _T1, class _T2>
+  concept __iter_exchange_movable =
+    !__unqualified_iter_swap<_T1, _T2> &&
+    !__ranges_swappable<_T1, _T2> &&
+    indirectly_movable_storable<remove_reference_t<_T1>, remove_reference_t<_T2>> &&
+    indirectly_movable_storable<remove_reference_t<_T2>, remove_reference_t<_T1>>;
+
   struct __fn {
     template <class _T1, class _T2>
       requires __unqualified_iter_swap<_T1, _T2>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void operator()(_T1&& __x, _T2&& __y) const
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    void operator()(_T1&& __x, _T2&& __y) const
       noexcept(noexcept(iter_swap(_VSTD::forward<_T1>(__x), _VSTD::forward<_T2>(__y))))
     {
       (void)iter_swap(_VSTD::forward<_T1>(__x), _VSTD::forward<_T2>(__y));
     }
 
     template <class _T1, class _T2>
-      requires (!__unqualified_iter_swap<_T1, _T2>) &&
-               __readable_swappable<_T1, _T2>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void operator()(_T1&& __x, _T2&& __y) const
+      requires __ranges_swappable<_T1, _T2>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    void operator()(_T1&& __x, _T2&& __y) const
       noexcept(noexcept(ranges::swap(*_VSTD::forward<_T1>(__x), *_VSTD::forward<_T2>(__y))))
     {
       ranges::swap(*_VSTD::forward<_T1>(__x), *_VSTD::forward<_T2>(__y));
     }
 
     template <class _T1, class _T2>
-      requires (!__unqualified_iter_swap<_T1, _T2> &&
-                !__readable_swappable<_T1, _T2>) &&
-               indirectly_movable_storable<_T1, _T2> &&
-               indirectly_movable_storable<_T2, _T1>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void operator()(_T1&& __x, _T2&& __y) const
+      requires __iter_exchange_movable<_T1, _T2>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    void operator()(_T1&& __x, _T2&& __y) const
       noexcept(noexcept(iter_value_t<_T2>(ranges::iter_move(__y))) &&
                noexcept(*__y = ranges::iter_move(__x)) &&
                noexcept(*_VSTD::forward<_T1>(__x) = declval<iter_value_t<_T2>>()))
     {
       iter_value_t<_T2> __old(ranges::iter_move(__y));
       *__y = ranges::iter_move(__x);
       *_VSTD::forward<_T1>(__x) = _VSTD::move(__old);
     }
   };
-} // end namespace __iter_swap
+} // namespace __iter_swap
 
 inline namespace __cpo {
   inline constexpr auto iter_swap = __iter_swap::__fn{};
 } // namespace __cpo
-
 } // namespace ranges
 
 template<class _I1, class _I2 = _I1>
 concept indirectly_swappable =
   indirectly_readable<_I1> && indirectly_readable<_I2> &&
   requires(const _I1 __i1, const _I2 __i2) {
     ranges::iter_swap(__i1, __i1);
     ranges::iter_swap(__i2, __i2);

libcxx/test/std/iterators/iterator.requirements/iterator.cust/iterator.cust.move/iter_move.pass.cpp

 
 #include <array>
 #include <algorithm>
 #include <cassert>
 #include <utility>
 
 #include "../unqualified_lookup_wrapper.h"
 
+using IterMoveT = decltype(std::ranges::iter_move);
+
 // Wrapper around an iterator for testing `iter_move` when an unqualified call to `iter_move` isn't
 // possible.
 template <typename I>
 class iterator_wrapper {
 public:
   iterator_wrapper() = default;
 
   constexpr explicit iterator_wrapper(I i) noexcept : base_(std::move(i)) {}

 struct WithoutADL {
   WithoutADL() = default;
   constexpr int operator*() const noexcept(NoExcept) { return 0; }
   constexpr WithoutADL& operator++();
   constexpr void operator++(int);
   constexpr bool operator==(WithoutADL const&) const;
 };
 
-constexpr bool check_iter_move() {
+constexpr bool test() {
   constexpr int full_size = 100;
   constexpr int half_size = full_size / 2;
   constexpr int reset = 0;
   auto v1 = std::array<move_tracker, full_size>{};
 
   auto move_counter_is = [](auto const n) { return [n](auto const& x) { return x.moves() == n; }; };
 
   auto v2 = std::array<move_tracker, half_size>{};
constexpr bool test() {
   static_assert(noexcept(std::ranges::iter_move(std::declval<WithADL<true>>())));
   static_assert(!noexcept(std::ranges::iter_move(std::declval<WithADL<false>>())));
   static_assert(noexcept(std::ranges::iter_move(std::declval<WithoutADL<true>>())));
   static_assert(!noexcept(std::ranges::iter_move(std::declval<WithoutADL<false>>())));
 
   return true;
 }
 
-template <typename T>
-concept can_iter_move = requires (T t) { std::ranges::iter_move(t); };
+static_assert(!std::is_invocable_v<IterMoveT, int*, int*>); // too many arguments
+static_assert(!std::is_invocable_v<IterMoveT, int>);
 
-int main(int, char**) {
-  static_assert(check_iter_move());
-  check_iter_move();
+// Test ADL-proofing.
+struct Incomplete;
+template<class T> struct Holder { T t; };
+static_assert(std::is_invocable_v<IterMoveT, Holder<Incomplete>**>);
+static_assert(std::is_invocable_v<IterMoveT, Holder<Incomplete>**&>);
 
-  // Make sure that `iter_move` SFINAEs away when the type can't be iter_move'd
-  {
-    struct NoIterMove { };
-    static_assert(!can_iter_move<NoIterMove>);
-  }
+int main(int, char**)
+  test();
+  static_assert(test());
 
   return 0;
 }

libcxx/test/std/iterators/iterator.requirements/iterator.cust/iterator.cust.swap/iter_swap.pass.cpp

 
 #include "../unqualified_lookup_wrapper.h"
 #include "test_iterators.h"
 
 using IterSwapT = decltype(std::ranges::iter_swap);
 
 struct HasIterSwap {
   int &value_;
-  explicit HasIterSwap(int &value) : value_(value) { assert(value == 0); }
+  constexpr explicit HasIterSwap(int &value) : value_(value) { assert(value == 0); }
 
   friend constexpr void iter_swap(HasIterSwap& a, HasIterSwap& b) {
     a.value_ = 1;
     b.value_ = 1;
   }
   friend constexpr void iter_swap(HasIterSwap& a, int& b) {
     a.value_ = 2;
     b = 2;

 struct NodiscardIterSwap {
   [[nodiscard]] friend int iter_swap(NodiscardIterSwap&, NodiscardIterSwap&) { return 0; }
 };
 
 void ensureVoidCast(NodiscardIterSwap& a, NodiscardIterSwap& b) { std::ranges::iter_swap(a, b); }
 
 struct HasRangesSwap {
   int &value_;
-  explicit HasRangesSwap(int &value) : value_(value) { assert(value == 0); }
+  constexpr explicit HasRangesSwap(int &value) : value_(value) { assert(value == 0); }
 
   friend constexpr void swap(HasRangesSwap& a, HasRangesSwap& b) {
     a.value_ = 1;
     b.value_ = 1;
   }
   friend constexpr void swap(HasRangesSwap& a, int& b) {
     a.value_ = 2;
     b = 2;
   }
 };
 
 struct HasRangesSwapWrapper {
   using value_type = HasRangesSwap;
 
   HasRangesSwap &value_;
-  explicit HasRangesSwapWrapper(HasRangesSwap &value) : value_(value) {}
+  constexpr explicit HasRangesSwapWrapper(HasRangesSwap &value) : value_(value) {}
 
-  HasRangesSwap& operator*() const { return value_; }
+  constexpr HasRangesSwap& operator*() const { return value_; }
 };
 
 static_assert( std::is_invocable_v<IterSwapT, HasRangesSwapWrapper&, HasRangesSwapWrapper&>);
 // Does not satisfy swappable_with, even though swap(X, Y) is valid.
 static_assert(!std::is_invocable_v<IterSwapT, HasRangesSwapWrapper&, int&>);
 static_assert(!std::is_invocable_v<IterSwapT, int&, HasRangesSwapWrapper&>);
 
 struct B;
 
 struct A {
   bool value = false;
-  A& operator=(const B&) {
+  constexpr A& operator=(const B&) {
     value = true;
     return *this;
   };
 };
 
 struct B {
   bool value = false;
-  B& operator=(const A&) {
+  constexpr B& operator=(const A&) {
     value = true;
     return *this;
   };
 };
 
 struct MoveOnly2;
 
 struct MoveOnly1 {
   bool value = false;
 
   MoveOnly1() = default;
   MoveOnly1(MoveOnly1&&) = default;
   MoveOnly1& operator=(MoveOnly1&&) = default;
   MoveOnly1(const MoveOnly1&) = delete;
   MoveOnly1& operator=(const MoveOnly1&) = delete;
 
-  MoveOnly1& operator=(MoveOnly2 &&) {
+  constexpr MoveOnly1& operator=(MoveOnly2 &&) {
     value = true;
     return *this;
   };
 };
 
 struct MoveOnly2 {
   bool value = false;
 
   MoveOnly2() = default;
   MoveOnly2(MoveOnly2&&) = default;
   MoveOnly2& operator=(MoveOnly2&&) = default;
   MoveOnly2(const MoveOnly2&) = delete;
   MoveOnly2& operator=(const MoveOnly2&) = delete;
 
-  MoveOnly2& operator=(MoveOnly1 &&) {
+  constexpr MoveOnly2& operator=(MoveOnly1 &&) {
     value = true;
     return *this;
   };
 };
 
-int main(int, char**) {
+constexpr bool test()
+{
   {
     int value1 = 0;
     int value2 = 0;
     HasIterSwap a(value1), b(value2);
     std::ranges::iter_swap(a, b);
     assert(value1 == 1 && value2 == 1);
   }
-
   {
     int value1 = 0;
     int value2 = 0;
     HasRangesSwap c(value1), d(value2);
     HasRangesSwapWrapper cWrapper(c), dWrapper(d);
     std::ranges::iter_swap(cWrapper, dWrapper);
     assert(value1 == 1 && value2 == 1);
   }
-
   {
     int value1 = 0;
     int value2 = 0;
     HasRangesSwap c(value1), d(value2);
     std::ranges::iter_swap(HasRangesSwapWrapper(c), HasRangesSwapWrapper(d));
     assert(value1 == 1 && value2 == 1);
   }
-
   {
     A e; B f;
     A *ePtr = &e;
     B *fPtr = &f;
     std::ranges::iter_swap(ePtr, fPtr);
     assert(e.value && f.value);
   }
-
   {
     MoveOnly1 g; MoveOnly2 h;
     std::ranges::iter_swap(&g, &h);
     assert(g.value && h.value);
   }
-
   {
     auto arr = std::array<move_tracker, 2>();
     std::ranges::iter_swap(arr.begin(), arr.begin() + 1);
+    if (std::is_constant_evaluated()) {
+      assert(arr[0].moves() == 1 && arr[1].moves() == 3);
+    } else {
       assert(arr[0].moves() == 1 && arr[1].moves() == 2);
     }
-
+  }
   {
     int buff[2] = {1, 2};
     std::ranges::iter_swap(buff + 0, buff + 1);
     assert(buff[0] == 2 && buff[1] == 1);
 
     std::ranges::iter_swap(cpp20_input_iterator(buff), cpp20_input_iterator(buff + 1));
     assert(buff[0] == 1 && buff[1] == 2);
 
     std::ranges::iter_swap(cpp17_input_iterator(buff), cpp17_input_iterator(buff + 1));
     assert(buff[0] == 2 && buff[1] == 1);
 
     std::ranges::iter_swap(forward_iterator(buff), forward_iterator(buff + 1));
     assert(buff[0] == 1 && buff[1] == 2);
 
     std::ranges::iter_swap(bidirectional_iterator(buff), bidirectional_iterator(buff + 1));
     assert(buff[0] == 2 && buff[1] == 1);
 
     std::ranges::iter_swap(random_access_iterator(buff), random_access_iterator(buff + 1));
     assert(buff[0] == 1 && buff[1] == 2);
 
     std::ranges::iter_swap(contiguous_iterator(buff), contiguous_iterator(buff + 1));
     assert(buff[0] == 2 && buff[1] == 1);
   }
+  return true;
+}
+
+static_assert(!std::is_invocable_v<IterSwapT, int*>); // too few arguments
+static_assert(!std::is_invocable_v<IterSwapT, int*, int*, int*>); // too many arguments
+static_assert(!std::is_invocable_v<IterSwapT, int, int*>);
+static_assert(!std::is_invocable_v<IterSwapT, int*, int>);
+static_assert(!std::is_invocable_v<IterSwapT, void*, void*>);
+
+// Test ADL-proofing.
+struct Incomplete;
+template<class T> struct Holder { T t; };
+static_assert(std::is_invocable_v<IterSwapT, Holder<Incomplete>**, Holder<Incomplete>**>);
+static_assert(std::is_invocable_v<IterSwapT, Holder<Incomplete>**, Holder<Incomplete>**&>);
+static_assert(std::is_invocable_v<IterSwapT, Holder<Incomplete>**&, Holder<Incomplete>**>);
+static_assert(std::is_invocable_v<IterSwapT, Holder<Incomplete>**&, Holder<Incomplete>**&>);
+
+int main(int, char**)
+{
+  test();
+  static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.req/range.refinements/bidirectional_range.compile.pass.cpp

 
 // template<class R>
 // concept bidirectional_range;
 
 #include <ranges>
 
 #include "test_range.h"
 
-
-
 template <template <class...> class I>
 constexpr bool check_bidirectional_range() {
   constexpr bool result = std::ranges::bidirectional_range<test_range<I> >;
   static_assert(std::ranges::bidirectional_range<test_range<I> const> == result);
   static_assert(std::ranges::bidirectional_range<test_non_const_common_range<I> > == result);
   static_assert(std::ranges::bidirectional_range<test_non_const_range<I> > == result);
   static_assert(std::ranges::bidirectional_range<test_common_range<I> > == result);
   static_assert(std::ranges::bidirectional_range<test_common_range<I> const> == result);
   static_assert(!std::ranges::bidirectional_range<test_non_const_common_range<I> const>);
   static_assert(!std::ranges::bidirectional_range<test_non_const_range<I> const>);
   return result;
 }
 
 static_assert(!check_bidirectional_range<cpp17_input_iterator>());
 static_assert(!check_bidirectional_range<cpp20_input_iterator>());
 static_assert(!check_bidirectional_range<forward_iterator>());
 static_assert(check_bidirectional_range<bidirectional_iterator>());
 static_assert(check_bidirectional_range<random_access_iterator>());
 static_assert(check_bidirectional_range<contiguous_iterator>());
+
+// Test ADL-proofing.
+struct Incomplete;
+template<class T> struct Holder { T t; };
+
+static_assert(!std::ranges::bidirectional_range<Holder<Incomplete>*>);
+static_assert(!std::ranges::bidirectional_range<Holder<Incomplete>*&>);
+static_assert(!std::ranges::bidirectional_range<Holder<Incomplete>*&&>);
+static_assert(!std::ranges::bidirectional_range<Holder<Incomplete>* const>);
+static_assert(!std::ranges::bidirectional_range<Holder<Incomplete>* const&>);
+static_assert(!std::ranges::bidirectional_range<Holder<Incomplete>* const&&>);
+
+static_assert( std::ranges::bidirectional_range<Holder<Incomplete>*[10]>);
+static_assert( std::ranges::bidirectional_range<Holder<Incomplete>*(&)[10]>);
+static_assert( std::ranges::bidirectional_range<Holder<Incomplete>*(&&)[10]>);
+static_assert( std::ranges::bidirectional_range<Holder<Incomplete>* const[10]>);
+static_assert( std::ranges::bidirectional_range<Holder<Incomplete>* const(&)[10]>);
+static_assert( std::ranges::bidirectional_range<Holder<Incomplete>* const(&&)[10]>);

libcxx/test/std/ranges/range.req/range.refinements/common_range.compile.pass.cpp

 // Test with a range that's a common_range only when not const-qualified.
 struct Range2 {
   int* begin() const;
   int* end();
   int const* end() const;
 };
 static_assert( std::ranges::common_range<Range2>);
 static_assert(!std::ranges::common_range<Range2 const>);
+
+// Test ADL-proofing.
+struct Incomplete;
+template<class T> struct Holder { T t; };
+
+static_assert(!std::ranges::common_range<Holder<Incomplete>*>);
+static_assert(!std::ranges::common_range<Holder<Incomplete>*&>);
+static_assert(!std::ranges::common_range<Holder<Incomplete>*&&>);
+static_assert(!std::ranges::common_range<Holder<Incomplete>* const>);
+static_assert(!std::ranges::common_range<Holder<Incomplete>* const&>);
+static_assert(!std::ranges::common_range<Holder<Incomplete>* const&&>);
+
+static_assert( std::ranges::common_range<Holder<Incomplete>*[10]>);
+static_assert( std::ranges::common_range<Holder<Incomplete>*(&)[10]>);
+static_assert( std::ranges::common_range<Holder<Incomplete>*(&&)[10]>);
+static_assert( std::ranges::common_range<Holder<Incomplete>* const[10]>);
+static_assert( std::ranges::common_range<Holder<Incomplete>* const(&)[10]>);
+static_assert( std::ranges::common_range<Holder<Incomplete>* const(&&)[10]>);

libcxx/test/std/ranges/range.req/range.refinements/contiguous_range.compile.pass.cpp

 static_assert(!std::ranges::contiguous_range<DataFunctionWrongReturnType>);
 
 struct WrongObjectness {
     const int *begin() const;
     const int *end() const;
     void *data() const;
 };
 static_assert(std::ranges::contiguous_range<WrongObjectness>);
+
+// Test ADL-proofing.
+struct Incomplete;
+template<class T> struct Holder { T t; };
+
+static_assert(!std::ranges::contiguous_range<Holder<Incomplete>*>);
+static_assert(!std::ranges::contiguous_range<Holder<Incomplete>*&>);
+static_assert(!std::ranges::contiguous_range<Holder<Incomplete>*&&>);
+static_assert(!std::ranges::contiguous_range<Holder<Incomplete>* const>);
+static_assert(!std::ranges::contiguous_range<Holder<Incomplete>* const&>);
+static_assert(!std::ranges::contiguous_range<Holder<Incomplete>* const&&>);
+
+static_assert( std::ranges::contiguous_range<Holder<Incomplete>*[10]>);
+static_assert( std::ranges::contiguous_range<Holder<Incomplete>*(&)[10]>);
+static_assert( std::ranges::contiguous_range<Holder<Incomplete>*(&&)[10]>);
+static_assert( std::ranges::contiguous_range<Holder<Incomplete>* const[10]>);
+static_assert( std::ranges::contiguous_range<Holder<Incomplete>* const(&)[10]>);
+static_assert( std::ranges::contiguous_range<Holder<Incomplete>* const(&&)[10]>);

libcxx/test/std/ranges/range.req/range.refinements/forward_range.compile.pass.cpp

 // template<class R>
 // concept forward_range;
 
 #include <ranges>
 
 #include "test_iterators.h"
 #include "test_range.h"
 
-
-
 template <template <class...> class I>
 constexpr bool check_forward_range() {
   constexpr bool result = std::ranges::forward_range<test_range<I> >;
   static_assert(std::ranges::forward_range<test_range<I> const> == result);
   static_assert(std::ranges::forward_range<test_non_const_common_range<I> > == result);
   static_assert(std::ranges::forward_range<test_non_const_range<I> > == result);
   static_assert(std::ranges::forward_range<test_common_range<I> > == result);
   static_assert(std::ranges::forward_range<test_common_range<I> const> == result);
   static_assert(!std::ranges::forward_range<test_non_const_common_range<I> const>);
   static_assert(!std::ranges::forward_range<test_non_const_range<I> const>);
   return result;
 }
 
 static_assert(!check_forward_range<cpp17_input_iterator>());
 static_assert(!check_forward_range<cpp20_input_iterator>());
 static_assert(check_forward_range<forward_iterator>());
 static_assert(check_forward_range<bidirectional_iterator>());
 static_assert(check_forward_range<random_access_iterator>());
 static_assert(check_forward_range<contiguous_iterator>());
+
+// Test ADL-proofing.
+struct Incomplete;
+template<class T> struct Holder { T t; };
+
+static_assert(!std::ranges::forward_range<Holder<Incomplete>*>);
+static_assert(!std::ranges::forward_range<Holder<Incomplete>*&>);
+static_assert(!std::ranges::forward_range<Holder<Incomplete>*&&>);
+static_assert(!std::ranges::forward_range<Holder<Incomplete>* const>);
+static_assert(!std::ranges::forward_range<Holder<Incomplete>* const&>);
+static_assert(!std::ranges::forward_range<Holder<Incomplete>* const&&>);
+
+static_assert( std::ranges::forward_range<Holder<Incomplete>*[10]>);
+static_assert( std::ranges::forward_range<Holder<Incomplete>*(&)[10]>);
+static_assert( std::ranges::forward_range<Holder<Incomplete>*(&&)[10]>);
+static_assert( std::ranges::forward_range<Holder<Incomplete>* const[10]>);
+static_assert( std::ranges::forward_range<Holder<Incomplete>* const(&)[10]>);
+static_assert( std::ranges::forward_range<Holder<Incomplete>* const(&&)[10]>);

libcxx/test/std/ranges/range.req/range.refinements/input_range.compile.pass.cpp

 // template<class R>
 // concept input_range;
 
 #include <ranges>
 
 #include "test_iterators.h"
 #include "test_range.h"
 
-
-
 static_assert(std::ranges::input_range<test_range<cpp17_input_iterator> >);
 static_assert(std::ranges::input_range<test_range<cpp17_input_iterator> const>);
 
 static_assert(std::ranges::input_range<test_range<cpp20_input_iterator> >);
 static_assert(std::ranges::input_range<test_range<cpp20_input_iterator> const>);
 
 static_assert(std::ranges::input_range<test_non_const_range<cpp17_input_iterator> >);
 static_assert(std::ranges::input_range<test_non_const_range<cpp20_input_iterator> >);
 
 static_assert(!std::ranges::input_range<test_non_const_range<cpp17_input_iterator> const>);
 static_assert(!std::ranges::input_range<test_non_const_range<cpp20_input_iterator> const>);
 
 static_assert(std::ranges::input_range<test_common_range<forward_iterator> >);
 static_assert(!std::ranges::input_range<test_common_range<cpp20_input_iterator> >);
 
 static_assert(std::ranges::input_range<test_common_range<forward_iterator> const>);
 static_assert(!std::ranges::input_range<test_common_range<cpp20_input_iterator> const>);
 
 static_assert(std::ranges::input_range<test_non_const_common_range<forward_iterator> >);
 static_assert(!std::ranges::input_range<test_non_const_common_range<cpp20_input_iterator> >);
 
 static_assert(!std::ranges::input_range<test_non_const_common_range<forward_iterator> const>);
 static_assert(!std::ranges::input_range<test_non_const_common_range<cpp20_input_iterator> const>);
+
+// Test ADL-proofing.
+struct Incomplete;
+template<class T> struct Holder { T t; };
+
+static_assert(!std::ranges::input_range<Holder<Incomplete>*>);
+static_assert(!std::ranges::input_range<Holder<Incomplete>*&>);
+static_assert(!std::ranges::input_range<Holder<Incomplete>*&&>);
+static_assert(!std::ranges::input_range<Holder<Incomplete>* const>);
+static_assert(!std::ranges::input_range<Holder<Incomplete>* const&>);
+static_assert(!std::ranges::input_range<Holder<Incomplete>* const&&>);
+
+static_assert( std::ranges::input_range<Holder<Incomplete>*[10]>);
+static_assert( std::ranges::input_range<Holder<Incomplete>*(&)[10]>);
+static_assert( std::ranges::input_range<Holder<Incomplete>*(&&)[10]>);
+static_assert( std::ranges::input_range<Holder<Incomplete>* const[10]>);
+static_assert( std::ranges::input_range<Holder<Incomplete>* const(&)[10]>);
+static_assert( std::ranges::input_range<Holder<Incomplete>* const(&&)[10]>);

libcxx/test/std/ranges/range.req/range.refinements/output_range.compile.pass.cpp

 // Not satisfied when the iterator is not an output_iterator
 struct RangeWithBadIterator {
     cpp17_input_iterator<T const*> begin();
     sentinel end();
 };
 static_assert( std::ranges::range<RangeWithBadIterator>);
 static_assert(!std::output_iterator<std::ranges::iterator_t<RangeWithBadIterator>, T>);
 static_assert(!std::ranges::output_range<RangeWithBadIterator, T>);
+
+// Test ADL-proofing.
+struct Incomplete;
+template<class T> struct Holder { T t; };
+
+static_assert(!std::ranges::output_range<Holder<Incomplete>*, Holder<Incomplete>*>);
+static_assert(!std::ranges::output_range<Holder<Incomplete>*&, Holder<Incomplete>*>);
+static_assert(!std::ranges::output_range<Holder<Incomplete>*&&, Holder<Incomplete>*>);
+static_assert(!std::ranges::output_range<Holder<Incomplete>* const, Holder<Incomplete>*>);
+static_assert(!std::ranges::output_range<Holder<Incomplete>* const&, Holder<Incomplete>*>);
+static_assert(!std::ranges::output_range<Holder<Incomplete>* const&&, Holder<Incomplete>*>);
+
+static_assert( std::ranges::output_range<Holder<Incomplete>*[10], Holder<Incomplete>*>);
+static_assert( std::ranges::output_range<Holder<Incomplete>*(&)[10], Holder<Incomplete>*>);
+static_assert( std::ranges::output_range<Holder<Incomplete>*(&&)[10], Holder<Incomplete>*>);
+static_assert(!std::ranges::output_range<Holder<Incomplete>* const[10], Holder<Incomplete>*>);
+static_assert(!std::ranges::output_range<Holder<Incomplete>* const(&)[10], Holder<Incomplete>*>);
+static_assert(!std::ranges::output_range<Holder<Incomplete>* const(&&)[10], Holder<Incomplete>*>);

libcxx/test/std/ranges/range.req/range.refinements/random_access_range.compile.pass.cpp

constexpr bool check_range() {
   return result;
 }
 
 static_assert(!check_range<cpp20_input_iterator>());
 static_assert(!check_range<forward_iterator>());
 static_assert(!check_range<bidirectional_iterator>());
 static_assert(check_range<random_access_iterator>());
 static_assert(check_range<contiguous_iterator>());
+
+// Test ADL-proofing.
+struct Incomplete;
+template<class T> struct Holder { T t; };
+
+static_assert(!std::ranges::random_access_range<Holder<Incomplete>*>);
+static_assert(!std::ranges::random_access_range<Holder<Incomplete>*&>);
+static_assert(!std::ranges::random_access_range<Holder<Incomplete>*&&>);
+static_assert(!std::ranges::random_access_range<Holder<Incomplete>* const>);
+static_assert(!std::ranges::random_access_range<Holder<Incomplete>* const&>);
+static_assert(!std::ranges::random_access_range<Holder<Incomplete>* const&&>);
+
+static_assert( std::ranges::random_access_range<Holder<Incomplete>*[10]>);
+static_assert( std::ranges::random_access_range<Holder<Incomplete>*(&)[10]>);
+static_assert( std::ranges::random_access_range<Holder<Incomplete>*(&&)[10]>);
+static_assert( std::ranges::random_access_range<Holder<Incomplete>* const[10]>);
+static_assert( std::ranges::random_access_range<Holder<Incomplete>* const(&)[10]>);
+static_assert( std::ranges::random_access_range<Holder<Incomplete>* const(&&)[10]>);

libcxx/test/std/ranges/range.req/range.refinements/viewable_range.compile.pass.cpp

 static_assert(!std::ranges::viewable_range<int>);
 static_assert(!std::ranges::viewable_range<int (*)(char)>);
 static_assert(!std::ranges::viewable_range<int[]>);
 static_assert(!std::ranges::viewable_range<int[10]>);
 static_assert(!std::ranges::viewable_range<int(&)[]>); // not a range
 static_assert( std::ranges::viewable_range<int(&)[10]>); // OK, lvalue
 static_assert(!std::ranges::viewable_range<int(&&)[]>);
 static_assert(!std::ranges::viewable_range<int(&&)[10]>);
+
+// Test ADL-proofing.
+struct Incomplete;
+template<class T> struct Holder { T t; };
+
+static_assert(!std::ranges::viewable_range<Holder<Incomplete>*>);
+static_assert(!std::ranges::viewable_range<Holder<Incomplete>*&>);
+static_assert(!std::ranges::viewable_range<Holder<Incomplete>*&&>);
+static_assert(!std::ranges::viewable_range<Holder<Incomplete>* const>);
+static_assert(!std::ranges::viewable_range<Holder<Incomplete>* const&>);
+static_assert(!std::ranges::viewable_range<Holder<Incomplete>* const&&>);
+
+static_assert(!std::ranges::viewable_range<Holder<Incomplete>*[10]>);
+static_assert( std::ranges::viewable_range<Holder<Incomplete>*(&)[10]>);
+static_assert(!std::ranges::viewable_range<Holder<Incomplete>*(&&)[10]>);
+static_assert(!std::ranges::viewable_range<Holder<Incomplete>* const[10]>);
+static_assert( std::ranges::viewable_range<Holder<Incomplete>* const(&)[10]>);
+static_assert(!std::ranges::viewable_range<Holder<Incomplete>* const(&&)[10]>);