[libc++] [test] Don't assume iterators are class types.

[• Quuxplusone]

Summary

In particular, `span<int>::iterator` may be a raw pointer type
and thus have no nested typedef `iterator::value_type`. However,
we already know that the value_type we expect for `span<int>` is just `int`.
Fix up all other iterator_concept_conformance tests in the same way.

[curdeius]

FWIW, LGTM.

libcxx/test/std/containers/associative/map/iterator_concept_conformance.compile.pass.cpp

 #include <map>
 
 #include <iterator>
 
 using iterator = std::map<int, int>::iterator;
 using const_iterator = std::map<int, int>::const_iterator;
 using reverse_iterator = std::map<int, int>::reverse_iterator;
 using const_reverse_iterator = std::map<int, int>::const_reverse_iterator;
-using value_type = iterator::value_type;
+using value_type = std::pair<const int, int>;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);

libcxx/test/std/containers/associative/multimap/iterator_concept_conformance.compile.pass.cpp

 #include <map>
 
 #include <iterator>
 
 using iterator = std::multimap<int, int>::iterator;
 using const_iterator = std::multimap<int, int>::const_iterator;
 using reverse_iterator = std::multimap<int, int>::reverse_iterator;
 using const_reverse_iterator = std::multimap<int, int>::const_reverse_iterator;
-using value_type = iterator::value_type;
+using value_type = std::pair<const int, int>;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);

libcxx/test/std/containers/associative/multiset/iterator_concept_conformance.compile.pass.cpp

 #include <set>
 
 #include <iterator>
 
 using iterator = std::multiset<int>::iterator;
 using const_iterator = std::multiset<int>::const_iterator;
 using reverse_iterator = std::multiset<int>::reverse_iterator;
 using const_reverse_iterator = std::multiset<int>::const_reverse_iterator;
-using value_type = iterator::value_type;
+using value_type = int;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);

libcxx/test/std/containers/associative/set/iterator_concept_conformance.compile.pass.cpp

 #include <set>
 
 #include <iterator>
 
 using iterator = std::set<int>::iterator;
 using const_iterator = std::set<int>::const_iterator;
 using reverse_iterator = std::set<int>::reverse_iterator;
 using const_reverse_iterator = std::set<int>::const_reverse_iterator;
-using value_type = iterator::value_type;
+using value_type = int;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);

libcxx/test/std/containers/sequences/deque/iterator_concept_conformance.compile.pass.cpp

 #include <deque>
 
 #include <iterator>
 
 using iterator = std::deque<int>::iterator;
 using const_iterator = std::deque<int>::const_iterator;
 using reverse_iterator = std::deque<int>::reverse_iterator;
 using const_reverse_iterator = std::deque<int>::const_reverse_iterator;
-using value_type = iterator::value_type;
+using value_type = int;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);

libcxx/test/std/containers/sequences/forwardlist/forwardlist.iter/iterator_concept_conformance.compile.pass.cpp

 // iterator, const_iterator
 
 #include <forward_list>
 
 #include <iterator>
 
 using iterator = std::forward_list<int>::iterator;
 using const_iterator = std::forward_list<int>::const_iterator;
-using value_type = iterator::value_type;
+using value_type = int;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, iterator>);

libcxx/test/std/containers/sequences/list/iterator_concept_conformance.compile.pass.cpp

 #include <list>
 
 #include <iterator>
 
 using iterator = std::list<int>::iterator;
 using const_iterator = std::list<int>::const_iterator;
 using reverse_iterator = std::list<int>::reverse_iterator;
 using const_reverse_iterator = std::list<int>::const_reverse_iterator;
-using value_type = iterator::value_type;
+using value_type = int;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);

libcxx/test/std/containers/sequences/vector.bool/iterator_concept_conformance.compile.pass.cpp

 #include <vector>
 
 #include <iterator>
 
 using iterator = std::vector<bool>::iterator;
 using const_iterator = std::vector<bool>::const_iterator;
 using reverse_iterator = std::vector<bool>::reverse_iterator;
 using const_reverse_iterator = std::vector<bool>::const_reverse_iterator;
-using value_type = iterator::value_type;
+using value_type = bool;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);

libcxx/test/std/containers/sequences/vector/iterator_concept_conformance.compile.pass.cpp

 #include <vector>
 
 #include <iterator>
 
 using iterator = std::vector<int>::iterator;
 using const_iterator = std::vector<int>::const_iterator;
 using reverse_iterator = std::vector<int>::reverse_iterator;
 using const_reverse_iterator = std::vector<int>::const_reverse_iterator;
-using value_type = iterator::value_type;
+using value_type = int;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);

libcxx/test/std/containers/unord/unord.map/iterator_concept_conformance.compile.pass.cpp

 #include <unordered_map>
 
 #include <iterator>
 
 using iterator = std::unordered_map<int, int>::iterator;
 using const_iterator = std::unordered_map<int, int>::const_iterator;
 using local_iterator = std::unordered_map<int, int>::local_iterator;
 using const_local_iterator = std::unordered_map<int, int>::const_local_iterator;
-using value_type = iterator::value_type;
+using value_type = std::pair<const int, int>;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, local_iterator>);

libcxx/test/std/containers/unord/unord.multimap/iterator_concept_conformance.compile.pass.cpp

 #include <unordered_map>
 
 #include <iterator>
 
 using iterator = std::unordered_multimap<int, int>::iterator;
 using const_iterator = std::unordered_multimap<int, int>::const_iterator;
 using local_iterator = std::unordered_multimap<int, int>::local_iterator;
 using const_local_iterator = std::unordered_multimap<int, int>::const_local_iterator;
-using value_type = iterator::value_type;
+using value_type = std::pair<const int, int>;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, local_iterator>);

libcxx/test/std/containers/unord/unord.multiset/iterator_concept_conformance.compile.pass.cpp

 #include <unordered_set>
 
 #include <iterator>
 
 using iterator = std::unordered_multiset<int>::iterator;
 using const_iterator = std::unordered_multiset<int>::const_iterator;
 using local_iterator = std::unordered_multiset<int>::local_iterator;
 using const_local_iterator = std::unordered_multiset<int>::const_local_iterator;
-using value_type = iterator::value_type;
+using value_type = int;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, local_iterator>);

libcxx/test/std/containers/unord/unord.set/iterator_concept_conformance.compile.pass.cpp

 #include <unordered_set>
 
 #include <iterator>
 
 using iterator = std::unordered_set<int>::iterator;
 using const_iterator = std::unordered_set<int>::const_iterator;
 using local_iterator = std::unordered_set<int>::local_iterator;
 using const_local_iterator = std::unordered_set<int>::const_local_iterator;
-using value_type = iterator::value_type;
+using value_type = int;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, local_iterator>);

libcxx/test/std/containers/views/span.iterators/iterator_concept_conformance.compile.pass.cpp

 // iterator, reverse_iterator
 
 #include <span>
 
 #include <iterator>
 
 using iterator = std::span<int>::iterator;
 using reverse_iterator = std::span<int>::reverse_iterator;
-using value_type = iterator::value_type;
+using value_type = int;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(std::sized_sentinel_for<iterator, iterator>);
 static_assert(!std::sized_sentinel_for<iterator, reverse_iterator>);

libcxx/test/std/input.output/filesystems/class.directory_iterator/iterator_concept_conformance.compile.pass.cpp

 // XFAIL: msvc && clang
 
 // directory_iterator, recursive_directory_iterator
 
 #include "filesystem_include.h"
 
 #include <iterator>
 
+using value_type = fs::directory_entry;
+
 static_assert(std::indirectly_readable<fs::directory_iterator>);
-static_assert(!std::indirectly_writable<fs::directory_iterator, fs::directory_iterator::value_type>);
+static_assert(!std::indirectly_writable<fs::directory_iterator, value_type>);
 static_assert(std::weakly_incrementable<fs::directory_iterator>);
 static_assert(!std::incrementable<fs::directory_iterator>);
 static_assert(std::input_or_output_iterator<fs::directory_iterator>);
 static_assert(std::sentinel_for<fs::directory_iterator, fs::directory_iterator>);
 static_assert(!std::sized_sentinel_for<fs::directory_iterator, fs::directory_iterator>);
 
 static_assert(std::indirectly_readable<fs::recursive_directory_iterator>);
-static_assert(
-    !std::indirectly_writable<fs::recursive_directory_iterator, fs::recursive_directory_iterator::value_type>);
+static_assert(!std::indirectly_writable<fs::recursive_directory_iterator, value_type>);
 static_assert(std::weakly_incrementable<fs::recursive_directory_iterator>);
 static_assert(!std::incrementable<fs::recursive_directory_iterator>);
 static_assert(std::input_or_output_iterator<fs::recursive_directory_iterator>);
 static_assert(std::sentinel_for<fs::recursive_directory_iterator, fs::recursive_directory_iterator>);
 static_assert(!std::sized_sentinel_for<fs::recursive_directory_iterator, fs::recursive_directory_iterator>);

libcxx/test/std/iterators/iterator.requirements/iterator.assoc.types/incrementable.traits/iter_difference_t.pass.cpp

[[nodiscard]] constexpr bool check_iter_difference_t() {
   static_assert(std::same_as<std::iter_difference_t<T volatile&&>, Expected> == result);
   static_assert(std::same_as<std::iter_difference_t<T const volatile&&>, Expected> == result);
 
   return result;
 }
 
 static_assert(check_iter_difference_t<int, int>());
 static_assert(check_iter_difference_t<int*, std::ptrdiff_t>());
-static_assert(check_iter_difference_t<std::vector<int>::iterator, std::vector<int>::iterator::difference_type>());
+static_assert(check_iter_difference_t<std::vector<int>::iterator, std::ptrdiff_t>());
 
 struct int_subtraction {
   friend int operator-(int_subtraction, int_subtraction) noexcept;
 };
 static_assert(check_iter_difference_t<int_subtraction, int>());
 
 // clang-format off
 template <class T>

libcxx/test/std/iterators/iterator.requirements/iterator.assoc.types/readable.traits/iter_value_t.pass.cpp

[[nodiscard]] constexpr bool check_iter_value_t() {
   static_assert(std::same_as<std::iter_value_t<T const volatile&&>, Expected> == result);
 
   return result;
 }
 
 static_assert(check_iter_value_t<int*, int>());
 static_assert(check_iter_value_t<int[], int>());
 static_assert(check_iter_value_t<int[10], int>());
-static_assert(check_iter_value_t<std::vector<int>::iterator, std::vector<int>::iterator::value_type>());
-static_assert(check_iter_value_t<std::shared_ptr<int>, std::shared_ptr<int>::element_type>());
+static_assert(check_iter_value_t<std::vector<int>::iterator, int>());
+static_assert(check_iter_value_t<std::shared_ptr<int>, int>());
 
 struct both_members {
   using value_type = double;
   using element_type = double;
 };
 static_assert(check_iter_value_t<both_members, double>());
 
 // clang-format off

libcxx/test/std/strings/basic.string/string.iterators/iterator_concept_conformance.compile.pass.cpp

 #include <string>
 
 #include <iterator>
 
 using iterator = std::string::iterator;
 using const_iterator = std::string::const_iterator;
 using reverse_iterator = std::string::reverse_iterator;
 using const_reverse_iterator = std::string::const_reverse_iterator;
-using value_type = iterator::value_type;
+using value_type = char;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);