[libcxx] adds `cpp17-.*iterator` concepts for iterator_traits

[cjdb]

Summary

The iterator_traits patch became too large for a concise review, so
the "bloat" —as it were— was moved into this patch. Also tests most
C++[98,17] iterator types to confirm backwards compatibility is
successful (regex iterators are intentionally not present, but directory
iterators are due to a peculiar error encountered while patching
iterator_traits).

Depends on D99461.

[cjdb]

rebases to activate CI

[cjdb]

adds guards around the filesystem stuff

[cjdb]

rebases to activate CI

[tcanens]

libcxx/include/iterator

660

LWG3420?

[cjdb]

applies LWG3420 and (hopefully) fixes locale build failure

[cjdb]

rebases to activate CI

[zoecarver]

Please mark LWG3420 as complete in the status. Haven't looked at the tests yet.

libcxx/include/iterator

554

I don't see any tests for iter_reference_t. I know it's used in the other implementations so no need to test it heavily, but a simple test file would probably be good.

652

How about _LIBCPP_HAS_NO_RANGES?

706

Why do we need __j too?

712

This could just be __i - __i which is what it says in the standard anyway.

[zoecarver]

libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_bidirectional_iterator.compile.pass.cpp

160

This should only have one template. Otherwise it's going to think int is the hash type ;)

libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_forward_iterator.compile.pass.cpp

71

Why isn't this a __legacy_forward_iterator?

152

Same comment. And for unordered_multiset. Also why not test (const_) local_iterator for both while you're at it?

[ldionne]

libcxx/include/iterator

545

I was surprised to see that we can't simply write typename _Tp&. I'm not sure what part of the concepts spec disallows it, do you know?

Would it make sense to rename this to __referenceable? Then below we would have

concept __dereferenceable = requires(_Tp& __t) {
  { *__t } -> __referenceable;
};

which I think is nicely consistent.

[CaseyCarter]

libcxx/include/iterator

545

I was surprised to see that we can't simply write typename _Tp&. I'm not sure what part of the concepts spec disallows it, do you know?

So was I! The _type-requirement_ grammar is "_type-requirement_: typename _nested-name-specifier_opt_ _type-name_ ;", which doesn't allow any kind of adornments. From a very high level I suppose this makes sense - _Tp& is a type, but not the _name_ of a type - but it does mean that some things we expect to work don't.

There's probably material here for a 1-2 page paper to propose a change.

706

IIRC one of them should be mutable for the LHS of the assignment operators, and the other const for all other uses.

[• Quuxplusone]

Once you've updated the line length for clang-format, please run the tests through clang-format a second time to remove the excess line-breaking and get them readable again.

libcxx/include/iterator

545

Re __can_reference versus __referenceable: This is matching the (current) draft wording in http://eel.is/c++draft/iterator.synopsis#concept:can-reference so I think it's defensible.

[zoecarver]

libcxx/include/iterator

545

I agree, __referenceable does sound better. But I think it's not outweighed by the benefit of having this code more or less match the standard wording verbatim.

[cjdb]

libcxx/include/iterator

545

That name can be editorially changed (probably with LWG's permission), so I'm okay with choosing the name that makes more sense.

554

Oops, done.

706

Looks like it's legacy wording now?

libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_bidirectional_iterator.compile.pass.cpp

160

Done, everywhere :-)

libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_forward_iterator.compile.pass.cpp

71

Diagnostics report that it's not equality_comparable.

152

TIL about local_iterator.

[cjdb]

applies feedback

[zoecarver]

Thanks for the updates!

[ldionne]

For each legacy iterator concept, would it be possible to create an archetype in the tests with the strict minimum requirements and check that it models the concept?

LGTM with CI passing and those tests added, unless you explain why they shouldn't be added.

libcxx/include/iterator

545

FWIW I would have been fine with keeping __can_reference after being told that it's what's used in the Standard. I'm fine either way, basically, feel free to do as you think is best.

[ldionne]

libcxx/include/iterator

545

Oh, and thanks for the explanation here @CaseyCarter !

[cjdb]

rebases to activate CI

[ldionne]

libcxx/include/iterator

659

@CaseyCarter Is it intended that the exposition-only concepts defined in http://eel.is/c++draft/iterator.traits#2 are not a literal translation of tables like http://eel.is/c++draft/iterator.cpp17#tab:iterator?

For example, the exposition-only concept cpp17-iterator adds the requirement { *i++ } -> can-reference, whereas the Cpp17Iterator concept does not contain that requirement.

There are similar differences in the other iterator concepts too, like operator-> being in the table but not in the exposition-only concept.

[cjdb]

adds archetype cpp17-iterators for testing

Per offline discussion, these have been renamed to __iterator_traits_detail::__cpp17_*_iterator to avoid confusion with the (subtly different) named requirements Cpp17*Iterator found in [iterator.cpp17].

[cjdb]

rebases to activate CI

[CaseyCarter]

libcxx/include/iterator

659

@CaseyCarter Is it intended that the exposition-only concepts defined in http://eel.is/c++draft/iterator.traits#2 are not a literal translation of tables like http://eel.is/c++draft/iterator.cpp17#tab:iterator?

Yes. It is intended.

For example, the exposition-only concept cpp17-iterator adds the requirement { *i++ } -> can-reference, whereas the Cpp17Iterator concept does not contain that requirement.

True, but both Cpp17InputIterator and Cpp17OutputIterator effectively require something stronger that refines this requirement. I _think_ this was just a convenient shortcut,

There are similar differences in the other iterator concepts too, like operator-> being in the table but not in the exposition-only concept.

There's no way to express the -> requirement with concepts, since we don't generally know the member names (if any) of the value type. This is also why we dropped -> from the iterator concepts: generic code can't use -> because it doesn't know what it can put on the right-hand side.

libcxx/include/iterator

 {
     typedef ptrdiff_t difference_type;
     typedef T value_type;
     typedef T* pointer;
     typedef T& reference;
     typedef random_access_iterator_tag iterator_category;
 };
 
+template<dereferenceable T>
+  using iter_reference_t = decltype(*declval<T&>());
+
 template<class Category, class T, class Distance = ptrdiff_t,
          class Pointer = T*, class Reference = T&>
 struct iterator
 {
     typedef T         value_type;
     typedef Distance  difference_type;
     typedef Pointer   pointer;
     typedef Reference reference;

 #include <type_traits>
 #include <compare>
 #include <concepts>
 #include <cstddef>
 #include <initializer_list>
 #include <__memory/addressof.h>
 #include <__memory/pointer_traits.h>
 #include <version>
-#include <concepts>
 
 #include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
+
+template<class _Tp>
+using __with_reference = _Tp&;
+
+template<class _Tp>
+concept __referenceable = requires {
+  typename __with_reference<_Tp>;
+};
+
+template<class _Tp>
+concept __dereferenceable = requires(_Tp& __t) {
+  { *__t } -> __referenceable; // not required to be equality-preserving
+};
+
 // [incrementable.traits]
 template<class> struct incrementable_traits {};
 
 template<class _Tp>
 requires is_object_v<_Tp>
 struct incrementable_traits<_Tp*> {
   using difference_type = ptrdiff_t;
 };

 struct indirectly_readable_traits<_Tp> {};
 template<__has_member_value_type _Tp>
 requires __has_member_element_type<_Tp> &&
          same_as<remove_cv_t<typename _Tp::element_type>,
                  remove_cv_t<typename _Tp::value_type>>
 struct indirectly_readable_traits<_Tp>
   : __cond_value_type<typename _Tp::value_type> {};
 
+// [iterator.traits]
+template<__dereferenceable _Tp>
+using iter_reference_t = decltype(*declval<_Tp&>());
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 template <class _Iter>
 struct _LIBCPP_TEMPLATE_VIS iterator_traits;
 
 struct _LIBCPP_TEMPLATE_VIS input_iterator_tag {};
 struct _LIBCPP_TEMPLATE_VIS output_iterator_tag {};
 struct _LIBCPP_TEMPLATE_VIS forward_iterator_tag       : public input_iterator_tag {};
 struct _LIBCPP_TEMPLATE_VIS bidirectional_iterator_tag : public forward_iterator_tag {};
 struct _LIBCPP_TEMPLATE_VIS random_access_iterator_tag : public bidirectional_iterator_tag {};
 #if _LIBCPP_STD_VER > 17
 struct _LIBCPP_TEMPLATE_VIS contiguous_iterator_tag    : public random_access_iterator_tag {};
 #endif
 
 template <class _Iter>
 struct __iter_traits_cache {
   using type = _If<
     __is_primary_template<iterator_traits<_Iter> >::value,
     _Iter,
     iterator_traits<_Iter>
   >;

 {
     typedef typename _Iter::difference_type   difference_type;
     typedef typename _Iter::value_type        value_type;
     typedef typename _Iter::pointer           pointer;
     typedef typename _Iter::reference         reference;
     typedef typename _Iter::iterator_category iterator_category;
 };
 
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+// The `cpp17.*-iterator` concepts have been dubbed `__legacy.*_iterator` because the name is both
+// clearer (C++98 iterators are still valid `cpp17-iterators`, for example), and because it's the
+// term that C++ Reference uses (which is what most users will look to when issued diagnostics).
+
+template<class _Ip>
+concept __legacy_iterator =
+  requires(_Ip __i) {
+    {   *__i } -> __referenceable;
+    {  ++__i } -> same_as<_Ip&>;
+    { *__i++ } -> __referenceable;
+  } &&
+  copyable<_Ip>;
+
+template<class _Ip>
+concept __legacy_input_iterator =
+  __legacy_iterator<_Ip> &&
+  equality_comparable<_Ip> &&
+  requires(_Ip __i) {
+    typename incrementable_traits<_Ip>::difference_type;
+    typename indirectly_readable_traits<_Ip>::value_type;
+    typename common_reference_t<iter_reference_t<_Ip>&&,
+                                typename indirectly_readable_traits<_Ip>::value_type&>;
+    typename common_reference_t<decltype(*__i++)&&,
+                                typename indirectly_readable_traits<_Ip>::value_type&>;
+    requires signed_integral<typename incrementable_traits<_Ip>::difference_type>;
+  };
+
+template<class _Ip>
+concept __legacy_forward_iterator =
+  __legacy_input_iterator<_Ip> &&
+  constructible_from<_Ip> &&
+  is_lvalue_reference_v<iter_reference_t<_Ip>> &&
+  same_as<remove_cvref_t<iter_reference_t<_Ip>>,
+          typename indirectly_readable_traits<_Ip>::value_type> &&
+  requires(_Ip __i) {
+    {  __i++ } -> convertible_to<_Ip const&>;
+    { *__i++ } -> same_as<iter_reference_t<_Ip>>;
+  };
+
+template<class _Ip>
+concept __legacy_bidirectional_iterator =
+  __legacy_forward_iterator<_Ip> &&
+  requires(_Ip __i) {
+    {  --__i } -> same_as<_Ip&>;
+    {  __i-- } -> convertible_to<_Ip const&>;
+    { *__i-- } -> same_as<iter_reference_t<_Ip>>;
+  };
+
+template<class _Ip>
+concept __legacy_random_access_iterator =
+  __legacy_bidirectional_iterator<_Ip> and
+  totally_ordered<_Ip> and
+  requires(_Ip __i, typename incrementable_traits<_Ip>::difference_type __n) {
+    { __i += __n } -> same_as<_Ip&>;
+    { __i -= __n } -> same_as<_Ip&>;
+    { __i +  __n } -> same_as<_Ip>;
+    { __n +  __i } -> same_as<_Ip>;
+    { __i -  __n } -> same_as<_Ip>;
+    { __i -  __i } -> same_as<decltype(__n)>;
+    {  __i[__n]  } -> convertible_to<iter_reference_t<_Ip>>;
+  };
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
 template <class _Iter, bool> struct __iterator_traits {};
 
 template <class _Iter>
 struct __iterator_traits<_Iter, true>
     :  __iterator_traits_impl
       <
         _Iter,
         is_convertible<typename _Iter::iterator_category, input_iterator_tag>::value ||

libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_bidirectional_iterator.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<class I>
+// concept __legacy_bidirectional_iterator;
+
+#include <iterator>
+
+#include <array>
+#include <deque>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+#include <filesystem>
+#endif
+#include <forward_list>
+#include <list>
+#include <map>
+#include <set>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+static_assert(std::__legacy_bidirectional_iterator<int*>);
+static_assert(std::__legacy_bidirectional_iterator<int const*>);
+static_assert(std::__legacy_bidirectional_iterator<int volatile*>);
+static_assert(std::__legacy_bidirectional_iterator<int const volatile*>);
+
+// <array>
+static_assert(std::__legacy_bidirectional_iterator<std::array<int, 10>::iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::array<int, 10>::const_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::array<int, 10>::reverse_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::array<int, 10>::const_reverse_iterator>);
+
+// <deque>
+static_assert(std::__legacy_bidirectional_iterator<std::deque<int>::iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::deque<int>::const_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::deque<int>::reverse_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::deque<int>::const_reverse_iterator>);
+
+// <filesystem>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+static_assert(!std::__legacy_bidirectional_iterator<std::filesystem::directory_iterator>);
+static_assert(!std::__legacy_bidirectional_iterator<std::filesystem::recursive_directory_iterator>);
+#endif
+
+// <forward_list>
+static_assert(!std::__legacy_bidirectional_iterator<std::forward_list<int>::iterator>);
+static_assert(!std::__legacy_bidirectional_iterator<std::forward_list<int>::const_iterator>);
+
+// <iterator>
+static_assert(!std::__legacy_bidirectional_iterator<std::back_insert_iterator<std::vector<int> > >);
+static_assert(!std::__legacy_bidirectional_iterator<std::front_insert_iterator<std::vector<int> > >);
+static_assert(!std::__legacy_bidirectional_iterator<std::insert_iterator<std::vector<int> > >);
+static_assert(!std::__legacy_bidirectional_iterator<std::move_iterator<std::vector<int>::iterator> >);
+
+// <list>
+static_assert(std::__legacy_bidirectional_iterator<std::list<int>::iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::list<int>::const_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::list<int>::reverse_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::list<int>::const_reverse_iterator>);
+
+// <map>
+static_assert(std::__legacy_bidirectional_iterator<std::map<int, int>::iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::map<int, int>::const_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::map<int, int>::reverse_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::map<int, int>::const_reverse_iterator>);
+
+static_assert(std::__legacy_bidirectional_iterator<std::multimap<int, int>::iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::multimap<int, int>::const_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::multimap<int, int>::reverse_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::multimap<int, int>::const_reverse_iterator>);
+
+// <set>
+static_assert(std::__legacy_bidirectional_iterator<std::set<int>::iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::set<int>::const_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::set<int>::reverse_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::set<int>::const_reverse_iterator>);
+
+static_assert(std::__legacy_bidirectional_iterator<std::multiset<int>::iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::multiset<int>::const_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::multiset<int>::reverse_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::multiset<int>::const_reverse_iterator>);
+
+// <string>
+static_assert(std::__legacy_bidirectional_iterator<std::string::iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::string::const_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::string::reverse_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::string::const_reverse_iterator>);
+
+// <string_view>
+static_assert(std::__legacy_bidirectional_iterator<std::string_view::iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::string_view::const_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::string_view::reverse_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::string_view::const_reverse_iterator>);
+
+// <unordered_map>
+static_assert(!std::__legacy_bidirectional_iterator<std::unordered_map<int, int>::iterator>);
+static_assert(!std::__legacy_bidirectional_iterator<std::unordered_map<int, int>::const_iterator>);
+static_assert(!std::__legacy_bidirectional_iterator<std::unordered_map<int, int>::local_iterator>);
+static_assert(!std::__legacy_bidirectional_iterator<std::unordered_map<int, int>::const_local_iterator>);
+
+static_assert(!std::__legacy_bidirectional_iterator<std::unordered_multimap<int, int>::iterator>);
+static_assert(!std::__legacy_bidirectional_iterator<std::unordered_multimap<int, int>::const_iterator>);
+static_assert(!std::__legacy_bidirectional_iterator<std::unordered_multimap<int, int>::local_iterator>);
+static_assert(!std::__legacy_bidirectional_iterator<std::unordered_multimap<int, int>::const_local_iterator>);
+
+// <unordered_set>
+static_assert(!std::__legacy_bidirectional_iterator<std::unordered_set<int>::iterator>);
+static_assert(!std::__legacy_bidirectional_iterator<std::unordered_set<int>::const_iterator>);
+static_assert(!std::__legacy_bidirectional_iterator<std::unordered_set<int>::local_iterator>);
+static_assert(!std::__legacy_bidirectional_iterator<std::unordered_set<int>::const_local_iterator>);
+
+static_assert(!std::__legacy_bidirectional_iterator<std::unordered_multiset<int>::iterator>);
+static_assert(!std::__legacy_bidirectional_iterator<std::unordered_multiset<int>::const_iterator>);
+static_assert(!std::__legacy_bidirectional_iterator<std::unordered_multiset<int>::local_iterator>);
+static_assert(!std::__legacy_bidirectional_iterator<std::unordered_multiset<int>::const_local_iterator>);
+
+// <vector>
+static_assert(std::__legacy_bidirectional_iterator<std::vector<int>::iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::vector<int>::const_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::vector<int>::reverse_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<std::vector<int>::const_reverse_iterator>);
+
+// Not iterators
+static_assert(!std::__legacy_bidirectional_iterator<void>);
+static_assert(!std::__legacy_bidirectional_iterator<void*>);
+static_assert(!std::__legacy_bidirectional_iterator<int* const>);
+static_assert(!std::__legacy_bidirectional_iterator<std::vector<int>::iterator volatile>);
+static_assert(!std::__legacy_bidirectional_iterator<std::vector<int>::iterator&>);
+static_assert(!std::__legacy_bidirectional_iterator<std::vector<int>::iterator&&>);
+static_assert(!std::__legacy_bidirectional_iterator<int>);
+static_assert(!std::__legacy_bidirectional_iterator<int[]>);
+static_assert(!std::__legacy_bidirectional_iterator<int[10]>);
+static_assert(!std::__legacy_bidirectional_iterator<int()>);
+static_assert(!std::__legacy_bidirectional_iterator<int (*)()>);
+static_assert(!std::__legacy_bidirectional_iterator<int (&)()>);
+
+struct S {};
+static_assert(!std::__legacy_bidirectional_iterator<S>);
+static_assert(!std::__legacy_bidirectional_iterator<int S::*>);
+static_assert(!std::__legacy_bidirectional_iterator<int (S::*)()>);

libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_forward_iterator.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<class I>
+// concept __legacy_forward_iterator;
+
+#include <iterator>
+
+#include <array>
+#include <deque>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+#include <filesystem>
+#endif
+#include <forward_list>
+#include <list>
+#include <map>
+#include <set>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+static_assert(std::__legacy_forward_iterator<int*>);
+static_assert(std::__legacy_forward_iterator<int const*>);
+static_assert(std::__legacy_forward_iterator<int volatile*>);
+static_assert(std::__legacy_forward_iterator<int const volatile*>);
+
+// <array>
+static_assert(std::__legacy_forward_iterator<std::array<int, 10>::iterator>);
+static_assert(std::__legacy_forward_iterator<std::array<int, 10>::const_iterator>);
+static_assert(std::__legacy_forward_iterator<std::array<int, 10>::reverse_iterator>);
+static_assert(std::__legacy_forward_iterator<std::array<int, 10>::const_reverse_iterator>);
+
+// <deque>
+static_assert(std::__legacy_forward_iterator<std::deque<int>::iterator>);
+static_assert(std::__legacy_forward_iterator<std::deque<int>::const_iterator>);
+static_assert(std::__legacy_forward_iterator<std::deque<int>::reverse_iterator>);
+static_assert(std::__legacy_forward_iterator<std::deque<int>::const_reverse_iterator>);
+
+// <filesystem>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+static_assert(!std::__legacy_forward_iterator<std::filesystem::directory_iterator>);
+static_assert(!std::__legacy_forward_iterator<std::filesystem::recursive_directory_iterator>);
+#endif
+
+// <forward_list>
+static_assert(std::__legacy_forward_iterator<std::forward_list<int>::iterator>);
+static_assert(std::__legacy_forward_iterator<std::forward_list<int>::const_iterator>);
+
+// <iterator>
+static_assert(!std::__legacy_forward_iterator<std::back_insert_iterator<std::vector<int> > >);
+static_assert(!std::__legacy_forward_iterator<std::front_insert_iterator<std::vector<int> > >);
+static_assert(!std::__legacy_forward_iterator<std::insert_iterator<std::vector<int> > >);
+static_assert(!std::__legacy_forward_iterator<std::move_iterator<std::vector<int>::iterator> >);
+
+// <list>
+static_assert(std::__legacy_forward_iterator<std::list<int>::iterator>);
+static_assert(std::__legacy_forward_iterator<std::list<int>::const_iterator>);
+static_assert(std::__legacy_forward_iterator<std::list<int>::reverse_iterator>);
+static_assert(std::__legacy_forward_iterator<std::list<int>::const_reverse_iterator>);
+
+// <map>
+static_assert(std::__legacy_forward_iterator<std::map<int, int>::iterator>);
+static_assert(std::__legacy_forward_iterator<std::map<int, int>::const_iterator>);
+static_assert(std::__legacy_forward_iterator<std::map<int, int>::reverse_iterator>);
+static_assert(std::__legacy_forward_iterator<std::map<int, int>::const_reverse_iterator>);
+
+static_assert(std::__legacy_forward_iterator<std::multimap<int, int>::iterator>);
+static_assert(std::__legacy_forward_iterator<std::multimap<int, int>::const_iterator>);
+static_assert(std::__legacy_forward_iterator<std::multimap<int, int>::reverse_iterator>);
+static_assert(std::__legacy_forward_iterator<std::multimap<int, int>::const_reverse_iterator>);
+
+// <set>
+static_assert(std::__legacy_forward_iterator<std::set<int>::iterator>);
+static_assert(std::__legacy_forward_iterator<std::set<int>::const_iterator>);
+static_assert(std::__legacy_forward_iterator<std::set<int>::reverse_iterator>);
+static_assert(std::__legacy_forward_iterator<std::set<int>::const_reverse_iterator>);
+
+static_assert(std::__legacy_forward_iterator<std::multiset<int>::iterator>);
+static_assert(std::__legacy_forward_iterator<std::multiset<int>::const_iterator>);
+static_assert(std::__legacy_forward_iterator<std::multiset<int>::reverse_iterator>);
+static_assert(std::__legacy_forward_iterator<std::multiset<int>::const_reverse_iterator>);
+
+// <string>
+static_assert(std::__legacy_forward_iterator<std::string::iterator>);
+static_assert(std::__legacy_forward_iterator<std::string::const_iterator>);
+static_assert(std::__legacy_forward_iterator<std::string::reverse_iterator>);
+static_assert(std::__legacy_forward_iterator<std::string::const_reverse_iterator>);
+
+// <string_view>
+static_assert(std::__legacy_forward_iterator<std::string_view::iterator>);
+static_assert(std::__legacy_forward_iterator<std::string_view::const_iterator>);
+static_assert(std::__legacy_forward_iterator<std::string_view::reverse_iterator>);
+static_assert(std::__legacy_forward_iterator<std::string_view::const_reverse_iterator>);
+
+// <unordered_map>
+static_assert(std::__legacy_forward_iterator<std::unordered_map<int, int>::iterator>);
+static_assert(std::__legacy_forward_iterator<std::unordered_map<int, int>::const_iterator>);
+static_assert(std::__legacy_forward_iterator<std::unordered_map<int, int>::local_iterator>);
+static_assert(std::__legacy_forward_iterator<std::unordered_map<int, int>::const_local_iterator>);
+
+static_assert(std::__legacy_forward_iterator<std::unordered_multimap<int, int>::iterator>);
+static_assert(std::__legacy_forward_iterator<std::unordered_multimap<int, int>::const_iterator>);
+static_assert(std::__legacy_forward_iterator<std::unordered_multimap<int, int>::local_iterator>);
+static_assert(std::__legacy_forward_iterator<std::unordered_multimap<int, int>::const_local_iterator>);
+
+// <unordered_set>
+static_assert(std::__legacy_forward_iterator<std::unordered_set<int>::iterator>);
+static_assert(std::__legacy_forward_iterator<std::unordered_set<int>::const_iterator>);
+static_assert(std::__legacy_forward_iterator<std::unordered_set<int>::local_iterator>);
+static_assert(std::__legacy_forward_iterator<std::unordered_set<int>::const_local_iterator>);
+
+static_assert(std::__legacy_forward_iterator<std::unordered_multiset<int>::iterator>);
+static_assert(std::__legacy_forward_iterator<std::unordered_multiset<int>::const_iterator>);
+static_assert(std::__legacy_forward_iterator<std::unordered_multiset<int>::local_iterator>);
+static_assert(std::__legacy_forward_iterator<std::unordered_multiset<int>::const_local_iterator>);
+
+// <vector>
+static_assert(std::__legacy_forward_iterator<std::vector<int>::iterator>);
+static_assert(std::__legacy_forward_iterator<std::vector<int>::const_iterator>);
+static_assert(std::__legacy_forward_iterator<std::vector<int>::reverse_iterator>);
+static_assert(std::__legacy_forward_iterator<std::vector<int>::const_reverse_iterator>);
+
+// Not iterators
+static_assert(!std::__legacy_forward_iterator<void>);
+static_assert(!std::__legacy_forward_iterator<void*>);
+static_assert(!std::__legacy_forward_iterator<int* const>);
+static_assert(!std::__legacy_forward_iterator<std::vector<int>::iterator volatile>);
+static_assert(!std::__legacy_forward_iterator<std::vector<int>::iterator&>);
+static_assert(!std::__legacy_forward_iterator<std::vector<int>::iterator&&>);
+static_assert(!std::__legacy_forward_iterator<int>);
+static_assert(!std::__legacy_forward_iterator<int[]>);
+static_assert(!std::__legacy_forward_iterator<int[10]>);
+static_assert(!std::__legacy_forward_iterator<int()>);
+static_assert(!std::__legacy_forward_iterator<int (*)()>);
+static_assert(!std::__legacy_forward_iterator<int (&)()>);
+
+struct S {};
+static_assert(!std::__legacy_forward_iterator<S>);
+static_assert(!std::__legacy_forward_iterator<int S::*>);
+static_assert(!std::__legacy_forward_iterator<int (S::*)()>);

libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_input_iterator.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<class I>
+// concept __legacy_input_iterator;
+
+#include <iterator>
+
+#include <array>
+#include <deque>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+#include <filesystem>
+#endif
+#include <forward_list>
+#include <list>
+#include <map>
+#include <set>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+static_assert(std::__legacy_input_iterator<int*>);
+static_assert(std::__legacy_input_iterator<int const*>);
+static_assert(std::__legacy_input_iterator<int volatile*>);
+static_assert(std::__legacy_input_iterator<int const volatile*>);
+
+// <array>
+static_assert(std::__legacy_input_iterator<std::array<int, 10>::iterator>);
+static_assert(std::__legacy_input_iterator<std::array<int, 10>::const_iterator>);
+static_assert(std::__legacy_input_iterator<std::array<int, 10>::reverse_iterator>);
+static_assert(std::__legacy_input_iterator<std::array<int, 10>::const_reverse_iterator>);
+
+// <deque>
+static_assert(std::__legacy_input_iterator<std::deque<int>::iterator>);
+static_assert(std::__legacy_input_iterator<std::deque<int>::const_iterator>);
+static_assert(std::__legacy_input_iterator<std::deque<int>::reverse_iterator>);
+static_assert(std::__legacy_input_iterator<std::deque<int>::const_reverse_iterator>);
+
+// <filesystem>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+static_assert(std::__legacy_input_iterator<std::filesystem::directory_iterator>);
+static_assert(std::__legacy_input_iterator<std::filesystem::recursive_directory_iterator>);
+#endif
+
+// <forward_list>
+static_assert(std::__legacy_input_iterator<std::forward_list<int>::iterator>);
+static_assert(std::__legacy_input_iterator<std::forward_list<int>::const_iterator>);
+
+// <iterator>
+static_assert(!std::__legacy_input_iterator<std::back_insert_iterator<std::vector<int> > >);
+static_assert(!std::__legacy_input_iterator<std::front_insert_iterator<std::vector<int> > >);
+static_assert(!std::__legacy_input_iterator<std::insert_iterator<std::vector<int> > >);
+static_assert(std::__legacy_input_iterator<std::move_iterator<std::vector<int>::iterator> >);
+
+// <list>
+static_assert(std::__legacy_input_iterator<std::list<int>::iterator>);
+static_assert(std::__legacy_input_iterator<std::list<int>::const_iterator>);
+static_assert(std::__legacy_input_iterator<std::list<int>::reverse_iterator>);
+static_assert(std::__legacy_input_iterator<std::list<int>::const_reverse_iterator>);
+
+// <map>
+static_assert(std::__legacy_input_iterator<std::map<int, int>::iterator>);
+static_assert(std::__legacy_input_iterator<std::map<int, int>::const_iterator>);
+static_assert(std::__legacy_input_iterator<std::map<int, int>::reverse_iterator>);
+static_assert(std::__legacy_input_iterator<std::map<int, int>::const_reverse_iterator>);
+
+static_assert(std::__legacy_input_iterator<std::multimap<int, int>::iterator>);
+static_assert(std::__legacy_input_iterator<std::multimap<int, int>::const_iterator>);
+static_assert(std::__legacy_input_iterator<std::multimap<int, int>::reverse_iterator>);
+static_assert(std::__legacy_input_iterator<std::multimap<int, int>::const_reverse_iterator>);
+
+// <set>
+static_assert(std::__legacy_input_iterator<std::set<int>::iterator>);
+static_assert(std::__legacy_input_iterator<std::set<int>::const_iterator>);
+static_assert(std::__legacy_input_iterator<std::set<int>::reverse_iterator>);
+static_assert(std::__legacy_input_iterator<std::set<int>::const_reverse_iterator>);
+
+static_assert(std::__legacy_input_iterator<std::multiset<int>::iterator>);
+static_assert(std::__legacy_input_iterator<std::multiset<int>::const_iterator>);
+static_assert(std::__legacy_input_iterator<std::multiset<int>::reverse_iterator>);
+static_assert(std::__legacy_input_iterator<std::multiset<int>::const_reverse_iterator>);
+
+// <string>
+static_assert(std::__legacy_input_iterator<std::string::iterator>);
+static_assert(std::__legacy_input_iterator<std::string::const_iterator>);
+static_assert(std::__legacy_input_iterator<std::string::reverse_iterator>);
+static_assert(std::__legacy_input_iterator<std::string::const_reverse_iterator>);
+
+// <string_view>
+static_assert(std::__legacy_input_iterator<std::string_view::iterator>);
+static_assert(std::__legacy_input_iterator<std::string_view::const_iterator>);
+static_assert(std::__legacy_input_iterator<std::string_view::reverse_iterator>);
+static_assert(std::__legacy_input_iterator<std::string_view::const_reverse_iterator>);
+
+// <unordered_map>
+static_assert(std::__legacy_input_iterator<std::unordered_map<int, int>::iterator>);
+static_assert(std::__legacy_input_iterator<std::unordered_map<int, int>::const_iterator>);
+static_assert(std::__legacy_input_iterator<std::unordered_map<int, int>::local_iterator>);
+static_assert(std::__legacy_input_iterator<std::unordered_map<int, int>::const_local_iterator>);
+
+static_assert(std::__legacy_input_iterator<std::unordered_multimap<int, int>::iterator>);
+static_assert(std::__legacy_input_iterator<std::unordered_multimap<int, int>::const_iterator>);
+static_assert(std::__legacy_input_iterator<std::unordered_multimap<int, int>::local_iterator>);
+static_assert(std::__legacy_input_iterator<std::unordered_multimap<int, int>::const_local_iterator>);
+
+// <unordered_set>
+static_assert(std::__legacy_input_iterator<std::unordered_set<int>::iterator>);
+static_assert(std::__legacy_input_iterator<std::unordered_set<int>::const_iterator>);
+static_assert(std::__legacy_input_iterator<std::unordered_set<int>::local_iterator>);
+static_assert(std::__legacy_input_iterator<std::unordered_set<int>::const_local_iterator>);
+
+static_assert(std::__legacy_input_iterator<std::unordered_multiset<int>::iterator>);
+static_assert(std::__legacy_input_iterator<std::unordered_multiset<int>::const_iterator>);
+static_assert(std::__legacy_input_iterator<std::unordered_multiset<int>::local_iterator>);
+static_assert(std::__legacy_input_iterator<std::unordered_multiset<int>::const_local_iterator>);
+
+// <vector>
+static_assert(std::__legacy_input_iterator<std::vector<int>::iterator>);
+static_assert(std::__legacy_input_iterator<std::vector<int>::const_iterator>);
+static_assert(std::__legacy_input_iterator<std::vector<int>::reverse_iterator>);
+static_assert(std::__legacy_input_iterator<std::vector<int>::const_reverse_iterator>);
+
+// Not iterators
+static_assert(!std::__legacy_input_iterator<void>);
+static_assert(!std::__legacy_input_iterator<void*>);
+static_assert(!std::__legacy_input_iterator<int* const>);
+static_assert(!std::__legacy_input_iterator<std::vector<int>::iterator volatile>);
+static_assert(!std::__legacy_input_iterator<std::vector<int>::iterator&>);
+static_assert(!std::__legacy_input_iterator<std::vector<int>::iterator&&>);
+static_assert(!std::__legacy_input_iterator<int>);
+static_assert(!std::__legacy_input_iterator<int[]>);
+static_assert(!std::__legacy_input_iterator<int[10]>);
+static_assert(!std::__legacy_input_iterator<int()>);
+static_assert(!std::__legacy_input_iterator<int (*)()>);
+static_assert(!std::__legacy_input_iterator<int (&)()>);
+
+struct S {};
+static_assert(!std::__legacy_input_iterator<S>);
+static_assert(!std::__legacy_input_iterator<int S::*>);
+static_assert(!std::__legacy_input_iterator<int (S::*)()>);

libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_iterator.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<class I>
+// concept __legacy_iterator;
+
+#include <iterator>
+
+#include <array>
+#include <deque>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+#include <filesystem>
+#endif
+#include <forward_list>
+#include <list>
+#include <map>
+#include <set>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+static_assert(std::__legacy_iterator<int*>);
+static_assert(std::__legacy_iterator<int const*>);
+static_assert(std::__legacy_iterator<int volatile*>);
+static_assert(std::__legacy_iterator<int const volatile*>);
+
+// <array>
+static_assert(std::__legacy_iterator<std::array<int, 10>::iterator>);
+static_assert(std::__legacy_iterator<std::array<int, 10>::const_iterator>);
+static_assert(std::__legacy_iterator<std::array<int, 10>::reverse_iterator>);
+static_assert(std::__legacy_iterator<std::array<int, 10>::const_reverse_iterator>);
+
+// <deque>
+static_assert(std::__legacy_iterator<std::deque<int>::iterator>);
+static_assert(std::__legacy_iterator<std::deque<int>::const_iterator>);
+static_assert(std::__legacy_iterator<std::deque<int>::reverse_iterator>);
+static_assert(std::__legacy_iterator<std::deque<int>::const_reverse_iterator>);
+
+// <filesystem>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+static_assert(std::__legacy_iterator<std::filesystem::directory_iterator>);
+static_assert(std::__legacy_iterator<std::filesystem::recursive_directory_iterator>);
+#endif
+
+// <forward_list>
+static_assert(std::__legacy_iterator<std::forward_list<int>::iterator>);
+static_assert(std::__legacy_iterator<std::forward_list<int>::const_iterator>);
+
+// <iterator>
+static_assert(std::__legacy_iterator<std::back_insert_iterator<std::vector<int> > >);
+static_assert(std::__legacy_iterator<std::front_insert_iterator<std::vector<int> > >);
+static_assert(std::__legacy_iterator<std::insert_iterator<std::vector<int> > >);
+static_assert(std::__legacy_iterator<std::move_iterator<std::vector<int>::iterator> >);
+
+// <list>
+static_assert(std::__legacy_iterator<std::list<int>::iterator>);
+static_assert(std::__legacy_iterator<std::list<int>::const_iterator>);
+static_assert(std::__legacy_iterator<std::list<int>::reverse_iterator>);
+static_assert(std::__legacy_iterator<std::list<int>::const_reverse_iterator>);
+
+// <map>
+static_assert(std::__legacy_iterator<std::map<int, int>::iterator>);
+static_assert(std::__legacy_iterator<std::map<int, int>::const_iterator>);
+static_assert(std::__legacy_iterator<std::map<int, int>::reverse_iterator>);
+static_assert(std::__legacy_iterator<std::map<int, int>::const_reverse_iterator>);
+
+static_assert(std::__legacy_iterator<std::multimap<int, int>::iterator>);
+static_assert(std::__legacy_iterator<std::multimap<int, int>::const_iterator>);
+static_assert(std::__legacy_iterator<std::multimap<int, int>::reverse_iterator>);
+static_assert(std::__legacy_iterator<std::multimap<int, int>::const_reverse_iterator>);
+
+// <set>
+static_assert(std::__legacy_iterator<std::set<int>::iterator>);
+static_assert(std::__legacy_iterator<std::set<int>::const_iterator>);
+static_assert(std::__legacy_iterator<std::set<int>::reverse_iterator>);
+static_assert(std::__legacy_iterator<std::set<int>::const_reverse_iterator>);
+
+static_assert(std::__legacy_iterator<std::multiset<int>::iterator>);
+static_assert(std::__legacy_iterator<std::multiset<int>::const_iterator>);
+static_assert(std::__legacy_iterator<std::multiset<int>::reverse_iterator>);
+static_assert(std::__legacy_iterator<std::multiset<int>::const_reverse_iterator>);
+
+// <string>
+static_assert(std::__legacy_iterator<std::string::iterator>);
+static_assert(std::__legacy_iterator<std::string::const_iterator>);
+static_assert(std::__legacy_iterator<std::string::reverse_iterator>);
+static_assert(std::__legacy_iterator<std::string::const_reverse_iterator>);
+
+// <string_view>
+static_assert(std::__legacy_iterator<std::string_view::iterator>);
+static_assert(std::__legacy_iterator<std::string_view::const_iterator>);
+static_assert(std::__legacy_iterator<std::string_view::reverse_iterator>);
+static_assert(std::__legacy_iterator<std::string_view::const_reverse_iterator>);
+
+// <unordered_map>
+static_assert(std::__legacy_iterator<std::unordered_map<int, int>::iterator>);
+static_assert(std::__legacy_iterator<std::unordered_map<int, int>::const_iterator>);
+static_assert(std::__legacy_iterator<std::unordered_map<int, int>::local_iterator>);
+static_assert(std::__legacy_iterator<std::unordered_map<int, int>::const_local_iterator>);
+
+static_assert(std::__legacy_iterator<std::unordered_multimap<int, int>::iterator>);
+static_assert(std::__legacy_iterator<std::unordered_multimap<int, int>::const_iterator>);
+static_assert(std::__legacy_iterator<std::unordered_multimap<int, int>::local_iterator>);
+static_assert(std::__legacy_iterator<std::unordered_multimap<int, int>::const_local_iterator>);
+
+// <unordered_set>
+static_assert(std::__legacy_iterator<std::unordered_set<int>::iterator>);
+static_assert(std::__legacy_iterator<std::unordered_set<int>::const_iterator>);
+static_assert(std::__legacy_iterator<std::unordered_set<int>::local_iterator>);
+static_assert(std::__legacy_iterator<std::unordered_set<int>::const_local_iterator>);
+
+static_assert(std::__legacy_iterator<std::unordered_multiset<int>::iterator>);
+static_assert(std::__legacy_iterator<std::unordered_multiset<int>::const_iterator>);
+static_assert(std::__legacy_iterator<std::unordered_multiset<int>::local_iterator>);
+static_assert(std::__legacy_iterator<std::unordered_multiset<int>::const_local_iterator>);
+
+// <vector>
+static_assert(std::__legacy_iterator<std::vector<int>::iterator>);
+static_assert(std::__legacy_iterator<std::vector<int>::const_iterator>);
+static_assert(std::__legacy_iterator<std::vector<int>::reverse_iterator>);
+static_assert(std::__legacy_iterator<std::vector<int>::const_reverse_iterator>);
+
+// Not iterators
+static_assert(!std::__legacy_iterator<void>);
+static_assert(!std::__legacy_iterator<void*>);
+static_assert(!std::__legacy_iterator<int* const>);
+static_assert(!std::__legacy_iterator<std::vector<int>::iterator volatile>);
+static_assert(!std::__legacy_iterator<std::vector<int>::iterator&>);
+static_assert(!std::__legacy_iterator<std::vector<int>::iterator&&>);
+static_assert(!std::__legacy_iterator<int>);
+static_assert(!std::__legacy_iterator<int[]>);
+static_assert(!std::__legacy_iterator<int[10]>);
+static_assert(!std::__legacy_iterator<int()>);
+static_assert(!std::__legacy_iterator<int (*)()>);
+static_assert(!std::__legacy_iterator<int (&)()>);
+
+struct S {};
+static_assert(!std::__legacy_iterator<S>);
+static_assert(!std::__legacy_iterator<int S::*>);
+static_assert(!std::__legacy_iterator<int (S::*)()>);

libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_random_access_iterator.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<class I>
+// concept __legacy_random_access_iterator;
+
+#include <iterator>
+
+#include <array>
+#include <deque>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+#include <filesystem>
+#endif
+#include <forward_list>
+#include <list>
+#include <map>
+#include <set>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+static_assert(std::__legacy_random_access_iterator<int*>);
+static_assert(std::__legacy_random_access_iterator<int const*>);
+static_assert(std::__legacy_random_access_iterator<int volatile*>);
+static_assert(std::__legacy_random_access_iterator<int const volatile*>);
+
+// <array>
+static_assert(std::__legacy_random_access_iterator<std::array<int, 10>::iterator>);
+static_assert(std::__legacy_random_access_iterator<std::array<int, 10>::const_iterator>);
+static_assert(std::__legacy_random_access_iterator<std::array<int, 10>::reverse_iterator>);
+static_assert(std::__legacy_random_access_iterator<std::array<int, 10>::const_reverse_iterator>);
+
+// <deque>
+static_assert(std::__legacy_random_access_iterator<std::deque<int>::iterator>);
+static_assert(std::__legacy_random_access_iterator<std::deque<int>::const_iterator>);
+static_assert(std::__legacy_random_access_iterator<std::deque<int>::reverse_iterator>);
+static_assert(std::__legacy_random_access_iterator<std::deque<int>::const_reverse_iterator>);
+
+// <filesystem>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+static_assert(!std::__legacy_random_access_iterator<std::filesystem::directory_iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::filesystem::recursive_directory_iterator>);
+#endif
+
+// <forward_list>
+static_assert(!std::__legacy_random_access_iterator<std::forward_list<int>::iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::forward_list<int>::const_iterator>);
+
+// <iterator>
+static_assert(!std::__legacy_random_access_iterator<std::back_insert_iterator<std::vector<int> > >);
+static_assert(!std::__legacy_random_access_iterator<std::front_insert_iterator<std::vector<int> > >);
+static_assert(!std::__legacy_random_access_iterator<std::insert_iterator<std::vector<int> > >);
+static_assert(!std::__legacy_random_access_iterator<std::move_iterator<std::vector<int>::iterator> >);
+
+// <list>
+static_assert(!std::__legacy_random_access_iterator<std::list<int>::iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::list<int>::const_iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::list<int>::reverse_iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::list<int>::const_reverse_iterator>);
+
+// <map>
+static_assert(!std::__legacy_random_access_iterator<std::map<int, int>::iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::map<int, int>::const_iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::map<int, int>::reverse_iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::map<int, int>::const_reverse_iterator>);
+
+static_assert(!std::__legacy_random_access_iterator<std::multimap<int, int>::iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::multimap<int, int>::const_iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::multimap<int, int>::reverse_iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::multimap<int, int>::const_reverse_iterator>);
+
+// <set>
+static_assert(!std::__legacy_random_access_iterator<std::set<int>::iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::set<int>::const_iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::set<int>::reverse_iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::set<int>::const_reverse_iterator>);
+
+static_assert(!std::__legacy_random_access_iterator<std::multiset<int>::iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::multiset<int>::const_iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::multiset<int>::reverse_iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::multiset<int>::const_reverse_iterator>);
+
+// <string>
+static_assert(std::__legacy_random_access_iterator<std::string::iterator>);
+static_assert(std::__legacy_random_access_iterator<std::string::const_iterator>);
+static_assert(std::__legacy_random_access_iterator<std::string::reverse_iterator>);
+static_assert(std::__legacy_random_access_iterator<std::string::const_reverse_iterator>);
+
+// <string_view>
+static_assert(std::__legacy_random_access_iterator<std::string_view::iterator>);
+static_assert(std::__legacy_random_access_iterator<std::string_view::const_iterator>);
+static_assert(std::__legacy_random_access_iterator<std::string_view::reverse_iterator>);
+static_assert(std::__legacy_random_access_iterator<std::string_view::const_reverse_iterator>);
+
+// <unordered_map>
+static_assert(!std::__legacy_random_access_iterator<std::unordered_map<int, int>::iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::unordered_map<int, int>::const_iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::unordered_map<int, int>::local_iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::unordered_map<int, int>::const_local_iterator>);
+
+static_assert(!std::__legacy_random_access_iterator<std::unordered_multimap<int, int>::iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::unordered_multimap<int, int>::const_iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::unordered_multimap<int, int>::local_iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::unordered_multimap<int, int>::const_local_iterator>);
+
+// <unordered_set>
+static_assert(!std::__legacy_random_access_iterator<std::unordered_set<int>::iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::unordered_set<int>::const_iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::unordered_set<int>::local_iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::unordered_set<int>::const_local_iterator>);
+
+static_assert(!std::__legacy_random_access_iterator<std::unordered_multiset<int>::iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::unordered_multiset<int>::const_iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::unordered_multiset<int>::local_iterator>);
+static_assert(!std::__legacy_random_access_iterator<std::unordered_multiset<int>::const_local_iterator>);
+
+// <vector>
+static_assert(std::__legacy_random_access_iterator<std::vector<int>::iterator>);
+static_assert(std::__legacy_random_access_iterator<std::vector<int>::const_iterator>);
+static_assert(std::__legacy_random_access_iterator<std::vector<int>::reverse_iterator>);
+static_assert(std::__legacy_random_access_iterator<std::vector<int>::const_reverse_iterator>);
+
+// Not iterators
+static_assert(!std::__legacy_random_access_iterator<void>);
+static_assert(!std::__legacy_random_access_iterator<void*>);
+static_assert(!std::__legacy_random_access_iterator<int* const>);
+static_assert(!std::__legacy_random_access_iterator<std::vector<int>::iterator volatile>);
+static_assert(!std::__legacy_random_access_iterator<std::vector<int>::iterator&>);
+static_assert(!std::__legacy_random_access_iterator<std::vector<int>::iterator&&>);
+static_assert(!std::__legacy_random_access_iterator<int>);
+static_assert(!std::__legacy_random_access_iterator<int[]>);
+static_assert(!std::__legacy_random_access_iterator<int[10]>);
+static_assert(!std::__legacy_random_access_iterator<int()>);
+static_assert(!std::__legacy_random_access_iterator<int (*)()>);
+static_assert(!std::__legacy_random_access_iterator<int (&)()>);
+
+struct S {};
+static_assert(!std::__legacy_random_access_iterator<S>);
+static_assert(!std::__legacy_random_access_iterator<int S::*>);
+static_assert(!std::__legacy_random_access_iterator<int (S::*)()>);

libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/locale_dependent.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// REQUIRES: locale.en_US.UTF-8
+
+#include <iterator>
+
+#include <istream>
+#include <ostream>
+
+static_assert(std::__legacy_iterator<std::istream_iterator<int, std::istream> >);
+static_assert(std::__legacy_iterator<std::istreambuf_iterator<int, std::istream> >);
+static_assert(std::__legacy_iterator<std::ostream_iterator<int, std::ostream> >);
+static_assert(std::__legacy_iterator<std::ostreambuf_iterator<int, std::ostream> >);
+
+static_assert(std::__legacy_input_iterator<std::istream_iterator<int, std::istream> >);
+static_assert(std::__legacy_input_iterator<std::istreambuf_iterator<int, std::istream> >);
+static_assert(!std::__legacy_input_iterator<std::ostream_iterator<int, std::ostream> >);
+static_assert(!std::__legacy_input_iterator<std::ostreambuf_iterator<int, std::ostream> >);
+
+// This is because the legacy iterator concepts don't care about iterator_category
+static_assert(std::__legacy_forward_iterator<std::istream_iterator<int, std::istream> >);
+
+static_assert(!std::__legacy_forward_iterator<std::istreambuf_iterator<int, std::istream> >);
+static_assert(!std::__legacy_forward_iterator<std::ostream_iterator<int, std::ostream> >);
+static_assert(!std::__legacy_forward_iterator<std::ostreambuf_iterator<int, std::ostream> >);
+
+static_assert(!std::__legacy_bidirectional_iterator<std::istream_iterator<int, std::istream> >);
+static_assert(!std::__legacy_bidirectional_iterator<std::istreambuf_iterator<int, std::istream> >);
+static_assert(!std::__legacy_bidirectional_iterator<std::ostream_iterator<int, std::ostream> >);
+static_assert(!std::__legacy_bidirectional_iterator<std::ostreambuf_iterator<int, std::ostream> >);
+
+static_assert(!std::__legacy_random_access_iterator<std::istream_iterator<int, std::istream> >);
+static_assert(!std::__legacy_random_access_iterator<std::istreambuf_iterator<int, std::istream> >);
+static_assert(!std::__legacy_random_access_iterator<std::ostream_iterator<int, std::ostream> >);
+static_assert(!std::__legacy_random_access_iterator<std::ostreambuf_iterator<int, std::ostream> >);

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class T>
+// using iter_reference_t = decltype(*declval<T&>());
+
+#include <iterator>
+
+#include <concepts>
+
+#include "test_iterators.h"
+
+static_assert(std::same_as<std::iter_reference_t<input_iterator<int*> >, int&>);
+static_assert(std::same_as<std::iter_reference_t<forward_iterator<int*> >, int&>);
+static_assert(std::same_as<std::iter_reference_t<bidirectional_iterator<int*> >, int&>);
+static_assert(std::same_as<std::iter_reference_t<random_access_iterator<int*> >, int&>);