[libcxx][iterator] adds `std::indirectly_readable` and `std::indirectly_writable`

[cjdb]

Summary

Implements parts of:

• P0896R4 The One Ranges Proposal`

Depends on D99873.

[cjdb]

moves types common to indirectly_readable and indirectly_writable tests into a header

[cjdb]

adds synopsis, rebases to activate CI

[ldionne]

LGTM with comments addressed. I marked blocking comments as such and non-blocking comments as such.

libcxx/include/iterator

2516–2531

This LGTM.

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.readable/indirectly_readable.compile.pass.cpp

120

You could use shorter names and instead use a comment to explain what this specific sub-test does. This way, you wouldn't have to carry around a name with almost 120 characters, which is kind of heavy on the eye and obscures the intent of the test.

This one is blocking.

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/read_write.h

1

Does it make sense to move this to test/support instead? Non blocking.

[zoecarver]

I have at least these few small comments, so please hold off on committing.

I'm not done reviewing yet, but I saw @ldionne approved it, so I wanted to get these in before you land it.

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.readable/indirectly_readable.compile.pass.cpp

38

I suppose I don't feel strongly, but are you using this elsewhere? Otherwise, maybe it makes sense to line the header; it's only 30 lines. WDYT?

57

Might as well put this in the header too, no? I think it makes sense to have all these types live together.

[zoecarver]

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.readable/indirectly_readable.compile.pass.cpp

93

Nit: Maybe missing_value_type is more accurate?

98

This type looks unused.

114

What's the difference between this test and indirection_mismatch? Maybe value_type should be iter_ref1 here? Because this should still fail, right?

128

This looks very similar to iter_move_mismatch. What's the difference?

[zoecarver]

Overall, I think this patch is great. There are a lot of tests, but they're all super simple and easily verifiable. Other than the few very small comments I made inline, this LGTM.

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.readable/indirectly_readable.compile.pass.cpp

1

I really like all the tests in here, thanks!

145

A bit shorter: different_reference_types_with_common_reference?

308

Only one template param.

[cjdb]

rebases to activate CI

[ldionne]

Actually, while looking at a different review, I stumbled upon this note: http://eel.is/c++draft/iterator.assoc.types#readable.traits-note-1

Some legacy output iterators define a nested type named value_­type that is an alias for void. These types are not indirectly_­readable and have no associated value types.

I don't think we have a test for that here, so we should add one if we don't. Then there's also this note: http://eel.is/c++draft/iterator.assoc.types#readable.traits-note-2, but I see we do have a test for that (great).

Requesting changes so this shows up correctly in the queue.

[• Quuxplusone]

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.readable/indirectly_readable.compile.pass.cpp

308

I can't follow all the template metaprogramming on lines 152-175, and lines 184-283 are obviously overkill (all iterator types are indirectly readable, by definition; we don't need a million header dependencies to prove that). The use of check_indirectly_readable<T>() in place of std::indirectly_readable<T> is also a bit obfuscatory; I would prefer to see the concept tested directly.

One test I'd like to see added is

struct NoConst { int& operator*(); };
static_assert(!std::indirectly_readable<NoConst>);

This is the sort of thing that (A) may come up in real code, and (B) may break under maintenance, if someone changes (const _In __in) to (_In __in) on line 2507. (requires-expression parameters are frequently treated the same as function parameters, and one would never const-qualify a function parameter; but here, the const keyword on the requires-parameter is actually the key to conformance. And we have no test for it.)

[cjdb]

responds to feedback

[cjdb]

In D100073#2692629, @ldionne wrote:

Actually, while looking at a different review, I stumbled upon this note: http://eel.is/c++draft/iterator.assoc.types#readable.traits-note-1

Some legacy output iterators define a nested type named value_­type that is an alias for void. These types are not indirectly_­readable and have no associated value types.

I don't think we have a test for that here, so we should add one if we don't. Then there's also this note: http://eel.is/c++draft/iterator.assoc.types#readable.traits-note-2, but I see we do have a test for that (great).

Requesting changes so this shows up correctly in the queue.

Are you sure? test/std/iterators/iterator.requirements/iterator.assoc.types/readable.traits/indirectly_readable_traits.compile.pass.cpp:179-87 already check for a void value_type/element_type. It doesn't really matter whether or not the type is an iterator.

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.readable/indirectly_readable.compile.pass.cpp

120

How about now?

128

It's a distinct type (one per test is necessary since common_reference needs to resolve as a different type).

308

I can't follow all the template metaprogramming on lines 152-175

common_reference_t<iter_ref4, iter_rvalue_ref> is iter_rvalue_ref and common_reference<iter_ref4 const&, iter_rvalue_ref&&>::type doesn't exist.

lines 184-283 are obviously overkill (all iterator types are indirectly readable, by definition; we don't need a million header dependencies to prove that)

This ensures conformance, which is a non-obvious thing to confirm. A full review of the tests would have revealed that not "all" iterators are indirectly readable, by definition. I'll leave it as an exercise for you to find those that don't satisfy the concept.

However, at your insistence, I've removed them from this file.

The use of check_indirectly_readable<T>() in place of std::indirectly_readable<T> is also a bit obfuscatory; I would prefer to see the concept tested directly.

What is being obfuscated?

One test I'd like to see added is

struct NoConst { int& operator*(); };
static_assert(!std::indirectly_readable<NoConst>);

This is the sort of thing that (A) may come up in real code, and (B) may break under maintenance, if someone changes (const _In __in) to (_In __in) on line 2507. (requires-expression parameters are frequently treated the same as function parameters, and one would never const-qualify a function parameter; but here, the const keyword on the requires-parameter is actually the key to conformance. And we have no test for it.)

Added.

[cjdb]

rebases so @zoecarver can continue working

The addition of indirectly_writable is accidental (probably a rebase gone wrong) and will be fixed in the next arc diff.
It shouldn't affect @zoecarver's work at all.

[cjdb]

In D100073#2702033, @cjdb wrote:

rebases so @zoecarver can continue working

The addition of indirectly_writable is accidental (probably a rebase gone wrong) and will be fixed in the next arc diff.
It shouldn't affect @zoecarver's work at all.

In hindsight, I think it might be easier to abandon D100078 since it's magically transported into D100073.

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.readable/indirectly_readable.compile.pass.cpp

57

These types are exclusively for indirectly_readable, so I'd prefer to keep them here.

[zoecarver]

This still mostly LGTM sans a few small comments.

Do you want to just merge this and indirectly writable into one patch? I'd be fine with that FWIW and it might make it easier to keep track of on your end.

Also, for what it's worth: I don't have a preference as to how you test the standard types. I think the current implementation (have each test be its own file) is nice, but also looks like a lot of work to write. So in the future, do whatever you'd prefer/is easier (imho).

libcxx/include/__iterator/iterator_traits.h

42 ↗

(On Diff #338905)

Shouldn't these go in __iterator/concepts.h?

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.readable/indirectly_readable.compile.pass.cpp

89

Non-blocking, nit: Apparently we're suppose to do this without opening the std namespace.

105

This name is long and hard to grok. Let's call it something like unrelated_ref.

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.writable/indirectly_writable.compile.pass.cpp

46 ↗

(On Diff #338905)

Non-blocking: I'm not sure we need to check this and void*, int.Same below.

[zoecarver]

Actually, I'm still not seeing a test where value_type = void. Please add that per Louis comment / http://eel.is/c++draft/iterator.assoc.types#readable.traits-note-1

Edit: I do however see {shared,unique}_ptr<void>, so that's good!

[• Quuxplusone]

Re @zoecarver's comment about value_type = void: I observe that std::ostream_iterator<int> is such a legacy output iterator today. However, please add a test that uses a simpler type, because I don't trust ostream_iterator to continue providing a value_type member for the next decade.

The Standard's wording is sadly very opaque and confusing and scattered all over [iterators]; I'm not sure how to achieve a type with value_type = void that doesn't fall foul of many other constraints. Maybe something like this:

struct ValueTypeVoid {
    using value_type = void;
    using iterator_category = std::output_iterator_tag;
    using pointer = void*;
    using reference = int&;
    using difference_type = int;
};
static_assert(std::same_as<std::iter_value_t<ValueTypeVoid>, void>);
static_assert(!std::indirectly_readable<ValueTypeVoid>);
static_assert(!requires { typename std::iter_reference_t<ValueTypeVoid> });  // or whatever one has to type to make this work

Of course anything with value_type = void can't be indirectly_readable, because the definition of indirectly_readable requires forming iter_value_t<In>& as part of its common-reference checks.

[cjdb]

In D100073#2702169, @zoecarver wrote:

Actually, I'm still not seeing a test where value_type = void. Please add that per Louis comment / http://eel.is/c++draft/iterator.assoc.types#readable.traits-note-1

Edit: I do however see {shared,unique}_ptr<void>, so that's good!

I don't think this isn't a property of std::indirectly_readable: it's a property of std::indirectly_readable_traits. Please check lines 179-87 in indirectly_readable_traits.compile.pass.cpp for confirmation.

libcxx/include/__iterator/iterator_traits.h

42 ↗

(On Diff #338905)

No, that will create a circular dependency.

[zoecarver]

libcxx/include/__iterator/iterator_traits.h

42 ↗

(On Diff #338905)

How so? iterator_traits.h should be able to include concepts.h.

[cjdb]

libcxx/include/__iterator/iterator_traits.h

42 ↗

(On Diff #338905)

concepts.h needs to include iterator_traits.h because it needs the iterator tag types. I could alternatively put them in their own small header, but something needs to be moved around.

[zoecarver]

I don't think this isn't a property of std::indirectly_readable: it's a property of std::indirectly_readable_traits. Please check lines 179-87 in indirectly_readable_traits.compile.pass.cpp for confirmation.

Yeah, I'm glad you have that test. But the standard specifically says indirectly_readable and links to the concept. So, I don't think it would hurt to add something like Arthur commented (even though anything with a void type will be rejected during the second check for iter_reference_t).

[zoecarver]

libcxx/include/__iterator/iterator_traits.h

42 ↗

(On Diff #338905)

So, no one else needs __dereferenceable and friends? Fair enough. I'm fine with this in that case. I'd also support moving the tags into their own header, but I don't feel strongly one way or another (we can always move stuff around after the fact).

[cjdb]

In D100073#2702490, @zoecarver wrote:

I don't think this isn't a property of std::indirectly_readable: it's a property of std::indirectly_readable_traits. Please check lines 179-87 in indirectly_readable_traits.compile.pass.cpp for confirmation.

Yeah, I'm glad you have that test. But the standard specifically says indirectly_readable and links to the concept. So, I don't think it would hurt to add something like Arthur commented (even though anything with a void type will be rejected during the second check for iter_reference_t).

I really don't think this test is necessary. The note is offering commentary on why legacy iterators with a void value type have an empty indirectly_readable_traits. That transitively means the iterator won't be indirectly_readable.

libcxx/include/__iterator/iterator_traits.h

42 ↗

(On Diff #338905)

Hmm good point. I'll make a tags header instead.

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.readable/indirectly_readable.compile.pass.cpp

93

Not sure what this is being applied to (seems to have been displaced).

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.writable/indirectly_writable.compile.pass.cpp

46 ↗

(On Diff #338905)

I do want some rudimentary tests ensuring void* isn't indirectly writable.

58–65 ↗

(On Diff #338905)

Need to delete these since they're accounted for in their types' respective iterator_concept_conformance.cpp files.

[cjdb]

rebases to activate CI

[cjdb]

removes circular dependency

[cjdb]

after (much) offline discussion, adds the legacy output iterator test as well as a few others

[cjdb]

rebases to activate CI

[cjdb]

one final attempt at getting CI to pass before pushing to main and letting scheduled CI take care of it (with @ldionne's permission)

[uabelho]

Hi,

With this patch I get errors in all the new testcases. I get

error: no member named 'indirectly_readable' in namespace 'std'

and

error: no member named 'indirectly_writable' in namespace 'std'

I noticed that if I explicitly add

#include <__iterator/concepts.h>

it seems to find indirectly_readable and indirectly_writable and the testcase I tried in passed.
I've looked at iterator and see it includes <concepts>, but I can't find anyone actually including <__iterator/concepts.h>?

How is this supposed to work?

[mstorsjo]

In D100073#2707604, @uabelho wrote:

Hi,

With this patch I get errors in all the new testcases. I get

error: no member named 'indirectly_readable' in namespace 'std'

and

error: no member named 'indirectly_writable' in namespace 'std'

I'm also seeing this. I also noticed that the last completed pre-merge check build of this failed to even build on Windows: https://buildkite.com/llvm-project/libcxx-ci/builds/2685#3708ce97-e66e-451f-99c0-a5ad71dfcc0e

The pushed version does seem to build, but fails a couple dozen tests.

[davezarzycki]

I'm the third person to notice the same problems, but this time on Fedora 34 (x86-64) so I reverted the change.

@ldionne -- if you need help debugging this, please let me know.

[ldionne]

I'm looking into this now. Thanks for the heads up.

[mstorsjo]

@ldionne @cjdb This is still failing in the Windows CI, see e.g. https://buildkite.com/llvm-project/libcxx-ci/builds/2747#766d601e-b153-4c1f-a649-dde27e2d6276 for the latest scheduled CI run on the main branch:

In file included from C:\ws\w16c2-2\llvm-project\libcxx-ci\libcxx\src\optional.cpp:9:
In file included from C:/ws/w16c2-2/llvm-project/libcxx-ci/build/generic-win/include/c++/v1\optional:154:
In file included from C:/ws/w16c2-2/llvm-project/libcxx-ci/build/generic-win/include/c++/v1\functional:514:
In file included from C:/ws/w16c2-2/llvm-project/libcxx-ci/build/generic-win/include/c++/v1\memory:675:
In file included from C:/ws/w16c2-2/llvm-project/libcxx-ci/build/generic-win/include/c++/v1\iterator:441:
C:/ws/w16c2-2/llvm-project/libcxx-ci/build/generic-win/include/c++/v1\__iterator/concepts.h(40,13): error: expected expression
    { *__in } -> same_as<iter_reference_t<_In> >;
            ^
C:/ws/w16c2-2/llvm-project/libcxx-ci/build/generic-win/include/c++/v1\__iterator/concepts.h(41,7): error: no matching function for call to object of type 'const std::__1::ranges::__iter_move::__fn'
    { ranges::iter_move(__in) } -> same_as<iter_rvalue_reference_t<_In> >;
      ^~~~~~~~~~~~~~~~~
C:/ws/w16c2-2/llvm-project/libcxx-ci/build/generic-win/include/c++/v1\__iterator/iter_move.h(48,42): note: candidate function template not viable: requires single argument '__i', but no arguments were provided
  [[nodiscard]] constexpr decltype(auto) operator()(_Ip&& __i) const
                                         ^
C:/ws/w16c2-2/llvm-project/libcxx-ci/build/generic-win/include/c++/v1\__iterator/iter_move.h(61,42): note: candidate function template not viable: requires single argument '__i', but no arguments were provided
  [[nodiscard]] constexpr decltype(auto) operator()(_Ip&& __i) const
                                         ^
2 errors generated.

This doesn't seem to happen in MinGW configurations, only when impersonating MSVC. The CI configuration still runs with Clang 11.0, but I just tested with Clang 12.0 and I get the exact same issue there too.

libcxx/include/iterator

 
 template<dereferenceable T>
   requires requires(T& t) {
     { ranges::iter_move(t) } -> can-reference;
   }
 using iter_rvalue_reference_t
   = decltype(ranges::iter_move(declval<T&>()));
 
+// [iterator.concepts], iterator concepts
+// [iterator.concept.readable], concept indirectly_­readable
+template<class In>
+  concept indirectly_readable = see below;                // since C++20
+
 template<class Category, class T, class Distance = ptrdiff_t,
          class Pointer = T*, class Reference = T&>
 struct iterator
 {
     typedef T         value_type;
     typedef Distance  difference_type;
     typedef Pointer   pointer;
     typedef Reference reference;

 namespace ranges::inline __cpo {
   inline constexpr auto iter_move = __iter_move::__fn{};
 }
 
 template<__dereferenceable _Tp>
 requires requires(_Tp& __t) { { ranges::iter_move(__t) } -> __can_reference; }
 using iter_rvalue_reference_t = decltype(ranges::iter_move(declval<_Tp&>()));
 
+// [iterator.concept.readable]
+template<class _In>
+concept __indirectly_readable_impl =
+  requires(const _In __in) {
+    typename iter_value_t<_In>;
+    typename iter_reference_t<_In>;
+    typename iter_rvalue_reference_t<_In>;
+    { *__in } -> same_as<iter_reference_t<_In>>;
+    { ranges::iter_move(__in) } -> same_as<iter_rvalue_reference_t<_In>>;
+  } &&
+  common_reference_with<iter_reference_t<_In>&&, iter_value_t<_In>&> &&
+  common_reference_with<iter_reference_t<_In>&&, iter_rvalue_reference_t<_In>&&> &&
+  common_reference_with<iter_rvalue_reference_t<_In>&&, const iter_value_t<_In>&>;
+
+template<class _In>
+concept indirectly_readable = __indirectly_readable_impl<remove_cvref_t<_In>>;
+
 #undef _LIBCPP_NOEXCEPT_RETURN
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_ITERATOR

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.readable/indirectly_readable.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<class In>
+// concept indirectly_readable;
+
+#include <iterator>
+
+#include <array>
+#include <concepts>
+#include <deque>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+#include <filesystem>
+#endif
+#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 "../read_write.h"
+
+template <class In>
+[[nodiscard]] constexpr bool check_indirectly_readable() {
+  constexpr bool result = std::indirectly_readable<In>;
+  static_assert(std::indirectly_readable<In const> == result);
+  static_assert(std::indirectly_readable<In volatile> == result);
+  static_assert(std::indirectly_readable<In const volatile> == result);
+  static_assert(std::indirectly_readable<In const&> == result);
+  static_assert(std::indirectly_readable<In volatile&> == result);
+  static_assert(std::indirectly_readable<In const volatile&> == result);
+  static_assert(std::indirectly_readable<In const&&> == result);
+  static_assert(std::indirectly_readable<In volatile&&> == result);
+  static_assert(std::indirectly_readable<In const volatile&&> == result);
+  return result;
+}
+
+static_assert(check_indirectly_readable<traditional_indirection>());
+
+struct alternative_indirection {
+  using element_type = long;
+  element_type& operator*() const;
+};
+static_assert(check_indirectly_readable<alternative_indirection>());
+
+static_assert(check_indirectly_readable<proxy_indirection>());
+static_assert(check_indirectly_readable<read_only_indirection>());
+
+struct indirection_mismatch {
+  using value_type = int;
+  float& operator*() const;
+};
+static_assert(!std::same_as<std::iter_value_t<indirection_mismatch>,
+                            std::iter_reference_t<indirection_mismatch> > &&
+              check_indirectly_readable<indirection_mismatch>());
+static_assert(!check_indirectly_readable<missing_dereference>());
+
+// `iter_rvalue_reference_t` can't be missing unless the dereference operator is also missing.
+
+struct iter_move_mismatch {
+  using value_type = int;
+  value_type& operator*() const;
+
+  friend float& iter_move(iter_move_mismatch&);
+};
+static_assert(!check_indirectly_readable<iter_move_mismatch>());
+
+struct indirection_and_iter_move_mismatch {
+  using value_type = int;
+  float& operator*() const;
+
+  friend unsigned long long& iter_move(indirection_and_iter_move_mismatch&);
+};
+static_assert(!check_indirectly_readable<indirection_and_iter_move_mismatch>());
+
+struct missing_iter_value_t {
+  int operator*() const;
+};
+static_assert(!check_indirectly_readable<missing_iter_value_t>());
+
+struct lvalue_ref_has_no_common_type_with_rvalue_ref {};
+
+struct iter_ref1 {};
+namespace std {
+template <>
+struct common_reference<iter_ref1&, iter_ref1&&> {};
+
+template <>
+struct common_reference<iter_ref1&&, iter_ref1&> {};
+} // namespace std
+static_assert(!std::common_reference_with<iter_ref1&, iter_ref1&&>);
+
+struct bad_iter_reference_t {
+  using value_type = int;
+  iter_ref1& operator*() const;
+};
+static_assert(!check_indirectly_readable<bad_iter_reference_t>());
+
+struct iter_ref2 {};
+struct iter_rvalue_ref {};
+
+struct
+    no_common_reference_between_rvalue_ref_to_iter_ref_and_rvalue_ref_to_iter_rvalue_ref {
+  using value_type = iter_ref2;
+  iter_ref2& operator*() const;
+  friend iter_rvalue_ref&& iter_move(
+      no_common_reference_between_rvalue_ref_to_iter_ref_and_rvalue_ref_to_iter_rvalue_ref);
+};
+static_assert(
+    !check_indirectly_readable<
+        no_common_reference_between_rvalue_ref_to_iter_ref_and_rvalue_ref_to_iter_rvalue_ref>());
+
+struct iter_ref3 {
+  operator iter_rvalue_ref() const;
+};
+namespace std {
+template <template <class> class XQual, template <class> class YQual>
+struct basic_common_reference<iter_ref3, iter_rvalue_ref, XQual, YQual> {
+  using type = iter_rvalue_ref;
+};
+template <template <class> class XQual, template <class> class YQual>
+struct basic_common_reference<iter_rvalue_ref, iter_ref3, XQual, YQual> {
+  using type = iter_rvalue_ref;
+};
+} // namespace std
+static_assert(std::common_reference_with<iter_ref3&&, iter_rvalue_ref&&>);
+
+struct different_reference_types_but_share_common_reference {
+  using value_type = iter_ref3;
+  iter_ref3& operator*() const;
+  friend iter_rvalue_ref&&
+      iter_move(different_reference_types_but_share_common_reference);
+};
+static_assert(check_indirectly_readable<
+              different_reference_types_but_share_common_reference>());
+
+struct iter_ref4 {
+  operator iter_rvalue_ref() const;
+};
+namespace std {
+template <template <class> class XQual, template <class> class YQual>
+struct basic_common_reference<iter_ref4, iter_rvalue_ref, XQual, YQual> {
+  using type = iter_rvalue_ref;
+};
+template <template <class> class XQual, template <class> class YQual>
+struct basic_common_reference<iter_rvalue_ref, iter_ref4, XQual, YQual> {
+  using type = iter_rvalue_ref;
+};
+
+template <>
+struct common_reference<iter_ref4 const&, iter_rvalue_ref&&> {};
+template <>
+struct common_reference<iter_rvalue_ref&&, iter_ref4 const&> {};
+} // namespace std
+static_assert(std::common_reference_with<iter_ref4&&, iter_rvalue_ref&&>);
+static_assert(!std::common_reference_with<iter_ref4 const&, iter_rvalue_ref&&>);
+
+struct different_reference_types_without_common_reference_to_const {
+  using value_type = iter_ref4;
+  iter_ref4& operator*() const;
+  friend iter_rvalue_ref&&
+      iter_move(different_reference_types_without_common_reference_to_const);
+};
+static_assert(!check_indirectly_readable<
+              different_reference_types_without_common_reference_to_const>());
+
+namespace standard_types {
+static_assert(check_indirectly_readable<int*>());
+static_assert(check_indirectly_readable<int const*>());
+static_assert(check_indirectly_readable<int volatile*>());
+static_assert(check_indirectly_readable<int const volatile*>());
+
+// <array>
+static_assert(check_indirectly_readable<std::array<int, 10>::iterator>());
+static_assert(check_indirectly_readable<std::array<int, 10>::const_iterator>());
+static_assert(
+    check_indirectly_readable<std::array<int, 10>::reverse_iterator>());
+static_assert(
+    check_indirectly_readable<std::array<int, 10>::const_reverse_iterator>());
+
+// <deque>
+static_assert(check_indirectly_readable<std::deque<int>::iterator>());
+static_assert(check_indirectly_readable<std::deque<int>::const_iterator>());
+static_assert(check_indirectly_readable<std::deque<int>::reverse_iterator>());
+static_assert(
+    check_indirectly_readable<std::deque<int>::const_reverse_iterator>());
+
+// <filesystem>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+static_assert(check_indirectly_readable<std::filesystem::directory_iterator>());
+static_assert(
+    check_indirectly_readable<std::filesystem::recursive_directory_iterator>());
+#endif
+
+// <forward_list>
+static_assert(check_indirectly_readable<std::forward_list<int>::iterator>());
+static_assert(
+    check_indirectly_readable<std::forward_list<int>::const_iterator>());
+
+// <iterator>
+static_assert(!check_indirectly_readable<
+              std::back_insert_iterator<std::vector<int> > >());
+static_assert(!check_indirectly_readable<
+              std::front_insert_iterator<std::deque<int> > >());
+static_assert(
+    !check_indirectly_readable<std::insert_iterator<std::deque<int> > >());
+static_assert(check_indirectly_readable<std::istream_iterator<int, char> >());
+static_assert(check_indirectly_readable<std::istreambuf_iterator<char> >());
+static_assert(check_indirectly_readable<
+              std::move_iterator<std::vector<int>::iterator> >());
+static_assert(!check_indirectly_readable<std::ostream_iterator<int, char> >());
+static_assert(
+    !check_indirectly_readable<std::ostreambuf_iterator<int, char> >());
+
+// <list>
+static_assert(check_indirectly_readable<std::list<int>::iterator>());
+static_assert(check_indirectly_readable<std::list<int>::const_iterator>());
+static_assert(check_indirectly_readable<std::list<int>::reverse_iterator>());
+static_assert(
+    check_indirectly_readable<std::list<int>::const_reverse_iterator>());
+
+// <map>
+static_assert(check_indirectly_readable<std::map<int, int>::iterator>());
+static_assert(check_indirectly_readable<std::map<int, int>::const_iterator>());
+static_assert(
+    check_indirectly_readable<std::map<int, int>::reverse_iterator>());
+static_assert(
+    check_indirectly_readable<std::map<int, int>::const_reverse_iterator>());
+
+static_assert(check_indirectly_readable<std::multimap<int, int>::iterator>());
+static_assert(
+    check_indirectly_readable<std::multimap<int, int>::const_iterator>());
+static_assert(
+    check_indirectly_readable<std::multimap<int, int>::reverse_iterator>());
+static_assert(check_indirectly_readable<
+              std::multimap<int, int>::const_reverse_iterator>());
+
+// <memory>
+static_assert(check_indirectly_readable<std::shared_ptr<int> >());
+static_assert(!check_indirectly_readable<std::shared_ptr<void> >());
+static_assert(check_indirectly_readable<std::unique_ptr<int> >());
+static_assert(!check_indirectly_readable<std::unique_ptr<void> >());
+
+// <optional>
+static_assert(!check_indirectly_readable<std::optional<int> >());
+
+// <set>
+static_assert(check_indirectly_readable<std::set<int>::iterator>());
+static_assert(check_indirectly_readable<std::set<int>::const_iterator>());
+static_assert(check_indirectly_readable<std::set<int>::reverse_iterator>());
+static_assert(
+    check_indirectly_readable<std::set<int>::const_reverse_iterator>());
+
+static_assert(check_indirectly_readable<std::multiset<int>::iterator>());
+static_assert(check_indirectly_readable<std::multiset<int>::const_iterator>());
+static_assert(
+    check_indirectly_readable<std::multiset<int>::reverse_iterator>());
+static_assert(
+    check_indirectly_readable<std::multiset<int>::const_reverse_iterator>());
+
+// <string>
+static_assert(check_indirectly_readable<std::string::iterator>());
+static_assert(check_indirectly_readable<std::string::const_iterator>());
+static_assert(check_indirectly_readable<std::string::reverse_iterator>());
+static_assert(check_indirectly_readable<std::string::const_reverse_iterator>());
+
+// <string_view>
+static_assert(check_indirectly_readable<std::string_view::iterator>());
+static_assert(check_indirectly_readable<std::string_view::const_iterator>());
+static_assert(check_indirectly_readable<std::string_view::reverse_iterator>());
+static_assert(
+    check_indirectly_readable<std::string_view::const_reverse_iterator>());
+
+// <unordered_map>
+static_assert(
+    check_indirectly_readable<std::unordered_map<int, int>::iterator>());
+static_assert(
+    check_indirectly_readable<std::unordered_map<int, int>::const_iterator>());
+
+static_assert(
+    check_indirectly_readable<std::unordered_multimap<int, int>::iterator>());
+static_assert(check_indirectly_readable<
+              std::unordered_multimap<int, int>::const_iterator>());
+
+// <unordered_set>
+static_assert(check_indirectly_readable<std::unordered_set<int>::iterator>());
+static_assert(
+    check_indirectly_readable<std::unordered_set<int>::const_iterator>());
+
+static_assert(
+    check_indirectly_readable<std::unordered_multiset<int, int>::iterator>());
+static_assert(check_indirectly_readable<
+              std::unordered_multiset<int, int>::const_iterator>());
+
+// <vector>
+static_assert(check_indirectly_readable<std::vector<int>::iterator>());
+static_assert(check_indirectly_readable<std::vector<int>::const_iterator>());
+static_assert(check_indirectly_readable<std::vector<int>::reverse_iterator>());
+static_assert(
+    check_indirectly_readable<std::vector<int>::const_reverse_iterator>());
+static_assert(!check_indirectly_readable<std::vector<int> >());
+} // namespace standard_types

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/read_write.h

+//===----------------------------------------------------------------------===//
+//
+// 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 LIBCPP_TEST_STD_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_CONCEPTS_READ_WRITE_H
+#define LIBCPP_TEST_STD_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_CONCEPTS_READ_WRITE_H
+
+struct traditional_indirection {
+  using value_type = int;
+  value_type& operator*() const;
+};
+
+struct proxy_indirection {
+  using value_type = int;
+  value_type operator*() const;
+};
+
+struct read_only_indirection {
+  using value_type = int const;
+  value_type& operator*() const;
+};
+
+// doubles as missing_iter_reference_t
+struct missing_dereference {
+  using value_type = int;
+};
+
+#endif // LIBCPP_TEST_STD_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_CONCEPTS_READ_WRITE_H