diff --git a/libcxx/include/iterator b/libcxx/include/iterator
--- a/libcxx/include/iterator
+++ b/libcxx/include/iterator
@@ -519,6 +519,22 @@
   : __cond_value_type<typename _Tp::value_type> {};
 
 // TODO(cjdb): add iter_value_t once iterator_traits is cleaned up.
+
+template<class _Tp>
+using __with_reference = _Tp&;
+
+template<class _Tp>
+concept __can_reference = requires {
+  typename __with_reference<_Tp>;
+};
+
+template<class _Tp>
+concept __dereferenceable = requires(_Tp& __t) {
+  { *__t } -> __can_reference; // not required to be equality-preserving
+};
+
+template<__dereferenceable _Tp>
+using iter_reference_t = decltype(*declval<_Tp&>());
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
 template <class _Iter>
@@ -629,6 +645,71 @@
     typedef typename _Iter::iterator_category iterator_category;
 };
 
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+// 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 =
+  copyable<_Ip> &&
+  requires(_Ip __i) {
+    {   *__i } -> __can_reference;
+    {  ++__i } -> same_as<_Ip&>;
+    { *__i++ } -> __can_reference;
+  };
+
+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, _Ip __j, 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 -  __j } -> same_as<decltype(__n)>;
+    {  __i[__n]  } -> convertible_to<iter_reference_t<_Ip>>;
+  };
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
 template <class _Iter, bool> struct __iterator_traits {};
 
 template <class _Iter>
diff --git a/libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_bidirectional_iterator.pass.cpp b/libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_bidirectional_iterator.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_bidirectional_iterator.pass.cpp
@@ -0,0 +1,205 @@
+//===----------------------------------------------------------------------===//
+//
+// 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>
+#include <filesystem>
+#include <forward_list>
+#include <istream>
+#include <list>
+#include <map>
+#include <ostream>
+#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>
+static_assert(
+    !std::__legacy_bidirectional_iterator<std::filesystem::directory_iterator>);
+static_assert(!std::__legacy_bidirectional_iterator<
+              std::filesystem::recursive_directory_iterator>);
+
+// <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::istream_iterator<int, std::istream> >);
+static_assert(!std::__legacy_bidirectional_iterator<
+              std::istreambuf_iterator<int, std::istream> >);
+static_assert(!std::__legacy_bidirectional_iterator<
+              std::move_iterator<std::vector<int>::iterator> >);
+static_assert(!std::__legacy_bidirectional_iterator<
+              std::ostream_iterator<int, std::ostream> >);
+static_assert(!std::__legacy_bidirectional_iterator<
+              std::ostreambuf_iterator<int, std::ostream> >);
+
+// <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, int>::iterator>);
+static_assert(
+    std::__legacy_bidirectional_iterator<std::set<int, int>::const_iterator>);
+static_assert(
+    std::__legacy_bidirectional_iterator<std::set<int, int>::reverse_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<
+              std::set<int, int>::const_reverse_iterator>);
+
+static_assert(
+    std::__legacy_bidirectional_iterator<std::multiset<int, int>::iterator>);
+static_assert(std::__legacy_bidirectional_iterator<
+              std::multiset<int, int>::const_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<
+              std::multiset<int, int>::reverse_iterator>);
+static_assert(std::__legacy_bidirectional_iterator<
+              std::multiset<int, 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_multimap<int, int>::iterator>);
+static_assert(!std::__legacy_bidirectional_iterator<
+              std::unordered_multimap<int, int>::const_iterator>);
+
+// <unordered_set>
+static_assert(!std::__legacy_bidirectional_iterator<
+              std::unordered_set<int, int>::iterator>);
+static_assert(!std::__legacy_bidirectional_iterator<
+              std::unordered_set<int, int>::const_iterator>);
+
+static_assert(!std::__legacy_bidirectional_iterator<
+              std::unordered_multiset<int, int>::iterator>);
+static_assert(!std::__legacy_bidirectional_iterator<
+              std::unordered_multiset<int, int>::const_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::*)()>);
+
+int main(int, char**) { return 0; }
diff --git a/libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_forward_iterator.pass.cpp b/libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_forward_iterator.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_forward_iterator.pass.cpp
@@ -0,0 +1,195 @@
+//===----------------------------------------------------------------------===//
+//
+// 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>
+#include <filesystem>
+#include <forward_list>
+#include <istream>
+#include <list>
+#include <map>
+#include <ostream>
+#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>
+static_assert(
+    !std::__legacy_forward_iterator<std::filesystem::directory_iterator>);
+static_assert(!std::__legacy_forward_iterator<
+              std::filesystem::recursive_directory_iterator>);
+
+// <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> > >);
+
+// 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::move_iterator<std::vector<int>::iterator> >);
+static_assert(
+    !std::__legacy_forward_iterator<std::ostream_iterator<int, std::ostream> >);
+static_assert(!std::__legacy_forward_iterator<
+              std::ostreambuf_iterator<int, std::ostream> >);
+
+// <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, int>::iterator>);
+static_assert(
+    std::__legacy_forward_iterator<std::set<int, int>::const_iterator>);
+static_assert(
+    std::__legacy_forward_iterator<std::set<int, int>::reverse_iterator>);
+static_assert(
+    std::__legacy_forward_iterator<std::set<int, int>::const_reverse_iterator>);
+
+static_assert(
+    std::__legacy_forward_iterator<std::multiset<int, int>::iterator>);
+static_assert(
+    std::__legacy_forward_iterator<std::multiset<int, int>::const_iterator>);
+static_assert(
+    std::__legacy_forward_iterator<std::multiset<int, int>::reverse_iterator>);
+static_assert(std::__legacy_forward_iterator<
+              std::multiset<int, 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_multimap<int, int>::iterator>);
+static_assert(std::__legacy_forward_iterator<
+              std::unordered_multimap<int, int>::const_iterator>);
+
+// <unordered_set>
+static_assert(
+    std::__legacy_forward_iterator<std::unordered_set<int, int>::iterator>);
+static_assert(std::__legacy_forward_iterator<
+              std::unordered_set<int, int>::const_iterator>);
+
+static_assert(std::__legacy_forward_iterator<
+              std::unordered_multiset<int, int>::iterator>);
+static_assert(std::__legacy_forward_iterator<
+              std::unordered_multiset<int, int>::const_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::*)()>);
+
+int main(int, char**) { return 0; }
diff --git a/libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_input_iterator.pass.cpp b/libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_input_iterator.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_input_iterator.pass.cpp
@@ -0,0 +1,185 @@
+//===----------------------------------------------------------------------===//
+//
+// 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>
+#include <filesystem>
+#include <forward_list>
+#include <istream>
+#include <list>
+#include <map>
+#include <ostream>
+#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>
+static_assert(
+    std::__legacy_input_iterator<std::filesystem::directory_iterator>);
+static_assert(std::__legacy_input_iterator<
+              std::filesystem::recursive_directory_iterator>);
+
+// <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::istream_iterator<int, std::istream> >);
+static_assert(
+    std::__legacy_input_iterator<std::istreambuf_iterator<int, std::istream> >);
+static_assert(std::__legacy_input_iterator<
+              std::move_iterator<std::vector<int>::iterator> >);
+static_assert(
+    !std::__legacy_input_iterator<std::ostream_iterator<int, std::ostream> >);
+static_assert(!std::__legacy_input_iterator<
+              std::ostreambuf_iterator<int, std::ostream> >);
+
+// <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, int>::iterator>);
+static_assert(std::__legacy_input_iterator<std::set<int, int>::const_iterator>);
+static_assert(
+    std::__legacy_input_iterator<std::set<int, int>::reverse_iterator>);
+static_assert(
+    std::__legacy_input_iterator<std::set<int, int>::const_reverse_iterator>);
+
+static_assert(std::__legacy_input_iterator<std::multiset<int, int>::iterator>);
+static_assert(
+    std::__legacy_input_iterator<std::multiset<int, int>::const_iterator>);
+static_assert(
+    std::__legacy_input_iterator<std::multiset<int, int>::reverse_iterator>);
+static_assert(std::__legacy_input_iterator<
+              std::multiset<int, 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_multimap<int, int>::iterator>);
+static_assert(std::__legacy_input_iterator<
+              std::unordered_multimap<int, int>::const_iterator>);
+
+// <unordered_set>
+static_assert(
+    std::__legacy_input_iterator<std::unordered_set<int, int>::iterator>);
+static_assert(
+    std::__legacy_input_iterator<std::unordered_set<int, int>::const_iterator>);
+
+static_assert(
+    std::__legacy_input_iterator<std::unordered_multiset<int, int>::iterator>);
+static_assert(std::__legacy_input_iterator<
+              std::unordered_multiset<int, int>::const_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::*)()>);
+
+int main(int, char**) { return 0; }
diff --git a/libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_iterator.pass.cpp b/libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_iterator.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_iterator.pass.cpp
@@ -0,0 +1,168 @@
+//===----------------------------------------------------------------------===//
+//
+// 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>
+#include <filesystem>
+#include <forward_list>
+#include <istream>
+#include <list>
+#include <map>
+#include <ostream>
+#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>
+static_assert(std::__legacy_iterator<std::filesystem::directory_iterator>);
+static_assert(
+    std::__legacy_iterator<std::filesystem::recursive_directory_iterator>);
+
+// <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::istream_iterator<int, std::istream> >);
+static_assert(
+    std::__legacy_iterator<std::istreambuf_iterator<int, std::istream> >);
+static_assert(
+    std::__legacy_iterator<std::move_iterator<std::vector<int>::iterator> >);
+static_assert(
+    std::__legacy_iterator<std::ostream_iterator<int, std::ostream> >);
+static_assert(
+    std::__legacy_iterator<std::ostreambuf_iterator<int, std::ostream> >);
+
+// <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, int>::iterator>);
+static_assert(std::__legacy_iterator<std::set<int, int>::const_iterator>);
+static_assert(std::__legacy_iterator<std::set<int, int>::reverse_iterator>);
+static_assert(
+    std::__legacy_iterator<std::set<int, int>::const_reverse_iterator>);
+
+static_assert(std::__legacy_iterator<std::multiset<int, int>::iterator>);
+static_assert(std::__legacy_iterator<std::multiset<int, int>::const_iterator>);
+static_assert(
+    std::__legacy_iterator<std::multiset<int, int>::reverse_iterator>);
+static_assert(
+    std::__legacy_iterator<std::multiset<int, 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_multimap<int, int>::iterator>);
+static_assert(
+    std::__legacy_iterator<std::unordered_multimap<int, int>::const_iterator>);
+
+// <unordered_set>
+static_assert(std::__legacy_iterator<std::unordered_set<int, int>::iterator>);
+static_assert(
+    std::__legacy_iterator<std::unordered_set<int, int>::const_iterator>);
+
+static_assert(
+    std::__legacy_iterator<std::unordered_multiset<int, int>::iterator>);
+static_assert(
+    std::__legacy_iterator<std::unordered_multiset<int, int>::const_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::*)()>);
+
+int main(int, char**) { return 0; }
diff --git a/libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_random_access_iterator.pass.cpp b/libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_random_access_iterator.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_random_access_iterator.pass.cpp
@@ -0,0 +1,205 @@
+//===----------------------------------------------------------------------===//
+//
+// 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>
+#include <filesystem>
+#include <forward_list>
+#include <istream>
+#include <list>
+#include <map>
+#include <ostream>
+#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>
+static_assert(
+    !std::__legacy_random_access_iterator<std::filesystem::directory_iterator>);
+static_assert(!std::__legacy_random_access_iterator<
+              std::filesystem::recursive_directory_iterator>);
+
+// <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::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::move_iterator<std::vector<int>::iterator> >);
+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> >);
+
+// <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, int>::iterator>);
+static_assert(
+    !std::__legacy_random_access_iterator<std::set<int, int>::const_iterator>);
+static_assert(!std::__legacy_random_access_iterator<
+              std::set<int, int>::reverse_iterator>);
+static_assert(!std::__legacy_random_access_iterator<
+              std::set<int, int>::const_reverse_iterator>);
+
+static_assert(
+    !std::__legacy_random_access_iterator<std::multiset<int, int>::iterator>);
+static_assert(!std::__legacy_random_access_iterator<
+              std::multiset<int, int>::const_iterator>);
+static_assert(!std::__legacy_random_access_iterator<
+              std::multiset<int, int>::reverse_iterator>);
+static_assert(!std::__legacy_random_access_iterator<
+              std::multiset<int, 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_multimap<int, int>::iterator>);
+static_assert(!std::__legacy_random_access_iterator<
+              std::unordered_multimap<int, int>::const_iterator>);
+
+// <unordered_set>
+static_assert(!std::__legacy_random_access_iterator<
+              std::unordered_set<int, int>::iterator>);
+static_assert(!std::__legacy_random_access_iterator<
+              std::unordered_set<int, int>::const_iterator>);
+
+static_assert(!std::__legacy_random_access_iterator<
+              std::unordered_multiset<int, int>::iterator>);
+static_assert(!std::__legacy_random_access_iterator<
+              std::unordered_multiset<int, int>::const_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::*)()>);
+
+int main(int, char**) { return 0; }