[libc++][ranges] Implement `indirectly_copyable{,_storable}`.

[var-const]

Summary

Also refactor tests for indirectly_movable{,_storable}.

[var-const]

Add a link to the patch to the status page.

[var-const]

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.move/indirectly_movable.compile.pass.cpp

19–20

It seems to be exactly the same as PointerTo<int>.

52

This line was redundant.

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.move/indirectly_movable_storable.compile.pass.cpp

41

IIUC, the details about conversions are the only interesting things about this class -- it doesn't have to be move-only and doesn't relate to MoveOnly. It seems simpler to create a separate group of classes rather than attach it to the existing MoveOnly.

74–119

While I think I understand the original intention here, specializing basic_common_reference doesn't seem to have any effect on the test (the test passes as is without the specialization and would fail if there is a conversion between ValueType and ReferenceType regardless of the specialization).

[• Quuxplusone]

I have many nits on the tests, but there's nothing terribly awful in there. It's great that you're finishing up these loose ends! Thanks!

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.copy/indirectly_copyable.compile.pass.cpp

22–28

(1) From the placement, I wonder if MoveOnly() = default; was meant to say ~MoveOnly() = default;.
(2) Lines 23 and 25 are superfluous.
(3) We could use "test/support/MoveOnly.h" instead; is it worth it?

73

I'm confused about this one. CopyOnly(CopyOnly&&) = delete;, so how is indirectly_writable<_Out, iter_value_t<_In>&&> satisfied?

81

I recommend replacing line 80 with

static_assert( std::indirectly_copyable<PointerTo<int>, int*>);
static_assert(!std::indirectly_copyable<PointerTo<const int>, const int*>);

for better symmetry with lines 78–79. (If symmetry with those lines wasn't the point, then I don't see the point.)

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.copy/indirectly_copyable.subsumption.compile.pass.cpp

17

This line can be removed AFAICT.

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.copy/indirectly_copyable_storable.compile.pass.cpp

38–42

The second template param is used on line 69 below. For simplicity, I'd rather see template<class T> struct PointerTo here, and a completely separate (non-template) struct ProxyPointer on line 69.
I'm also currently puzzled by the name "proxy pointer" and the comment on lines 67–68: how is this like a proxy? But I think that will become clearer as you simplify. I believe both Foo and FooConvertible can become members of struct ProxyPointer, which will encapsulate them a bit better and perhaps also eliminate the need for the forward declaration of FooConvertible.

74–124

I think these 50 lines are pointless; none of these types are even movable, so of course pointers to them won't be indirectly_copyable.

137–138

Same comment here as above: PointerTo should be a template of one parameter, ProxyPointerBar should be a struct not an alias, and Bar/AssignableToBar should be members of ProxyPointerBar.

141

This should be a member of NotConstructibleFromRefIn.

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.move/indirectly_movable.compile.pass.cpp

24–26

The comment on line 39 is wrong (but also unnecessary).
Line 41 is now redundant with line 37. I think all you really want is to replace lines 35–41 with

static_assert( std::indirectly_movable<int*, int*>);
static_assert(!std::indirectly_movable<int*, const int*>);
static_assert( std::indirectly_movable<const int*, int*>);
static_assert(!std::indirectly_movable<const int*, const int*>);

with no comments necessary at all.

28

You certainly can move from an array (element), so this comment is wrong.
My intuition says that the real hurdle here is that an array type is not an iterator type, so it's not indirectly-anything — it has no iter_value_t. (But then, an optional isn't an iterator either, and I think optionals are indirectly-fooable, so my intuitive explanation may be wrong.)

37–38

FWIW, this test strikes me as redundant. There's nothing special about empty types in this context; changing the distracting name, this is really just testing that struct A {}; is movable. Which of course it is; there's nothing special about class types as opposed to int in this context, either.

But, it might be nice to see ~10 lines of sanity tests for e.g. indirectly_movable<void*, void*>, indirectly_movable<int*, void*>, indirectly_movable<int(), int()>, indirectly_movable<int*, int()>, indirectly_movable<void, void>, indirectly_movable<int*, void>... just to prove they don't explode.

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.move/indirectly_movable_storable.compile.pass.cpp

136

Could you use AssignableFromAnything* here instead of AssignableFromAnythingProxy? I don't see that AssignableFromAnythingProxy's struct-ness matters to this test.
Ditto line 167.

[var-const]

Address review feedback.

[var-const]

Very useful comments, thanks!

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.copy/indirectly_copyable.compile.pass.cpp

22–28

1. Hmm, semantically it makes sense to define the default constructor (move/copy constructor inhibit the compiler-generated default constructor), but not the default destructor (which is pretty much always generated).

2. True -- I guess the original intent was to be more explicit. I don't have a strong preference.

3. I think so; it also sidesteps issues 1 and 2.

73

indirectly_copyable only requires indirectly_writable<_Out, iter_reference_t<_In>>. Maybe you're thinking of indirectly_copyable_storable, which does require indirectly_writable<_Out, iter_value_t<_In>&&> ?

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.copy/indirectly_copyable_storable.compile.pass.cpp

38–42

Done (it looks like the forward declaration is still necessary, unfortunately).

Regarding the name -- the idea was that it's a pointer that returns a proxy of the type it points to, rather than the type itself (similar to how vector<bool>'s reference type isn't the same as value_type&). So it's more like "a pointer that returns a proxy" rather than "a pointer that itself is a proxy".

74–124

Actually, while none of these types are copyable, DeletedNonconstCopyCtor and DeletedNonconstCopyAssignment _are_ movable. Do you think this is an issue with movable?

141

Done. Whether basic_common_reference is specialized still has no effect on the test.

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.move/indirectly_movable.compile.pass.cpp

24–26

Thanks for catching this! I'd still keep the comment, though -- mostly because it helps me split the tests into logical groups visually.

28

I'm actually not sure about the behavior here.

Intuitively, it would seem to me that:

• indirectly_movable<int[2], int*> _should_ work due to array-to-pointer decay. After all, just like you said, you can move from an array -- int *ptr, arr[2]; *ptr = std::move(*arr); is certainly valid;
• in either case, I would expect this to be commutative -- i.e., indirectly_movable<int*, int[2]> and indirectly_movable<int[2], int*> should either both be true or both be false.

My intuition says that the real hurdle here is that an array type is not an iterator type, so it's not indirectly-anything — it has no iter_value_t.

iter_value_t does in fact work on array types -- static_assert(is_same_v<iter_value_t<int[2]>, int>); is successful with both libc++ and libstdc++, at least.

Digging a little into this, it appears that for indirectly_movable<int[2], int*> is false because it is indirectly writable but not indirectly readable. Reducing as much as possible, it boils down to:

template<class In>
concept simplified_indirectly_readable =
  requires(const In i) {
    { *i } -> same_as<iter_reference_t<In>>;
  };

static_assert( simplified_indirectly_readable<int*>);
static_assert(!simplified_indirectly_readable<int[2]>);

(there's also { ranges::iter_move(i) } -> same_as<iter_rvalue_reference_t<In>>; failing for the same reason, so it can be ignored)

The reason this check:

{ *i } -> same_as<iter_reference_t<In>>

works for pointers but fails for arrays comes down to template argument deduction. The const In i argument decays from array to pointer as expected; however:

• when In is a pointer, the const in the signature "attaches" to the pointer itself, so that it is a const pointer to a non-const object (int* const);
• when In is an array, the const in the signature "attaches" to the type referred to, so that it's a const array that decays to a non-const pointer to a const object (const int*).

For a quick illustration:

template <class T>
void Foo(const T x) {
  static_assert(is_same_v<decltype(x), const int*>);
}

template <class T>
void Bar(const T x) {
  static_assert(is_same_v<decltype(x), int* const>);
}

void Test() {
  int arr[2];
  Foo<int[2]>(arr);
  
  int* ptr = nullptr;
  Bar<int*>(ptr);
}

(link)

It seems to me that this is pretty subtle and I wonder whether this is intentional -- basically, whether arrays are intentionally not indirectly_readable, or it's just a by-product of the implementation. If arrays are intentionally not_readable, it seems like they should be excluded in a more obvious way.

Let me know what you think (and if you see any errors in my reasoning).

37–38

Agreed on both.

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.move/indirectly_movable_storable.compile.pass.cpp

136

Right -- I got too caught up in renamings and missed that it could just be a pointer. Thanks!

[var-const]

Update all iterator_concept_conformance tests.

[var-const]

Note: I've also updated all the iterator_concept_conformance tests (under the assumption that for iterators, indirectly_copyable{,_storable} always behaves the same as indirectly_movable{,_storable}.

[• Quuxplusone]

In D118432#3281339, @var-const wrote:

Note: I've also updated all the iterator_concept_conformance tests (under the assumption that for iterators, indirectly_copyable{,_storable} always behaves the same as indirectly_movable{,_storable}.

I have a patch locally (but apparently never got around to submitting it for review) that simply removes all of the "detail" concepts from every iterator_concept_conformance.compile.pass.cpp, leaving only the iterator concepts like forward_iterator and bidirectional_iterator (and only the relevant ones of those, even). I don't object to your expanding those tests, but I certainly wasn't going to ask you to do it.

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.move/indirectly_movable.compile.pass.cpp

37–38

Foo is now unused (right?)

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.move/indirectly_movable_storable.compile.pass.cpp

26–36

In the time it takes to explain that this check is non-exhaustive, you could have made it exhaustive. :)

static_assert( std::indirectly_movable_storable<int*, int*>);
static_assert( std::indirectly_movable_storable<const int*, int *>);
static_assert(!std::indirectly_movable_storable<int*, const int*>);
static_assert(!std::indirectly_movable_storable<const int*, const int *>);
static_assert( std::indirectly_movable_storable<int*, int[2]>);
static_assert(!std::indirectly_movable_storable<int[2], int*>);  // right?

59

Here I think you could just test !std::indirectly_movable_storable<FooConvertible*, Foo*>, couldn't you? You've got the same weird pattern on lines 47-48 as on line 82 below, but even if you change it to Foo operator*() const, I don't see why you need ProxyPointerFoo's value_type to be different from its actual decay_t<decltype(*it)>. This test seems just to be testing that if you have In and Out where *Out = *In isn't well-formed, then indirectly_movable_storable is false.

88

ProxyPointerBar seems like the wrong name for this type. It's basically just a PointerTo<Bar> — you dereference it, you get a reference to an existing Bar object — but it's just got the "wrong" value_type.
To make this more like a proxy iterator (like vector<bool>::iterator, for example), you should declare Bar operator*() const; without the ampersand. If you do that, does the test still pass? Does it still test whatever-is-being-tested-here?
(Strongly consider renaming s/Bar/Reference/ and s/AssignableToBar/ValueType/.)

99–101

Move this definition up to line 92, to eliminate the forward reference.

108–109

Same comment here as on line 82: it's highly unusual to have an iterator type whose operator* returns an X& but whose value type is Y. To make this a proxy iterator, change ReferenceType& to just ReferenceType. (And I'd drop the Type, for consistency with the name of the iterator trait reference.)

126

Let's add above this line

static_assert( std::indirectly_movable_storable<int*, AssignableFromAnything*>);

just to prove it's testing what we think it's testing.

[var-const]

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.move/indirectly_movable.compile.pass.cpp

28

@Quuxplusone Any thoughts on this?

[• Quuxplusone]

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.move/indirectly_movable.compile.pass.cpp

28

@Quuxplusone Any thoughts on this?

Not particularly. As you say, "when In is a pointer, the const in the signature "attaches" to the pointer itself [...] when In is an array, the const in the signature "attaches" to the type referred to". It would probably be a bit nicer if the requires-expression's parameter list in https://eel.is/c++draft/iterator.concept.readable took const In& instead of const In; but that wouldn't change the outcome.

Anyway, the comment "cannot move from an array" is still wrong. Personally I'd solve the issue by eliminating all these comments; but if you really want keep the comment, I still think "an array is not an iterator" is a reasonable explanation.

[var-const]

In D118432#3281773, @Quuxplusone wrote:

In D118432#3281339, @var-const wrote:

Note: I've also updated all the iterator_concept_conformance tests (under the assumption that for iterators, indirectly_copyable{,_storable} always behaves the same as indirectly_movable{,_storable}.

I have a patch locally (but apparently never got around to submitting it for review) that simply removes all of the "detail" concepts from every iterator_concept_conformance.compile.pass.cpp, leaving only the iterator concepts like forward_iterator and bidirectional_iterator (and only the relevant ones of those, even). I don't object to your expanding those tests, but I certainly wasn't going to ask you to do it.

I see, thanks for the heads-up.

[var-const]

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.move/indirectly_movable.compile.pass.cpp

28

I mean I'm not sure indirectly_movable<int[2], int*> is actually supposed to be false. I'll start a thread on the LWG reflector.

Anyway, the comment "cannot move from an array" is still wrong. Personally I'd solve the issue by eliminating all these comments; but if you really want keep the comment, I still think "an array is not an iterator" is a reasonable explanation.

My intended meaning was "cannot indirectly-move from an array" (which is true because it's basically saying indirectly_movable<array_type, pointer> == false in natural language). I'm not sure that the problem is that an array is not an iterator -- at least iterator traits do consider it an iterator (due to decay). Removing the comment is tempting but feels like sidestepping the issue. All in all, I'd go with "Arrays are not considered indirectly movable-from".

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.move/indirectly_movable_storable.compile.pass.cpp

26–36

Added these tests (but I still don't consider these exhaustive, exhaustive would be completely copying the tests for indirectly_movable).

126

Thanks!

[var-const]

Address feedback

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.move/indirectly_movable_storable.compile.pass.cpp

59

(this is a pre-existing test)
I think what's being tested here is that indirectly_movable_storable requires (omitting irrelevant part) indirectly_movable<In, Out> and indirectly_writable<Out, iter_value_t<In>>. indirectly_movable<In, Out, in turn, requires indirectly_writable<Out, iter_rvalue_reference<In>>; in the end, it boils down to:

indirectly_writable<Out, iter_value_t<In>> &&
indirectly_writable<Out, iter_rvalue_reference_t<In>>;

So this test tries to set up the situation where only one of these requirements is true. I don't think !std::indirectly_movable_storable<FooConvertible*, Foo*> covers the same case:

static_assert(!std::indirectly_writable<Foo*, std::iter_rvalue_reference_t<FooConvertible*>>); // False
static_assert( std::indirectly_writable<ProxyPointerFoo, std::iter_rvalue_reference_t<ProxyPointerFoo>>); // True

88

If you do that, does the test still pass?

No -- it's no longer indirectly_writable.

While I see your point about the ProxyPointer name, I think the fact that it has "wrong" value_type is crucial for the class (it's essentially the reason for its existence), and just PointerTo omits that. How about InconsistentIterator? (It's not really a pointer)

Strongly consider renaming s/Bar/Reference/ and s/AssignableToBar/ValueType/

The current names are supposed to convey that Bar is a completely uninteresting class on its own and AssignableToBar is a class that can be assigned to Bar. ValueType and Reference obscure that -- in fact, just looking at them, I'd expect that Reference is an alias for ValueType&. So I'd rather keep the current names.

108–109

I'd prefer to keep as is, at least for this patch (this is preexisting code).

[• Quuxplusone]

You can fix the Apple-Clang CI failures by rebasing.
(Incidentally, I'm surprised that people don't rebase reflexively when reuploading a diff. I rebase like five times a day even when I'm not uploading. :D)

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.move/indirectly_movable_storable.compile.pass.cpp

88

The current names are supposed to convey that Bar is a completely uninteresting class on its own and AssignableToBar is a class that can be assigned to Bar.

But those names aren't being used anywhere where that isn't already abundantly obvious (i.e., within 2 lines of the class definition). Contrariwise, the fact that some type is the ValueType of InconsistentIteratorBar, I think, is relevant information. Actually the presence of Bar in the name InconsistentIteratorBar is the thing that stands out right now: what is a Bar? There's no Bar in the global scope, no reason for any user to care about Bar. The only salient thing about Bar is that it's the value type of InconsistentIterator[Bar]... well, except that it's not. Which is why this test is weird. It's not a "proxy iterator", but it's also... well, what is it? If there's no sensible name for it, I'd just as soon name it struct A...

[var-const]

Rebase on main.

[var-const]

• address feedback;
• exhaustively check all the indirectly_writable requirements of indirectly_copyable_storable.

[var-const]

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.move/indirectly_movable_storable.compile.pass.cpp

88

Ok, I decided to check these requirements exhaustively:

template<class _In, class _Out>
concept indirectly_copyable_storable =
  indirectly_writable<_Out, iter_value_t<_In>&> &&
  indirectly_writable<_Out, const iter_value_t<_In>&> &&
  indirectly_writable<_Out, iter_value_t<_In>&&> &&
  indirectly_writable<_Out, const iter_value_t<_In>&&> &&
  ...

This created 4 forms of InconsistentIteratorFoo and led me to rename them just to show the most interesting thing about them, like NoConstRvalueAssignment. Let me know what you think. I also applied your suggestion to use ValueType and ReferenceType as names.

[ldionne]

Trusting Arthur's review.

libcxx/docs/Status/RangesPaper.csv

 | `indirectly_regular_unary_invocable <https://llvm.org/D101277>`_
 | `indirectly_unary_predicate <https://llvm.org/D101277>`_
 | `indirectly_binary_predicate <https://llvm.org/D101277>`_
 | `indirectly_equivalence_relation <https://llvm.org/D101277>`_
 | `indirectly_strict_weak_order <https://llvm.org/D101277>`_",[readable.traits],Louis Dionne,✅
 `[projected] <https://wg21.link/projected>`_,`ranges::projected <https://llvm.org/D101277>`_,[iterator.concepts],Louis Dionne,✅
 `[common.alg.req] <https://wg21.link/common.alg.req>`_: pt. 1,"| `indirectly_movable <https://llvm.org/D102639>`_
 | `indirectly_movable_storable <https://llvm.org/D102639>`_
-| indirectly_copyable
-| indirectly_copyable_storable",[iterator.concepts],Zoe Carver,In progress
+| `indirectly_copyable <https://llvm.org/D118432>`_
+| `indirectly_copyable_storable <https://llvm.org/D118432>`_",[iterator.concepts],Zoe Carver and Konstantin Varlamov,✅
 `[common.alg.req] <https://wg21.link/common.alg.req>`_: pt. 2,`indirectly_swappable <https://llvm.org/D105304>`_,"| [iterator.concepts]
 | [iterator.cust.swap]",Zoe Carver,✅
 `[common.alg.req] <https://wg21.link/common.alg.req>`_: pt. 3,`indirectly_comparable <https://llvm.org/D116268>`_,[projected],Nikolas Klauser,✅
 `[common.alg.req] <https://wg21.link/common.alg.req>`_: pt. 4,"| permutable
 | mergeable
 | sortable",[iterator.concepts],Unassigned,Not started
 `[std.iterator.tags] <https://wg21.link/std.iterator.tags>`_,"`contiguous_iterator_tag <https://reviews.llvm.org/rG45d048c20440989df2b4e1be1f9343225e7741ab>`_
 | `iterator_concept specialization for pointers <https://reviews.llvm.org/rG45d048c20440989df2b4e1be1f9343225e7741ab>`_

libcxx/include/__iterator/concepts.h

 template<class _In, class _Out>
 concept indirectly_movable_storable =
   indirectly_movable<_In, _Out> &&
   indirectly_writable<_Out, iter_value_t<_In>> &&
   movable<iter_value_t<_In>> &&
   constructible_from<iter_value_t<_In>, iter_rvalue_reference_t<_In>> &&
   assignable_from<iter_value_t<_In>&, iter_rvalue_reference_t<_In>>;
 
+template<class _In, class _Out>
+concept indirectly_copyable =
+  indirectly_readable<_In> &&
+  indirectly_writable<_Out, iter_reference_t<_In>>;
+
+template<class _In, class _Out>
+concept indirectly_copyable_storable =
+  indirectly_copyable<_In, _Out> &&
+  indirectly_writable<_Out, iter_value_t<_In>&> &&
+  indirectly_writable<_Out, const iter_value_t<_In>&> &&
+  indirectly_writable<_Out, iter_value_t<_In>&&> &&
+  indirectly_writable<_Out, const iter_value_t<_In>&&> &&
+  copyable<iter_value_t<_In>> &&
+  constructible_from<iter_value_t<_In>, iter_reference_t<_In>> &&
+  assignable_from<iter_value_t<_In>&, iter_reference_t<_In>>;
+
 // Note: indirectly_swappable is located in iter_swap.h to prevent a dependency cycle
 // (both iter_swap and indirectly_swappable require indirectly_readable).
 
 #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_CONCEPTS_H

libcxx/include/iterator

 
 // [alg.req.ind.move], concept indirectly_movable
 template<class In, class Out>
   concept indirectly_movable = see below;                  // since C++20
 
 template<class In, class Out>
   concept indirectly_movable_storable = see below;         // since C++20
 
+// [alg.req.ind.copy], concept indirectly_copyable
+template<class In, class Out>
+  concept indirectly_copyable = see below;                  // since C++20
+
+template<class In, class Out>
+  concept indirectly_copyable_storable = see below;         // since C++20
+
 // [alg.req.ind.swap], concept indirectly_swappable
 template<class I1, class I2 = I1>
   concept indirectly_swappable = see below;                // since C++20
 
 template<class I1, class I2, class R, class P1 = identity,
          class P2 = identity>
   concept indirectly_comparable =
     indirect_binary_predicate<R, projected<I1, P1>, projected<I2, P2>>; // since C++20

libcxx/test/std/containers/associative/map/iterator_concept_conformance.compile.pass.cpp

 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, iterator>);
 static_assert(!std::sized_sentinel_for<iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, const_reverse_iterator>);
 static_assert( std::indirectly_movable<iterator, std::pair<int, int>*>);
 static_assert(!std::indirectly_movable_storable<iterator, std::pair<int, int>*>);
+static_assert( std::indirectly_copyable<iterator, std::pair<int, int>*>);
+static_assert(!std::indirectly_copyable_storable<iterator, std::pair<int, int>*>);
 static_assert(!std::indirectly_swappable<iterator, iterator>);
 
 static_assert(std::bidirectional_iterator<const_iterator>);
 static_assert(!std::random_access_iterator<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert(!std::indirectly_swappable<const_iterator, const_iterator>);

libcxx/test/std/containers/associative/multimap/iterator_concept_conformance.compile.pass.cpp

 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, iterator>);
 static_assert(!std::sized_sentinel_for<iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, const_reverse_iterator>);
 static_assert( std::indirectly_movable<iterator, std::pair<int, int>*>);
 static_assert(!std::indirectly_movable_storable<iterator, std::pair<int, int>*>);
+static_assert( std::indirectly_copyable<iterator, std::pair<int, int>*>);
+static_assert(!std::indirectly_copyable_storable<iterator, std::pair<int, int>*>);
 static_assert(!std::indirectly_swappable<iterator, iterator>);
 
 static_assert(std::bidirectional_iterator<const_iterator>);
 static_assert(!std::random_access_iterator<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert(!std::indirectly_swappable<const_iterator, const_iterator>);

libcxx/test/std/containers/associative/multiset/iterator_concept_conformance.compile.pass.cpp

 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, iterator>);
 static_assert(!std::sized_sentinel_for<iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, const_reverse_iterator>);
 static_assert(std::indirectly_movable<iterator, int*>);
 static_assert(std::indirectly_movable_storable<iterator, int*>);
+static_assert(std::indirectly_copyable<iterator, int*>);
+static_assert(std::indirectly_copyable_storable<iterator, int*>);
 static_assert(!std::indirectly_swappable<iterator, iterator>);
 
 static_assert(std::bidirectional_iterator<const_iterator>);
 static_assert(!std::random_access_iterator<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert(!std::indirectly_swappable<const_iterator, const_iterator>);

libcxx/test/std/containers/associative/set/iterator_concept_conformance.compile.pass.cpp

 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, iterator>);
 static_assert(!std::sized_sentinel_for<iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, const_reverse_iterator>);
 static_assert(std::indirectly_movable<iterator, int*>);
 static_assert(std::indirectly_movable_storable<iterator, int*>);
+static_assert(std::indirectly_copyable<iterator, int*>);
+static_assert(std::indirectly_copyable_storable<iterator, int*>);
 static_assert(!std::indirectly_swappable<iterator, iterator>);
 
 static_assert(std::bidirectional_iterator<const_iterator>);
 static_assert(!std::random_access_iterator<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert(!std::indirectly_swappable<const_iterator, const_iterator>);

libcxx/test/std/containers/sequences/array/iterator_concept_conformance.compile.pass.cpp

 static_assert( std::indirectly_movable<iterator, iterator>);
 static_assert( std::indirectly_movable_storable<iterator, iterator>);
 static_assert(!std::indirectly_movable<iterator, const_iterator>);
 static_assert(!std::indirectly_movable_storable<iterator, const_iterator>);
 static_assert( std::indirectly_movable<iterator, reverse_iterator>);
 static_assert( std::indirectly_movable_storable<iterator, reverse_iterator>);
 static_assert(!std::indirectly_movable<iterator, const_reverse_iterator>);
 static_assert(!std::indirectly_movable_storable<iterator, const_reverse_iterator>);
+static_assert( std::indirectly_copyable<iterator, iterator>);
+static_assert( std::indirectly_copyable_storable<iterator, iterator>);
+static_assert(!std::indirectly_copyable<iterator, const_iterator>);
+static_assert(!std::indirectly_copyable_storable<iterator, const_iterator>);
+static_assert( std::indirectly_copyable<iterator, reverse_iterator>);
+static_assert( std::indirectly_copyable_storable<iterator, reverse_iterator>);
+static_assert(!std::indirectly_copyable<iterator, const_reverse_iterator>);
+static_assert(!std::indirectly_copyable_storable<iterator, const_reverse_iterator>);
 static_assert( std::indirectly_swappable<iterator, iterator>);
 
 static_assert(std::contiguous_iterator<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, int>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert(std::sized_sentinel_for<const_iterator, iterator>);
 static_assert(std::sized_sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert( std::indirectly_movable<const_iterator, iterator>);
 static_assert( std::indirectly_movable_storable<const_iterator, iterator>);
 static_assert(!std::indirectly_movable<const_iterator, const_iterator>);
 static_assert(!std::indirectly_movable_storable<const_iterator, const_iterator>);
 static_assert( std::indirectly_movable<const_iterator, reverse_iterator>);
 static_assert( std::indirectly_movable_storable<const_iterator, reverse_iterator>);
 static_assert(!std::indirectly_movable<const_iterator, const_reverse_iterator>);
 static_assert(!std::indirectly_movable_storable<const_iterator, const_reverse_iterator>);
+static_assert( std::indirectly_copyable<const_iterator, iterator>);
+static_assert( std::indirectly_copyable_storable<const_iterator, iterator>);
+static_assert(!std::indirectly_copyable<const_iterator, const_iterator>);
+static_assert(!std::indirectly_copyable_storable<const_iterator, const_iterator>);
+static_assert( std::indirectly_copyable<const_iterator, reverse_iterator>);
+static_assert( std::indirectly_copyable_storable<const_iterator, reverse_iterator>);
+static_assert(!std::indirectly_copyable<const_iterator, const_reverse_iterator>);
+static_assert(!std::indirectly_copyable_storable<const_iterator, const_reverse_iterator>);
 static_assert(!std::indirectly_swappable<const_iterator, const_iterator>);

libcxx/test/std/containers/sequences/deque/iterator_concept_conformance.compile.pass.cpp

 static_assert( std::indirectly_movable<iterator, iterator>);
 static_assert( std::indirectly_movable_storable<iterator, iterator>);
 static_assert(!std::indirectly_movable<iterator, const_iterator>);
 static_assert(!std::indirectly_movable_storable<iterator, const_iterator>);
 static_assert( std::indirectly_movable<iterator, reverse_iterator>);
 static_assert( std::indirectly_movable_storable<iterator, reverse_iterator>);
 static_assert(!std::indirectly_movable<iterator, const_reverse_iterator>);
 static_assert(!std::indirectly_movable_storable<iterator, const_reverse_iterator>);
+static_assert( std::indirectly_copyable<iterator, iterator>);
+static_assert( std::indirectly_copyable_storable<iterator, iterator>);
+static_assert(!std::indirectly_copyable<iterator, const_iterator>);
+static_assert(!std::indirectly_copyable_storable<iterator, const_iterator>);
+static_assert( std::indirectly_copyable<iterator, reverse_iterator>);
+static_assert( std::indirectly_copyable_storable<iterator, reverse_iterator>);
+static_assert(!std::indirectly_copyable<iterator, const_reverse_iterator>);
+static_assert(!std::indirectly_copyable_storable<iterator, const_reverse_iterator>);
 static_assert(std::indirectly_swappable<iterator, iterator>);
 
 static_assert(std::random_access_iterator<const_iterator>);
 static_assert(!std::contiguous_iterator<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert(std::sized_sentinel_for<const_iterator, iterator>);
 static_assert(std::sized_sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert( std::indirectly_movable<const_iterator, iterator>);
 static_assert( std::indirectly_movable_storable<const_iterator, iterator>);
 static_assert(!std::indirectly_movable<const_iterator, const_iterator>);
 static_assert(!std::indirectly_movable_storable<const_iterator, const_iterator>);
 static_assert( std::indirectly_movable<const_iterator, reverse_iterator>);
 static_assert( std::indirectly_movable_storable<const_iterator, reverse_iterator>);
 static_assert(!std::indirectly_movable<const_iterator, const_reverse_iterator>);
 static_assert(!std::indirectly_movable_storable<const_iterator, const_reverse_iterator>);
+static_assert( std::indirectly_copyable<const_iterator, iterator>);
+static_assert( std::indirectly_copyable_storable<const_iterator, iterator>);
+static_assert(!std::indirectly_copyable<const_iterator, const_iterator>);
+static_assert(!std::indirectly_copyable_storable<const_iterator, const_iterator>);
+static_assert( std::indirectly_copyable<const_iterator, reverse_iterator>);
+static_assert( std::indirectly_copyable_storable<const_iterator, reverse_iterator>);
+static_assert(!std::indirectly_copyable<const_iterator, const_reverse_iterator>);
+static_assert(!std::indirectly_copyable_storable<const_iterator, const_reverse_iterator>);
 static_assert(!std::indirectly_swappable<const_iterator, const_iterator>);

libcxx/test/std/containers/sequences/forwardlist/forwardlist.iter/iterator_concept_conformance.compile.pass.cpp

 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, iterator>);
 static_assert(!std::sized_sentinel_for<iterator, const_iterator>);
 static_assert( std::indirectly_movable<iterator, iterator>);
 static_assert( std::indirectly_movable_storable<iterator, iterator>);
 static_assert(!std::indirectly_movable<iterator, const_iterator>);
 static_assert(!std::indirectly_movable_storable<iterator, const_iterator>);
+static_assert( std::indirectly_copyable<iterator, iterator>);
+static_assert( std::indirectly_copyable_storable<iterator, iterator>);
+static_assert(!std::indirectly_copyable<iterator, const_iterator>);
+static_assert(!std::indirectly_copyable_storable<iterator, const_iterator>);
 static_assert(std::indirectly_swappable<iterator, iterator>);
 
 static_assert(std::forward_iterator<const_iterator>);
 static_assert(!std::bidirectional_iterator<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_iterator>);
 static_assert( std::indirectly_movable<const_iterator, iterator>);
 static_assert( std::indirectly_movable_storable<const_iterator, iterator>);
 static_assert(!std::indirectly_movable<const_iterator, const_iterator>);
 static_assert(!std::indirectly_movable_storable<const_iterator, const_iterator>);
+static_assert( std::indirectly_copyable<const_iterator, iterator>);
+static_assert( std::indirectly_copyable_storable<const_iterator, iterator>);
+static_assert(!std::indirectly_copyable<const_iterator, const_iterator>);
+static_assert(!std::indirectly_copyable_storable<const_iterator, const_iterator>);
 static_assert(!std::indirectly_swappable<const_iterator, const_iterator>);

libcxx/test/std/containers/sequences/list/iterator_concept_conformance.compile.pass.cpp

 static_assert( std::indirectly_movable<iterator, iterator>);
 static_assert( std::indirectly_movable_storable<iterator, iterator>);
 static_assert(!std::indirectly_movable<iterator, const_iterator>);
 static_assert(!std::indirectly_movable_storable<iterator, const_iterator>);
 static_assert( std::indirectly_movable<iterator, reverse_iterator>);
 static_assert( std::indirectly_movable_storable<iterator, reverse_iterator>);
 static_assert(!std::indirectly_movable<iterator, const_reverse_iterator>);
 static_assert(!std::indirectly_movable_storable<iterator, const_reverse_iterator>);
+static_assert( std::indirectly_copyable<iterator, iterator>);
+static_assert( std::indirectly_copyable_storable<iterator, iterator>);
+static_assert(!std::indirectly_copyable<iterator, const_iterator>);
+static_assert(!std::indirectly_copyable_storable<iterator, const_iterator>);
+static_assert( std::indirectly_copyable<iterator, reverse_iterator>);
+static_assert( std::indirectly_copyable_storable<iterator, reverse_iterator>);
+static_assert(!std::indirectly_copyable<iterator, const_reverse_iterator>);
+static_assert(!std::indirectly_copyable_storable<iterator, const_reverse_iterator>);
 static_assert(std::indirectly_swappable<iterator, iterator>);
 
 static_assert(std::bidirectional_iterator<const_iterator>);
 static_assert(!std::random_access_iterator<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert( std::indirectly_movable<const_iterator, iterator>);
 static_assert( std::indirectly_movable_storable<const_iterator, iterator>);
 static_assert(!std::indirectly_movable<const_iterator, const_iterator>);
 static_assert(!std::indirectly_movable_storable<const_iterator, const_iterator>);
 static_assert( std::indirectly_movable<const_iterator, reverse_iterator>);
 static_assert( std::indirectly_movable_storable<const_iterator, reverse_iterator>);
 static_assert(!std::indirectly_movable<const_iterator, const_reverse_iterator>);
 static_assert(!std::indirectly_movable_storable<const_iterator, const_reverse_iterator>);
+static_assert( std::indirectly_copyable<const_iterator, iterator>);
+static_assert( std::indirectly_copyable_storable<const_iterator, iterator>);
+static_assert(!std::indirectly_copyable<const_iterator, const_iterator>);
+static_assert(!std::indirectly_copyable_storable<const_iterator, const_iterator>);
+static_assert( std::indirectly_copyable<const_iterator, reverse_iterator>);
+static_assert( std::indirectly_copyable_storable<const_iterator, reverse_iterator>);
+static_assert(!std::indirectly_copyable<const_iterator, const_reverse_iterator>);
+static_assert(!std::indirectly_copyable_storable<const_iterator, const_reverse_iterator>);
 static_assert(!std::indirectly_swappable<const_iterator, const_iterator>);

libcxx/test/std/containers/sequences/vector.bool/iterator_concept_conformance.compile.pass.cpp

 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
 static_assert( std::sized_sentinel_for<iterator, iterator>);
 static_assert( std::sized_sentinel_for<iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, const_reverse_iterator>);
 static_assert(std::indirectly_movable<iterator, bool*>);
 static_assert(std::indirectly_movable_storable<iterator, bool*>);
+static_assert(std::indirectly_copyable<iterator, bool*>);
+static_assert(std::indirectly_copyable_storable<iterator, bool*>);
 static_assert(std::indirectly_swappable<iterator, iterator>);
 
 static_assert( std::random_access_iterator<const_iterator>);
 static_assert( std::random_access_iterator<const_reverse_iterator>);
 static_assert(!std::contiguous_iterator<const_iterator>);
 static_assert(!std::contiguous_iterator<const_reverse_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert( std::sentinel_for<const_iterator, iterator>);
 static_assert( std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert( std::sized_sentinel_for<const_iterator, iterator>);
 static_assert( std::sized_sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert(!std::indirectly_swappable<const_iterator, const_iterator>);

libcxx/test/std/containers/sequences/vector/iterator_concept_conformance.compile.pass.cpp

 static_assert( std::indirectly_movable<iterator, iterator>);
 static_assert( std::indirectly_movable_storable<iterator, iterator>);
 static_assert(!std::indirectly_movable<iterator, const_iterator>);
 static_assert(!std::indirectly_movable_storable<iterator, const_iterator>);
 static_assert( std::indirectly_movable<iterator, reverse_iterator>);
 static_assert( std::indirectly_movable_storable<iterator, reverse_iterator>);
 static_assert(!std::indirectly_movable<iterator, const_reverse_iterator>);
 static_assert(!std::indirectly_movable_storable<iterator, const_reverse_iterator>);
+static_assert( std::indirectly_copyable<iterator, iterator>);
+static_assert( std::indirectly_copyable_storable<iterator, iterator>);
+static_assert(!std::indirectly_copyable<iterator, const_iterator>);
+static_assert(!std::indirectly_copyable_storable<iterator, const_iterator>);
+static_assert( std::indirectly_copyable<iterator, reverse_iterator>);
+static_assert( std::indirectly_copyable_storable<iterator, reverse_iterator>);
+static_assert(!std::indirectly_copyable<iterator, const_reverse_iterator>);
+static_assert(!std::indirectly_copyable_storable<iterator, const_reverse_iterator>);
 static_assert(std::indirectly_swappable<iterator, iterator>);
 
 static_assert( std::contiguous_iterator<const_iterator>);
 static_assert( std::random_access_iterator<const_reverse_iterator>);
 static_assert(!std::contiguous_iterator<const_reverse_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert( std::sentinel_for<const_iterator, iterator>);
 static_assert( std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert( std::sized_sentinel_for<const_iterator, iterator>);
 static_assert( std::sized_sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert( std::indirectly_movable<const_iterator, iterator>);
 static_assert( std::indirectly_movable_storable<const_iterator, iterator>);
 static_assert(!std::indirectly_movable<const_iterator, const_iterator>);
 static_assert(!std::indirectly_movable_storable<const_iterator, const_iterator>);
 static_assert( std::indirectly_movable<const_iterator, reverse_iterator>);
 static_assert( std::indirectly_movable_storable<const_iterator, reverse_iterator>);
 static_assert(!std::indirectly_movable<const_iterator, const_reverse_iterator>);
 static_assert(!std::indirectly_movable_storable<const_iterator, const_reverse_iterator>);
+static_assert( std::indirectly_copyable<const_iterator, iterator>);
+static_assert( std::indirectly_copyable_storable<const_iterator, iterator>);
+static_assert(!std::indirectly_copyable<const_iterator, const_iterator>);
+static_assert(!std::indirectly_copyable_storable<const_iterator, const_iterator>);
+static_assert( std::indirectly_copyable<const_iterator, reverse_iterator>);
+static_assert( std::indirectly_copyable_storable<const_iterator, reverse_iterator>);
+static_assert(!std::indirectly_copyable<const_iterator, const_reverse_iterator>);
+static_assert(!std::indirectly_copyable_storable<const_iterator, const_reverse_iterator>);
 static_assert(!std::indirectly_swappable<const_iterator, const_iterator>);

libcxx/test/std/containers/unord/unord.map/iterator_concept_conformance.compile.pass.cpp

 LIBCPP_STATIC_ASSERT(!std::bidirectional_iterator<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, iterator>);
 static_assert(!std::sized_sentinel_for<iterator, const_iterator>);
 static_assert(std::indirectly_movable<iterator, std::pair<int, int>*>);
 static_assert(!std::indirectly_movable_storable<iterator, std::pair<int, int>*>);
+static_assert(std::indirectly_copyable<iterator, std::pair<int, int>*>);
+static_assert(!std::indirectly_copyable_storable<iterator, std::pair<int, int>*>);
 static_assert(!std::indirectly_swappable<iterator, iterator>);
 
 static_assert(std::forward_iterator<const_iterator>);
 LIBCPP_STATIC_ASSERT(!std::bidirectional_iterator<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_iterator>);
 static_assert(std::indirectly_movable<const_iterator, std::pair<int, int>*>);
 static_assert(!std::indirectly_movable_storable<const_iterator, std::pair<int, int>*>);
+static_assert(std::indirectly_copyable<const_iterator, std::pair<int, int>*>);
+static_assert(!std::indirectly_copyable_storable<const_iterator, std::pair<int, int>*>);
 static_assert(!std::indirectly_swappable<const_iterator, const_iterator>);
 
 static_assert(std::forward_iterator<local_iterator>);
 LIBCPP_STATIC_ASSERT(!std::bidirectional_iterator<local_iterator>);
 static_assert(!std::indirectly_writable<local_iterator, value_type>);
 static_assert(std::sentinel_for<local_iterator, local_iterator>);
 static_assert(std::sentinel_for<local_iterator, const_local_iterator>);
 static_assert(!std::sized_sentinel_for<local_iterator, local_iterator>);
 static_assert(!std::sized_sentinel_for<local_iterator, const_local_iterator>);
 static_assert(std::indirectly_movable<local_iterator, std::pair<int, int>*>);
 static_assert(!std::indirectly_movable_storable<local_iterator, std::pair<int, int>*>);
+static_assert(std::indirectly_copyable<local_iterator, std::pair<int, int>*>);
+static_assert(!std::indirectly_copyable_storable<local_iterator, std::pair<int, int>*>);
 static_assert(!std::indirectly_swappable<local_iterator, local_iterator>);
 
 static_assert(std::forward_iterator<const_local_iterator>);
 LIBCPP_STATIC_ASSERT(!std::bidirectional_iterator<const_local_iterator>);
 static_assert(!std::indirectly_writable<const_local_iterator, value_type>);
 static_assert(std::sentinel_for<const_local_iterator, local_iterator>);
 static_assert(std::sentinel_for<const_local_iterator, const_local_iterator>);
 static_assert(!std::sized_sentinel_for<const_local_iterator, local_iterator>);
 static_assert(!std::sized_sentinel_for<const_local_iterator, const_local_iterator>);
 static_assert(std::indirectly_movable<const_local_iterator, std::pair<int, int>*>);
 static_assert(!std::indirectly_movable_storable<const_local_iterator, std::pair<int, int>*>);
+static_assert(std::indirectly_copyable<const_local_iterator, std::pair<int, int>*>);
+static_assert(!std::indirectly_copyable_storable<const_local_iterator, std::pair<int, int>*>);
 static_assert(!std::indirectly_swappable<const_local_iterator, const_local_iterator>);

libcxx/test/std/containers/unord/unord.multimap/iterator_concept_conformance.compile.pass.cpp

 LIBCPP_STATIC_ASSERT(!std::bidirectional_iterator<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, iterator>);
 static_assert(!std::sized_sentinel_for<iterator, const_iterator>);
 static_assert(std::indirectly_movable<iterator, std::pair<int, int>*>);
 static_assert(!std::indirectly_movable_storable<iterator, std::pair<int, int>*>);
+static_assert(std::indirectly_copyable<iterator, std::pair<int, int>*>);
+static_assert(!std::indirectly_copyable_storable<iterator, std::pair<int, int>*>);
 static_assert(!std::indirectly_swappable<iterator, iterator>);
 
 static_assert(std::forward_iterator<const_iterator>);
 LIBCPP_STATIC_ASSERT(!std::bidirectional_iterator<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_iterator>);
 static_assert(std::indirectly_movable<const_iterator, std::pair<int, int>*>);
 static_assert(!std::indirectly_movable_storable<const_iterator, std::pair<int, int>*>);
+static_assert(std::indirectly_copyable<const_iterator, std::pair<int, int>*>);
+static_assert(!std::indirectly_copyable_storable<const_iterator, std::pair<int, int>*>);
 static_assert(!std::indirectly_swappable<const_iterator, const_iterator>);
 
 static_assert(std::forward_iterator<local_iterator>);
 LIBCPP_STATIC_ASSERT(!std::bidirectional_iterator<local_iterator>);
 static_assert(!std::indirectly_writable<local_iterator, value_type>);
 static_assert(std::sentinel_for<local_iterator, local_iterator>);
 static_assert(std::sentinel_for<local_iterator, const_local_iterator>);
 static_assert(!std::sized_sentinel_for<local_iterator, local_iterator>);
 static_assert(!std::sized_sentinel_for<local_iterator, const_local_iterator>);
 static_assert(std::indirectly_movable<local_iterator, std::pair<int, int>*>);
 static_assert(!std::indirectly_movable_storable<local_iterator, std::pair<int, int>*>);
+static_assert(std::indirectly_copyable<local_iterator, std::pair<int, int>*>);
+static_assert(!std::indirectly_copyable_storable<local_iterator, std::pair<int, int>*>);
 static_assert(!std::indirectly_swappable<local_iterator, local_iterator>);
 
 static_assert(std::forward_iterator<const_local_iterator>);
 LIBCPP_STATIC_ASSERT(!std::bidirectional_iterator<const_local_iterator>);
 static_assert(!std::indirectly_writable<const_local_iterator, value_type>);
 static_assert(std::sentinel_for<const_local_iterator, local_iterator>);
 static_assert(std::sentinel_for<const_local_iterator, const_local_iterator>);
 static_assert(!std::sized_sentinel_for<const_local_iterator, local_iterator>);
 static_assert(!std::sized_sentinel_for<const_local_iterator, const_local_iterator>);
 static_assert(std::indirectly_movable<const_local_iterator, std::pair<int, int>*>);
 static_assert(!std::indirectly_movable_storable<const_local_iterator, std::pair<int, int>*>);
+static_assert(std::indirectly_copyable<const_local_iterator, std::pair<int, int>*>);
+static_assert(!std::indirectly_copyable_storable<const_local_iterator, std::pair<int, int>*>);
 static_assert(!std::indirectly_swappable<const_local_iterator, const_local_iterator>);

libcxx/test/std/containers/unord/unord.multiset/iterator_concept_conformance.compile.pass.cpp

 LIBCPP_STATIC_ASSERT(!std::bidirectional_iterator<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, iterator>);
 static_assert(!std::sized_sentinel_for<iterator, const_iterator>);
 static_assert(std::indirectly_movable<iterator, int*>);
 static_assert(std::indirectly_movable_storable<iterator, int*>);
+static_assert(std::indirectly_copyable<iterator, int*>);
+static_assert(std::indirectly_copyable_storable<iterator, int*>);
 static_assert(!std::indirectly_swappable<iterator, iterator>);
 
 static_assert(std::forward_iterator<const_iterator>);
 LIBCPP_STATIC_ASSERT(!std::bidirectional_iterator<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_iterator>);
 static_assert(std::indirectly_movable<const_iterator, int*>);
 static_assert(std::indirectly_movable_storable<const_iterator, int*>);
+static_assert(std::indirectly_copyable<const_iterator, int*>);
+static_assert(std::indirectly_copyable_storable<const_iterator, int*>);
 static_assert(!std::indirectly_swappable<const_iterator, const_iterator>);
 
 static_assert(std::forward_iterator<local_iterator>);
 LIBCPP_STATIC_ASSERT(!std::bidirectional_iterator<local_iterator>);
 static_assert(!std::indirectly_writable<local_iterator, value_type>);
 static_assert(std::sentinel_for<local_iterator, local_iterator>);
 static_assert(std::sentinel_for<local_iterator, const_local_iterator>);
 static_assert(!std::sized_sentinel_for<local_iterator, local_iterator>);
 static_assert(!std::sized_sentinel_for<local_iterator, const_local_iterator>);
 static_assert(std::indirectly_movable<local_iterator, int*>);
 static_assert(std::indirectly_movable_storable<local_iterator, int*>);
+static_assert(std::indirectly_copyable<local_iterator, int*>);
+static_assert(std::indirectly_copyable_storable<local_iterator, int*>);
 static_assert(!std::indirectly_swappable<local_iterator, local_iterator>);
 
 static_assert(std::forward_iterator<const_local_iterator>);
 LIBCPP_STATIC_ASSERT(!std::bidirectional_iterator<const_local_iterator>);
 static_assert(!std::indirectly_writable<const_local_iterator, value_type>);
 static_assert(std::sentinel_for<const_local_iterator, local_iterator>);
 static_assert(std::sentinel_for<const_local_iterator, const_local_iterator>);
 static_assert(!std::sized_sentinel_for<const_local_iterator, local_iterator>);
 static_assert(!std::sized_sentinel_for<const_local_iterator, const_local_iterator>);
 static_assert(std::indirectly_movable<const_local_iterator, int*>);
 static_assert(std::indirectly_movable_storable<const_local_iterator, int*>);
+static_assert(std::indirectly_copyable<const_local_iterator, int*>);
+static_assert(std::indirectly_copyable_storable<const_local_iterator, int*>);
 static_assert(!std::indirectly_swappable<const_local_iterator, const_local_iterator>);

libcxx/test/std/containers/unord/unord.set/iterator_concept_conformance.compile.pass.cpp

 LIBCPP_STATIC_ASSERT(!std::bidirectional_iterator<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sentinel_for<iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, iterator>);
 static_assert(!std::sized_sentinel_for<iterator, const_iterator>);
 static_assert(std::indirectly_movable<iterator, int*>);
 static_assert(std::indirectly_movable_storable<iterator, int*>);
+static_assert(std::indirectly_copyable<iterator, int*>);
+static_assert(std::indirectly_copyable_storable<iterator, int*>);
 static_assert(!std::indirectly_swappable<iterator, iterator>);
 
 static_assert(std::forward_iterator<const_iterator>);
 LIBCPP_STATIC_ASSERT(!std::bidirectional_iterator<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_iterator>);
 static_assert(std::indirectly_movable<const_iterator, int*>);
 static_assert(std::indirectly_movable_storable<const_iterator, int*>);
+static_assert(std::indirectly_copyable<const_iterator, int*>);
+static_assert(std::indirectly_copyable_storable<const_iterator, int*>);
 static_assert(!std::indirectly_swappable<const_iterator, const_iterator>);
 
 static_assert(std::forward_iterator<local_iterator>);
 LIBCPP_STATIC_ASSERT(!std::bidirectional_iterator<local_iterator>);
 static_assert(std::sentinel_for<local_iterator, local_iterator>);
 static_assert(std::sentinel_for<local_iterator, const_local_iterator>);
 static_assert(!std::sized_sentinel_for<local_iterator, local_iterator>);
 static_assert(!std::sized_sentinel_for<local_iterator, const_local_iterator>);
 static_assert(std::indirectly_movable<local_iterator, int*>);
 static_assert(std::indirectly_movable_storable<local_iterator, int*>);
+static_assert(std::indirectly_copyable<local_iterator, int*>);
+static_assert(std::indirectly_copyable_storable<local_iterator, int*>);
 static_assert(!std::indirectly_swappable<local_iterator, local_iterator>);
 
 static_assert(std::forward_iterator<const_local_iterator>);
 LIBCPP_STATIC_ASSERT(!std::bidirectional_iterator<const_local_iterator>);
 static_assert(!std::indirectly_writable<const_local_iterator, value_type>);
 static_assert(std::sentinel_for<const_local_iterator, local_iterator>);
 static_assert(std::sentinel_for<const_local_iterator, const_local_iterator>);
 static_assert(!std::sized_sentinel_for<const_local_iterator, local_iterator>);
 static_assert(!std::sized_sentinel_for<const_local_iterator, const_local_iterator>);
 static_assert(std::indirectly_movable<const_local_iterator, int*>);
 static_assert(std::indirectly_movable_storable<const_local_iterator, int*>);
+static_assert(std::indirectly_copyable<const_local_iterator, int*>);
+static_assert(std::indirectly_copyable_storable<const_local_iterator, int*>);
 static_assert(!std::indirectly_swappable<const_local_iterator, const_local_iterator>);

libcxx/test/std/containers/views/span.iterators/iterator_concept_conformance.compile.pass.cpp

 LIBCPP_STATIC_ASSERT(std::__is_cpp17_random_access_iterator<iterator>::value);
 static_assert(std::indirectly_writable<iterator, value_type>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(std::sized_sentinel_for<iterator, iterator>);
 static_assert(!std::sized_sentinel_for<iterator, reverse_iterator>);
 static_assert(std::indirectly_movable<iterator, int*>);
 static_assert(std::indirectly_movable_storable<iterator, int*>);
+static_assert(std::indirectly_copyable<iterator, int*>);
+static_assert(std::indirectly_copyable_storable<iterator, int*>);
 static_assert(std::indirectly_swappable<iterator, iterator>);

libcxx/test/std/input.output/filesystems/class.directory_iterator/iterator_concept_conformance.compile.pass.cpp

 static_assert(std::input_iterator<fs::directory_iterator>);
 static_assert(!std::forward_iterator<fs::directory_iterator>);
 static_assert(!std::indirectly_writable<fs::directory_iterator, value_type>);
 static_assert(!std::incrementable<fs::directory_iterator>);
 static_assert(std::sentinel_for<fs::directory_iterator, fs::directory_iterator>);
 static_assert(!std::sized_sentinel_for<fs::directory_iterator, fs::directory_iterator>);
 static_assert(!std::indirectly_movable<fs::directory_iterator, fs::directory_iterator>);
 static_assert(!std::indirectly_movable_storable<fs::directory_iterator, fs::directory_iterator>);
+static_assert(!std::indirectly_copyable<fs::directory_iterator, fs::directory_iterator>);
+static_assert(!std::indirectly_copyable_storable<fs::directory_iterator, fs::directory_iterator>);
 static_assert(!std::indirectly_swappable<fs::directory_iterator, fs::directory_iterator>);
 
 static_assert(std::input_iterator<fs::recursive_directory_iterator>);
 static_assert(!std::forward_iterator<fs::recursive_directory_iterator>);
 static_assert(!std::indirectly_writable<fs::recursive_directory_iterator, value_type>);
 static_assert(!std::incrementable<fs::recursive_directory_iterator>);
 static_assert(std::sentinel_for<fs::recursive_directory_iterator, fs::recursive_directory_iterator>);
 static_assert(!std::sized_sentinel_for<fs::recursive_directory_iterator, fs::recursive_directory_iterator>);
 static_assert(!std::indirectly_movable<fs::recursive_directory_iterator, fs::recursive_directory_iterator>);
 static_assert(!std::indirectly_movable_storable<fs::recursive_directory_iterator, fs::recursive_directory_iterator>);
+static_assert(!std::indirectly_copyable<fs::recursive_directory_iterator, fs::recursive_directory_iterator>);
+static_assert(!std::indirectly_copyable_storable<fs::recursive_directory_iterator, fs::recursive_directory_iterator>);
 static_assert(!std::indirectly_swappable<fs::recursive_directory_iterator, fs::recursive_directory_iterator>);

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.copy/indirectly_copyable.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class In, class Out>
+// concept indirectly_copyable;
+
+#include <iterator>
+
+#include "MoveOnly.h"
+#include "test_macros.h"
+
+struct CopyOnly {
+  CopyOnly() = default;
+
+  CopyOnly(CopyOnly const&) = default;
+  CopyOnly& operator=(CopyOnly const&) = default;
+
+  CopyOnly(CopyOnly&&) = delete;
+  CopyOnly& operator=(CopyOnly&&) = delete;
+};
+
+// Can copy the underlying objects between pointers.
+static_assert( std::indirectly_copyable<int*, int*>);
+static_assert( std::indirectly_copyable<const int*, int *>);
+
+// Can't copy if the output pointer is const.
+static_assert(!std::indirectly_copyable<int*, const int *>);
+static_assert(!std::indirectly_copyable<const int*, const int *>);
+
+// Can copy from a pointer into an array but arrays aren't considered indirectly copyable-from.
+static_assert( std::indirectly_copyable<int*, int[2]>);
+static_assert(!std::indirectly_copyable<int[2], int*>);
+static_assert(!std::indirectly_copyable<int[2], int[2]>);
+static_assert(!std::indirectly_copyable<int(&)[2], int(&)[2]>);
+
+// Can't copy between non-pointer types.
+static_assert(!std::indirectly_copyable<int*, int>);
+static_assert(!std::indirectly_copyable<int, int*>);
+static_assert(!std::indirectly_copyable<int, int>);
+
+// Check some less common types.
+static_assert(!std::indirectly_movable<void*, void*>);
+static_assert(!std::indirectly_movable<int*, void*>);
+static_assert(!std::indirectly_movable<int(), int()>);
+static_assert(!std::indirectly_movable<int*, int()>);
+static_assert(!std::indirectly_movable<void, void>);
+
+// Can't copy move-only objects.
+static_assert(!std::indirectly_copyable<MoveOnly*, MoveOnly*>);
+static_assert(!std::indirectly_copyable<MoveOnly*, const MoveOnly*>);
+static_assert(!std::indirectly_copyable<const MoveOnly*, MoveOnly*>);
+static_assert(!std::indirectly_copyable<const MoveOnly*, const MoveOnly*>);
+
+// Can copy copy-only objects.
+static_assert( std::indirectly_copyable<CopyOnly*, CopyOnly*>);
+static_assert(!std::indirectly_copyable<CopyOnly*, const CopyOnly*>);
+static_assert( std::indirectly_copyable<const CopyOnly*, CopyOnly*>);
+static_assert(!std::indirectly_copyable<const CopyOnly*, const CopyOnly*>);
+
+template<class T>
+struct PointerTo {
+  using value_type = T;
+  T& operator*() const;
+};
+
+// Can copy through a dereferenceable class.
+static_assert( std::indirectly_copyable<int*, PointerTo<int>>);
+static_assert(!std::indirectly_copyable<int*, PointerTo<const int>>);
+static_assert( std::indirectly_copyable<PointerTo<int>, PointerTo<int>>);
+static_assert(!std::indirectly_copyable<PointerTo<int>, PointerTo<const int>>);
+static_assert( std::indirectly_copyable<CopyOnly*, PointerTo<CopyOnly>>);
+static_assert( std::indirectly_copyable<PointerTo<CopyOnly>, CopyOnly*>);
+static_assert( std::indirectly_copyable<PointerTo<CopyOnly>, PointerTo<CopyOnly>>);

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.copy/indirectly_copyable.subsumption.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class In, class Out>
-// concept indirectly_movable;
+// concept indirectly_copyable;
 
 #include <iterator>
 
-#include <concepts>
-
 template<std::indirectly_readable I, class O>
-constexpr bool indirectly_movable_subsumption() {
+constexpr bool indirectly_copyable_subsumption() {
   return false;
 }
 
 template<class I, class O>
-  requires std::indirectly_movable<I, O>
-constexpr bool indirectly_movable_subsumption() {
+  requires std::indirectly_copyable<I, O>
+constexpr bool indirectly_copyable_subsumption() {
   return true;
 }
 
-static_assert(indirectly_movable_subsumption<int*, int*>());
+static_assert(indirectly_copyable_subsumption<int*, int*>());

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.copy/indirectly_copyable_storable.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class In, class Out>
+// concept indirectly_copyable_storable;
+
+#include <iterator>
+
+#include "MoveOnly.h"
+#include "test_macros.h"
+
+struct CopyOnly {
+  CopyOnly(CopyOnly&&) = delete;
+  CopyOnly(CopyOnly const&) = default;
+  CopyOnly& operator=(CopyOnly&&) = delete;
+  CopyOnly& operator=(CopyOnly const&) = default;
+  CopyOnly() = default;
+};
+
+template<class T>
+struct PointerTo {
+  using value_type = T;
+  T& operator*() const;
+};
+
+// Copying the underlying object between pointers (or dereferenceable classes) works. This is a non-exhaustive check
+// because this functionality comes from `indirectly_copyable`.
+static_assert( std::indirectly_copyable_storable<int*, int*>);
+static_assert( std::indirectly_copyable_storable<const int*, int*>);
+static_assert(!std::indirectly_copyable_storable<int*, const int*>);
+static_assert(!std::indirectly_copyable_storable<const int*, const int*>);
+static_assert( std::indirectly_copyable_storable<int*, int[2]>);
+static_assert(!std::indirectly_copyable_storable<int[2], int*>);
+static_assert(!std::indirectly_copyable_storable<MoveOnly*, MoveOnly*>);
+static_assert(!std::indirectly_copyable_storable<PointerTo<MoveOnly>, PointerTo<MoveOnly>>);
+// `indirectly_copyable_storable` requires the type to be `copyable`, which in turns requires it to be `movable`.
+static_assert(!std::indirectly_copyable_storable<CopyOnly*, CopyOnly*>);
+static_assert(!std::indirectly_copyable_storable<PointerTo<CopyOnly>, PointerTo<CopyOnly>>);
+
+// The dereference operator returns a different type from `value_type` and the reference type cannot be assigned from a
+// non-const lvalue of `ValueType` (but all other forms of assignment from `ValueType` work).
+struct NoLvalueAssignment {
+  struct ValueType;
+
+  struct ReferenceType {
+    ReferenceType& operator=(ValueType const&);
+    ReferenceType& operator=(ValueType&) = delete;
+    ReferenceType& operator=(ValueType&&);
+    ReferenceType& operator=(ValueType const&&);
+  };
+
+  struct ValueType {
+    operator ReferenceType&() const;
+  };
+
+  using value_type = ValueType;
+  ReferenceType& operator*() const;
+};
+
+static_assert( std::indirectly_writable<NoLvalueAssignment, std::iter_reference_t<NoLvalueAssignment>>);
+static_assert(!std::indirectly_writable<NoLvalueAssignment, std::iter_value_t<NoLvalueAssignment>&>);
+static_assert( std::indirectly_writable<NoLvalueAssignment, const std::iter_value_t<NoLvalueAssignment>&>);
+static_assert( std::indirectly_writable<NoLvalueAssignment, std::iter_value_t<NoLvalueAssignment>&&>);
+static_assert( std::indirectly_writable<NoLvalueAssignment, const std::iter_value_t<NoLvalueAssignment>&&>);
+static_assert(!std::indirectly_copyable_storable<NoLvalueAssignment, NoLvalueAssignment>);
+
+// The dereference operator returns a different type from `value_type` and the reference type cannot be assigned from a
+// const lvalue of `ValueType` (but all other forms of assignment from `ValueType` work).
+struct NoConstLvalueAssignment {
+  struct ValueType;
+
+  struct ReferenceType {
+    ReferenceType& operator=(ValueType const&) = delete;
+    ReferenceType& operator=(ValueType&);
+    ReferenceType& operator=(ValueType&&);
+    ReferenceType& operator=(ValueType const&&);
+  };
+
+  struct ValueType {
+    operator ReferenceType&() const;
+  };
+
+  using value_type = ValueType;
+  ReferenceType& operator*() const;
+};
+
+static_assert( std::indirectly_writable<NoConstLvalueAssignment, std::iter_reference_t<NoConstLvalueAssignment>>);
+static_assert( std::indirectly_writable<NoConstLvalueAssignment, std::iter_value_t<NoConstLvalueAssignment>&>);
+static_assert(!std::indirectly_writable<NoConstLvalueAssignment, const std::iter_value_t<NoConstLvalueAssignment>&>);
+static_assert( std::indirectly_writable<NoConstLvalueAssignment, std::iter_value_t<NoConstLvalueAssignment>&&>);
+static_assert( std::indirectly_writable<NoConstLvalueAssignment, const std::iter_value_t<NoConstLvalueAssignment>&&>);
+static_assert(!std::indirectly_copyable_storable<NoConstLvalueAssignment, NoConstLvalueAssignment>);
+
+// The dereference operator returns a different type from `value_type` and the reference type cannot be assigned from a
+// non-const rvalue of `ValueType` (but all other forms of assignment from `ValueType` work).
+struct NoRvalueAssignment {
+  struct ValueType;
+
+  struct ReferenceType {
+    ReferenceType& operator=(ValueType const&);
+    ReferenceType& operator=(ValueType&);
+    ReferenceType& operator=(ValueType&&) = delete;
+    ReferenceType& operator=(ValueType const&&);
+  };
+
+  struct ValueType {
+    operator ReferenceType&() const;
+  };
+
+  using value_type = ValueType;
+  ReferenceType& operator*() const;
+};
+
+static_assert( std::indirectly_writable<NoRvalueAssignment, std::iter_reference_t<NoRvalueAssignment>>);
+static_assert( std::indirectly_writable<NoRvalueAssignment, std::iter_value_t<NoRvalueAssignment>&>);
+static_assert( std::indirectly_writable<NoRvalueAssignment, const std::iter_value_t<NoRvalueAssignment>&>);
+static_assert(!std::indirectly_writable<NoRvalueAssignment, std::iter_value_t<NoRvalueAssignment>&&>);
+static_assert( std::indirectly_writable<NoRvalueAssignment, const std::iter_value_t<NoRvalueAssignment>&&>);
+static_assert(!std::indirectly_copyable_storable<NoRvalueAssignment, NoRvalueAssignment>);
+
+// The dereference operator returns a different type from `value_type` and the reference type cannot be assigned from a
+// const rvalue of `ValueType` (but all other forms of assignment from `ValueType` work).
+struct NoConstRvalueAssignment {
+  struct ValueType;
+
+  struct ReferenceType {
+    ReferenceType& operator=(ValueType const&);
+    ReferenceType& operator=(ValueType&);
+    ReferenceType& operator=(ValueType&&);
+    ReferenceType& operator=(ValueType const&&) = delete;
+  };
+
+  struct ValueType {
+    operator ReferenceType&() const;
+  };
+
+  using value_type = ValueType;
+  ReferenceType& operator*() const;
+};
+
+static_assert( std::indirectly_writable<NoConstRvalueAssignment, std::iter_reference_t<NoConstRvalueAssignment>>);
+static_assert( std::indirectly_writable<NoConstRvalueAssignment, std::iter_value_t<NoConstRvalueAssignment>&>);
+static_assert( std::indirectly_writable<NoConstRvalueAssignment, const std::iter_value_t<NoConstRvalueAssignment>&>);
+static_assert( std::indirectly_writable<NoConstRvalueAssignment, std::iter_value_t<NoConstRvalueAssignment>&&>);
+static_assert(!std::indirectly_writable<NoConstRvalueAssignment, const std::iter_value_t<NoConstRvalueAssignment>&&>);
+static_assert(!std::indirectly_copyable_storable<NoConstRvalueAssignment, NoConstRvalueAssignment>);
+
+struct DeletedCopyCtor {
+  DeletedCopyCtor(DeletedCopyCtor const&) = delete;
+  DeletedCopyCtor& operator=(DeletedCopyCtor const&) = default;
+};
+
+struct DeletedNonconstCopyCtor {
+  DeletedNonconstCopyCtor(DeletedNonconstCopyCtor const&) = default;
+  DeletedNonconstCopyCtor(DeletedNonconstCopyCtor&) = delete;
+  DeletedNonconstCopyCtor& operator=(DeletedNonconstCopyCtor const&) = default;
+};
+
+struct DeletedMoveCtor {
+  DeletedMoveCtor(DeletedMoveCtor&&) = delete;
+  DeletedMoveCtor& operator=(DeletedMoveCtor&&) = default;
+};
+
+struct DeletedConstMoveCtor {
+  DeletedConstMoveCtor(DeletedConstMoveCtor&&) = default;
+  DeletedConstMoveCtor(DeletedConstMoveCtor const&&) = delete;
+  DeletedConstMoveCtor& operator=(DeletedConstMoveCtor&&) = default;
+};
+
+struct DeletedCopyAssignment {
+  DeletedCopyAssignment(DeletedCopyAssignment const&) = default;
+  DeletedCopyAssignment& operator=(DeletedCopyAssignment const&) = delete;
+};
+
+struct DeletedNonconstCopyAssignment {
+  DeletedNonconstCopyAssignment(DeletedNonconstCopyAssignment const&) = default;
+  DeletedNonconstCopyAssignment& operator=(DeletedNonconstCopyAssignment const&) = default;
+  DeletedNonconstCopyAssignment& operator=(DeletedNonconstCopyAssignment&) = delete;
+};
+
+struct DeletedMoveAssignment {
+  DeletedMoveAssignment(DeletedMoveAssignment&&) = default;
+  DeletedMoveAssignment& operator=(DeletedMoveAssignment&&) = delete;
+};
+
+struct DeletedConstMoveAssignment {
+  DeletedConstMoveAssignment(DeletedConstMoveAssignment&&) = default;
+  DeletedConstMoveAssignment& operator=(DeletedConstMoveAssignment&&) = delete;
+};
+
+static_assert(!std::indirectly_copyable_storable<DeletedCopyCtor*, DeletedCopyCtor*>);
+static_assert(!std::indirectly_copyable_storable<DeletedNonconstCopyCtor*, DeletedNonconstCopyCtor*>);
+static_assert(!std::indirectly_copyable_storable<DeletedMoveCtor*, DeletedMoveCtor*>);
+static_assert(!std::indirectly_copyable_storable<DeletedConstMoveCtor*, DeletedConstMoveCtor*>);
+static_assert(!std::indirectly_copyable_storable<DeletedCopyAssignment*, DeletedCopyAssignment*>);
+static_assert(!std::indirectly_copyable_storable<DeletedNonconstCopyAssignment*, DeletedNonconstCopyAssignment*>);
+static_assert(!std::indirectly_copyable_storable<DeletedMoveAssignment*, DeletedMoveAssignment*>);
+static_assert(!std::indirectly_copyable_storable<DeletedConstMoveAssignment*, DeletedConstMoveAssignment*>);
+
+struct InconsistentIterator {
+  struct ValueType;
+
+  struct ReferenceType {
+    ReferenceType& operator=(ValueType const&);
+  };
+
+  struct ValueType {
+    ValueType() = default;
+    ValueType(const ReferenceType&);
+  };
+
+  using value_type = ValueType;
+  ReferenceType& operator*() const;
+};
+
+// `ValueType` can be constructed with a `ReferenceType` and assigned to a `ReferenceType`, so it does model
+// `indirectly_copyable_storable`.
+static_assert( std::indirectly_copyable_storable<InconsistentIterator, InconsistentIterator>);
+
+struct CommonType { };
+
+// ReferenceType is a (proxy) reference for ValueType, but ValueType is not constructible from ReferenceType.
+struct NotConstructibleFromRefIn {
+  struct ReferenceType;
+
+  struct ValueType {
+    ValueType(ReferenceType) = delete;
+    operator CommonType&() const;
+  };
+
+  struct ReferenceType {
+    operator CommonType&() const;
+  };
+
+  using value_type = ValueType;
+  ReferenceType& operator*() const;
+};
+
+template <template <class> class X, template <class> class Y>
+struct std::basic_common_reference<NotConstructibleFromRefIn::ValueType,
+                                   NotConstructibleFromRefIn::ReferenceType, X, Y> {
+  using type = CommonType&;
+};
+
+template <template <class> class X, template <class> class Y>
+struct std::basic_common_reference<NotConstructibleFromRefIn::ReferenceType,
+                                   NotConstructibleFromRefIn::ValueType, X, Y> {
+  using type = CommonType&;
+};
+
+static_assert(std::common_reference_with<NotConstructibleFromRefIn::ValueType&,
+    NotConstructibleFromRefIn::ReferenceType&>);
+
+struct AssignableFromAnything {
+  template<class T>
+  AssignableFromAnything& operator=(T&&);
+};
+
+// A type that can't be constructed from its own reference isn't `indirectly_copyable_storable`, even when assigning it
+// to a type that can be assigned from anything.
+static_assert(!std::indirectly_copyable_storable<NotConstructibleFromRefIn, AssignableFromAnything*>);
+
+// ReferenceType is a (proxy) reference for ValueType, but ValueType is not assignable from ReferenceType.
+struct NotAssignableFromRefIn {
+  struct ReferenceType;
+
+  struct ValueType {
+    ValueType(ReferenceType);
+    ValueType& operator=(ReferenceType) = delete;
+    operator CommonType&() const;
+  };
+
+  struct ReferenceType {
+    operator CommonType&() const;
+  };
+
+  using value_type = ValueType;
+  ReferenceType& operator*() const;
+};
+
+template <template <class> class X, template <class> class Y>
+struct std::basic_common_reference<NotAssignableFromRefIn::ValueType,
+                                   NotAssignableFromRefIn::ReferenceType, X, Y> {
+  using type = CommonType&;
+};
+
+template <template <class> class X, template <class> class Y>
+struct std::basic_common_reference<NotAssignableFromRefIn::ReferenceType,
+                                   NotAssignableFromRefIn::ValueType, X, Y> {
+  using type = CommonType&;
+};
+
+static_assert(std::common_reference_with<NotAssignableFromRefIn::ValueType&, NotAssignableFromRefIn::ReferenceType&>);
+
+// A type that can't be assigned from its own reference isn't `indirectly_copyable_storable`, even when assigning it
+// to a type that can be assigned from anything.
+static_assert(!std::indirectly_copyable_storable<NotAssignableFromRefIn, AssignableFromAnything*>);

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.copy/indirectly_copyable_storable.subsumption.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class In, class Out>
-// concept indirectly_movable_storable;
+// concept indirectly_copyable_storable;
 
 #include <iterator>
 
-#include <concepts>
-
 template<class I, class O>
-  requires std::indirectly_movable<I, O>
-constexpr bool indirectly_movable_storable_subsumption() {
+  requires std::indirectly_copyable<I, O>
+constexpr bool indirectly_copyable_storable_subsumption() {
   return false;
 }
 
 template<class I, class O>
-  requires std::indirectly_movable_storable<I, O>
-constexpr bool indirectly_movable_storable_subsumption() {
+  requires std::indirectly_copyable_storable<I, O>
+constexpr bool indirectly_copyable_storable_subsumption() {
   return true;
 }
 
-static_assert(indirectly_movable_storable_subsumption<int*, int*>());
+static_assert(indirectly_copyable_storable_subsumption<int*, int*>());

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.move/indirectly_movable.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class In, class Out>
 // concept indirectly_movable;
 
 #include <iterator>
 
+#include "MoveOnly.h"
 #include "test_macros.h"
 
-struct IndirectlyMovableWithInt {
-  int& operator*() const;
-};
-
-struct Empty {};
-
-struct MoveOnly {
-  MoveOnly(MoveOnly&&) = default;
-  MoveOnly(MoveOnly const&) = delete;
-  MoveOnly& operator=(MoveOnly&&) = default;
-  MoveOnly& operator=(MoveOnly const&) = delete;
-  MoveOnly() = default;
-};
-
-template<class T>
-struct PointerTo {
-  using value_type = T;
-  T& operator*() const;
-};
-
+// Can move between pointers.
 static_assert( std::indirectly_movable<int*, int*>);
-static_assert( std::indirectly_movable<const int*, int *>);
-static_assert(!std::indirectly_movable<int*, const int *>);
-static_assert(!std::indirectly_movable<const int*, const int *>);
+static_assert( std::indirectly_movable<const int*, int*>);
+static_assert(!std::indirectly_movable<int*, const int*>);
+static_assert( std::indirectly_movable<const int*, int*>);
+
+// Can move from a pointer into an array but arrays aren't considered indirectly movable-from.
 static_assert( std::indirectly_movable<int*, int[2]>);
 static_assert(!std::indirectly_movable<int[2], int*>);
 static_assert(!std::indirectly_movable<int[2], int[2]>);
 static_assert(!std::indirectly_movable<int(&)[2], int(&)[2]>);
+
+// Can't move between non-pointer types.
+static_assert(!std::indirectly_movable<int*, int>);
 static_assert(!std::indirectly_movable<int, int*>);
 static_assert(!std::indirectly_movable<int, int>);
-static_assert( std::indirectly_movable<Empty*, Empty*>);
-static_assert( std::indirectly_movable<int*, IndirectlyMovableWithInt>);
-static_assert(!std::indirectly_movable<Empty*, IndirectlyMovableWithInt>);
-static_assert( std::indirectly_movable<int*, IndirectlyMovableWithInt>);
+
+// Check some less common types.
+static_assert(!std::indirectly_movable<void*, void*>);
+static_assert(!std::indirectly_movable<int*, void*>);
+static_assert(!std::indirectly_movable<int(), int()>);
+static_assert(!std::indirectly_movable<int*, int()>);
+static_assert(!std::indirectly_movable<void, void>);
+
+// Can move move-only objects.
 static_assert( std::indirectly_movable<MoveOnly*, MoveOnly*>);
 static_assert(!std::indirectly_movable<MoveOnly*, const MoveOnly*>);
 static_assert(!std::indirectly_movable<const MoveOnly*, const MoveOnly*>);
 static_assert(!std::indirectly_movable<const MoveOnly*, MoveOnly*>);
-static_assert( std::indirectly_movable<PointerTo<MoveOnly>, PointerTo<MoveOnly>>);
+
+template<class T>
+struct PointerTo {
+  using value_type = T;
+  T& operator*() const;
+};
+
+// Can copy through a dereferenceable class.
+static_assert( std::indirectly_movable<int*, PointerTo<int>>);
+static_assert(!std::indirectly_movable<int*, PointerTo<const int>>);
+static_assert( std::indirectly_copyable<PointerTo<int>, PointerTo<int>>);
+static_assert(!std::indirectly_copyable<PointerTo<int>, PointerTo<const int>>);
 static_assert( std::indirectly_movable<MoveOnly*, PointerTo<MoveOnly>>);
+static_assert( std::indirectly_movable<PointerTo<MoveOnly>, MoveOnly*>);
+static_assert( std::indirectly_movable<PointerTo<MoveOnly>, PointerTo<MoveOnly>>);

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.move/indirectly_movable.subsumption.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class In, class Out>
 // concept indirectly_movable;
 
 #include <iterator>
 
-#include <concepts>
-
 template<std::indirectly_readable I, class O>
 constexpr bool indirectly_movable_subsumption() {
   return false;
 }
 
 template<class I, class O>
   requires std::indirectly_movable<I, O>
 constexpr bool indirectly_movable_subsumption() {
   return true;
 }
 
 static_assert(indirectly_movable_subsumption<int*, int*>());

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.move/indirectly_movable_storable.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class In, class Out>
 // concept indirectly_movable_storable;
 
 #include <iterator>
 
+#include "MoveOnly.h"
 #include "test_macros.h"
 
-struct Empty {};
+template <class T>
+struct PointerTo {
+  using value_type = T;
+  T& operator*() const;
+};
 
-struct MoveOnlyConvertible;
-struct AssignableToMoveOnly;
+// Copying the underlying object between pointers (or dereferenceable classes) works. This is a non-exhaustive check
+// because this functionality comes from `indirectly_movable`.
+static_assert( std::indirectly_movable_storable<int*, int*>);
+static_assert( std::indirectly_movable_storable<const int*, int*>);
+static_assert(!std::indirectly_movable_storable<int*, const int*>);
+static_assert(!std::indirectly_movable_storable<const int*, const int*>);
+static_assert( std::indirectly_movable_storable<int*, int[2]>);
+static_assert(!std::indirectly_movable_storable<int[2], int*>);
+static_assert( std::indirectly_movable_storable<MoveOnly*, MoveOnly*>);
+static_assert( std::indirectly_movable_storable<PointerTo<MoveOnly>, PointerTo<MoveOnly>>);
 
-struct MoveOnly {
-  MoveOnly(MoveOnly&&) = default;
-  MoveOnly(MoveOnly const&) = delete;
-  MoveOnly& operator=(MoveOnly&&) = default;
-  MoveOnly& operator=(MoveOnly const&) = delete;
-  MoveOnly() = default;
+// The dereference operator returns a different type from `value_type` and the reference type cannot be assigned from a
+// `ValueType`.
+struct NoAssignment {
+  struct ValueType;
 
-  MoveOnly& operator=(MoveOnlyConvertible const&) = delete;
-  MoveOnly& operator=(AssignableToMoveOnly const&);
+  struct ReferenceType {
+    ReferenceType& operator=(ValueType) = delete;
   };
 
-template<class T, class ValueType = T>
-struct PointerTo {
-  using value_type = ValueType;
-  T& operator*() const;
+  // `ValueType` is convertible to `ReferenceType` but not assignable to it. This is implemented by explicitly deleting
+  // `operator=(ValueType)` in `ReferenceType`.
+  struct ValueType {
+    operator ReferenceType&() const;
   };
 
-// MoveOnlyConvertible is convertible to MoveOnly, but not assignable to it. This is
-// implemented by explicitly deleting "operator=(MoveOnlyConvertible)" in MoveOnly.
-struct MoveOnlyConvertible {
-  operator MoveOnly&() const;
+  using value_type = ValueType;
+  ReferenceType& operator*() const;
 };
 
-// This type can be constructed with a MoveOnly and assigned to a MoveOnly, so it does
-// model indirectly_movable_storable.
-struct AssignableToMoveOnly {
-  AssignableToMoveOnly() = default;
-  AssignableToMoveOnly(const MoveOnly&);
-};
+// The case when `indirectly_writable<iter_rvalue_reference>` but not `indirectly_writable<iter_value>` (you can
+// do `ReferenceType r = ValueType();` but not `r = ValueType();`).
+static_assert( std::indirectly_writable<NoAssignment, std::iter_rvalue_reference_t<NoAssignment>>);
+static_assert(!std::indirectly_writable<NoAssignment, std::iter_value_t<NoAssignment>>);
+static_assert(!std::indirectly_movable_storable<NoAssignment, NoAssignment>);
 
 struct DeletedMoveCtor {
   DeletedMoveCtor(DeletedMoveCtor&&) = delete;
   DeletedMoveCtor& operator=(DeletedMoveCtor&&) = default;
 };
 
-struct CommonType { };
+struct DeletedMoveAssignment {
+  DeletedMoveAssignment(DeletedMoveAssignment&&) = default;
+  DeletedMoveAssignment& operator=(DeletedMoveAssignment&&) = delete;
+};
+
+static_assert(!std::indirectly_movable_storable<DeletedMoveCtor*, DeletedMoveCtor*>);
+static_assert(!std::indirectly_movable_storable<DeletedMoveAssignment*, DeletedMoveAssignment*>);
+
+struct InconsistentIterator {
+  struct ValueType;
+
+  struct ReferenceType {
+    ReferenceType& operator=(ValueType const&);
+  };
 
-struct NotConstructibleFromRefIn {
   struct ValueType {
-    operator CommonType&() const;
-  };
+    ValueType() = default;
+    ValueType(const ReferenceType&);
+  };
+
+  using value_type = ValueType;
+  ReferenceType& operator*() const;
 
+// `ValueType` can be constructed with a `ReferenceType` and assigned to a `ReferenceType`, so it does model
+// `indirectly_movable_storable`.
+static_assert( std::indirectly_movable_storable<InconsistentIterator, InconsistentIterator>);
+
+// ReferenceType is a (proxy) reference for ValueType, but ValueType is not constructible from ReferenceType.
+struct NotConstructibleFromRefIn {
+  struct CommonType { };
+
   struct ReferenceType {
     operator CommonType&() const;
   };
 
+  struct ValueType {
+    ValueType(ReferenceType) = delete;
+    operator CommonType&() const;
+  };
+
   using value_type = ValueType;
   ReferenceType& operator*() const;
 };
 
 template <template <class> class X, template <class> class Y>
 struct std::basic_common_reference<NotConstructibleFromRefIn::ValueType,
                                    NotConstructibleFromRefIn::ReferenceType, X, Y> {
-  using type = CommonType&;
+  using type = NotConstructibleFromRefIn::CommonType&;
 };
 
 template <template <class> class X, template <class> class Y>
 struct std::basic_common_reference<NotConstructibleFromRefIn::ReferenceType,
                                    NotConstructibleFromRefIn::ValueType, X, Y> {
-  using type = CommonType&;
+  using type = NotConstructibleFromRefIn::CommonType&;
+};
+
+static_assert(std::common_reference_with<NotConstructibleFromRefIn::ValueType&,
+    NotConstructibleFromRefIn::ReferenceType&>);
+
+struct AssignableFromAnything {
+  template<class T>
+  AssignableFromAnything& operator=(T&&);
 };
 
+// A type that can't be constructed from its own reference isn't `indirectly_movable_storable`, even when assigning it
+// to a type that can be assigned from anything.
+static_assert( std::indirectly_movable_storable<int*, AssignableFromAnything*>);
+static_assert(!std::indirectly_movable_storable<NotConstructibleFromRefIn, AssignableFromAnything*>);
+
+// ReferenceType is a (proxy) reference for ValueType, but ValueType is not assignable from ReferenceType.
 struct NotAssignableFromRefIn {
-  struct ReferenceType;
+  struct CommonType { };
 
-  struct ValueType {
-    ValueType(ReferenceType);
-    ValueType& operator=(ReferenceType) = delete;
+  struct ReferenceType {
     operator CommonType&() const;
   };
 
-  struct ReferenceType {
+  struct ValueType {
+    ValueType(ReferenceType);
+    ValueType& operator=(ReferenceType) = delete;
     operator CommonType&() const;
   };
 
   using value_type = ValueType;
   ReferenceType& operator*() const;
 };
 
 template <template <class> class X, template <class> class Y>
 struct std::basic_common_reference<NotAssignableFromRefIn::ValueType,
                                    NotAssignableFromRefIn::ReferenceType, X, Y> {
-  using type = CommonType&;
+  using type = NotAssignableFromRefIn::CommonType&;
 };
 
 template <template <class> class X, template <class> class Y>
 struct std::basic_common_reference<NotAssignableFromRefIn::ReferenceType,
                                    NotAssignableFromRefIn::ValueType, X, Y> {
-  using type = CommonType&;
+  using type = NotAssignableFromRefIn::CommonType&;
 };
 
-struct AnyWritable {
-  template<class T>
-  AnyWritable& operator=(T&&);
-};
+static_assert(std::common_reference_with<NotAssignableFromRefIn::ValueType&, NotAssignableFromRefIn::ReferenceType&>);
 
-struct AnyOutput {
-  using value_type = AnyWritable;
-  AnyWritable& operator*() const;
-};
-
-static_assert( std::indirectly_movable_storable<int*, int*>);
-static_assert( std::indirectly_movable_storable<const int*, int *>);
-static_assert( std::indirectly_movable_storable<int*, int[2]>);
-static_assert( std::indirectly_movable_storable<Empty*, Empty*>);
-static_assert( std::indirectly_movable_storable<MoveOnly*, MoveOnly*>);
-static_assert( std::indirectly_movable_storable<PointerTo<MoveOnly>, PointerTo<MoveOnly>>);
-// The case when indirectly_writable<iter_rvalue_reference> but not indirectly_writable<iter_value>.
-static_assert( std::indirectly_writable<
-                 PointerTo<MoveOnly, MoveOnlyConvertible>,
-                 std::iter_rvalue_reference_t<
-                    PointerTo<MoveOnly, MoveOnlyConvertible>>>);
-static_assert(!std::indirectly_movable_storable<PointerTo<MoveOnly, MoveOnlyConvertible>,
-                                                PointerTo<MoveOnly, MoveOnlyConvertible>>);
-static_assert(!std::indirectly_movable_storable<DeletedMoveCtor*, DeletedMoveCtor*>);
-static_assert( std::indirectly_movable_storable<PointerTo<MoveOnly, AssignableToMoveOnly>,
-                                                PointerTo<MoveOnly, AssignableToMoveOnly>>);
-static_assert(!std::indirectly_movable_storable<NotConstructibleFromRefIn, AnyOutput>);
-static_assert(!std::indirectly_movable_storable<NotAssignableFromRefIn, AnyOutput>);
+// A type that can't be assigned from its own reference isn't `indirectly_movable_storable`, even when assigning it
+// to a type that can be assigned from anything.
+static_assert(!std::indirectly_movable_storable<NotAssignableFromRefIn, AssignableFromAnything*>);

libcxx/test/std/iterators/iterator.requirements/alg.req.ind.move/indirectly_movable_storable.subsumption.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class In, class Out>
 // concept indirectly_movable_storable;
 
 #include <iterator>
 
-#include <concepts>
-
 template<class I, class O>
   requires std::indirectly_movable<I, O>
 constexpr bool indirectly_movable_storable_subsumption() {
   return false;
 }
 
 template<class I, class O>
   requires std::indirectly_movable_storable<I, O>
 constexpr bool indirectly_movable_storable_subsumption() {
   return true;
 }
 
 static_assert(indirectly_movable_storable_subsumption<int*, int*>());

libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/iterator_concept_conformance.compile.pass.cpp

 static_assert(std::indirectly_writable<iterator, int>);
 static_assert(std::weakly_incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(!std::sentinel_for<iterator, iterator>);
 static_assert(!std::sized_sentinel_for<iterator, iterator>);
 static_assert(!std::input_iterator<iterator>);
 static_assert(std::indirectly_movable<int*, iterator>);
 static_assert(std::indirectly_movable_storable<int*, iterator>);
+static_assert(std::indirectly_copyable<int*, iterator>);
+static_assert(std::indirectly_copyable_storable<int*, iterator>);
 static_assert(!std::indirectly_swappable<iterator, iterator>);

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/iterator_concept_conformance.compile.pass.cpp

 static_assert(std::indirectly_writable<iterator, int>);
 static_assert(std::weakly_incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(!std::sentinel_for<iterator, iterator>);
 static_assert(!std::sized_sentinel_for<iterator, iterator>);
 static_assert(!std::input_iterator<iterator>);
 static_assert(std::indirectly_movable<int*, iterator>);
 static_assert(std::indirectly_movable_storable<int*, iterator>);
+static_assert(std::indirectly_copyable<int*, iterator>);
+static_assert(std::indirectly_copyable_storable<int*, iterator>);
 static_assert(!std::indirectly_swappable<iterator, iterator>);

libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/iterator_concept_conformance.compile.pass.cpp

 static_assert(!std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
 static_assert(std::weakly_incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(!std::sentinel_for<iterator, iterator>);
 static_assert(!std::input_iterator<iterator>);
 static_assert(std::indirectly_movable<int*, iterator>);
 static_assert(std::indirectly_movable_storable<int*, iterator>);
+static_assert(std::indirectly_copyable<int*, iterator>);
+static_assert(std::indirectly_copyable_storable<int*, iterator>);
 static_assert(!std::indirectly_swappable<iterator, iterator>);

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/iterator_concept_conformance.compile.pass.cpp

 static_assert(std::input_iterator<iterator>);
 static_assert(!std::forward_iterator<iterator>);
 static_assert(!std::indirectly_writable<iterator, int>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(std::sized_sentinel_for<iterator, iterator>);
 static_assert(!std::indirectly_movable<int*, iterator>);
 static_assert(!std::indirectly_movable_storable<int*, iterator>);
+static_assert(!std::indirectly_copyable<int*, iterator>);
+static_assert(!std::indirectly_copyable_storable<int*, iterator>);
 static_assert(!std::indirectly_swappable<iterator, iterator>);

libcxx/test/std/iterators/predef.iterators/reverse.iterators/iterator_concept_conformance.compile.pass.cpp

 
 using reverse_bidirectional_iterator = std::reverse_iterator<bidirectional_iterator<int*>>;
 static_assert(common_reverse_iterator_checks<reverse_bidirectional_iterator>());
 static_assert(std::bidirectional_iterator<reverse_bidirectional_iterator>);
 static_assert(!std::random_access_iterator<reverse_bidirectional_iterator>);
 static_assert(!std::sized_sentinel_for<reverse_bidirectional_iterator, reverse_bidirectional_iterator>);
 static_assert( std::indirectly_movable<reverse_bidirectional_iterator, reverse_bidirectional_iterator>);
 static_assert( std::indirectly_movable_storable<reverse_bidirectional_iterator, reverse_bidirectional_iterator>);
+static_assert( std::indirectly_copyable<reverse_bidirectional_iterator, reverse_bidirectional_iterator>);
+static_assert( std::indirectly_copyable_storable<reverse_bidirectional_iterator, reverse_bidirectional_iterator>);
 static_assert( std::indirectly_swappable<reverse_bidirectional_iterator, reverse_bidirectional_iterator>);
 
 using reverse_random_access_iterator = std::reverse_iterator<random_access_iterator<int*>>;
 static_assert(common_reverse_iterator_checks<reverse_random_access_iterator>());
 static_assert(std::random_access_iterator<reverse_random_access_iterator>);
 static_assert(!std::contiguous_iterator<reverse_random_access_iterator>);
 static_assert(std::sized_sentinel_for<reverse_random_access_iterator, reverse_random_access_iterator>);
 static_assert( std::indirectly_movable<reverse_random_access_iterator, reverse_random_access_iterator>);
 static_assert( std::indirectly_movable_storable<reverse_random_access_iterator, reverse_random_access_iterator>);
+static_assert( std::indirectly_copyable<reverse_random_access_iterator, reverse_random_access_iterator>);
+static_assert( std::indirectly_copyable_storable<reverse_random_access_iterator, reverse_random_access_iterator>);
 static_assert( std::indirectly_swappable<reverse_random_access_iterator, reverse_random_access_iterator>);
 
 using reverse_contiguous_iterator = std::reverse_iterator<contiguous_iterator<int*>>;
 static_assert(common_reverse_iterator_checks<reverse_contiguous_iterator>());
 static_assert(std::random_access_iterator<reverse_contiguous_iterator>);
 static_assert(!std::contiguous_iterator<reverse_contiguous_iterator>);
 static_assert(std::sized_sentinel_for<reverse_contiguous_iterator, reverse_contiguous_iterator>);
 static_assert( std::indirectly_movable<reverse_contiguous_iterator, reverse_contiguous_iterator>);
 static_assert( std::indirectly_movable_storable<reverse_contiguous_iterator, reverse_contiguous_iterator>);
+static_assert( std::indirectly_copyable<reverse_contiguous_iterator, reverse_contiguous_iterator>);
+static_assert( std::indirectly_copyable_storable<reverse_contiguous_iterator, reverse_contiguous_iterator>);
 static_assert( std::indirectly_swappable<reverse_contiguous_iterator, reverse_contiguous_iterator>);

libcxx/test/std/iterators/stream.iterators/istream.iterator/iterator_concept_conformance.compile.pass.cpp

 static_assert(!std::indirectly_writable<iterator, int>);
 static_assert(std::incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(!std::sized_sentinel_for<iterator, iterator>);
 static_assert(std::input_iterator<iterator>);
 static_assert(!std::indirectly_movable<int*, iterator>);
 static_assert(!std::indirectly_movable_storable<int*, iterator>);
+static_assert(!std::indirectly_copyable<int*, iterator>);
+static_assert(!std::indirectly_copyable_storable<int*, iterator>);
 static_assert(!std::indirectly_swappable<iterator, iterator>);

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/iterator_concept_conformance.compile.pass.cpp

 static_assert(std::input_iterator<iterator>);
 static_assert(!std::forward_iterator<iterator>);
 static_assert(!std::indirectly_writable<iterator, char>);
 static_assert(!std::incrementable<iterator>);
 static_assert(std::sentinel_for<iterator, iterator>);
 static_assert(!std::sized_sentinel_for<iterator, iterator>);
 static_assert(std::indirectly_movable<iterator, char*>);
 static_assert(std::indirectly_movable_storable<iterator, char*>);
+static_assert(std::indirectly_copyable<iterator, char*>);
+static_assert(std::indirectly_copyable_storable<iterator, char*>);
 static_assert(!std::indirectly_swappable<iterator, iterator>);

libcxx/test/std/iterators/stream.iterators/ostream.iterator/iterator_concept_conformance.compile.pass.cpp

 static_assert(std::indirectly_writable<iterator, int>);
 static_assert(std::weakly_incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(!std::sentinel_for<iterator, iterator>);
 static_assert(!std::sized_sentinel_for<iterator, iterator>);
 static_assert(!std::input_iterator<iterator>);
 static_assert(std::indirectly_movable<int*, iterator>);
 static_assert(std::indirectly_movable_storable<int*, iterator>);
+static_assert(std::indirectly_copyable<int*, iterator>);
+static_assert(std::indirectly_copyable_storable<int*, iterator>);
 static_assert(!std::indirectly_swappable<iterator, iterator>);

libcxx/test/std/iterators/stream.iterators/ostreambuf.iterator/iterator_concept_conformance.compile.pass.cpp

 static_assert(std::indirectly_writable<iterator, char>);
 static_assert(std::weakly_incrementable<iterator>);
 static_assert(std::input_or_output_iterator<iterator>);
 static_assert(!std::sentinel_for<iterator, iterator>);
 static_assert(!std::sized_sentinel_for<iterator, iterator>);
 static_assert(!std::input_iterator<iterator>);
 static_assert(std::indirectly_movable<char*, iterator>);
 static_assert(std::indirectly_movable_storable<char*, iterator>);
+static_assert(std::indirectly_copyable<char*, iterator>);
+static_assert(std::indirectly_copyable_storable<char*, iterator>);
 static_assert(!std::indirectly_swappable<iterator, iterator>);

libcxx/test/std/re/re.iter/re.regiter/iterator_concept_conformance.compile.pass.cpp

 
 static_assert(std::forward_iterator<std::cregex_iterator>);
 static_assert(!std::bidirectional_iterator<std::cregex_iterator>);
 static_assert(!std::indirectly_writable<std::cregex_iterator, char>);
 static_assert(std::sentinel_for<std::cregex_iterator, std::cregex_iterator>);
 static_assert(!std::sized_sentinel_for<std::cregex_iterator, std::cregex_iterator>);
 static_assert(!std::indirectly_movable<std::cregex_iterator, std::cregex_iterator>);
 static_assert(!std::indirectly_movable_storable<std::cregex_iterator, std::cregex_iterator>);
+static_assert(!std::indirectly_copyable<std::cregex_iterator, std::cregex_iterator>);
+static_assert(!std::indirectly_copyable_storable<std::cregex_iterator, std::cregex_iterator>);
 static_assert(!std::indirectly_swappable<std::cregex_iterator, std::cregex_iterator>);

libcxx/test/std/re/re.iter/re.tokiter/iterator_concept_conformance.compile.pass.cpp

 
 static_assert(std::forward_iterator<std::cregex_token_iterator>);
 static_assert(!std::bidirectional_iterator<std::cregex_token_iterator>);
 static_assert(!std::indirectly_writable<std::cregex_token_iterator, char>);
 static_assert(std::sentinel_for<std::cregex_token_iterator, std::cregex_token_iterator>);
 static_assert(!std::sized_sentinel_for<std::cregex_token_iterator, std::cregex_token_iterator>);
 static_assert(!std::indirectly_movable<std::cregex_token_iterator, std::cregex_token_iterator>);
 static_assert(!std::indirectly_movable_storable<std::cregex_token_iterator, std::cregex_token_iterator>);
+static_assert(!std::indirectly_copyable<std::cregex_token_iterator, std::cregex_token_iterator>);
+static_assert(!std::indirectly_copyable_storable<std::cregex_token_iterator, std::cregex_token_iterator>);
 static_assert(!std::indirectly_swappable<std::cregex_token_iterator, std::cregex_token_iterator>);

libcxx/test/std/strings/basic.string/string.iterators/iterator_concept_conformance.compile.pass.cpp

 static_assert( std::indirectly_movable<iterator, iterator>);
 static_assert( std::indirectly_movable_storable<iterator, iterator>);
 static_assert(!std::indirectly_movable<iterator, const_iterator>);
 static_assert(!std::indirectly_movable_storable<iterator, const_iterator>);
 static_assert( std::indirectly_movable<iterator, reverse_iterator>);
 static_assert( std::indirectly_movable_storable<iterator, reverse_iterator>);
 static_assert(!std::indirectly_movable<iterator, const_reverse_iterator>);
 static_assert(!std::indirectly_movable_storable<iterator, const_reverse_iterator>);
+static_assert( std::indirectly_copyable<iterator, iterator>);
+static_assert( std::indirectly_copyable_storable<iterator, iterator>);
+static_assert(!std::indirectly_copyable<iterator, const_iterator>);
+static_assert(!std::indirectly_copyable_storable<iterator, const_iterator>);
+static_assert( std::indirectly_copyable<iterator, reverse_iterator>);
+static_assert( std::indirectly_copyable_storable<iterator, reverse_iterator>);
+static_assert(!std::indirectly_copyable<iterator, const_reverse_iterator>);
+static_assert(!std::indirectly_copyable_storable<iterator, const_reverse_iterator>);
 static_assert( std::indirectly_swappable<iterator, iterator>);
 
 static_assert(std::contiguous_iterator<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert(std::sized_sentinel_for<const_iterator, iterator>);
 static_assert(std::sized_sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert( std::indirectly_movable<const_iterator, iterator>);
 static_assert( std::indirectly_movable_storable<const_iterator, iterator>);
 static_assert(!std::indirectly_movable<const_iterator, const_iterator>);
 static_assert(!std::indirectly_movable_storable<const_iterator, const_iterator>);
 static_assert( std::indirectly_movable<const_iterator, reverse_iterator>);
 static_assert( std::indirectly_movable_storable<const_iterator, reverse_iterator>);
 static_assert(!std::indirectly_movable<const_iterator, const_reverse_iterator>);
 static_assert(!std::indirectly_movable_storable<const_iterator, const_reverse_iterator>);
+static_assert( std::indirectly_copyable<const_iterator, iterator>);
+static_assert( std::indirectly_copyable_storable<const_iterator, iterator>);
+static_assert(!std::indirectly_copyable<const_iterator, const_iterator>);
+static_assert(!std::indirectly_copyable_storable<const_iterator, const_iterator>);
+static_assert( std::indirectly_copyable<const_iterator, reverse_iterator>);
+static_assert( std::indirectly_copyable_storable<const_iterator, reverse_iterator>);
+static_assert(!std::indirectly_copyable<const_iterator, const_reverse_iterator>);
+static_assert(!std::indirectly_copyable_storable<const_iterator, const_reverse_iterator>);
 static_assert(!std::indirectly_swappable<const_iterator, const_iterator>);

libcxx/test/std/strings/string.view/string.view.iterators/iterator_concept_conformance.compile.pass.cpp

 static_assert(!std::sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<iterator, const_reverse_iterator>);
 static_assert(std::sized_sentinel_for<iterator, iterator>);
 static_assert(std::sized_sentinel_for<iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<iterator, const_reverse_iterator>);
 static_assert(std::indirectly_movable<iterator, char*>);
 static_assert(std::indirectly_movable_storable<iterator, char*>);
+static_assert(std::indirectly_copyable<iterator, char*>);
+static_assert(std::indirectly_copyable_storable<iterator, char*>);
 static_assert(!std::indirectly_swappable<iterator, iterator>);
 
 static_assert(std::contiguous_iterator<const_iterator>);
 LIBCPP_STATIC_ASSERT(std::__is_cpp17_random_access_iterator<const_iterator>::value);
 static_assert(!std::indirectly_writable<const_iterator, char>);
 static_assert(std::sentinel_for<const_iterator, iterator>);
 static_assert(std::sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert(std::sized_sentinel_for<const_iterator, iterator>);
 static_assert(std::sized_sentinel_for<const_iterator, const_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, reverse_iterator>);
 static_assert(!std::sized_sentinel_for<const_iterator, const_reverse_iterator>);
 static_assert(!std::indirectly_swappable<const_iterator, const_iterator>);

libcxx/test/std/utilities/memory/unique.ptr/iterator_concept_conformance.compile.pass.cpp

 
 #include <iterator>
 
 static_assert(std::indirectly_readable<std::unique_ptr<int> >);
 static_assert(std::indirectly_writable<std::unique_ptr<int>, int>);
 static_assert(!std::weakly_incrementable<std::unique_ptr<int> >);
 static_assert(std::indirectly_movable<std::unique_ptr<int>, std::unique_ptr<int>>);
 static_assert(std::indirectly_movable_storable<std::unique_ptr<int>, std::unique_ptr<int>>);
+static_assert(std::indirectly_copyable<std::unique_ptr<int>, std::unique_ptr<int>>);
+static_assert(std::indirectly_copyable_storable<std::unique_ptr<int>, std::unique_ptr<int>>);
 static_assert(std::indirectly_swappable<std::unique_ptr<int>, std::unique_ptr<int> >);
 
 static_assert(!std::indirectly_readable<std::unique_ptr<void> >);
 static_assert(!std::indirectly_writable<std::unique_ptr<void>, void>);
 static_assert(!std::weakly_incrementable<std::unique_ptr<void> >);
 static_assert(!std::indirectly_movable<std::unique_ptr<void>, std::unique_ptr<void>>);
 static_assert(!std::indirectly_movable_storable<std::unique_ptr<void>, std::unique_ptr<void>>);
+static_assert(!std::indirectly_copyable<std::unique_ptr<void>, std::unique_ptr<void>>);
+static_assert(!std::indirectly_copyable_storable<std::unique_ptr<void>, std::unique_ptr<void>>);

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/iterator_concept_conformance.compile.pass.cpp

 
 #include <iterator>
 
 static_assert(std::indirectly_readable<std::shared_ptr<int> >);
 static_assert(std::indirectly_writable<std::shared_ptr<int>, int>);
 static_assert(!std::weakly_incrementable<std::shared_ptr<int> >);
 static_assert(std::indirectly_movable<std::shared_ptr<int>, std::shared_ptr<int>>);
 static_assert(std::indirectly_movable_storable<std::shared_ptr<int>, std::shared_ptr<int>>);
+static_assert(std::indirectly_copyable<std::shared_ptr<int>, std::shared_ptr<int>>);
+static_assert(std::indirectly_copyable_storable<std::shared_ptr<int>, std::shared_ptr<int>>);
 static_assert(std::indirectly_swappable<std::shared_ptr<int>, std::shared_ptr<int> >);
 
 static_assert(!std::indirectly_readable<std::shared_ptr<void> >);
 static_assert(!std::indirectly_writable<std::shared_ptr<void>, void>);
 static_assert(!std::weakly_incrementable<std::shared_ptr<void> >);
 static_assert(!std::indirectly_movable<std::shared_ptr<void>, std::shared_ptr<void>>);
 static_assert(!std::indirectly_movable_storable<std::shared_ptr<void>, std::shared_ptr<void>>);
+static_assert(!std::indirectly_copyable<std::shared_ptr<void>, std::shared_ptr<void>>);
+static_assert(!std::indirectly_copyable_storable<std::shared_ptr<void>, std::shared_ptr<void>>);

libcxx/test/std/utilities/optional/iterator_concept_conformance.compile.pass.cpp

 
 #include <iterator>
 
 static_assert(!std::indirectly_readable<std::optional<int> >);
 static_assert(!std::indirectly_writable<std::optional<int>, int>);
 static_assert(!std::weakly_incrementable<std::optional<int> >);
 static_assert(!std::indirectly_movable<std::optional<int>, std::optional<int>>);
 static_assert(!std::indirectly_movable_storable<std::optional<int>, std::optional<int>>);
+static_assert(!std::indirectly_copyable<std::optional<int>, std::optional<int>>);
+static_assert(!std::indirectly_copyable_storable<std::optional<int>, std::optional<int>>);