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&>());
@@ -546,18 +533,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,
@@ -621,10 +596,188 @@
     {  __i[__n]  } -> convertible_to<iter_reference_t<_Ip>>;
   };
 } // namespace __iterator_traits_detail
-#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+template<class _Ip>
+concept __has_member_reference = requires { typename _Ip::reference; };
+
+template<class _Ip>
+concept __has_member_pointer = requires { typename _Ip::pointer; };
+
+template<class _Ip>
+concept __has_member_iterator_category = requires { typename _Ip::iterator_category; };
+
+template<class _Ip>
+concept __specifies_members = requires {
+    typename _Ip::value_type;
+    typename _Ip::difference_type;
+    requires __has_member_reference<_Ip>;
+    requires __has_member_iterator_category<_Ip>;
+  };
+
+template<class>
+struct __iterator_traits_member_pointer_or_void {
+  using type = void;
+};
+
+template<__has_member_pointer _Tp>
+struct __iterator_traits_member_pointer_or_void<_Tp> {
+  using type = typename _Tp::pointer;
+};
+
+template<class _Tp>
+concept __cpp17_iterator_missing_members =
+  !__specifies_members<_Tp> &&
+  __iterator_traits_detail::__cpp17_iterator<_Tp>;
+
+template<class _Tp>
+concept __cpp17_input_iterator_missing_members =
+  __cpp17_iterator_missing_members<_Tp> &&
+  __iterator_traits_detail::__cpp17_input_iterator<_Tp>;
+
+// Otherwise, `pointer` names `void`.
+template<class>
+struct __iterator_traits_member_pointer_or_arrow_or_void { using type = void; };
+
+// [iterator.traits]/3.2.1
+// If the qualified-id `I::pointer` is valid and denotes a type, `pointer` names that type.
+template<__has_member_pointer _Ip>
+struct __iterator_traits_member_pointer_or_arrow_or_void<_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 =
+  requires(_Ip& __i) {
+    __i.operator->();
+  };
+
+template<class _Ip>
+  requires __has_arrow<_Ip> && (!__has_member_pointer<_Ip>)
+struct __iterator_traits_member_pointer_or_arrow_or_void<_Ip> {
+  using type = decltype(declval<_Ip&>().operator->());
+};
+
+// 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.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; };
+
+// [iterator.traits]/3.2.3.4
+// input_iterator_tag
+template<class _Ip>
+struct __deduce_iterator_category {
+  using type = input_iterator_tag;
+};
+
+// [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;
+};
+
+template<class _Ip>
+struct __iterator_traits_iterator_category : __deduce_iterator_category<_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, it names void.
+template<class>
+struct __iterator_traits_difference_type { using type = 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;
+};
+
+// [iterator.traits]/3.4
+// Otherwise, `iterator_traits<I>` has no members by any of the above names.
+template<class>
+struct __iterator_traits {};
+
+// [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_or_void<_Ip>::type;
+  using reference          = typename _Ip::reference;
+};
+
+// [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<__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_or_arrow_or_void<_Ip>::type;
+  using reference         = typename __iterator_traits_member_reference<_Ip>::type;
+};
+
+// Otherwise, if `I` satisfies the exposition-only concept `cpp17-iterator`, then
+// `iterator_traits<I>` has the following publicly accessible members:
+template<__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;
+};
+
+template<class _Ip>
+struct iterator_traits : __iterator_traits<_Ip> {
+  using __primary_template = iterator_traits;
+};
+
+#else // !defined(_LIBCPP_HAS_NO_RANGES)
 
 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
@@ -646,8 +799,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/const_pointer.pass.cpp b/libcxx/test/std/iterators/iterator.primitives/iterator.traits/const_pointer.pass.cpp
--- a/libcxx/test/std/iterators/iterator.primitives/iterator.traits/const_pointer.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.primitives/iterator.traits/const_pointer.pass.cpp
@@ -34,5 +34,9 @@
     static_assert((std::is_same<It::reference, const A&>::value), "");
     static_assert((std::is_same<It::iterator_category, std::random_access_iterator_tag>::value), "");
 
-  return 0;
+#if TEST_STD_VER > 17
+    ASSERT_SAME_TYPE(It::iterator_concept, std::contiguous_iterator_tag);
+#endif
+
+    return 0;
 }
diff --git a/libcxx/test/std/iterators/iterator.primitives/iterator.traits/const_volatile_pointer.pass.cpp b/libcxx/test/std/iterators/iterator.primitives/iterator.traits/const_volatile_pointer.pass.cpp
--- a/libcxx/test/std/iterators/iterator.primitives/iterator.traits/const_volatile_pointer.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.primitives/iterator.traits/const_volatile_pointer.pass.cpp
@@ -26,6 +26,8 @@
     static_assert((std::is_same<It::pointer, const volatile A*>::value), "");
     static_assert((std::is_same<It::reference, const volatile A&>::value), "");
     static_assert((std::is_same<It::iterator_category, std::random_access_iterator_tag>::value), "");
-
-  return 0;
+#if TEST_STD_VER > 17
+    ASSERT_SAME_TYPE(It::iterator_concept, std::contiguous_iterator_tag);
+#endif
+    return 0;
 }
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,648 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 <array>
+#include <concepts>
+#include <deque>
+#include <forward_list>
+#include <istream>
+#include <list>
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <string_view>
+#include <optional>
+#include <ostream>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "iterator_traits_cpp17_iterators.h"
+
+template <class Traits>
+constexpr bool has_iterator_concept_v = requires {
+  typename Traits::iterator_concept;
+};
+
+// Standard types.
+
+using PointerIteratorTraits = std::iterator_traits<int*>;
+static_assert(std::same_as<PointerIteratorTraits::iterator_category,
+                           std::random_access_iterator_tag>);
+static_assert(std::same_as<PointerIteratorTraits::value_type, int>);
+static_assert(
+    std::same_as<PointerIteratorTraits::difference_type, std::ptrdiff_t>);
+static_assert(std::same_as<PointerIteratorTraits::reference, int&>);
+static_assert(std::same_as<PointerIteratorTraits::pointer, int*>);
+static_assert(std::same_as<PointerIteratorTraits::iterator_concept,
+                           std::contiguous_iterator_tag>);
+
+using ConstPointerIteratorTraits = std::iterator_traits<const int*>;
+static_assert(std::same_as<ConstPointerIteratorTraits::iterator_category,
+                           std::random_access_iterator_tag>);
+static_assert(std::same_as<ConstPointerIteratorTraits::value_type, int>);
+static_assert(
+    std::same_as<ConstPointerIteratorTraits::difference_type, std::ptrdiff_t>);
+static_assert(std::same_as<ConstPointerIteratorTraits::reference, const int&>);
+static_assert(std::same_as<ConstPointerIteratorTraits::pointer, const int*>);
+static_assert(std::same_as<ConstPointerIteratorTraits::iterator_concept,
+                           std::contiguous_iterator_tag>);
+
+template <class Iter, class ValueType, class Category, class IterConcept = void>
+constexpr bool testStdlibIterator() {
+  using Traits = std::iterator_traits<Iter>;
+  static_assert(std::same_as<typename Traits::iterator_category, Category>);
+  static_assert(std::same_as<typename Traits::value_type, ValueType>);
+  static_assert(std::same_as<typename Traits::difference_type, std::ptrdiff_t>);
+  static_assert(std::same_as<typename Traits::reference, ValueType&>);
+  static_assert(std::same_as<typename Traits::pointer, ValueType*>);
+  if constexpr (std::same_as<IterConcept, void>)
+    static_assert(!has_iterator_concept_v<Traits>);
+  else
+    static_assert(std::same_as<typename Traits::iterator_concept, IterConcept>);
+
+  return true;
+}
+
+template <class Iter, class ValueType, class Category, class Diff = void>
+requires std::same_as<ValueType, void> constexpr bool testStdlibIterator() {
+  using Traits = std::iterator_traits<Iter>;
+  static_assert(std::same_as<typename Traits::iterator_category, Category>);
+  static_assert(std::same_as<typename Traits::value_type, void>);
+  static_assert(std::same_as<typename Traits::difference_type, Diff>);
+  static_assert(std::same_as<typename Traits::reference, void>);
+  static_assert(std::same_as<typename Traits::pointer, void>);
+  static_assert(!has_iterator_concept_v<Traits>);
+
+  return true;
+}
+
+template <class Iter, class ValueType, class DiffType, class RefType, class PtrType, class Category,
+          class IterConcept = void>
+constexpr bool testStdlibIterator() {
+  using Traits = std::iterator_traits<Iter>;
+  static_assert(std::same_as<typename Traits::iterator_category, Category>);
+  static_assert(std::same_as<typename Traits::value_type, ValueType>);
+  static_assert(std::same_as<typename Traits::difference_type, DiffType>);
+  static_assert(std::same_as<typename Traits::reference, RefType>);
+  static_assert(std::same_as<typename Traits::pointer, PtrType>);
+  if constexpr (std::same_as<IterConcept, void>)
+    static_assert(!has_iterator_concept_v<Traits>);
+  else
+    static_assert(std::same_as<typename Traits::iterator_concept, IterConcept>);
+
+  return true;
+}
+
+static_assert(testStdlibIterator<std::vector<int>::iterator, int, std::random_access_iterator_tag>());
+static_assert(testStdlibIterator<std::string::iterator, char, std::random_access_iterator_tag>());
+static_assert(testStdlibIterator<std::string_view::iterator, char, std::ptrdiff_t, const char&, const char*,
+                                 std::random_access_iterator_tag, std::contiguous_iterator_tag>());
+static_assert(testStdlibIterator<std::array<int, 10>::iterator, int, std::random_access_iterator_tag,
+                                 std::contiguous_iterator_tag>());
+static_assert(testStdlibIterator<std::deque<int>::iterator, int, std::random_access_iterator_tag>());
+static_assert(testStdlibIterator<std::forward_list<int>::iterator, int, std::forward_iterator_tag>());
+static_assert(testStdlibIterator<std::deque<int>::iterator, int, std::random_access_iterator_tag>());
+static_assert(testStdlibIterator<std::list<int>::iterator, int, std::bidirectional_iterator_tag>());
+static_assert(testStdlibIterator<std::set<int>::iterator, int, std::ptrdiff_t, const int&, const int*,
+                                 std::bidirectional_iterator_tag>());
+static_assert(
+    testStdlibIterator<std::map<int, int>::iterator, std::pair<const int, int>, std::bidirectional_iterator_tag>());
+static_assert(
+    testStdlibIterator<std::unordered_map<int, int>::iterator, std::pair<const int, int>, std::forward_iterator_tag>());
+static_assert(testStdlibIterator<std::unordered_set<int>::iterator, int, std::ptrdiff_t, const int&, const int*,
+                                 std::forward_iterator_tag>());
+
+static_assert(testStdlibIterator<std::back_insert_iterator<std::vector<int> >, void, std::output_iterator_tag>());
+static_assert(testStdlibIterator<std::front_insert_iterator<std::vector<int> >, void, std::output_iterator_tag>());
+static_assert(testStdlibIterator<std::insert_iterator<std::vector<int> >, void, std::output_iterator_tag>());
+static_assert(testStdlibIterator<std::istream_iterator<int, char>, int, std::ptrdiff_t, const int&, const int*,
+                                 std::input_iterator_tag>());
+static_assert(
+    testStdlibIterator<std::istreambuf_iterator<char>, char, long long, char, char*, std::input_iterator_tag>());
+using MoveIter = std::move_iterator<std::vector<int>::iterator>;
+static_assert(
+    testStdlibIterator<MoveIter, int, std::ptrdiff_t, int&&, MoveIter::pointer, std::random_access_iterator_tag>());
+static_assert(testStdlibIterator<std::ostream_iterator<int, char>, void, std::output_iterator_tag, std::ptrdiff_t>());
+static_assert(
+    testStdlibIterator<std::ostreambuf_iterator<int, char>, void, std::output_iterator_tag, std::ptrdiff_t>());
+
+//
+
+struct AllMembers {
+  struct iterator_category {};
+  struct value_type {};
+  struct difference_type {};
+  struct reference {};
+  struct pointer {};
+};
+using AllMembersTraits = std::iterator_traits<AllMembers>;
+static_assert(std::same_as<AllMembersTraits::iterator_category,
+                           AllMembers::iterator_category>);
+static_assert(
+    std::same_as<AllMembersTraits::value_type, AllMembers::value_type>);
+static_assert(std::same_as<AllMembersTraits::difference_type,
+                           AllMembers::difference_type>);
+static_assert(std::same_as<AllMembersTraits::reference, AllMembers::reference>);
+static_assert(std::same_as<AllMembersTraits::pointer, AllMembers::pointer>);
+static_assert(!has_iterator_concept_v<AllMembersTraits>);
+
+struct NoPointerMember {
+  struct iterator_category {};
+  struct value_type {};
+  struct difference_type {};
+  struct reference {};
+  // ignored, because NoPointerMember is not a LegacyInputIterator:
+  value_type* operator->() const;
+};
+using NoPointerMemberTraits = std::iterator_traits<NoPointerMember>;
+static_assert(std::same_as<NoPointerMemberTraits::iterator_category,
+                           NoPointerMember::iterator_category>);
+static_assert(std::same_as<NoPointerMemberTraits::value_type,
+                           NoPointerMember::value_type>);
+static_assert(std::same_as<NoPointerMemberTraits::difference_type,
+                           NoPointerMember::difference_type>);
+static_assert(
+    std::same_as<NoPointerMemberTraits::reference, NoPointerMember::reference>);
+static_assert(std::same_as<NoPointerMemberTraits::pointer, void>);
+static_assert(!has_iterator_concept_v<NoPointerMemberTraits>);
+
+struct IterConcept {
+  struct iterator_category {};
+  // "iterator_concept" must be defined in a specialization of "iterator_traits", it
+  // should not be a member of the iterator itself, so this is ignored.
+  struct iterator_concept {};
+  struct value_type {};
+  struct difference_type {};
+  struct reference {};
+  struct pointer {};
+};
+using IterConceptTraits = std::iterator_traits<IterConcept>;
+static_assert(std::same_as<IterConceptTraits::iterator_category,
+                           IterConcept::iterator_category>);
+static_assert(
+    std::same_as<IterConceptTraits::value_type, IterConcept::value_type>);
+static_assert(std::same_as<IterConceptTraits::difference_type,
+                           IterConcept::difference_type>);
+static_assert(
+    std::same_as<IterConceptTraits::reference, IterConcept::reference>);
+static_assert(std::same_as<IterConceptTraits::pointer, IterConcept::pointer>);
+static_assert(!has_iterator_concept_v<IterConceptTraits>);
+
+struct LegacyInput {
+  struct iterator_category {};
+  struct value_type {};
+  struct reference {
+    operator value_type() const;
+  };
+
+  friend bool operator==(LegacyInput, LegacyInput);
+  reference operator*() const;
+  LegacyInput& operator++();
+  LegacyInput operator++(int);
+};
+template <>
+struct std::incrementable_traits<LegacyInput> {
+  using difference_type = short;
+};
+using LegacyInputTraits = std::iterator_traits<LegacyInput>;
+static_assert(std::same_as<LegacyInputTraits::iterator_category,
+                           LegacyInput::iterator_category>);
+static_assert(
+    std::same_as<LegacyInputTraits::value_type, LegacyInput::value_type>);
+static_assert(std::same_as<LegacyInputTraits::difference_type, short>);
+static_assert(
+    std::same_as<LegacyInputTraits::reference, LegacyInput::reference>);
+static_assert(std::same_as<LegacyInputTraits::pointer, void>);
+static_assert(!has_iterator_concept_v<LegacyInputTraits>);
+
+struct LegacyInputNoValueType {
+  struct not_value_type {};
+  using difference_type = int; // or any signed integral type
+  struct reference {
+    operator not_value_type() const;
+  };
+
+  friend bool operator==(LegacyInputNoValueType, LegacyInputNoValueType);
+  reference operator*() const;
+  LegacyInputNoValueType& operator++();
+  LegacyInputNoValueType operator++(int);
+};
+template <>
+struct std::indirectly_readable_traits<LegacyInputNoValueType> {
+  using value_type = LegacyInputNoValueType::not_value_type;
+};
+using LegacyInputNoValueTypeTraits =
+    std::iterator_traits<LegacyInputNoValueType>;
+static_assert(std::same_as<LegacyInputNoValueTypeTraits::iterator_category,
+                           std::input_iterator_tag>);
+static_assert(std::same_as<LegacyInputNoValueTypeTraits::value_type,
+                           LegacyInputNoValueType::not_value_type>);
+static_assert(std::same_as<LegacyInputNoValueTypeTraits::difference_type, int>);
+static_assert(std::same_as<LegacyInputNoValueTypeTraits::reference,
+                           LegacyInputNoValueType::reference>);
+static_assert(std::same_as<LegacyInputNoValueTypeTraits::pointer, void>);
+static_assert(!has_iterator_concept_v<LegacyInputNoValueTypeTraits>);
+
+struct LegacyForward {
+  struct not_value_type {};
+
+  friend bool operator==(LegacyForward, LegacyForward);
+  const not_value_type& operator*() const;
+  LegacyForward& operator++();
+  LegacyForward operator++(int);
+};
+template <>
+struct std::indirectly_readable_traits<LegacyForward> {
+  using value_type = LegacyForward::not_value_type;
+};
+template <>
+struct std::incrementable_traits<LegacyForward> {
+  using difference_type = short; // or any signed integral type
+};
+using LegacyForwardTraits = std::iterator_traits<LegacyForward>;
+static_assert(std::same_as<LegacyForwardTraits::iterator_category,
+                           std::forward_iterator_tag>);
+static_assert(std::same_as<LegacyForwardTraits::value_type,
+                           LegacyForward::not_value_type>);
+static_assert(std::same_as<LegacyForwardTraits::difference_type, short>);
+static_assert(std::same_as<LegacyForwardTraits::reference,
+                           const LegacyForward::not_value_type&>);
+static_assert(std::same_as<LegacyForwardTraits::pointer, void>);
+static_assert(!has_iterator_concept_v<LegacyForwardTraits>);
+
+struct LegacyBidirectional {
+  struct value_type {};
+
+  friend bool operator==(LegacyBidirectional, LegacyBidirectional);
+  const value_type& operator*() const;
+  LegacyBidirectional& operator++();
+  LegacyBidirectional operator++(int);
+  LegacyBidirectional& operator--();
+  LegacyBidirectional operator--(int);
+  friend short operator-(LegacyBidirectional, LegacyBidirectional);
+};
+using LegacyBidirectionalTraits = std::iterator_traits<LegacyBidirectional>;
+static_assert(std::same_as<LegacyBidirectionalTraits::iterator_category,
+                           std::bidirectional_iterator_tag>);
+static_assert(std::same_as<LegacyBidirectionalTraits::value_type,
+                           LegacyBidirectional::value_type>);
+static_assert(std::same_as<LegacyBidirectionalTraits::difference_type, short>);
+static_assert(std::same_as<LegacyBidirectionalTraits::reference,
+                           const LegacyBidirectional::value_type&>);
+static_assert(std::same_as<LegacyBidirectionalTraits::pointer, void>);
+static_assert(!has_iterator_concept_v<LegacyBidirectionalTraits>);
+
+// Almost a random access iterator except it is missing operator-(It, It).
+struct MinusNotDeclaredIter {
+  struct value_type {};
+
+  friend auto operator<=>(MinusNotDeclaredIter, MinusNotDeclaredIter) = default;
+  const value_type& operator*() const;
+  const value_type& operator[](long) const;
+  MinusNotDeclaredIter& operator++();
+  MinusNotDeclaredIter operator++(int);
+  MinusNotDeclaredIter& operator--();
+  MinusNotDeclaredIter operator--(int);
+  MinusNotDeclaredIter& operator+=(long);
+  MinusNotDeclaredIter& operator-=(long);
+
+  // Providing difference_type does not fully compensate for missing operator-(It, It).
+  friend MinusNotDeclaredIter operator-(MinusNotDeclaredIter, int);
+  friend MinusNotDeclaredIter operator+(MinusNotDeclaredIter, int);
+  friend MinusNotDeclaredIter operator+(int, MinusNotDeclaredIter);
+};
+template <>
+struct std::incrementable_traits<MinusNotDeclaredIter> {
+  using difference_type = short;
+};
+using MinusNotDeclaredIterTraits = std::iterator_traits<MinusNotDeclaredIter>;
+static_assert(std::same_as<MinusNotDeclaredIterTraits::iterator_category,
+                           std::bidirectional_iterator_tag>);
+static_assert(std::same_as<MinusNotDeclaredIterTraits::value_type,
+                           MinusNotDeclaredIter::value_type>);
+static_assert(std::same_as<MinusNotDeclaredIterTraits::difference_type, short>);
+static_assert(std::same_as<MinusNotDeclaredIterTraits::reference,
+                           const MinusNotDeclaredIter::value_type&>);
+static_assert(std::same_as<MinusNotDeclaredIterTraits::pointer, void>);
+static_assert(!has_iterator_concept_v<MinusNotDeclaredIterTraits>);
+
+struct WrongSubscriptReturnType {
+  struct value_type {};
+
+  friend auto operator<=>(WrongSubscriptReturnType,
+                          WrongSubscriptReturnType) = default;
+  // The type of it[n] is not convertible to the type of *it; therefore, this is not random-access.
+  value_type& operator*() const;
+  const value_type& operator[](long) const;
+  WrongSubscriptReturnType& operator++();
+  WrongSubscriptReturnType operator++(int);
+  WrongSubscriptReturnType& operator--();
+  WrongSubscriptReturnType operator--(int);
+  WrongSubscriptReturnType& operator+=(long);
+  WrongSubscriptReturnType& operator-=(long);
+  friend short operator-(WrongSubscriptReturnType, WrongSubscriptReturnType);
+  friend WrongSubscriptReturnType operator-(WrongSubscriptReturnType, int);
+  friend WrongSubscriptReturnType operator+(WrongSubscriptReturnType, int);
+  friend WrongSubscriptReturnType operator+(int, WrongSubscriptReturnType);
+};
+using WrongSubscriptReturnTypeTraits =
+    std::iterator_traits<WrongSubscriptReturnType>;
+static_assert(std::same_as<WrongSubscriptReturnTypeTraits::iterator_category,
+                           std::bidirectional_iterator_tag>);
+static_assert(std::same_as<WrongSubscriptReturnTypeTraits::value_type,
+                           WrongSubscriptReturnType::value_type>);
+static_assert(
+    std::same_as<WrongSubscriptReturnTypeTraits::difference_type, short>);
+static_assert(std::same_as<WrongSubscriptReturnTypeTraits::reference,
+                           WrongSubscriptReturnType::value_type&>);
+static_assert(std::same_as<WrongSubscriptReturnTypeTraits::pointer, void>);
+static_assert(!has_iterator_concept_v<WrongSubscriptReturnTypeTraits>);
+
+struct LegacyRandomAccess {
+  struct value_type {};
+
+  friend bool operator==(LegacyRandomAccess, LegacyRandomAccess);
+  friend bool operator<(LegacyRandomAccess, LegacyRandomAccess);
+  friend bool operator<=(LegacyRandomAccess, LegacyRandomAccess);
+  friend bool operator>(LegacyRandomAccess, LegacyRandomAccess);
+  friend bool operator>=(LegacyRandomAccess, LegacyRandomAccess);
+  const value_type& operator*() const;
+  const value_type& operator[](long) const;
+  LegacyRandomAccess& operator++();
+  LegacyRandomAccess operator++(int);
+  LegacyRandomAccess& operator--();
+  LegacyRandomAccess operator--(int);
+  LegacyRandomAccess& operator+=(long);
+  LegacyRandomAccess& operator-=(long);
+  friend short operator-(LegacyRandomAccess, LegacyRandomAccess);
+  friend LegacyRandomAccess operator-(LegacyRandomAccess, int);
+  friend LegacyRandomAccess operator+(LegacyRandomAccess, int);
+  friend LegacyRandomAccess operator+(int, LegacyRandomAccess);
+};
+using LegacyRandomAccessTraits = std::iterator_traits<LegacyRandomAccess>;
+static_assert(std::same_as<LegacyRandomAccessTraits::iterator_category,
+                           std::random_access_iterator_tag>);
+static_assert(std::same_as<LegacyRandomAccessTraits::value_type,
+                           LegacyRandomAccess::value_type>);
+static_assert(std::same_as<LegacyRandomAccessTraits::difference_type, short>);
+static_assert(std::same_as<LegacyRandomAccessTraits::reference,
+                           const LegacyRandomAccess::value_type&>);
+static_assert(std::same_as<LegacyRandomAccessTraits::pointer, void>);
+static_assert(!has_iterator_concept_v<LegacyRandomAccessTraits>);
+
+struct LegacyRandomAccessSpaceship {
+  struct not_value_type {};
+  struct ReferenceConvertible {
+    operator not_value_type&() const;
+  };
+
+  friend auto operator<=>(LegacyRandomAccessSpaceship,
+                          LegacyRandomAccessSpaceship) = default;
+  not_value_type& operator*() const;
+  ReferenceConvertible operator[](long) const;
+  LegacyRandomAccessSpaceship& operator++();
+  LegacyRandomAccessSpaceship operator++(int);
+  LegacyRandomAccessSpaceship& operator--();
+  LegacyRandomAccessSpaceship operator--(int);
+  LegacyRandomAccessSpaceship& operator+=(long);
+  LegacyRandomAccessSpaceship& operator-=(long);
+  friend short operator-(LegacyRandomAccessSpaceship,
+                         LegacyRandomAccessSpaceship);
+  friend LegacyRandomAccessSpaceship operator-(LegacyRandomAccessSpaceship,
+                                               int);
+  friend LegacyRandomAccessSpaceship operator+(LegacyRandomAccessSpaceship,
+                                               int);
+  friend LegacyRandomAccessSpaceship operator+(int,
+                                               LegacyRandomAccessSpaceship);
+};
+template <>
+struct std::indirectly_readable_traits<LegacyRandomAccessSpaceship> {
+  using value_type = LegacyRandomAccessSpaceship::not_value_type;
+};
+template <>
+struct std::incrementable_traits<LegacyRandomAccessSpaceship> {
+  using difference_type = short; // or any signed integral type
+};
+using LegacyRandomAccessSpaceshipTraits =
+    std::iterator_traits<LegacyRandomAccessSpaceship>;
+static_assert(std::same_as<LegacyRandomAccessSpaceshipTraits::iterator_category,
+                           std::random_access_iterator_tag>);
+static_assert(std::same_as<LegacyRandomAccessSpaceshipTraits::value_type,
+                           LegacyRandomAccessSpaceship::not_value_type>);
+static_assert(
+    std::same_as<LegacyRandomAccessSpaceshipTraits::difference_type, short>);
+static_assert(std::same_as<LegacyRandomAccessSpaceshipTraits::reference,
+                           LegacyRandomAccessSpaceship::not_value_type&>);
+static_assert(std::same_as<LegacyRandomAccessSpaceshipTraits::pointer, void>);
+static_assert(!has_iterator_concept_v<LegacyRandomAccessSpaceshipTraits>);
+
+// For output iterators, value_type, difference_type, and reference may be void.
+struct BareLegacyOutput {
+  struct Empty {};
+  Empty operator*() const;
+  BareLegacyOutput& operator++();
+  BareLegacyOutput operator++(int);
+};
+using BareLegacyOutputTraits = std::iterator_traits<BareLegacyOutput>;
+static_assert(std::same_as<BareLegacyOutputTraits::iterator_category,
+                           std::output_iterator_tag>);
+static_assert(std::same_as<BareLegacyOutputTraits::value_type, void>);
+static_assert(std::same_as<BareLegacyOutputTraits::difference_type, void>);
+static_assert(std::same_as<BareLegacyOutputTraits::reference, void>);
+static_assert(std::same_as<BareLegacyOutputTraits::pointer, void>);
+static_assert(!has_iterator_concept_v<BareLegacyOutputTraits>);
+
+// The operator- means we get difference_type.
+struct LegacyOutputWithMinus {
+  struct Empty {};
+  Empty operator*() const;
+  LegacyOutputWithMinus& operator++();
+  LegacyOutputWithMinus operator++(int);
+  friend short operator-(LegacyOutputWithMinus, LegacyOutputWithMinus);
+  // Lacking operator==, this is a LegacyIterator but not a LegacyInputIterator.
+};
+using LegacyOutputWithMinusTraits = std::iterator_traits<LegacyOutputWithMinus>;
+static_assert(std::same_as<LegacyOutputWithMinusTraits::iterator_category,
+                           std::output_iterator_tag>);
+static_assert(std::same_as<LegacyOutputWithMinusTraits::value_type, void>);
+static_assert(
+    std::same_as<LegacyOutputWithMinusTraits::difference_type, short>);
+static_assert(std::same_as<LegacyOutputWithMinusTraits::reference, void>);
+static_assert(std::same_as<LegacyOutputWithMinusTraits::pointer, void>);
+static_assert(!has_iterator_concept_v<LegacyOutputWithMinusTraits>);
+
+struct LegacyOutputWithMemberTypes {
+  struct value_type {}; // ignored
+  struct reference {};  // ignored
+  using difference_type = long;
+
+  friend bool operator==(LegacyOutputWithMemberTypes,
+                         LegacyOutputWithMemberTypes);
+  reference operator*() const;
+  LegacyOutputWithMemberTypes& operator++();
+  LegacyOutputWithMemberTypes operator++(int);
+  friend short operator-(LegacyOutputWithMemberTypes,
+                         LegacyOutputWithMemberTypes); // ignored
+  // Since (*it) is not convertible to value_type, this is not a LegacyInputIterator.
+};
+using LegacyOutputWithMemberTypesTraits =
+    std::iterator_traits<LegacyOutputWithMemberTypes>;
+static_assert(std::same_as<LegacyOutputWithMemberTypesTraits::iterator_category,
+                           std::output_iterator_tag>);
+static_assert(
+    std::same_as<LegacyOutputWithMemberTypesTraits::value_type, void>);
+static_assert(
+    std::same_as<LegacyOutputWithMemberTypesTraits::difference_type, long>);
+static_assert(std::same_as<LegacyOutputWithMemberTypesTraits::reference, void>);
+static_assert(std::same_as<LegacyOutputWithMemberTypesTraits::pointer, void>);
+static_assert(!has_iterator_concept_v<LegacyOutputWithMemberTypesTraits>);
+
+struct LegacyRandomAccessSpecialized {
+  struct not_value_type {};
+
+  friend auto operator<=>(LegacyRandomAccessSpecialized,
+                          LegacyRandomAccessSpecialized) = default;
+  not_value_type& operator*() const;
+  not_value_type& operator[](long) const;
+  LegacyRandomAccessSpecialized& operator++();
+  LegacyRandomAccessSpecialized operator++(int);
+  LegacyRandomAccessSpecialized& operator--();
+  LegacyRandomAccessSpecialized operator--(int);
+  LegacyRandomAccessSpecialized& operator+=(long);
+  LegacyRandomAccessSpecialized& operator-=(long);
+  friend long operator-(LegacyRandomAccessSpecialized,
+                        LegacyRandomAccessSpecialized);
+  friend LegacyRandomAccessSpecialized operator-(LegacyRandomAccessSpecialized,
+                                                 int);
+  friend LegacyRandomAccessSpecialized operator+(LegacyRandomAccessSpecialized,
+                                                 int);
+  friend LegacyRandomAccessSpecialized operator+(int,
+                                                 LegacyRandomAccessSpecialized);
+};
+template <class I>
+requires std::same_as<
+    I, LegacyRandomAccessSpecialized> struct std::iterator_traits<I> {
+  using iterator_category = std::output_iterator_tag;
+  using value_type = short;
+  using difference_type = short;
+  using reference = short&;
+  using pointer = short*;
+};
+using LegacyRandomAccessSpecializedTraits =
+    std::iterator_traits<LegacyRandomAccessSpecialized>;
+static_assert(
+    std::same_as<LegacyRandomAccessSpecializedTraits::iterator_category,
+                 std::output_iterator_tag>);
+static_assert(
+    std::same_as<LegacyRandomAccessSpecializedTraits::value_type, short>);
+static_assert(
+    std::same_as<LegacyRandomAccessSpecializedTraits::difference_type, short>);
+static_assert(
+    std::same_as<LegacyRandomAccessSpecializedTraits::reference, short&>);
+static_assert(
+    std::same_as<LegacyRandomAccessSpecializedTraits::pointer, short*>);
+static_assert(!has_iterator_concept_v<LegacyRandomAccessSpecializedTraits>);
+
+// Other test iterators.
+
+using InputTestItereatorTraits = std::iterator_traits<input_iterator<int*> >;
+static_assert(std::same_as<InputTestItereatorTraits::iterator_category,
+                           std::input_iterator_tag>);
+static_assert(std::same_as<InputTestItereatorTraits::value_type, int>);
+static_assert(std::same_as<InputTestItereatorTraits::difference_type, long>);
+static_assert(std::same_as<InputTestItereatorTraits::reference, int&>);
+static_assert(std::same_as<InputTestItereatorTraits::pointer, int*>);
+static_assert(!has_iterator_concept_v<InputTestItereatorTraits>);
+
+using OutputTestItereatorTraits = std::iterator_traits<output_iterator<int*> >;
+static_assert(std::same_as<OutputTestItereatorTraits::iterator_category,
+                           std::output_iterator_tag>);
+static_assert(std::same_as<OutputTestItereatorTraits::value_type, void>);
+static_assert(std::same_as<OutputTestItereatorTraits::difference_type, long>);
+static_assert(std::same_as<OutputTestItereatorTraits::reference, int&>);
+static_assert(std::same_as<OutputTestItereatorTraits::pointer, int*>);
+static_assert(!has_iterator_concept_v<OutputTestItereatorTraits>);
+
+using ForwardTestIteratorTraits = std::iterator_traits<forward_iterator<int*> >;
+static_assert(std::same_as<ForwardTestIteratorTraits::iterator_category,
+                           std::forward_iterator_tag>);
+static_assert(std::same_as<ForwardTestIteratorTraits::value_type, int>);
+static_assert(std::same_as<ForwardTestIteratorTraits::difference_type, long>);
+static_assert(std::same_as<ForwardTestIteratorTraits::reference, int&>);
+static_assert(std::same_as<ForwardTestIteratorTraits::pointer, int*>);
+static_assert(!has_iterator_concept_v<ForwardTestIteratorTraits>);
+
+using BidirectionalTestIteratorTraits =
+    std::iterator_traits<bidirectional_iterator<int*> >;
+static_assert(std::same_as<BidirectionalTestIteratorTraits::iterator_category,
+                           std::bidirectional_iterator_tag>);
+static_assert(std::same_as<BidirectionalTestIteratorTraits::value_type, int>);
+static_assert(
+    std::same_as<BidirectionalTestIteratorTraits::difference_type, long>);
+static_assert(std::same_as<BidirectionalTestIteratorTraits::reference, int&>);
+static_assert(std::same_as<BidirectionalTestIteratorTraits::pointer, int*>);
+static_assert(!has_iterator_concept_v<BidirectionalTestIteratorTraits>);
+
+using RandomAccessTestIteratorTraits =
+    std::iterator_traits<random_access_iterator<int*> >;
+static_assert(std::same_as<RandomAccessTestIteratorTraits::iterator_category,
+                           std::random_access_iterator_tag>);
+static_assert(std::same_as<RandomAccessTestIteratorTraits::value_type, int>);
+static_assert(
+    std::same_as<RandomAccessTestIteratorTraits::difference_type, long>);
+static_assert(std::same_as<RandomAccessTestIteratorTraits::reference, int&>);
+static_assert(std::same_as<RandomAccessTestIteratorTraits::pointer, int*>);
+static_assert(!has_iterator_concept_v<RandomAccessTestIteratorTraits>);
+
+using ContiguousTestIteratorTraits =
+    std::iterator_traits<contiguous_iterator<int*> >;
+static_assert(std::same_as<ContiguousTestIteratorTraits::iterator_category,
+                           std::contiguous_iterator_tag>);
+static_assert(std::same_as<ContiguousTestIteratorTraits::value_type, int>);
+static_assert(
+    std::same_as<ContiguousTestIteratorTraits::difference_type, long>);
+static_assert(std::same_as<ContiguousTestIteratorTraits::reference, int&>);
+static_assert(std::same_as<ContiguousTestIteratorTraits::pointer, int*>);
+static_assert(!has_iterator_concept_v<ContiguousTestIteratorTraits>);
+
+using Cpp17BasicIteratorTraits = std::iterator_traits<iterator_traits_cpp17_iterator>;
+static_assert(std::same_as<Cpp17BasicIteratorTraits::iterator_category, std::output_iterator_tag>);
+static_assert(std::same_as<Cpp17BasicIteratorTraits::value_type, void>);
+static_assert(std::same_as<Cpp17BasicIteratorTraits::difference_type, void>);
+static_assert(std::same_as<Cpp17BasicIteratorTraits::reference, void>);
+static_assert(std::same_as<Cpp17BasicIteratorTraits::pointer, void>);
+static_assert(!has_iterator_concept_v<Cpp17BasicIteratorTraits>);
+
+using Cpp17InputIteratorTraits = std::iterator_traits<iterator_traits_cpp17_input_iterator>;
+static_assert(std::same_as<Cpp17InputIteratorTraits::iterator_category, std::input_iterator_tag>);
+static_assert(std::same_as<Cpp17InputIteratorTraits::value_type, long>);
+static_assert(std::same_as<Cpp17InputIteratorTraits::difference_type, int>);
+static_assert(std::same_as<Cpp17InputIteratorTraits::reference, int&>);
+static_assert(std::same_as<Cpp17InputIteratorTraits::pointer, void>);
+static_assert(!has_iterator_concept_v<Cpp17InputIteratorTraits>);
+
+using Cpp17ForwardIteratorTraits = std::iterator_traits<iterator_traits_cpp17_forward_iterator>;
+static_assert(std::same_as<Cpp17ForwardIteratorTraits::iterator_category, std::forward_iterator_tag>);
+static_assert(std::same_as<Cpp17ForwardIteratorTraits::value_type, int>);
+static_assert(std::same_as<Cpp17ForwardIteratorTraits::difference_type, int>);
+static_assert(std::same_as<Cpp17ForwardIteratorTraits::reference, int&>);
+static_assert(std::same_as<Cpp17ForwardIteratorTraits::pointer, void>);
+static_assert(!has_iterator_concept_v<Cpp17ForwardIteratorTraits>);
\ No newline at end of file
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 // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_HAS_NO_CONCEPTS)
     {
     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/volatile_pointer.pass.cpp b/libcxx/test/std/iterators/iterator.primitives/iterator.traits/volatile_pointer.pass.cpp
--- a/libcxx/test/std/iterators/iterator.primitives/iterator.traits/volatile_pointer.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.primitives/iterator.traits/volatile_pointer.pass.cpp
@@ -26,6 +26,8 @@
     static_assert((std::is_same<It::pointer, volatile A*>::value), "");
     static_assert((std::is_same<It::reference, volatile A&>::value), "");
     static_assert((std::is_same<It::iterator_category, std::random_access_iterator_tag>::value), "");
-
-  return 0;
+#if TEST_STD_VER > 17
+    ASSERT_SAME_TYPE(It::iterator_concept, std::contiguous_iterator_tag);
+#endif
+    return 0;
 }
diff --git a/libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/iterator_traits_cpp17_iterators.h b/libcxx/test/support/iterator_traits_cpp17_iterators.h
rename from libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/iterator_traits_cpp17_iterators.h
rename to libcxx/test/support/iterator_traits_cpp17_iterators.h
--- a/libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/iterator_traits_cpp17_iterators.h
+++ b/libcxx/test/support/iterator_traits_cpp17_iterators.h
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef TEST_LIBCXX_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_ASSOC_TYPES_ITERATOR_TRAITS_ITERATOR_TRAITS_CPP17_ITERATORS
-#define TEST_LIBCXX_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_ASSOC_TYPES_ITERATOR_TRAITS_ITERATOR_TRAITS_CPP17_ITERATORS
+#ifndef TEST_SUPPORT_ITERATOR_TRAITS_ITERATOR_TRAITS_CPP17_ITERATORS
+#define TEST_SUPPORT_ITERATOR_TRAITS_ITERATOR_TRAITS_CPP17_ITERATORS
 
 struct iterator_traits_cpp17_iterator {
   int& operator*();
@@ -101,4 +101,4 @@
                                    iterator_traits_cpp17_random_access_iterator);
 };
 
-#endif // TEST_LIBCXX_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_ASSOC_TYPES_ITERATOR_TRAITS_ITERATOR_TRAITS_CPP17_ITERATORS
+#endif // TEST_SUPPORT_ITERATOR_TRAITS_ITERATOR_TRAITS_CPP17_ITERATORS