[libcxx][test] array and basic_string_view iterators are not portably pointers

[CaseyCarter]

Summary

Fixup tests that believe them to be so. Most notably including some heavy refactoring in std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp, which now detects pointers and validates that iterator_concept is present only for pointers.

[• Quuxplusone]

libcxx/test/std/strings/string.view/string.view.cons/from_iterator_sentinel.pass.cpp

28

This initially struck me as the wrong fix — this test is supposed to be checking the iterator-sentinel ctor, not a pointer-sentinel ctor! But I see now that the old code was never trying to test any non-pointer iterator types anyway. Which is... also bad. :P

template<class CharT, class It, class Sent>
constexpr void test() {
  auto val = MAKE_STRING_VIEW(CharT, "test");
  It first = It(val.data());
  Sent last = Sent(It(val.data() + val.size());
  auto sv = std::basic_string_view<CharT>(first, last);
  assert(sv.data() == val.data());
  assert(sv.size() == 4);
}

and then we should test with, like,

  test<char, char*, char*>();
  test<char, char*, const char*>();
  test<char, const char*, sentinel<const char*>>();  // is this supposed to work?
  test<char, const char*, sized_sentinel<const char*>>();
  test<char, contiguous_iterator<char*>, contiguous_iterator<char*>>();
  test<char, contiguous_iterator<char*>, sized_sentinel<contiguous_iterator<char*>>>();

  // Test other character types
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
  test<wchar_t, wchar_t*>();
#endif
  test<char8_t, char8_t*>();
  test<char16_t, char16_t*>();
  test<char32_t, char32_t*>();

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/end.pass.cpp

27

These added to_addresses seem uncontroversial to me. (@Mordante, these make sense to you too?) Maybe you want to pull them out into a separate PR and/or commit them immediately.

libcxx/test/support/test_iterators.h

359

What necessitated this? I'd prefer to fix the users, instead of legalizing what they're doing.

[CaseyCarter]

libcxx/test/std/strings/string.view/string.view.cons/from_iterator_sentinel.pass.cpp

28

I've also just realized that the ASSERT_SAME_TYPE which intends to test the deduction guide is doing nothing since we don't use CTAD on this line. Cleanup time.

libcxx/test/support/test_iterators.h

359

Code wrapping array and/or string_view iterators in contiguous_iterator - I don't recall precisely where. If the intent is to only admit pointers, why are we using iterator_traits<It>?

[CaseyCarter]

Address some review comments.

[• Quuxplusone]

libcxx/test/std/strings/string.view/string.view.deduct/iterator_sentinel.pass.cpp

26–33

Surely string_view::iterator is never char* (because it would be const char*). But anyway this if is redundant because if iterator actually were a pointer, then val.begin() and val.data() would be the same value of the same type and thus completely interchangeable. Just use .data() (as you did above).
This test deserves the same refactoring that you did above, e.g. it should test contiguous_iterator<const char*> and so on.

libcxx/test/support/test_iterators.h

359

AIUI, the original intent of e.g. forward_iterator (which I'm going to use as the type specimen for all test iterators) was to permit wrapping weirder iterator types; but if you actually want to do that correctly, the metaprogramming gets awful. And we were never actually relying on it to work with any non-pointer type. (Except, apparently, by accident. ;))
Mantra: "If you're not testing it, it doesn't work." So since we never (intentionally) used these types with non-pointer Its, it just makes sense to static_assert against that usage in the future. (Or, by accident, on other platforms in the present!)

In D116613 I suggested that we ought to permit forward_iterator<stride_counter<int*>>, to cut down on the absolutely abominable metaprogramming involved with our current stride_counting_iterator<forward_iterator<int*>>. If we did, then that would be a reason to remove this assertion... but we still might want to keep some kind of assertion, because I would bet money that e.g. forward_iterator<std::vector<bool>::iterator> would explode.

[ldionne]

LGTM except for Arthur's comments, which I agree with (but IMO removing the static_assert in contiguous_iterator is fine).

I checked everything and I originally thought the libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp changes were weakening the tests for libc++, but it turns out they don't.

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

52–53

Here and in the functions below too. We generally don't use a single template parameter named O.

[CaseyCarter]

Moar review comments

libcxx/test/std/strings/string.view/string.view.cons/from_iterator_sentinel.pass.cpp

28

I've also just realized that the ASSERT_SAME_TYPE which intends to test the deduction guide is doing nothing since we don't use CTAD on this line. Cleanup time.

Wrong test - the deduction guide test is just below. ASSERT_SAME_TYPE here is copy-pasta.

libcxx/test/std/strings/string.view/string.view.deduct/iterator_sentinel.pass.cpp

26–33

This is ridiculous. Fixing and refactoring.

libcxx/test/support/test_iterators.h

359

I'll revert this change. Oddly, I'm finding no test fallout now - I assume the problems have either been corrected elsewhere since I first found this, or are fixed in later commits on my branch.

[CaseyCarter]

Resolve merge conflicts.

[• Quuxplusone]

LGTM; none of my remaining nits are blocking.

libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp

102–103

FWIW, I'm predictably un-thrilled by the overloading of test<It, V, C> and test<It, V, D, R, P, C>; I would rather they were named differently, like testOrdinary and testUnusual, or test and test5, or something; but I have no really good naming suggestion, and this is still an improvement over the status quo, so no action required unless you feel like it.

libcxx/test/std/strings/string.view/string.view.deduct/iterator_sentinel.pass.cpp

27

Consider s/test_deduction/test_ctad/g for clarity.

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/advance_to.pass.cpp

42

Both on lines 29,32 and 42,45, consider spelling the right-hand side of the == as just fmt + 1.
That is, both &fmt[1] and std::to_address(view.begin()) + 1 are verbose synonyms for fmt + 1.

@CaseyCarter, for my own curiosity, would MSVC be happy with

assert(context.begin() == view.begin() + 1);

or is that considered problematic because of comparing iterators into two different string_views (even though they view the same underlying range)? ...Hmm, looks like we're doing exactly that on line 33 of format.parse.ctx/end.pass.cpp. So maybe it's OK to do it here too?

[CaseyCarter]

More refactoring!

[CaseyCarter]

libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp

102–103

I see now that test<I, V, C>, testConst<I, V, C>, and testIOterator are equivalent to calling test with different template arguments. I'll rename the first to testMutable, and refactor all of them to actually call test to eliminate duplication.

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/advance_to.pass.cpp

42

@CaseyCarter, for my own curiosity, would MSVC be happy with

assert(context.begin() == view.begin() + 1);

or is that considered problematic because of comparing iterators into two different string_views (even though they view the same underlying range)? ...Hmm, looks like we're doing exactly that on line 33 of format.parse.ctx/end.pass.cpp. So maybe it's OK to do it here too?

For basic_string_view we interpret "same underlying sequence" to mean "both iterators were obtained from basic_string_views with the same first and last character", so that would be a problem. (And yes, it's a problem in end. I have more patches to submit, I've been trying to keep a relatively constant five outstanding reviews.)

[• Quuxplusone]

One more whitespace/grammar nit in a comment. Ship it!

libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp

121

libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp

constexpr bool testIOIterator() {
   static_assert(std::same_as<typename Traits::reference, void>);
   static_assert(std::same_as<typename Traits::pointer, void>);
   static_assert(!has_iterator_concept_v<Traits>);
 
   return true;
 }
 
 template <class Iter, class ValueType, class Category>
-constexpr bool testConstWithoutConcept() {
+constexpr bool testConst() {
   using Traits = std::iterator_traits<Iter>;
   static_assert(std::same_as<typename Traits::iterator_category, Category>);
   static_assert(std::same_as<typename Traits::value_type, ValueType>);
   static_assert(std::same_as<typename Traits::difference_type, std::ptrdiff_t>);
   static_assert(std::same_as<typename Traits::reference, const ValueType&>);
   static_assert(std::same_as<typename Traits::pointer, const ValueType*>);
+  if constexpr (std::is_pointer_v<Iter>) {
+    static_assert(std::same_as<typename Traits::iterator_concept, std::contiguous_iterator_tag>);
+  } else {
     static_assert(!has_iterator_concept_v<Traits>);
-
-  return true;
   }
 
-template <class Iter, class ValueType, class Category, class IterConcept>
-constexpr bool testConstWithConcept() {
-  using Traits = std::iterator_traits<Iter>;
-  static_assert(std::same_as<typename Traits::iterator_category, Category>);
-  static_assert(std::same_as<typename Traits::value_type, ValueType>);
-  static_assert(std::same_as<typename Traits::difference_type, std::ptrdiff_t>);
-  static_assert(std::same_as<typename Traits::reference, const ValueType&>);
-  static_assert(std::same_as<typename Traits::pointer, const ValueType*>);
-  static_assert(std::same_as<typename Traits::iterator_concept, IterConcept>);
-
   return true;
 }
 
 template <class Iter, class ValueType, class Category>
-constexpr bool testWithoutConcept() {
+constexpr bool test() {
   using Traits = std::iterator_traits<Iter>;
   static_assert(std::same_as<typename Traits::iterator_category, Category>);
   static_assert(std::same_as<typename Traits::value_type, ValueType>);
   static_assert(std::same_as<typename Traits::difference_type, std::ptrdiff_t>);
   static_assert(std::same_as<typename Traits::reference, ValueType&>);
   static_assert(std::same_as<typename Traits::pointer, ValueType*>);
+  if constexpr (std::is_pointer_v<Iter>) {
+    static_assert(std::same_as<typename Traits::iterator_concept, std::contiguous_iterator_tag>);
+  } else {
     static_assert(!has_iterator_concept_v<Traits>);
-
-  return true;
   }
 
-template <class Iter, class ValueType, class Category, class IterConcept>
-constexpr bool testWithConcept() {
-  using Traits = std::iterator_traits<Iter>;
-  static_assert(std::same_as<typename Traits::iterator_category, Category>);
-  static_assert(std::same_as<typename Traits::value_type, ValueType>);
-  static_assert(std::same_as<typename Traits::difference_type, std::ptrdiff_t>);
-  static_assert(std::same_as<typename Traits::reference, ValueType&>);
-  static_assert(std::same_as<typename Traits::pointer, ValueType*>);
-  static_assert(std::same_as<typename Traits::iterator_concept, IterConcept>);
-
   return true;
 }
 
 template <class Iter, class ValueType, class DiffType, class RefType, class PtrType, class Category>
-constexpr bool testWithoutConcept() {
+constexpr bool test() {
   using Traits = std::iterator_traits<Iter>;
   static_assert(std::same_as<typename Traits::iterator_category, Category>);
   static_assert(std::same_as<typename Traits::value_type, ValueType>);
   static_assert(std::same_as<typename Traits::difference_type, DiffType>);
   static_assert(std::same_as<typename Traits::reference, RefType>);
   static_assert(std::same_as<typename Traits::pointer, PtrType>);
+  if constexpr (std::is_pointer_v<Iter>) {
+    static_assert(std::same_as<typename Traits::iterator_concept, std::contiguous_iterator_tag>);
+  } else {
     static_assert(!has_iterator_concept_v<Traits>);
-
-  return true;
   }
 
-template <class Iter, class ValueType, class DiffType, class RefType, class PtrType, class Category, class IterConcept>
-constexpr bool testWithConcept() {
-  using Traits = std::iterator_traits<Iter>;
-  static_assert(std::same_as<typename Traits::iterator_category, Category>);
-  static_assert(std::same_as<typename Traits::value_type, ValueType>);
-  static_assert(std::same_as<typename Traits::difference_type, DiffType>);
-  static_assert(std::same_as<typename Traits::reference, RefType>);
-  static_assert(std::same_as<typename Traits::pointer, PtrType>);
-  static_assert(std::same_as<typename Traits::iterator_concept, IterConcept>);
-
   return true;
 }
 
 // Standard types.
 
-// These tests depend on implementation details of libc++,
-// e.g. that std::array::iterator is a raw pointer type but std::string::iterator is not.
-// The Standard does not specify whether iterator_traits<It>::iterator_concept exists for any particular non-pointer type.
+// The Standard does not specify whether iterator_traits<It>::iterator_concept exists for any particular non-pointer type, we assume it is present only for pointers.
 //
-static_assert(testWithConcept<std::array<int, 10>::iterator, int, std::random_access_iterator_tag, std::contiguous_iterator_tag>());
-static_assert(testConstWithConcept<std::array<int, 10>::const_iterator, int, std::random_access_iterator_tag, std::contiguous_iterator_tag>());
-static_assert(testWithoutConcept<std::string::iterator, char, std::random_access_iterator_tag>());
-static_assert(testConstWithoutConcept<std::string::const_iterator, char, std::random_access_iterator_tag>());
-static_assert(testConstWithConcept<std::string_view::iterator, char, std::random_access_iterator_tag, std::contiguous_iterator_tag>());
-static_assert(testConstWithConcept<std::string_view::const_iterator, char, std::random_access_iterator_tag, std::contiguous_iterator_tag>());
-static_assert(testWithoutConcept<std::vector<int>::iterator, int, std::random_access_iterator_tag>());
-static_assert(testConstWithoutConcept<std::vector<int>::const_iterator, int, std::random_access_iterator_tag>());
-
-static_assert(testWithoutConcept<std::deque<int>::iterator, int, std::random_access_iterator_tag>());
-static_assert(testConstWithoutConcept<std::deque<int>::const_iterator, int, std::random_access_iterator_tag>());
-static_assert(testWithoutConcept<std::forward_list<int>::iterator, int, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::forward_list<int>::const_iterator, int, std::forward_iterator_tag>());
-static_assert(testWithoutConcept<std::list<int>::iterator, int, std::bidirectional_iterator_tag>());
-static_assert(testConstWithoutConcept<std::list<int>::const_iterator, int, std::bidirectional_iterator_tag>());
-
-static_assert(testWithoutConcept<std::map<int, int>::iterator, std::pair<const int, int>, std::bidirectional_iterator_tag>());
-static_assert(testConstWithoutConcept<std::map<int, int>::const_iterator, std::pair<const int, int>, std::bidirectional_iterator_tag>());
-static_assert(testWithoutConcept<std::multimap<int, int>::iterator, std::pair<const int, int>, std::bidirectional_iterator_tag>());
-static_assert(testConstWithoutConcept<std::multimap<int, int>::const_iterator, std::pair<const int, int>, std::bidirectional_iterator_tag>());
-
-static_assert(testConstWithoutConcept<std::set<int>::iterator, int, std::bidirectional_iterator_tag>());
-static_assert(testConstWithoutConcept<std::set<int>::const_iterator, int, std::bidirectional_iterator_tag>());
-static_assert(testConstWithoutConcept<std::multiset<int>::iterator, int, std::bidirectional_iterator_tag>());
-static_assert(testConstWithoutConcept<std::multiset<int>::const_iterator, int, std::bidirectional_iterator_tag>());
-
-static_assert(testWithoutConcept<std::unordered_map<int, int>::iterator, std::pair<const int, int>, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::unordered_map<int, int>::const_iterator, std::pair<const int, int>, std::forward_iterator_tag>());
-static_assert(testWithoutConcept<std::unordered_map<int, int>::local_iterator, std::pair<const int, int>, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::unordered_map<int, int>::const_local_iterator, std::pair<const int, int>, std::forward_iterator_tag>());
-static_assert(testWithoutConcept<std::unordered_multimap<int, int>::iterator, std::pair<const int, int>, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::unordered_multimap<int, int>::const_iterator, std::pair<const int, int>, std::forward_iterator_tag>());
-static_assert(testWithoutConcept<std::unordered_multimap<int, int>::local_iterator, std::pair<const int, int>, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::unordered_multimap<int, int>::const_local_iterator, std::pair<const int, int>, std::forward_iterator_tag>());
-
-static_assert(testConstWithoutConcept<std::unordered_set<int>::iterator, int, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::unordered_set<int>::const_iterator, int, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::unordered_set<int>::local_iterator, int, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::unordered_set<int>::const_local_iterator, int, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::unordered_multiset<int>::iterator, int, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::unordered_multiset<int>::const_iterator, int, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::unordered_multiset<int>::local_iterator, int, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::unordered_multiset<int>::const_local_iterator, int, std::forward_iterator_tag>());
+static_assert(test<std::array<int, 10>::iterator, int, std::random_access_iterator_tag>());
+static_assert(testConst<std::array<int, 10>::const_iterator, int, std::random_access_iterator_tag>());
+static_assert(test<std::string::iterator, char, std::random_access_iterator_tag>());
+static_assert(testConst<std::string::const_iterator, char, std::random_access_iterator_tag>());
+static_assert(testConst<std::string_view::iterator, char, std::random_access_iterator_tag>());
+static_assert(testConst<std::string_view::const_iterator, char, std::random_access_iterator_tag>());
+static_assert(test<std::vector<int>::iterator, int, std::random_access_iterator_tag>());
+static_assert(testConst<std::vector<int>::const_iterator, int, std::random_access_iterator_tag>());
+
+static_assert(test<std::deque<int>::iterator, int, std::random_access_iterator_tag>());
+static_assert(testConst<std::deque<int>::const_iterator, int, std::random_access_iterator_tag>());
+static_assert(test<std::forward_list<int>::iterator, int, std::forward_iterator_tag>());
+static_assert(testConst<std::forward_list<int>::const_iterator, int, std::forward_iterator_tag>());
+static_assert(test<std::list<int>::iterator, int, std::bidirectional_iterator_tag>());
+static_assert(testConst<std::list<int>::const_iterator, int, std::bidirectional_iterator_tag>());
+
+static_assert(test<std::map<int, int>::iterator, std::pair<const int, int>, std::bidirectional_iterator_tag>());
+static_assert(testConst<std::map<int, int>::const_iterator, std::pair<const int, int>, std::bidirectional_iterator_tag>());
+static_assert(test<std::multimap<int, int>::iterator, std::pair<const int, int>, std::bidirectional_iterator_tag>());
+static_assert(testConst<std::multimap<int, int>::const_iterator, std::pair<const int, int>, std::bidirectional_iterator_tag>());
+
+static_assert(testConst<std::set<int>::iterator, int, std::bidirectional_iterator_tag>());
+static_assert(testConst<std::set<int>::const_iterator, int, std::bidirectional_iterator_tag>());
+static_assert(testConst<std::multiset<int>::iterator, int, std::bidirectional_iterator_tag>());
+static_assert(testConst<std::multiset<int>::const_iterator, int, std::bidirectional_iterator_tag>());
+
+#ifdef _MSVC_STL_VERSION
+using unordered_iterator_category = std::bidirectional_iterator_tag;
+#else // ^^^ MSVC STL / other vvv
+using unordered_iterator_category = std::forward_iterator_tag;
+#endif // _MSVC_STL_VERSION
+
+static_assert(test<std::unordered_map<int, int>::iterator, std::pair<const int, int>, unordered_iterator_category>());
+static_assert(testConst<std::unordered_map<int, int>::const_iterator, std::pair<const int, int>, unordered_iterator_category>());
+static_assert(test<std::unordered_map<int, int>::local_iterator, std::pair<const int, int>, unordered_iterator_category>());
+static_assert(testConst<std::unordered_map<int, int>::const_local_iterator, std::pair<const int, int>, unordered_iterator_category>());
+static_assert(test<std::unordered_multimap<int, int>::iterator, std::pair<const int, int>, unordered_iterator_category>());
+static_assert(testConst<std::unordered_multimap<int, int>::const_iterator, std::pair<const int, int>, unordered_iterator_category>());
+static_assert(test<std::unordered_multimap<int, int>::local_iterator, std::pair<const int, int>, unordered_iterator_category>());
+static_assert(testConst<std::unordered_multimap<int, int>::const_local_iterator, std::pair<const int, int>, unordered_iterator_category>());
+
+static_assert(testConst<std::unordered_set<int>::iterator, int, unordered_iterator_category>());
+static_assert(testConst<std::unordered_set<int>::const_iterator, int, unordered_iterator_category>());
+static_assert(testConst<std::unordered_set<int>::local_iterator, int, unordered_iterator_category>());
+static_assert(testConst<std::unordered_set<int>::const_local_iterator, int, unordered_iterator_category>());
+static_assert(testConst<std::unordered_multiset<int>::iterator, int, unordered_iterator_category>());
+static_assert(testConst<std::unordered_multiset<int>::const_iterator, int, unordered_iterator_category>());
+static_assert(testConst<std::unordered_multiset<int>::local_iterator, int, unordered_iterator_category>());
+static_assert(testConst<std::unordered_multiset<int>::const_local_iterator, int, unordered_iterator_category>());
 
-static_assert(testWithoutConcept<std::reverse_iterator<int*>, int, std::random_access_iterator_tag>());
+static_assert(test<std::reverse_iterator<int*>, int, std::random_access_iterator_tag>());
 static_assert(testIOIterator<std::back_insert_iterator<std::vector<int>>, std::output_iterator_tag>());
 static_assert(testIOIterator<std::front_insert_iterator<std::vector<int>>, std::output_iterator_tag>());
 static_assert(testIOIterator<std::insert_iterator<std::vector<int>>, std::output_iterator_tag>());
-static_assert(testConstWithoutConcept<std::istream_iterator<int, char>, int, std::input_iterator_tag>());
+static_assert(testConst<std::istream_iterator<int, char>, int, std::input_iterator_tag>());
 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-static_assert(testWithoutConcept<std::istreambuf_iterator<char>, char, long long, char, char*, std::input_iterator_tag>());
-static_assert(testWithoutConcept<std::move_iterator<int*>, int, std::ptrdiff_t, int&&, int*, std::random_access_iterator_tag>());
+// libc++-specific since pointer type is unspecified:
+LIBCPP_STATIC_ASSERT(test<std::istreambuf_iterator<char>, char, long long, char, char*, std::input_iterator_tag>());
+static_assert(test<std::move_iterator<int*>, int, std::ptrdiff_t, int&&, int*, std::random_access_iterator_tag>());
 static_assert(testIOIterator<std::ostream_iterator<int, char>, std::output_iterator_tag>());
 static_assert(testIOIterator<std::ostreambuf_iterator<int, char>, std::output_iterator_tag>());
-static_assert(testConstWithoutConcept<std::cregex_iterator, std::cmatch, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::cregex_token_iterator, std::csub_match, std::forward_iterator_tag>());
+static_assert(testConst<std::cregex_iterator, std::cmatch, std::forward_iterator_tag>());
+static_assert(testConst<std::cregex_token_iterator, std::csub_match, std::forward_iterator_tag>());
 #endif // !_LIBCPP_HAS_NO_LOCALIZATION
 
 #ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
-static_assert(testWithoutConcept<std::filesystem::directory_iterator, std::filesystem::directory_entry, std::ptrdiff_t,
-                                 const std::filesystem::directory_entry&, const std::filesystem::directory_entry*,
-                                 std::input_iterator_tag>());
-static_assert(testWithoutConcept<std::filesystem::recursive_directory_iterator, std::filesystem::directory_entry,
-                                 std::ptrdiff_t, const std::filesystem::directory_entry&,
-                                 const std::filesystem::directory_entry*, std::input_iterator_tag>());
+static_assert(test<std::filesystem::directory_iterator, std::filesystem::directory_entry, std::ptrdiff_t,
+static_assert(test<std::filesystem::recursive_directory_iterator, std::filesystem::directory_entry,
 #endif
 
 // Local test iterators.
 
 struct AllMembers {
   struct iterator_category {};
   struct value_type {};
   struct difference_type {};

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

public:
   constexpr void operator++(int) noexcept { ++base_; }
 
   constexpr bool operator==(iterator_wrapper const& other) const noexcept { return base_ == other.base_; }
 
 private:
   I base_ = I{};
 };
 
-template <typename I>
-constexpr void unqualified_lookup_move(I first_, I last_, I result_first_, I result_last_) {
+template <typename I, typename O>
+constexpr void unqualified_lookup_move(I first_, I last_, O result_first_, O result_last_) {
   auto first = ::check_unqualified_lookup::unqualified_lookup_wrapper{std::move(first_)};
   auto last = ::check_unqualified_lookup::unqualified_lookup_wrapper{std::move(last_)};
   auto result_first = ::check_unqualified_lookup::unqualified_lookup_wrapper{std::move(result_first_)};
   auto result_last = ::check_unqualified_lookup::unqualified_lookup_wrapper{std::move(result_last_)};
 
   static_assert(!noexcept(std::ranges::iter_move(first)), "unqualified-lookup case not being chosen");
 
   for (; first != last && result_first != result_last; (void)++first, ++result_first) {
     *result_first = std::ranges::iter_move(first);
   }
 }
 
-template <typename I>
-constexpr void lvalue_move(I first_, I last_, I result_first_, I result_last_) {
+template <typename I, typename O>
+constexpr void lvalue_move(I first_, I last_, O result_first_, O result_last_) {
   auto first = iterator_wrapper{std::move(first_)};
   auto last = ::iterator_wrapper{std::move(last_)};
   auto result_first = iterator_wrapper{std::move(result_first_)};
   auto result_last = iterator_wrapper{std::move(result_last_)};
 
   static_assert(!noexcept(std::ranges::iter_move(first)), "`operator*() const&` is not noexcept, and there's no hidden "
                                                           "friend iter_move.");
 
   for (; first != last && result_first != result_last; (void)++first, ++result_first) {
     *result_first = std::ranges::iter_move(first);
   }
 }
 
-template <typename I>
-constexpr void rvalue_move(I first_, I last_, I result_first_, I result_last_) {
+template <typename I, typename O>
+constexpr void rvalue_move(I first_, I last_, O result_first_, O result_last_) {
   auto first = iterator_wrapper{std::move(first_)};
   auto last = iterator_wrapper{std::move(last_)};
   auto result_first = iterator_wrapper{std::move(result_first_)};
   auto result_last = iterator_wrapper{std::move(result_last_)};
 
   static_assert(noexcept(std::ranges::iter_move(std::move(first))),
                 "`operator*() &&` is noexcept, and there's no hidden friend iter_move.");
 

libcxx/test/std/strings/string.view/string.view.cons/from_iterator_sentinel.pass.cpp

 #include <ranges>
 
 #include "make_string.h"
 #include "test_iterators.h"
 
 template<class CharT, class Sentinel>
 constexpr void test() {
   auto val = MAKE_STRING_VIEW(CharT, "test");
-  auto sv = std::basic_string_view<CharT>(val.begin(), Sentinel(val.end()));
+  auto sv = std::basic_string_view<CharT>(val.data(), Sentinel(val.data() + val.size()));
   ASSERT_SAME_TYPE(decltype(sv), std::basic_string_view<CharT>);
   assert(sv.size() == val.size());
   assert(sv.data() == val.data());
 }
 
 constexpr bool test() {
   test<char, char*>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
struct ThrowingSentinel {
   friend std::iter_difference_t<const CharT*> operator-(const CharT*, ThrowingSentinel) noexcept { return {}; }
   friend std::iter_difference_t<const CharT*> operator-(ThrowingSentinel, const CharT*) { throw 42; }
 };
 
 template <class CharT>
 void test_throwing() {
   auto val = MAKE_STRING_VIEW(CharT, "test");
   try {
-    (void)std::basic_string_view<CharT>(val.begin(), ThrowingSentinel<CharT>());
+    (void)std::basic_string_view<CharT>(val.data(), ThrowingSentinel<CharT>());
     assert(false);
   } catch (int i) {
     assert(i == 42);
   }
 }
 
 void test_throwing() {
   test_throwing<char>();
int main(int, char**) {
   static_assert(test());
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
   test_throwing();
 #endif
 
   return 0;
 }
-

libcxx/test/std/strings/string.view/string.view.deduct/iterator_sentinel.pass.cpp

 
 #include "make_string.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
 template<class CharT, class Sentinel>
 constexpr void test() {
   auto val = MAKE_STRING_VIEW(CharT, "test");
-  auto sv = std::basic_string_view(val.begin(), Sentinel(val.end()));
+  auto sv = [&] {
+    if constexpr (std::same_as<std::string_view::iterator, char*>) {
+      return std::basic_string_view(val.begin(), Sentinel(val.end()));
+    } else {
+      return std::basic_string_view(val.data(), Sentinel(val.data() + val.size()));
+    }
+  }();
   ASSERT_SAME_TYPE(decltype(sv), std::basic_string_view<CharT>);
   assert(sv.size() == val.size());
   assert(sv.data() == val.data());
 }
 
 constexpr void test() {
   test<char, char*>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t, wchar_t*>();
 #endif
   test<char8_t, char8_t*>();
   test<char16_t, char16_t*>();
   test<char32_t, char32_t*>();
   test<char, const char*>();
   test<char, sized_sentinel<const char*>>();
 }
 
 int main(int, char**) {
   test();
 
   return 0;
 }
-

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/advance_to.pass.cpp

 #include "test_macros.h"
 
 template <class CharT>
 constexpr void test(const CharT* fmt) {
   {
     std::basic_format_parse_context<CharT> context(fmt);
 
     context.advance_to(context.begin() + 1);
-    assert(context.begin() == &fmt[1]);
+    assert(std::to_address(context.begin()) == &fmt[1]);
 
     context.advance_to(context.begin() + 1);
-    assert(context.begin() == &fmt[2]);
+    assert(std::to_address(context.begin()) == &fmt[2]);
 
     context.advance_to(context.begin() + 1);
     assert(context.begin() == context.end());
   }
   {
     std::basic_string_view view{fmt};
     std::basic_format_parse_context context(view);
 
     context.advance_to(context.begin() + 1);
     assert(context.begin() == view.begin() + 1);
 
     context.advance_to(context.begin() + 1);
     assert(context.begin() == view.begin() + 2);
 
     context.advance_to(context.begin() + 1);
     assert(context.begin() == context.end());
   }
 }

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/begin.pass.cpp

 #include <string_view>
 
 #include "test_macros.h"
 
 template <class CharT>
 constexpr void test(const CharT* fmt) {
   {
     std::basic_format_parse_context<CharT> context(fmt);
-    assert(context.begin() == &fmt[0]);
+    assert(std::to_address(context.begin()) == &fmt[0]);
     ASSERT_NOEXCEPT(context.begin());
   }
   {
     std::basic_string_view view{fmt};
     std::basic_format_parse_context context(view);
     assert(context.begin() == view.begin());
     ASSERT_NOEXCEPT(context.begin());
   }

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/ctor.pass.cpp

constexpr void test(const CharT* fmt) {
 
   ASSERT_NOEXCEPT(
       std::basic_format_parse_context{std::basic_string_view<CharT>{}});
   ASSERT_NOEXCEPT(
       std::basic_format_parse_context{std::basic_string_view<CharT>{}, 42});
 
   {
     std::basic_format_parse_context<CharT> context(fmt);
-    assert(context.begin() == &fmt[0]);
-    assert(context.end() == &fmt[3]);
+    assert(std::to_address(context.begin()) == &fmt[0]);
+    assert(std::to_address(context.end()) == &fmt[3]);
   }
   {
     std::basic_string_view view{fmt};
     std::basic_format_parse_context context(view);
     assert(context.begin() == view.begin());
     assert(context.end() == view.end());
   }
 }

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/end.pass.cpp

 #include <string_view>
 
 #include "test_macros.h"
 
 template <class CharT>
 constexpr void test(const CharT* fmt) {
   {
     std::basic_format_parse_context<CharT> context(fmt);
-    assert(context.end() == &fmt[3]);
+    assert(std::to_address(context.end()) == &fmt[3]);
     ASSERT_NOEXCEPT(context.end());
   }
   {
     std::basic_string_view view{fmt};
     std::basic_format_parse_context context(view);
     assert(context.end() == view.end());
     ASSERT_NOEXCEPT(context.end());
   }

libcxx/test/support/test_iterators.h

 {
     return x.base() - y.base();
 }
 
 #if TEST_STD_VER > 17
 template <class It>
 class contiguous_iterator
 {
-    static_assert(std::is_pointer_v<It>, "Things probably break in this case");
-
     It it_;
 
     template <class U> friend class contiguous_iterator;
 public:
     typedef          std::contiguous_iterator_tag              iterator_category;
     typedef typename std::iterator_traits<It>::value_type      value_type;
     typedef typename std::iterator_traits<It>::difference_type difference_type;
     typedef It                                                 pointer;
     typedef typename std::iterator_traits<It>::reference       reference;
-    typedef typename std::remove_pointer<It>::type             element_type;
+    typedef typename std::remove_reference<reference>::type    element_type;
 
     TEST_CONSTEXPR_CXX14 It base() const {return it_;}
 
     TEST_CONSTEXPR_CXX14 contiguous_iterator() : it_() {}
     explicit TEST_CONSTEXPR_CXX14 contiguous_iterator(It it) : it_(it) {}
     template <class U>
         TEST_CONSTEXPR_CXX14 contiguous_iterator(const contiguous_iterator<U>& u) : it_(u.it_) {}