diff --git a/libcxx/include/iterator b/libcxx/include/iterator
--- a/libcxx/include/iterator
+++ b/libcxx/include/iterator
@@ -21,24 +21,11 @@
 template<class> struct indirectly_readable_traits; // since C++20
 
 template<class Iterator>
-struct iterator_traits
-{
-    typedef typename Iterator::difference_type difference_type;
-    typedef typename Iterator::value_type value_type;
-    typedef typename Iterator::pointer pointer;
-    typedef typename Iterator::reference reference;
-    typedef typename Iterator::iterator_category iterator_category;
-};
+struct iterator_traits;
 
 template<class T>
-struct iterator_traits<T*>
-{
-    typedef ptrdiff_t difference_type;
-    typedef T value_type;
-    typedef T* pointer;
-    typedef T& reference;
-    typedef random_access_iterator_tag iterator_category;
-};
+  requires is_object_v<T>                    // since C++20
+struct iterator_traits<T*>;
 
 template<dereferenceable T>
   using iter_reference_t = decltype(*declval<T&>());
@@ -637,18 +624,6 @@
     static const bool value = sizeof(__test<_Tp>(nullptr)) == 1;
 };
 
-template <class _Iter, bool> struct __iterator_traits_impl {};
-
-template <class _Iter>
-struct __iterator_traits_impl<_Iter, true>
-{
-    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` exposition-only concepts are easily confused with the Cpp17*Iterator tables,
@@ -712,10 +687,193 @@
     {  __i[__n]  } -> convertible_to<iter_reference_t<_Ip>>;
   };
 } // namespace __iterator_traits_detail
-#endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
+template<class> struct __iterator_traits;
+
+template<class _Ip>
+struct iterator_traits : __iterator_traits<_Ip> {
+  using __primary_template = iterator_traits;
+};
+
+template<class> struct __iterator_traits_member_pointer;
+template<class> struct __iterator_traits_member_reference;
+template<class> struct __iterator_traits_iterator_category;
+
+template<class _Ip>
+concept __has_member_reference = requires { typename _Ip::reference; };
+
+template<class _Ip>
+concept __has_member_iterator_category = requires { typename _Ip::iterator_category; };
+
+template<class _Ip>
+concept __specifies_members =
+  __has_member_reference<_Ip> &&
+  __has_member_iterator_category<_Ip> &&
+  requires {
+    typename _Ip::difference_type;
+    typename _Ip::value_type;
+  };
+
+// [iterator.traits]/3.1
+// If `I` has valid ([temp.deduct]) member types `difference_­type`, `value_­type`, `reference`, and
+// `iterator_­category`, then `iterator_­traits<I>` has the following publicly accessible members:
+template<__specifies_members _Ip>
+struct __iterator_traits<_Ip> {
+  using iterator_category  = typename _Ip::iterator_category;
+  using value_type         = typename _Ip::value_type;
+  using difference_type    = typename _Ip::difference_type;
+  using pointer            = typename __iterator_traits_member_pointer<_Ip>::type;
+  using reference          = typename _Ip::reference;
+};
+
+namespace __iterator_traits_detail {
+template<class _Tp>
+concept __cpp17_iterator_missing_members =
+  !__specifies_members<_Tp> &&
+  __cpp17_iterator<_Tp>;
+
+template<class _Tp>
+concept __cpp17_input_iterator_missing_members =
+  __cpp17_iterator_missing_members<_Tp> &&
+  __cpp17_input_iterator<_Tp>;
+} // namespace __iterator_traits_detail
+
+// [iterator.traits]/3.2
+// Otherwise, if `I` satisfies the exposition-only concept `cpp17-input-iterator`,
+// `iterator_­traits<I>` has the following publicly accessible members:
+template<__iterator_traits_detail::__cpp17_input_iterator_missing_members _Ip>
+struct __iterator_traits<_Ip> {
+  using iterator_category = typename __iterator_traits_iterator_category<_Ip>::type;
+  using value_type        = typename indirectly_readable_traits<_Ip>::value_type;
+  using difference_type   = typename incrementable_traits<_Ip>::difference_type;
+  using pointer           = typename __iterator_traits_member_pointer<_Ip>::type;
+  using reference         = typename __iterator_traits_member_reference<_Ip>::type;
+};
+
+// [iterator.traits]/3.2.1
+// If the qualified-id `I::pointer` is valid and denotes a type, `pointer` names that type.
+template<class _Ip>
+concept __has_member_pointer = requires { typename _Ip::pointer; };
+
+template<__has_member_pointer _Ip>
+struct __iterator_traits_member_pointer<_Ip> { using type = typename _Ip::pointer; };
+
+// Otherwise, if `decltype(declval<I&>().operator->())` is well-formed, then `pointer` names that
+// type.
+template<class _Ip>
+concept __has_arrow =
+  !__has_member_pointer<_Ip> &&
+  requires(_Ip& __i) {
+    __i.operator->();
+  };
+
+template<__has_arrow _Ip>
+struct __iterator_traits_member_pointer<_Ip> {
+  using type = decltype(declval<_Ip&>().operator->());
+};
+
+// Otherwise, `pointer` names `void`.
+template<class>
+struct __iterator_traits_member_pointer { using type = void; };
+
+// [iterator.traits]/3.2.2
+// If the qualified-id `I::reference` is valid and denotes a type, `reference` names that type.
+template<__has_member_reference _Ip>
+struct __iterator_traits_member_reference<_Ip> { using type = typename _Ip::reference; };
+
+// Otherwise, `reference` names `iter_­reference_­t<I>`.
+template<class _Ip>
+struct __iterator_traits_member_reference { using type = iter_reference_t<_Ip>; };
+
+// [iterator.traits]/3.2.3
+// If the qualified-id `I::iterator_­category` is valid and denotes a type, `iterator_­category` names
+// that type.
+template<__has_member_iterator_category _Ip>
+struct __iterator_traits_iterator_category<_Ip> {
+  using type = typename _Ip::iterator_category;
+};
+
+// Otherwise, iterator_­category names:
+template<class>
+struct __deduce_iterator_category;
+
+template<class _Ip>
+struct __iterator_traits_iterator_category : __deduce_iterator_category<_Ip> {};
+
+// [iterator.traits]/3.2.3.1
+// `random_­access_­iterator_­tag` if `I` satisfies `cpp17-random-access-iterator`, or otherwise
+template<__iterator_traits_detail::__cpp17_random_access_iterator _Ip>
+struct __deduce_iterator_category<_Ip> {
+  using type = random_access_iterator_tag;
+};
+
+// [iterator.traits]/3.2.3.2
+// `bidirectional_­iterator_­tag` if `I` satisfies `cpp17-bidirectional-iterator`, or otherwise
+template<__iterator_traits_detail::__cpp17_bidirectional_iterator _Ip>
+struct __deduce_iterator_category<_Ip> {
+  using type = bidirectional_iterator_tag;
+};
+
+// [iterator.traits]/3.2.3.3
+// `forward_­iterator_­tag` if `I` satisfies `cpp17-forward-iterator`, or otherwise
+template<__iterator_traits_detail::__cpp17_forward_iterator _Ip>
+struct __deduce_iterator_category<_Ip> {
+  using type = forward_iterator_tag;
+};
+
+// [iterator.traits]/3.2.3.4
+// input_­iterator_­tag
+template<class _Ip>
+struct __deduce_iterator_category {
+  using type = input_iterator_tag;
+};
+
+
+// [iterator.traits]/3.3
+template<class> struct __iterator_traits_difference_type;
+
+// Otherwise, if `I` satisfies the exposition-only concept `cpp17-iterator`, then
+// `iterator_­traits<I>` has the following publicly accessible members:
+template<__iterator_traits_detail::__cpp17_iterator_missing_members _Ip>
+struct __iterator_traits<_Ip> {
+  using iterator_category = output_iterator_tag;
+  using value_type        = void;
+  using difference_type   = typename __iterator_traits_difference_type<_Ip>::type;
+  using pointer           = void;
+  using reference         = void;
+};
+
+// If the qualified-id `incrementable_­traits<I>::difference_­type` is valid and denotes a type, then
+// `difference_­type` names that type;
+template<class _Ip>
+requires requires { typename incrementable_traits<_Ip>::difference_type; }
+struct __iterator_traits_difference_type<_Ip> {
+  using type = typename incrementable_traits<_Ip>::difference_type;
+};
+
+// otherwise, it names void.
+template<class>
+struct __iterator_traits_difference_type { using type = void; };
+
+// [iterator.traits]/3.4
+// Otherwise, `iterator_­traits<I>` has no members by any of the above names.
+template<class>
+struct __iterator_traits {};
+#else
 template <class _Iter, bool> struct __iterator_traits {};
 
+template <class _Iter, bool> struct __iterator_traits_impl {};
+
+template <class _Iter>
+struct __iterator_traits_impl<_Iter, true>
+{
+    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;
+};
+
 template <class _Iter>
 struct __iterator_traits<_Iter, true>
     :  __iterator_traits_impl
@@ -737,8 +895,12 @@
 
   using __primary_template = iterator_traits;
 };
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 template<class _Tp>
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+requires is_object_v<_Tp>
+#endif
 struct _LIBCPP_TEMPLATE_VIS iterator_traits<_Tp*>
 {
     typedef ptrdiff_t difference_type;
diff --git a/libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp b/libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp
@@ -0,0 +1,258 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 T>
+// struct iterator_traits;
+
+#include <iterator>
+
+#include <concepts>
+#include <vector>
+
+#include "legacy_iterator_wrappers.h"
+
+template <class Category, class Value, class Difference, class Reference>
+struct explicit_members {
+  using iterator_category = Category;
+  using value_type = Value;
+  using difference_type = Difference;
+  using reference = Reference;
+};
+
+template <class Category, class Value, class Difference, class Reference>
+struct explicit_members_with_pointer : explicit_members<Category, Value, Difference, Reference> {
+  using pointer = typename explicit_members<Category, Value, Difference, Reference>::value_type*;
+};
+
+template <class Category, class Value, class Difference, class Reference>
+[[nodiscard]] constexpr bool check_members_explicitly_provided() {
+  {
+    using fake_iterator = explicit_members<Category, Value, Difference, Reference>;
+    using iterator_traits = std::iterator_traits<fake_iterator>;
+    static_assert(std::same_as<typename iterator_traits::iterator_category, Category>);
+    static_assert(std::same_as<typename iterator_traits::value_type, Value>);
+    static_assert(std::same_as<typename iterator_traits::difference_type, Difference>);
+    static_assert(std::same_as<typename iterator_traits::reference, Reference>);
+    static_assert(std::same_as<typename iterator_traits::pointer, void>);
+  }
+
+  {
+    using fake_iterator = explicit_members_with_pointer<Category, Value, Difference, Reference>;
+    using iterator_traits = std::iterator_traits<fake_iterator>;
+    static_assert(std::same_as<typename iterator_traits::iterator_category, Category>);
+    static_assert(std::same_as<typename iterator_traits::value_type, Value>);
+    static_assert(std::same_as<typename iterator_traits::difference_type, Difference>);
+    static_assert(std::same_as<typename iterator_traits::reference, Reference>);
+    static_assert(std::same_as<typename iterator_traits::pointer, Value*>);
+  }
+  return true;
+}
+
+static_assert(check_members_explicitly_provided<std::input_iterator_tag, int, int, int&>());
+static_assert(check_members_explicitly_provided<std::input_iterator_tag, int, long, int&>());
+static_assert(check_members_explicitly_provided<std::forward_iterator_tag, int, double, int&>());
+
+struct S {};
+static_assert(check_members_explicitly_provided<std::bidirectional_iterator_tag, S, int, long long>());
+static_assert(check_members_explicitly_provided<std::random_access_iterator_tag, S, int, long long>());
+
+template <class I, class Wrapper>
+struct get_reference {
+  using type = std::iter_reference_t<Wrapper>;
+};
+
+template <class I, std::derived_from<reference_extension<I> > Wrapper>
+struct get_reference<I, Wrapper> {
+  using type = typename Wrapper::reference;
+};
+
+template <class, class>
+struct get_pointer {
+  using type = void;
+};
+
+template <class I, std::derived_from<pointer_extension<I> > Wrapper>
+struct get_pointer<I, Wrapper> {
+  using type = typename Wrapper::pointer;
+};
+
+template <class I, has_arrow Wrapper>
+struct get_pointer<I, Wrapper> {
+  using type = decltype(std::declval<I&>().operator->());
+};
+
+template <class I, class Wrapper, class Category>
+[[nodiscard]] constexpr bool check_wrapper_traits() {
+  using Traits = std::iterator_traits<Wrapper>;
+  static_assert(std::same_as<typename Traits::iterator_category, Category>);
+  static_assert(std::same_as<typename Traits::value_type, typename std::indirectly_readable_traits<I>::value_type>);
+  static_assert(std::same_as<typename Traits::difference_type, typename std::incrementable_traits<I>::difference_type>);
+  static_assert(std::same_as<typename Traits::reference, typename get_reference<I, Wrapper>::type>);
+  static_assert(std::same_as<typename Traits::pointer, typename get_pointer<I, Wrapper>::type>);
+  return true;
+}
+
+template <class I, template <typename> class... Args>
+requires(sizeof...(Args) > 0) constexpr void check_with_legacy_input_iterator() {
+  {
+    using iterator = legacy_input_iterator<I, Args...>;
+    static_assert(check_wrapper_traits<I, iterator, std::input_iterator_tag>());
+  }
+  {
+    using iterator = legacy_forward_iterator<I, Args...>;
+    static_assert(check_wrapper_traits<I, iterator, std::forward_iterator_tag>());
+  }
+  {
+    using iterator = legacy_bidirectional_iterator<I, Args...>;
+    static_assert(check_wrapper_traits<I, iterator, std::bidirectional_iterator_tag>());
+  }
+  {
+    using iterator = legacy_random_access_iterator<I, Args...>;
+    static_assert(check_wrapper_traits<I, iterator, std::random_access_iterator_tag>());
+  }
+}
+
+template <class I>
+[[nodiscard]] constexpr bool check_with_legacy_input_iterator() {
+  check_with_legacy_input_iterator<I, empty_extension>();
+  check_with_legacy_input_iterator<I, reference_extension>();
+  check_with_legacy_input_iterator<I, pointer_extension>();
+  check_with_legacy_input_iterator<I, arrow_extension>();
+  check_with_legacy_input_iterator<I, reference_extension, pointer_extension>();
+  check_with_legacy_input_iterator<I, reference_extension, arrow_extension>();
+  return true;
+}
+static_assert(check_with_legacy_input_iterator<std::vector<int>::iterator>());
+static_assert(check_with_legacy_input_iterator<std::vector<int>::const_iterator>());
+
+template <class I>
+[[nodiscard]] constexpr bool check_with_legacy_iterator() {
+  {
+    using iterator = legacy_iterator<I>;
+    using iterator_traits = std::iterator_traits<iterator>;
+    static_assert(std::same_as<typename iterator_traits::iterator_category, std::output_iterator_tag>);
+    static_assert(std::same_as<typename iterator_traits::value_type, void>);
+    static_assert(std::same_as<typename iterator_traits::difference_type, void>);
+    static_assert(std::same_as<typename iterator_traits::reference, void>);
+    static_assert(std::same_as<typename iterator_traits::pointer, void>);
+  }
+  {
+    using iterator = legacy_iterator<I, std::incrementable_traits>;
+    using iterator_traits = std::iterator_traits<iterator>;
+    static_assert(std::same_as<typename iterator_traits::iterator_category, std::output_iterator_tag>);
+    static_assert(std::same_as<typename iterator_traits::value_type, void>);
+    static_assert(std::same_as<typename iterator_traits::difference_type, typename iterator::difference_type>);
+    static_assert(std::same_as<typename iterator_traits::reference, void>);
+    static_assert(std::same_as<typename iterator_traits::pointer, void>);
+  }
+  return true;
+}
+
+static_assert(check_with_legacy_iterator<std::vector<int>::iterator>());
+static_assert(check_with_legacy_iterator<std::vector<int>::const_iterator>());
+
+template <typename T>
+[[nodiscard]] constexpr bool check_fails() {
+  static_assert(!requires { typename std::iterator_traits<T>::iterator_concept; });
+  static_assert(!requires { typename std::iterator_traits<T>::iterator_category; });
+  static_assert(!requires { typename std::iterator_traits<T>::value_type; });
+  static_assert(!requires { typename std::iterator_traits<T>::difference_type; });
+  static_assert(!requires { typename std::iterator_traits<T>::pointer; });
+  static_assert(!requires { typename std::iterator_traits<T>::reference; });
+  return true;
+}
+
+static_assert(check_fails<void>());
+static_assert(check_fails<void*>());
+static_assert(check_fails<int[]>());
+static_assert(check_fails<int const[]>());
+static_assert(check_fails<double[]>());
+
+static_assert(check_fails<S>());
+static_assert(check_fails<S&>());
+static_assert(check_fails<S* const>());
+static_assert(check_fails<S const&>());
+static_assert(check_fails<S (*)()>());
+static_assert(check_fails<S (&)()>());
+static_assert(check_fails<S[]>());
+
+struct missing_iterator_category {
+  using value_type = int;
+  using difference_type = int;
+  using pointer = int*;
+  using reference = int&;
+};
+static_assert(check_fails<missing_iterator_category>());
+
+struct iterator_category_as_static_member {
+  using value_type = int;
+  using difference_type = int;
+  using pointer = int*;
+  using reference = int&;
+
+  inline static constexpr int iterator_category = 0;
+};
+static_assert(check_fails<iterator_category_as_static_member>());
+
+struct missing_value_type {
+  using iterator_category = std::input_iterator_tag;
+  using difference_type = int;
+  using pointer = int*;
+  using reference = int&;
+};
+static_assert(check_fails<missing_value_type>());
+
+struct value_type_as_static_member {
+  using iterator_category = std::input_iterator_tag;
+  using difference_type = int;
+  using pointer = int*;
+  using reference = int&;
+
+  inline static constexpr int value_type = 0;
+};
+static_assert(check_fails<value_type_as_static_member>());
+
+struct missing_difference_type {
+  using iterator_category = std::input_iterator_tag;
+  using value_type = int;
+  using pointer = int*;
+  using reference = int&;
+};
+static_assert(check_fails<missing_difference_type>());
+
+struct difference_type_as_static_member {
+  using iterator_category = std::input_iterator_tag;
+  using value_type = int;
+  using pointer = int*;
+  using reference = int&;
+
+  inline static constexpr int difference_type = 0;
+};
+static_assert(check_fails<difference_type_as_static_member>());
+
+struct missing_reference {
+  using iterator_category = std::input_iterator_tag;
+  using value_type = int;
+  using difference_type = int;
+  using pointer = int*;
+};
+static_assert(check_fails<missing_reference>());
+
+struct reference_as_static_member {
+  using iterator_category = std::input_iterator_tag;
+  using value_type = int;
+  using difference_type = int;
+  using pointer = int*;
+
+  inline static constexpr int reference = 0;
+};
+static_assert(check_fails<reference_as_static_member>());
diff --git a/libcxx/test/std/iterators/iterator.primitives/iterator.traits/empty.fail.cpp b/libcxx/test/std/iterators/iterator.primitives/iterator.traits/empty.fail.cpp
--- a/libcxx/test/std/iterators/iterator.primitives/iterator.traits/empty.fail.cpp
+++ b/libcxx/test/std/iterators/iterator.primitives/iterator.traits/empty.fail.cpp
@@ -91,7 +91,7 @@
     typedef T::reference         RT; // expected-error-re {{no type named 'reference' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::iterator_category CT; // expected-error-re {{no type named 'iterator_category' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     }
-
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_HAS_NO_CONCEPTS)
     {
     typedef std::iterator_traits<NotAnIteratorNoPointer> T;
     typedef T::difference_type   DT; // expected-error-re {{no type named 'difference_type' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
@@ -100,7 +100,7 @@
     typedef T::reference         RT; // expected-error-re {{no type named 'reference' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     typedef T::iterator_category CT; // expected-error-re {{no type named 'iterator_category' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
     }
-
+#endif
     {
     typedef std::iterator_traits<NotAnIteratorNoReference> T;
     typedef T::difference_type   DT; // expected-error-re {{no type named 'difference_type' in 'std:{{.*}}:iterator_traits<{{.+}}>}}
diff --git a/libcxx/test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp b/libcxx/test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp
--- a/libcxx/test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp
@@ -36,6 +36,9 @@
 {
     typedef std::iterator_traits<not_an_iterator> It;
     static_assert(!(has_value_type<It>::value), "");
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+    static_assert(!(has_value_type<std::iterator_traits<void*> >::value));
+#endif
 
-  return 0;
+    return 0;
 }
diff --git a/libcxx/test/std/iterators/iterator.primitives/iterator.traits/legacy_iterator_wrappers.h b/libcxx/test/std/iterators/iterator.primitives/iterator.traits/legacy_iterator_wrappers.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/iterators/iterator.primitives/iterator.traits/legacy_iterator_wrappers.h
@@ -0,0 +1,125 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+#ifndef STD_ITERATORS_ITERATOR_PRIMITIVES_ITERATOR_TRAITS_LEGACY_ITERATORS_H
+#define STD_ITERATORS_ITERATOR_PRIMITIVES_ITERATOR_TRAITS_LEGACY_ITERATORS_H
+
+template <class I>
+concept has_arrow = requires(I& i) {
+  i.operator->();
+};
+
+// Extension point for `legacy_iterator_wrapper` to support `operator->`.
+template <has_arrow I>
+struct arrow_extension {
+  decltype(std::declval<I&>().operator->()) operator->() const;
+};
+
+// Wrapper around a legacy C++ iterator to give it a minimal interface.
+//
+// The key difference between these `legacy.*_iterator` types and those found in
+// `support/test_iterators.h` is that the legacy iterator class are designed to support mixins and
+// specifically test C++20's changes to `iterator_traits`. Namely, the absence of members and the
+// arrow operator is important.
+template <class I, template <typename> class... Args>
+class legacy_iterator : public Args<I>... {
+public:
+  legacy_iterator() = default;
+  explicit legacy_iterator(I i) : base_(i) {}
+
+  decltype(auto) operator*() const { return *base_; }
+
+  legacy_iterator& operator++();
+  legacy_iterator operator++(int);
+
+private:
+  I base_ = I();
+};
+
+// Wrapper around a legacy C++ input iterator to give it a minimal interface.
+template <class I, template <typename> class... Args>
+class legacy_input_iterator : public legacy_iterator<I, Args...> {
+public:
+  using iterator_category = std::input_iterator_tag;
+  using difference_type = typename std::incrementable_traits<I>::difference_type;
+  using value_type = typename std::indirectly_readable_traits<I>::value_type;
+
+  using legacy_iterator<I, Args...>::legacy_iterator;
+  bool operator==(legacy_input_iterator const&) const;
+  legacy_input_iterator& operator++();
+  legacy_input_iterator operator++(int);
+};
+
+// Wrapper around a legacy C++ forward iterator to give it a minimal interface.
+template <class I, template <typename> class... Args>
+class legacy_forward_iterator : public legacy_input_iterator<I, Args...> {
+public:
+  using iterator_category = std::forward_iterator_tag;
+  using legacy_input_iterator<I, Args...>::legacy_input_iterator;
+
+  legacy_forward_iterator& operator++();
+  legacy_forward_iterator operator++(int);
+};
+
+// Wrapper around a legacy C++ bidirectional iterator to give it a minimal interface.
+template <class I, template <typename> class... Args>
+class legacy_bidirectional_iterator : public legacy_forward_iterator<I, Args...> {
+public:
+  using iterator_category = std::bidirectional_iterator_tag;
+  using legacy_forward_iterator<I, Args...>::legacy_forward_iterator;
+
+  legacy_bidirectional_iterator& operator++();
+  legacy_bidirectional_iterator operator++(int);
+  legacy_bidirectional_iterator& operator--();
+  legacy_bidirectional_iterator operator--(int);
+};
+
+// Wrapper around a legacy C++ random-access iterator to give it a minimal interface.
+template <class I, template <typename> class... Args>
+class legacy_random_access_iterator : public legacy_bidirectional_iterator<I, Args...> {
+public:
+  using iterator_category = std::random_access_iterator_tag;
+  using legacy_bidirectional_iterator<I, Args...>::legacy_bidirectional_iterator;
+  using typename legacy_bidirectional_iterator<I, Args...>::difference_type;
+
+  legacy_random_access_iterator& operator++();
+  legacy_random_access_iterator operator++(int);
+  legacy_random_access_iterator& operator--();
+  legacy_random_access_iterator operator--(int);
+  legacy_random_access_iterator& operator+=(difference_type);
+  legacy_random_access_iterator& operator-=(difference_type);
+
+  friend legacy_random_access_iterator operator+(legacy_random_access_iterator, difference_type);
+  friend legacy_random_access_iterator operator+(difference_type, legacy_random_access_iterator);
+  friend legacy_random_access_iterator operator-(legacy_random_access_iterator, difference_type);
+
+  difference_type operator-(legacy_random_access_iterator) const;
+  decltype(auto) operator[](difference_type const n) const { return *(*this + n); }
+  bool operator<(legacy_random_access_iterator) const;
+  bool operator>(legacy_random_access_iterator) const;
+  bool operator<=(legacy_random_access_iterator) const;
+  bool operator>=(legacy_random_access_iterator) const;
+};
+
+// Extension point for reference member.
+template <class I>
+struct reference_extension {
+  using reference = typename I::reference;
+};
+
+// Extension point for pointer member.
+template <typename I>
+struct pointer_extension {
+  using pointer = typename I::pointer;
+};
+
+// Extension point to indicate no extension points.
+// This is used for function overloading when there isn't a better name for two overloads.
+template <class I>
+struct empty_extension {};
+
+#endif // STD_ITERATORS_ITERATOR_PRIMITIVES_ITERATOR_TRAITS_LEGACY_ITERATORS_H