[libc++][ranges] Implement `uninitialized_copy{,_n}` and `uninitialized_move{,_n}`.

[var-const]

Summary

Also implement in_out_result which is a prerequisite.

[var-const]

Fix C++03 mode.

[var-const]

Small fixes.

[var-const]

Update status docs.

[var-const]

libcxx/include/__memory/uninitialized_algorithms.h

28

This class is to allow the non-ranges versions of algorithms operating on two sequences to use the same internal implementation (because the non-ranges versions only provide the beginning of the output range, so some placeholder is necessary for the end of the output range).

39

Note: __compressed_pair cannot be used here because it doesn't support its two types being the same type. tuple, which supports EBO, also cannot be used here because uninitialized_copy must be available in the C++03 mode.

41

I made some refactorings throughout to make the implementations in this file to be more similar to each other (using same names and similar code flow).

45–46

From a quick look at the Standard's definition of unreachable_sentinel, it only defines operator== (not !=) and the sentinel is the first argument. I didn't want to expand the interface, hence the somewhat convoluted comparison here. However, maybe I'm missing something and other forms of comparison are synthesized somehow for unreachable_sentinel?

282

There is an important implementation difference between the ranges- and non-ranges versions of uninitialized_move: the old version simply calls std::move on each element, while the ranges version calls std::ranges::iter_move, which is a customization point. To avoid maintaining two parallel implementations, use a functor.

283

Note: I could use tuple here to get EBO (suggested by @ldionne). I'm a little concerned about consistency with the very similar uninitialized_copy algorithm (though it can be argues that uninitialized_move already diverges quite a bit). Happy to change to tuple if other people feel it's appropriate here.

libcxx/include/memory

185

For entities in the nested ranges namespace, is it preferable to specify them like this:

template <class A, class B>
ranges::foo_result ranges::foo(A a, B b);

or like this:

namespace ranges {
template <class A, class B>
foo_result foo(A a, B b);
}

?

[• Quuxplusone]

libcxx/include/__memory/uninitialized_algorithms.h

45–46

Yes, C++20's operator-spaceship feature includes the ability to create "rewritten candidates," so that a < b might actually call (a <=> b) < 0 or 0 < (b <=> a), and a != b might actually call !(a == b) or !(b == a).

My first impression here is that the benefits of sharing this code between C++11 and C++20 are outweighed by the costs, and we should just write a new file <__memory/ranges_uninitialized_algorithms.h> without trying to share code at all.

Actually, didn't we already do that? <__memory/ranges_uninitialized_algorithms.h> seems to exist! Can you double-check how this PR interacts with whatever PR introduced <__memory/ranges_uninitialized_algorithms.h> already?

However, you can at least simplify the C++11 codepath by making your new C++11-friendly __unreachable_sentinel provide friend bool operator!=(const _Iter&, __unreachable_sentinel) (and nothing else), because that's the unwritten syntactic requirement implied by the body of the (old) C++11 function template __uninitialized_copy. The template does require (it != sent) to compile, so your sentinel type should provide that operator. The template does not require (sent == it) to compile, so (to keep things simple) your sentinel type should not provide that operator.

libcxx/include/memory

185

The precedent here is "do as https://eel.is/c++draft/memory.syn does" (which means reopen namespace ranges).

libcxx/include/module.modulemap

223

(1, moot) Inconsistent pluralization here.
(2) Please call this __algorithm/in_out_result.h for now. If there are more types that need to be rolled into this same header, we can always rename it later if needed.

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/ranges_uninitialized_copy.pass.cpp

34–37

FWIW, ultimately we'll probably want to move all these assertions into one centralized place similar to what @jloser did with the "customization point" CPOs and as I did with ADL-proofing and predicate-copying. Otherwise ultimately you're spending 4 lines in each of 100 different test files, and you probably end up missing a few dozen without noticing.
No action needed for now, though.

61

Style nit: I'd prefer

auto it = forward_iterator<Counted*>(in);

for readability. ( https://quuxplusone.github.io/blog/2019/02/18/knightmare-of-initialization/#simple-guidelines-for-variable-i )

175–176

IIUC, these two lines could be just

auto view = in | std::views::reverse;

except that in has 5 elements when it probably was intended to have only 3? The last 2 of in's elements aren't being used in this test.

255–285

These two tests seem backwards to me. The important thing about "works with const iterators" is that it needs to work when the destination range has const iterators. Making the elements of the source range const — that also ought to work, sure, but it's significantly less interesting than making the elements of the destination range const.

[var-const]

• add tests for in_out_result;
• add tests for conversions;
• address feedback.

[var-const]

libcxx/include/__memory/uninitialized_algorithms.h

45–46

__memory/ranges_uninitialized_algorithms.h was introduced by my first patch in this series. It deliberately delegates most of the work to the internal functions contained in __memory/uninitialized_algorithms.h.

I have considered maintaining separate implementations before starting on this path. The amount of code duplication would be significant, with all the associated drawbacks. Already in uninitialized_algorithms.h before these changes there was a lot of inconsistency between very similar functions, this would only grow worse with twice the duplication and code being split among two different files.

However, you can at least simplify the C++11 codepath by making your new C++11-friendly unreachable_sentinel provide friend bool operator!=(const _Iter&, unreachable_sentinel) (and nothing else)

Done.

libcxx/include/memory

185

Done (throughout the file).

Another question on this topic -- I've seen a few instances where lines in the synopsis run longer than even 120 characters. Is this intentional or just an oversight?

libcxx/include/module.modulemap

223

If there are more types that need to be rolled into this same header, we can always rename it later if needed.

There are a plenty of very similar closely-related types:

in_fun_result
in_in_result
in_out_result
in_in_out_result
in_out_out_result
min_max_result
in_found_result

Given how small and similar they are, it seemed to me like consolidating them in a single file makes sense. Do you feel these should be separated?

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/ranges_uninitialized_copy.pass.cpp

34–37

I would prefer having a single test file devoted to this as well. Added a TODO throughout.

61

Thank you for the link. While I can see the benefit described there, this form also makes me wonder whether forward_iterator is a type or a function, and if it's the latter, then what kind of a return type it might have. This makes me hesitant to make this change.

175–176

except that in has 5 elements when it probably was intended to have only 3?

I wanted to have a test case where only a part of the output buffer is used (here and in similar recently-committed tests). If you feel it doesn't add value, I can reduce the size of the buffer to 3.

255–285

Thanks for spotting this!

[var-const]

Rebase on main.

[ldionne]

Left some comments -- I don't need to see this again if you agree with my suggestions. I don't want to block you since I'll be out for the holidays soon.

libcxx/include/__algorithm/algorithms_results.h

34 ↗

(On Diff #395559)

_LIBCPP_HIDE_FROM_ABI

libcxx/include/__memory/ranges_uninitialized_algorithms.h

401–402

Suggestion, we often have the return type above the rest of the function. I'm not a big fan of that convention, but here it might help.

libcxx/include/__memory/uninitialized_algorithms.h

45–46

Note from our discussion: you noticed you are missing a test case in the ranges version when __idx reaches __olast before __ifirst reaches __ilast.

283

I am not utterly concerned by using pair and not doing EBO. I believe these algorithms will be used with stateful iterators where EBO wouldn't help most of the time anyway.

libcxx/include/memory

185

I don't think anyone has ever asked the question. I think we should just copy-paste the formatting of the Standard, as you seem to be doing already.

libcxx/test/std/algorithms/algorithms.results/algorithms.results.compile.pass.cpp

9 ↗

(On Diff #395559)

I suspect this test is going to have to be XFAILed for Clang on Windows, because I don't think the Clang emulation of MSVC supports [[no_unique_address]]. You can see whether that's correct once CI runs.

23 ↗

(On Diff #395559)

You seem to be missing a test case for when the members of in_out_result are move constructible vs copy constructible, i.e. the const& vs && variant.

Also, there should be runtime tests actually running those conversion operators to make sure they are implemented correctly, even though I know it's an almost trivial class. (This means you'll need to move from .compile.pass.cpp to .pass.cpp)

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/ranges_uninitialized_copy.pass.cpp

216–217

This comment should clarify what "existing objects" means. Are we talking about the objects in the source range?

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/ranges_uninitialized_move.pass.cpp

87–92

Suggestion. It helps clarify that the test cases are 100% unrelated, and also allows skipping the numbering. All that for just two spaces of indentation!

250–251

What http://eel.is/c++draft/specialized.algorithms#uninitialized.move-5 says is basically that if one of the move constructor throws, the objects in the source range (that have been moved-from) will now be left in a moved-from state (aka the valid-but-unspecified-state wording used in the spec).

Instead, IMO we should be asserting that the moved-from objects (i.e. in[0], in[1], in[2]) are indeed moved-from after the exception has been thrown.

349

Here and elsewhere.

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/ranges_uninitialized_move_n.pass.cpp

100

I don't think I've seen tests that the various std::ranges:: algorithms are returning exactly the type specified in the standard. If that's right, we should add some.

In other words, it's not sufficient to be returning some type that happens to have .in and .out, they need to be exactly what the spec says.

[• Quuxplusone]

libcxx/include/__memory/uninitialized_algorithms.h

283

EBO is only a concern when ABI is a concern. Here, if you're thinking about ABI, you've already lost. If this return value is ever materialized into memory, your perf is already shot to heck. (This is a general complaint of mine about C++20 Ranges and refactorings-to-use-more-helper-functions: the optimizer can paper over a lot of sins, but the flip side of that is that the library gradually becomes even less usable at -O0.)

libcxx/include/module.modulemap

223

Given how small and similar they are, it seemed to me like consolidating them in a single file makes sense. Do you feel these should be separated?

I feel that there are two things to consider, and right now both of them militate in favor of in_out_result.h:
(1) .h files should be named for what's in them. What's in this file right now is in_out_result. Maybe that'll change in a few weeks; if it does, then we can change the file's name to match its new contents.
(2) Minimize dependencies: things should be combined if they're often used together, and split up if they're basically never used together. My ill-informed impression is that these *_result types are (2a) literally never used together, and (2b) in some cases, single-purpose types which really belong in their appropriate algorithm .h file; e.g. min_max_result probably belongs in __algorithm/ranges_min_max.h (and nowhere else).

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/ranges_uninitialized_copy.pass.cpp

61

While I can see the benefit described there, this form also makes me wonder whether forward_iterator is a type or a function

True. Of course this isn't unique to forward_iterator<int*>; we see that kind of ambiguity with std::ranges::subrange (type) on line 68 versus std::ranges::uninitialized_copy (function) on line 69.
Anyway, I think in this case it reads better with = instead of (); but I definitely can't claim that we use = 100% consistently.

Btw, if you're implying "Someone working on this file might not instantly understand that forward_iterator<It> is one of our test iterators from test_iterators.h," well, I would disagree with that implication. :) The test iterators are used in enough places that we should expect people to be at least as familiar with that vocabulary as with the std::ranges vocabulary (and hopefully more so!). I grant that auto it = mary_poppins<int*>(in) would be legitimately mysterious as to what kind of entity mary_poppins is; but auto it = forward_iterator<int*>(in) in this codebase shouldn't have quite that same level of mystery.

No action needed here, but if I've reduced your hesitancy, consider un-hesitating. ;)

216–217

I assume it means "any of the existing objects in the destination range (which have not yet been overwritten)."

Line 224 says "the fourth object," but N is actually 3 and there's also a 5 involved, so I don't know which direction the off-by-one math is happening. IIUC, that comment could just say Throw when constructing out[3].

Line 226 should be followed by an assert(false) (inside the try, but never hit because we expect to throw an exception).

And then circa line 229, we should do what the comment says we're doing: we should check that the value of out[4].value remains 5. Without that check, I don't think this test is doing anything.

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/ranges_uninitialized_copy_n.pass.cpp

39–40

clang-format strikes again. I suggest

static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_copy_n),
    int*, size_t, NotConvertibleFromInt*, NotConvertibleFromInt*>);

or even better, just

static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_copy_n), int**, size_t, int*, int*>);

since IIUC the point of this assertion is to test that it SFINAEs away when the source element type isn't convertible to the dest element type (e.g. int isn't convertible to int*).

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/ranges_uninitialized_move.pass.cpp

72–76

I'd feel better if this were a non-template hidden friend:

friend T&& iter_move(Iterator it) {
    ++iter_move_invocations;
    return std::move(*it);
}

Also, in writing that, I noticed that you were passing it by mutable reference on line 72. That's because https://eel.is/c++draft/specialized.algorithms#uninitialized.move-4 is overspecified, right? Personally I think we shouldn't bother to test that, and should file yet another LWG issue about the overspecification. This is the same overspecification problem as in resize_and_overwrite; and I hadn't noticed it before.

Intuition tells me that for the programmer to provide an ADL iter_move that works only with lvalues, might actually be IFNDR for some reason related to https://github.com/cplusplus/nbballot/issues/183 "implicit expression variations." But I certainly don't know for sure.

87–92

+1... and note that in many existing tests, we don't even bother to pay the 2 spaces of indentation. ;)

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/ranges_uninitialized_move_n.pass.cpp

100

Pro tip: in tests that already require Concepts, this can be as simple as

std::same_as<std::ranges::in_out_result> auto result =
    std::ranges::uninitialized_move_n(in, N, out.begin(), out.end());

although I guess that syntax works better for shorter types/expressions. :) Here it's not saving you much (if anything) over the old-school

auto result = std::ranges::uninitialized_move_n(in, N, out.begin(), out.end());
ASSERT_SAME_TYPE(decltype(result), std::ranges::in_out_result);

[var-const]

• Use a different branch which is correctly based on main. The previous branch's history was unfortunately broken;
• address feedback.

libcxx/include/__memory/uninitialized_algorithms.h

45–46

Added.

283

but the flip side of that is that the library gradually becomes even less usable at -O0.

It's a very valid concern, but I don't see a great way around it without a lot of code duplication (or code generation, which comes with its own set of problems).

libcxx/include/module.modulemap

223

Renamed to in_out_result.h.

Regarding whether they're used together -- I don't think they're ever used within the same function, but I'm also pretty sure that including <algorithm> will drag in all of them. That was part of my thinking when I decided to define them in a single file. However, having them in separate files would mean we "import" less stuff internally.

libcxx/test/std/algorithms/algorithms.results/algorithms.results.compile.pass.cpp

23 ↗

(On Diff #395559)

Done.

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/ranges_uninitialized_copy.pass.cpp

61

The problem with initialization styles is that their main benefits happen when they are used consistently. Personally, I always use the old T foo(x, y) unless there's a reason not to -- this is why when I see auto foo = T(x, y), my thought process goes something like "I _think_ T is a class, but if it were, why wouldn't they just write T foo(x, y)? Am I missing something? Is it actually some T2 class with a very similar name? Or perhaps it comes from some different namespace? Oh, I see, it is in fact T, they just prefer to use auto initialization for some reason".

This would be less of an issue if auto foo = ... form was used consistently, but to a certain extent the issue is unavoidable -- it's inherent in the fact that this form of initialization invokes regular functions just as happily as constructors. The fact that current code sometimes uses the same naming convention for functions as for types doesn't help, either. I generally prefer to use the most restricted form that achieves the necessary result, and in this case the T foo(x, y) form seems more restricted (T can only be a type, and thus this can only be a constructor call).

It's true that the reader can be expected to know the commonly-used types, but I think it poses new questions. At which point can a type be considered a commonly-used type within a file? It's an additional judgment call for the writer, and I don't think using two different forms of initialization makes things easier for the reader either.

The fact that I'm using the auto = form with subrange is actually a mistake on my part -- I did presume subrange was a function. Yes, it is my fault for not checking, but I wouldn't _need_ to check if a different form of initialization was used.

216–217

Thanks for calling it out. Should be in a better shape now, PTAL.

I assume it means "any of the existing objects in the destination range (which have not yet been overwritten)."

Yes (because it uses copying, the fact that objects in the source range are unchanged seems like a given, but please let me know if you disagree and I can add checks). However, now that I think of it, I'm not sure this is a valid use case -- this algorithm is supposed to be used on uninitialized memory. I'm also not 100% sure that calling placement new on an object without calling its destructor first isn't undefined behavior for trivially-destructible types (though I would think so).

Line 224 says "the fourth object," but N is actually 3 and there's also a 5 involved, so I don't know which direction the off-by-one math is happening. IIUC, that comment could just say Throw when constructing out[3].

Your rephrasing is much better, thanks. The original comment meant "fourth" if using "natural" counting order (counting from one).

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/ranges_uninitialized_copy_n.pass.cpp

39–40

I don't feel too strongly about it, but my current preference is to keep it as-is. The class name, verbose as it is, makes the purpose of the test obvious, whereas the distinction between one asterisk vs. two asterisks requires a closer look.

In my experience, manually changing the output of a formatting tool largely defeats the purpose of using one. While I agree that the proposed formatting is better, I wouldn't say that what clang-format produced is broken to justify manual editing.

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/ranges_uninitialized_move.pass.cpp

72–76

Done.

87–92

Done. I'd prefer to use consistent indentation everywhere.

250–251

Done, thanks!

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/ranges_uninitialized_move_n.pass.cpp

100

Added, will add similar tests to the already-committed algorithms in a follow-up.

@Quuxplusone Thanks for providing two versions! I agree that Concepts don't seem to have a huge advantage, so I went with ASSERT_SAME_TYPE. Happy to change, though.

[var-const]

Run libcxx-generate-files.

[var-const]

Fix CI.

[var-const]

Rebase on main.

[var-const]

Fix CI.

[var-const]

Fix CI on Windows.

[• Quuxplusone]

libcxx/include/__memory/ranges_uninitialized_algorithms.h

182

Does this just need to be rebased? I think I remember fixing that fil to fill as a drive-by, too.
Ditto throughout: I believe we agreed (at least for now) not to indent the big namespace but to leave the one-liner indented. Anyway, please look at the existing code (as it is now in main, not how it was last month ;)) and let's be consistent with whatever it looks like.

398

Please remove all clang-format comments.

432–433

Readability nit. ("Semantic linebreaks")

libcxx/include/__memory/uninitialized_algorithms.h

30

I suspect the _NOEXCEPT is useless and thus should be removed; but I'm not sure. (Which is why I'd rather it hadn't been there at all! Frost's corollary to Chesterton's Fence: it's going to take more work to remove a fence [keyword] than to erect one unnecessarily, so let's make sure we're only erecting the necessary ones.)

37–39

and so on throughout — let's not go out of our way to fit everything in 80 columns, but let's not go out of our way to shove everything onto one line either :)

libcxx/test/std/algorithms/algorithms.results/in_out_result.pass.cpp

24–31

I remember a similar issue in the in_in_result review. Is this consistent with what we landed on there? (I don't think it is...?)

[var-const]

Address feedback.

libcxx/include/__memory/ranges_uninitialized_algorithms.h

182

Done.

After some thinking, I still feel that having special rules for special cases adds more complexity than it's worth. Would a new programmer starting on the code base be able to figure out the reason for the inconsistency? Are we realistically going to document the rationale for all the special cases? I feel the answer to both is more likely no than yes.

398

I'd rather leave these in. clang-format doesn't format requires clauses well. I understand you're not a big fan of clang-format, but removing those statements after they're already added seems a little overkill.

libcxx/include/__memory/uninitialized_algorithms.h

30

This class mimics std::unreachable_sentinel_t which does define its operator== as noexcept. I'd rather be consistent with the standard class, for simplicity if nothing else.

37–39

Done, but I'm not very happy with the change. If we say that we're using 120 columns width, we should be using it.

libcxx/test/std/algorithms/algorithms.results/in_out_result.pass.cpp

24–31

Made it consistent and copied a group of tests from that patch. Thanks for bringing this up!

[gulfem]

This patch seems to break the Fuchsia builds.

Failed Tests (1):
  libc++ :: std/algorithms/algorithms.results/in_out_result.pass.cpp

https://logs.chromium.org/logs/fuchsia/buildbucket/cr-buildbucket/8825352420796900577/+/u/clang/test/stdout

This is the link to the cmake commands:
https://logs.chromium.org/logs/fuchsia/buildbucket/cr-buildbucket/8825352420796900577/+/u/clang/configure/execution_details

[gulfem]

Would you mind reverting it unless the issue can be fixed quickly?

[var-const]

In D116023#3234931, @gulfem wrote:

This patch seems to break the Fuchsia builds.

Failed Tests (1):
  libc++ :: std/algorithms/algorithms.results/in_out_result.pass.cpp

https://logs.chromium.org/logs/fuchsia/buildbucket/cr-buildbucket/8825352420796900577/+/u/clang/test/stdout

This is the link to the cmake commands:
https://logs.chromium.org/logs/fuchsia/buildbucket/cr-buildbucket/8825352420796900577/+/u/clang/configure/execution_details

I don't see any details on what is failing in the logs. If I were to guess, I'd presume that the [[no_unique_address]] attribute doesn't work on Fuchsia.

[var-const]

In D116023#3235538, @gulfem wrote:

Would you mind reverting it unless the issue can be fixed quickly?

I'll see if I can mark the test as XFAIL on Fuchsia. If not, I'll change the test.

[var-const]

@gulfem The test should be disabled on Fuchsia by commit 9e634b35ff51d0eb2b38013111491e88bdbae388.

I would need a log that indicates the exact failure in the test (I don't see that in the log you provided) or a way to reproduce in order to fix this properly. Can you help me with that?

[vvereschaka]

@var-const, @gulfem

The libc++::in_out_result.pass.cpp test gets failed to build with the following error:

C:/buildbot/as-builder-1/x-armv7l/build/include/c++/v1\__algorithm/in_out_result.h:36:13: error: non-constant-expression cannot be narrowed from type 'int' to 'double' in initializer list [-Wc++11-narrowing]
    return {in, out};
            ^~
C:\buildbot\as-builder-1\x-armv7l\llvm-project\libcxx\test\std\algorithms\algorithms.results\in_out_result.pass.cpp:49:50: note: in instantiation of function template specialization 'std::ranges::in_out_result<int, bool>::operator in_out_result<double, char>' requested here
    std::ranges::in_out_result<double, char> y = x;
                                                 ^
C:/buildbot/as-builder-1/x-armv7l/build/include/c++/v1\__algorithm/in_out_result.h:36:13: note: insert an explicit cast to silence this issue
    return {in, out};
            ^~
            static_cast<double>( )
1 error generated.
error: command failed with exit status: 1

I suspect the same problem for Fuchsia also.

• https://lab.llvm.org/buildbot/#/builders/60/builds/6143
• https://lab.llvm.org/buildbot/#/builders/119/builds/7169

[uabelho]

In D116023#3236465, @vvereschaka wrote:

@var-const, @gulfem

The libc++::in_out_result.pass.cpp test gets failed to build with the following error:

I see this error too in our downstream tests:

In file included from /repo/uabelho/master-github/libcxx/test/std/algorithms/algorithms.results/in_out_result.pass.cpp:19:
In file included from /repo/uabelho/master-github/llvm/build-all-builtins/include/c++/v1/algorithm:659:
In file included from /repo/uabelho/master-github/llvm/build-all-builtins/include/c++/v1/functional:506:
In file included from /repo/uabelho/master-github/llvm/build-all-builtins/include/c++/v1/__functional/function.h:24:
In file included from /repo/uabelho/master-github/llvm/build-all-builtins/include/c++/v1/memory:793:
In file included from /repo/uabelho/master-github/llvm/build-all-builtins/include/c++/v1/__memory/ranges_uninitialized_algorithms.h:13:
/repo/uabelho/master-github/llvm/build-all-builtins/include/c++/v1/__algorithm/in_out_result.h:36:13: error: non-constant-expression cannot be narrowed from type 'int' to 'double' in initializer list [-Wc++11-narrowing]
    return {in, out};
            ^~
/repo/uabelho/master-github/libcxx/test/std/algorithms/algorithms.results/in_out_result.pass.cpp:49:50: note: in instantiation of function template specialization 'std::ranges::in_out_result<int, bool>::operator in_out_result<double, char>' requested here
    std::ranges::in_out_result<double, char> y = x;
                                                 ^
/repo/uabelho/master-github/llvm/build-all-builtins/include/c++/v1/__algorithm/in_out_result.h:36:13: note: insert an explicit cast to silence this issue
    return {in, out};
            ^~
            static_cast<double>( )
1 error generated.

error: command failed with exit status: 1

I'm on RHEL7 compiling with clang 8.

[var-const]

@vvereschaka, @uabelho Thanks for the error messages! I'll prepare a fix ASAP.

[var-const]

@vvereschaka @uabelho I'll submit a quick fix today after https://reviews.llvm.org/D117089 passes CI.

[phosek]

In D116023#3236480, @var-const wrote:

@vvereschaka, @uabelho Thanks for the error messages! I'll prepare a fix ASAP.

That test isn't failing on Fuchsia (we don't run libc++ tests on Fuchsia yet), it's failing on Fuchsia toolchain bots which are building and running tests on Linux, but in this particular case it's an arm64 machine.

[var-const]

Hopefully fixed by commit fe958b140ab37acf316f5b98318e75ba2119d5a2.

[gulfem]

Thank you @var-const, fe958b140ab37acf316f5b98318e75ba2119d5a2 fixed the issue that we were seeing in the Fuchsia toolchain bots.
I think you can also revert 9e634b35ff51d0eb2b38013111491e88bdbae388 as there is no need for that.

libcxx/docs/Status/RangesAlgorithms.csv

 Permutation,nth_element,Not assigned,n/a,Not started
 Permutation,inplace_merge,Not assigned,n/a,Not started
 Permutation,make_heap,Not assigned,n/a,Not started
 Permutation,push_heap,Not assigned,n/a,Not started
 Permutation,pop_heap,Not assigned,n/a,Not started
 Permutation,sort_heap,Not assigned,n/a,Not started
 Permutation,prev_permutation,Not assigned,n/a,Not started
 Permutation,next_permutation,Not assigned,n/a,Not started
-Uninitialised memory,uninitialized_copy,Konstantin Varlamov,n/a,Not started
-Uninitialised memory,uninitialized_copy_n,Konstantin Varlamov,n/a,Not started
+Uninitialised memory,uninitialized_copy,Konstantin Varlamov,`D116023 <https://llvm.org/D116023>`_,✅
+Uninitialised memory,uninitialized_copy_n,Konstantin Varlamov,`D116023 <https://llvm.org/D116023>`_,✅
 Uninitialised memory,uninitialized_fill,Konstantin Varlamov,`D115626 <https://llvm.org/D115626>`_,✅
 Uninitialised memory,uninitialized_fill_n,Konstantin Varlamov,`D115626 <https://llvm.org/D115626>`_,✅
-Uninitialised memory,uninitialized_move,Konstantin Varlamov,n/a,Not started
-Uninitialised memory,uninitialized_move_n,Konstantin Varlamov,n/a,Not started
+Uninitialised memory,uninitialized_move,Konstantin Varlamov,`D116023 <https://llvm.org/D116023>`_,✅
+Uninitialised memory,uninitialized_move_n,Konstantin Varlamov,`D116023 <https://llvm.org/D116023>`_,✅
 Uninitialised memory,uninitialized_default_construct,Konstantin Varlamov,`D115315 <https://llvm.org/D115315>`_,✅
 Uninitialised memory,uninitialized_default_construct_n,Konstantin Varlamov,`D115315 <https://llvm.org/D115315>`_,✅
 Uninitialised memory,uninitialized_value_construct,Konstantin Varlamov,`D115626 <https://llvm.org/D115626>`_,✅
 Uninitialised memory,uninitialized_value_construct_n,Konstantin Varlamov,`D115626 <https://llvm.org/D115626>`_,✅
 Uninitialised memory,destroy,Konstantin Varlamov,n/a,Not started
 Uninitialised memory,destroy_n,Konstantin Varlamov,n/a,Not started
 Uninitialised memory,destroy_at,Konstantin Varlamov,n/a,Not started
 Uninitialised memory,construct_at,Konstantin Varlamov,n/a,Not started

libcxx/docs/Status/RangesPaper.csv

 | *nothrow-input-range*
 | *nothrow-forward-iterator*
 | *nothrow-forward-range*","| [iterator.concepts]
 | [range.refinements]",Konstantin Varlamov,✅
 `[specialized.algorithms] <http://wg21.link/specialized.algorithms>`_,"| `ranges::uninitialized_default_construct <https://llvm.org/D115315>`_
 | `ranges::uninitialized_default_construct_n <https://llvm.org/D115315>`_
 | `ranges::uninitialized_value_construct <https://llvm.org/D115626>`_
 | `ranges::uninitialized_value_construct_n <https://llvm.org/D115626>`_
-| ranges::uninitialized_copy
-| ranges::uninitialized_copy_n
-| ranges::uninitialized_move
-| ranges::uninitialized_move_n
+| `ranges::uninitialized_copy <https://llvm.org/D116023>`_
+| `ranges::uninitialized_copy_n <https://llvm.org/D116023>`_
+| `ranges::uninitialized_move <https://llvm.org/D116023>`_
+| `ranges::uninitialized_move_n <https://llvm.org/D116023>`_
 | `ranges::uninitialized_fill <https://llvm.org/D115626>`_
 | `ranges::uninitialized_fill_n <https://llvm.org/D115626>`_
 | ranges::construct_at
 | ranges::destroy
 | ranges::destroy_at
 | ranges::destroy_n",[special.mem.concepts],Konstantin Varlamov,In progress
 [strings],Adds begin/end and updates const_iterator.,[iterator.concepts],Unassigned,Not started
 [views.span],Same as [strings],[iterator.concepts],Unassigned,Not started

libcxx/include/CMakeLists.txt

set(files
   __algorithm/find_first_of.h
   __algorithm/find_if.h
   __algorithm/find_if_not.h
   __algorithm/for_each.h
   __algorithm/for_each_n.h
   __algorithm/generate.h
   __algorithm/generate_n.h
   __algorithm/half_positive.h
+  __algorithm/in_out_result.h
   __algorithm/includes.h
   __algorithm/inplace_merge.h
   __algorithm/is_heap.h
   __algorithm/is_heap_until.h
   __algorithm/is_partitioned.h
   __algorithm/is_permutation.h
   __algorithm/is_sorted.h
   __algorithm/is_sorted_until.h

libcxx/include/__algorithm/in_out_result.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ALGORITHM_IN_OUT_RESULT_H
+#define _LIBCPP___ALGORITHM_IN_OUT_RESULT_H
+
+#include <__concepts/convertible_to.h>
+#include <__config>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+namespace ranges {
+
+template<class _InputIterator, class _OutputIterator>
+struct in_out_result {
+  [[no_unique_address]] _InputIterator in;
+  [[no_unique_address]] _OutputIterator out;
+
+  template <class _InputIterator2, class _OutputIterator2>
+    requires convertible_to<const _InputIterator&, _InputIterator2> && convertible_to<const _OutputIterator&,
+                           _OutputIterator2>
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr operator in_out_result<_InputIterator2, _OutputIterator2>() const & {
+    return {in, out};
+  }
+
+  template <class _InputIterator2, class _OutputIterator2>
+    requires convertible_to<_InputIterator, _InputIterator2> && convertible_to<_OutputIterator, _OutputIterator2>
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr operator in_out_result<_InputIterator2, _OutputIterator2>() && {
+    return {_VSTD::move(in), _VSTD::move(out)};
+  }
+};
+
+} // namespace ranges
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ALGORITHM_IN_OUT_RESULT_H

libcxx/include/__memory/ranges_uninitialized_algorithms.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___MEMORY_RANGES_UNINITIALIZED_ALGORITHMS_H
 #define _LIBCPP___MEMORY_RANGES_UNINITIALIZED_ALGORITHMS_H
 
+#include <__algorithm/in_out_result.h>
 #include <__concepts/constructible.h>
 #include <__config>
 #include <__function_like.h>
+#include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
+#include <__iterator/iter_move.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/readable_traits.h>
 #include <__memory/concepts.h>
 #include <__memory/uninitialized_algorithms.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
 #include <__utility/move.h>
borrowed_iterator_t<_ForwardRange> operator()(_ForwardRange&& __range) const {
     return (*this)(ranges::begin(__range), ranges::end(__range));
   }
 
 };
 
 } // namespace __uninitialized_default_construct
 
 inline namespace __cpo {
   inline constexpr auto uninitialized_default_construct =
       __uninitialized_default_construct::__fn(__function_like::__tag());
 } // namespace __cpo
 
 // uninitialized_default_construct_n
 
 namespace __uninitialized_default_construct_n {
 
 struct __fn final : private __function_like {
 
   constexpr explicit __fn(__tag __x) noexcept :
       __function_like(__x) {}
 
   template <__nothrow_forward_iterator _ForwardIterator>
     requires default_initializable<iter_value_t<_ForwardIterator>>
   _ForwardIterator operator()(_ForwardIterator __first,
                               iter_difference_t<_ForwardIterator> __n) const {
     using _ValueType = remove_reference_t<iter_reference_t<_ForwardIterator>>;
     return _VSTD::__uninitialized_default_construct_n<_ValueType>(_VSTD::move(__first), __n);
   }
 
 };
 
 } // namespace __uninitialized_default_construct_n
 
 inline namespace __cpo {
   inline constexpr auto uninitialized_default_construct_n =
       __uninitialized_default_construct_n::__fn(__function_like::__tag());
 } // namespace __cpo
 
 // uninitialized_value_construct
 
 namespace __uninitialized_value_construct {
 
 struct __fn final : private __function_like {
 
borrowed_iterator_t<_ForwardRange> operator()(_ForwardRange&& __range) const {
     return (*this)(ranges::begin(__range), ranges::end(__range));
   }
 
 };
 
 } // namespace __uninitialized_value_construct
 
 inline namespace __cpo {
   inline constexpr auto uninitialized_value_construct =
       __uninitialized_value_construct::__fn(__function_like::__tag());
 } // namespace __cpo
 
 // uninitialized_value_construct_n
 
 namespace __uninitialized_value_construct_n {
 
 struct __fn final : private __function_like {
 
   constexpr explicit __fn(__tag __x) noexcept : __function_like(__x) {}
 
   template <__nothrow_forward_iterator _ForwardIterator>
     requires default_initializable<iter_value_t<_ForwardIterator>>
   _ForwardIterator operator()(_ForwardIterator __first,
                               iter_difference_t<_ForwardIterator> __n) const {
     using _ValueType = remove_reference_t<iter_reference_t<_ForwardIterator>>;
     return _VSTD::__uninitialized_value_construct_n<_ValueType>(_VSTD::move(__first), __n);
   }
 
 };
 
 } // namespace __uninitialized_value_construct_n
 
 inline namespace __cpo {
   inline constexpr auto uninitialized_value_construct_n =
       __uninitialized_value_construct_n::__fn(__function_like::__tag());
 } // namespace __cpo
 
 // uninitialized_fill
 
 namespace __uninitialized_fill {
 
 struct __fn final : private __function_like {
 
struct __fn final : private __function_like {
   template <__nothrow_forward_range _ForwardRange, class _Tp>
     requires constructible_from<range_value_t<_ForwardRange>, const _Tp&>
   borrowed_iterator_t<_ForwardRange> operator()(_ForwardRange&& __range, const _Tp& __x) const {
     return (*this)(ranges::begin(__range), ranges::end(__range), __x);
   }
 
 };
 
-} // namespace __uninitialized_fil
+} // namespace __uninitialized_fill
 
 inline namespace __cpo {
   inline constexpr auto uninitialized_fill = __uninitialized_fill::__fn(__function_like::__tag());
 } // namespace __cpo
 
 // uninitialized_fill_n
 
 namespace __uninitialized_fill_n {
 
 struct __fn final : private __function_like {
 
   constexpr explicit __fn(__tag __x) noexcept : __function_like(__x) {}
 
   template <__nothrow_forward_iterator _ForwardIterator, class _Tp>
     requires constructible_from<iter_value_t<_ForwardIterator>, const _Tp&>
   _ForwardIterator operator()(_ForwardIterator __first,
                               iter_difference_t<_ForwardIterator> __n,
                               const _Tp& __x) const {
     using _ValueType = remove_reference_t<iter_reference_t<_ForwardIterator>>;
     return _VSTD::__uninitialized_fill_n<_ValueType>(_VSTD::move(__first), __n, __x);
   }
 
 };
 
 } // namespace __uninitialized_fill_n
 
 inline namespace __cpo {
   inline constexpr auto uninitialized_fill_n = __uninitialized_fill_n::__fn(__function_like::__tag());
 } // namespace __cpo
 
+// uninitialized_copy
+
+template <class _InputIterator, class _OutputIterator>
+using uninitialized_copy_result = in_out_result<_InputIterator, _OutputIterator>;
+
+namespace __uninitialized_copy {
+
+struct __fn final : private __function_like {
+
+  constexpr explicit __fn(__tag __x) noexcept : __function_like(__x) {}
+
+  // clang-format off
+  template <input_iterator _InputIterator,
+            sentinel_for<_InputIterator> _Sentinel1,
+            __nothrow_forward_iterator _OutputIterator,
+            __nothrow_sentinel_for<_OutputIterator> _Sentinel2>
+    requires constructible_from<iter_value_t<_OutputIterator>, iter_reference_t<_InputIterator>>
+  uninitialized_copy_result<_InputIterator, _OutputIterator>
+  operator()(_InputIterator __ifirst, _Sentinel1 __ilast, _OutputIterator __ofirst, _Sentinel2 __olast) const {
+    // clang-format on
+    using _ValueType = remove_reference_t<iter_reference_t<_OutputIterator>>;
+
+    auto __result = _VSTD::__uninitialized_copy<_ValueType>(_VSTD::move(__ifirst), _VSTD::move(__ilast),
+                                                            _VSTD::move(__ofirst), _VSTD::move(__olast));
+    return {_VSTD::move(__result.first), _VSTD::move(__result.second)};
+  }
+
+  // clang-format off
+  template <input_range _InputRange, __nothrow_forward_range _OutputRange>
+    requires constructible_from<range_value_t<_OutputRange>, range_reference_t<_InputRange>>
+  uninitialized_copy_result<borrowed_iterator_t<_InputRange>, borrowed_iterator_t<_OutputRange>>
+  operator()( _InputRange&& __in_range, _OutputRange&& __out_range) const {
+    // clang-format on
+    return (*this)(ranges::begin(__in_range), ranges::end(__in_range), ranges::begin(__out_range),
+                   ranges::end(__out_range));
+  }
+};
+
+} // namespace __uninitialized_copy
+
+inline namespace __cpo {
+  inline constexpr auto uninitialized_copy = __uninitialized_copy::__fn(__function_like::__tag());
+} // namespace __cpo
+
+// uninitialized_copy_n
+
+template <class _InputIterator, class _OutputIterator>
+using uninitialized_copy_n_result = in_out_result<_InputIterator, _OutputIterator>;
+
+namespace __uninitialized_copy_n {
+
+struct __fn final : private __function_like {
+
+  constexpr explicit __fn(__tag __x) noexcept : __function_like(__x) {}
+
+  // clang-format off
+  template <input_iterator _InputIterator,
+           __nothrow_forward_iterator _OutputIterator,
+           __nothrow_sentinel_for<_OutputIterator> _Sentinel>
+    requires constructible_from<iter_value_t<_OutputIterator>, iter_reference_t<_InputIterator>>
+  uninitialized_copy_n_result<_InputIterator, _OutputIterator>
+  operator()(_InputIterator __ifirst, iter_difference_t<_InputIterator> __n,
+             _OutputIterator __ofirst, _Sentinel __olast) const {
+    // clang-format on
+    using _ValueType = remove_reference_t<iter_reference_t<_OutputIterator>>;
+
+    auto __result = _VSTD::__uninitialized_copy_n<_ValueType>(_VSTD::move(__ifirst), __n, _VSTD::move(__ofirst),
+                                                              _VSTD::move(__olast));
+    return {_VSTD::move(__result.first), _VSTD::move(__result.second)};
+  }
+
+};
+
+} // namespace __uninitialized_copy_n
+
+inline namespace __cpo {
+  inline constexpr auto uninitialized_copy_n = __uninitialized_copy_n::__fn(__function_like::__tag());
+} // namespace __cpo
+
+// uninitialized_move
+
+template <class _InputIterator, class _OutputIterator>
+using uninitialized_move_result = in_out_result<_InputIterator, _OutputIterator>;
+
+namespace __uninitialized_move {
+
+struct __fn final : private __function_like {
+
+  constexpr explicit __fn(__tag __x) noexcept : __function_like(__x) {}
+
+  // clang-format off
+  template <input_iterator _InputIterator,
+            sentinel_for<_InputIterator> _Sentinel1,
+            __nothrow_forward_iterator _OutputIterator,
+            __nothrow_sentinel_for<_OutputIterator> _Sentinel2>
+    requires constructible_from<iter_value_t<_OutputIterator>, iter_reference_t<_InputIterator>>
+  uninitialized_move_result<_InputIterator, _OutputIterator>
+  operator()(_InputIterator __ifirst, _Sentinel1 __ilast, _OutputIterator __ofirst, _Sentinel2 __olast) const {
+    // clang-format on
+    using _ValueType = remove_reference_t<iter_reference_t<_OutputIterator>>;
+    auto __iter_move = [](auto&& __iter) -> decltype(auto) { return ranges::iter_move(__iter); };
+
+    auto __result = _VSTD::__uninitialized_move<_ValueType>(_VSTD::move(__ifirst), _VSTD::move(__ilast),
+                                                            _VSTD::move(__ofirst), _VSTD::move(__olast), __iter_move);
+    return {_VSTD::move(__result.first), _VSTD::move(__result.second)};
+  }
+
+  // clang-format off
+  template <input_range _InputRange, __nothrow_forward_range _OutputRange>
+    requires constructible_from<range_value_t<_OutputRange>, range_reference_t<_InputRange>>
+  uninitialized_move_result<borrowed_iterator_t<_InputRange>, borrowed_iterator_t<_OutputRange>>
+  operator()(_InputRange&& __in_range, _OutputRange&& __out_range) const {
+    // clang-format on
+    return (*this)(ranges::begin(__in_range), ranges::end(__in_range), ranges::begin(__out_range),
+                   ranges::end(__out_range));
+  }
+
+};
+
+} // namespace __uninitialized_move
+
+inline namespace __cpo {
+  inline constexpr auto uninitialized_move = __uninitialized_move::__fn(__function_like::__tag());
+} // namespace __cpo
+
+// uninitialized_move_n
+
+template <class _InputIterator, class _OutputIterator>
+using uninitialized_move_n_result = in_out_result<_InputIterator, _OutputIterator>;
+
+namespace __uninitialized_move_n {
+
+struct __fn final : private __function_like {
+
+  constexpr explicit __fn(__tag __x) noexcept : __function_like(__x) {}
+
+  // clang-format off
+  template <input_iterator _InputIterator,
+           __nothrow_forward_iterator _OutputIterator,
+           __nothrow_sentinel_for<_OutputIterator> _Sentinel>
+    requires constructible_from<iter_value_t<_OutputIterator>, iter_reference_t<_InputIterator>>
+  uninitialized_move_n_result<_InputIterator, _OutputIterator>
+  operator()(_InputIterator __ifirst, iter_difference_t<_InputIterator> __n, _OutputIterator __ofirst,
+             _Sentinel __olast) const {
+    // clang-format on
+    using _ValueType = remove_reference_t<iter_reference_t<_OutputIterator>>;
+    auto __iter_move = [](auto&& __iter) -> decltype(auto) { return ranges::iter_move(__iter); };
+
+    auto __result = _VSTD::__uninitialized_move_n<_ValueType>(_VSTD::move(__ifirst), __n, _VSTD::move(__ofirst),
+                                                              _VSTD::move(__olast), __iter_move);
+    return {_VSTD::move(__result.first), _VSTD::move(__result.second)};
+  }
+
+};
+
+} // namespace __uninitialized_move_n
+
+inline namespace __cpo {
+  inline constexpr auto uninitialized_move_n = __uninitialized_move_n::__fn(__function_like::__tag());
+} // namespace __cpo
+
 } // namespace ranges
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MEMORY_RANGES_UNINITIALIZED_ALGORITHMS_H

libcxx/include/__memory/uninitialized_algorithms.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//

 #include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _InputIterator, class _ForwardIterator>
-_ForwardIterator
-uninitialized_copy(_InputIterator __f, _InputIterator __l, _ForwardIterator __r)
-{
-    typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
+// This is a simplified version of C++20 `unreachable_sentinel` that doesn't use concepts and thus can be used in any
+// language mode.
+struct __unreachable_sentinel {
+  template <class _Iter>
+  _LIBCPP_HIDE_FROM_ABI friend _LIBCPP_CONSTEXPR bool operator!=(const _Iter&, __unreachable_sentinel) _NOEXCEPT {
+    return true;
+  }
+};
+
+// uninitialized_copy
+
+template <class _ValueType, class _InputIterator, class _Sentinel1, class _ForwardIterator, class _Sentinel2>
+inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
+__uninitialized_copy(_InputIterator __ifirst, _Sentinel1 __ilast,
+                     _ForwardIterator __ofirst, _Sentinel2 __olast) {
+  _ForwardIterator __idx = __ofirst;
 #ifndef _LIBCPP_NO_EXCEPTIONS
-    _ForwardIterator __s = __r;
-    try
-    {
+  try {
 #endif
-        for (; __f != __l; ++__f, (void) ++__r)
-            ::new ((void*)_VSTD::addressof(*__r)) value_type(*__f);
+    for (; __ifirst != __ilast && __idx != __olast; ++__ifirst, (void)++__idx)
+      ::new (_VSTD::__voidify(*__idx)) _ValueType(*__ifirst);
 #ifndef _LIBCPP_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        for (; __s != __r; ++__s)
-            __s->~value_type();
-        throw;
-    }
+  } catch (...) {
+    _VSTD::__destroy(__ofirst, __idx);
 #endif
-    return __r;
+
+  return pair<_InputIterator, _ForwardIterator>(_VSTD::move(__ifirst), _VSTD::move(__idx));
 }
 
-template <class _InputIterator, class _Size, class _ForwardIterator>
-_ForwardIterator
-uninitialized_copy_n(_InputIterator __f, _Size __n, _ForwardIterator __r)
-{
-    typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
+template <class _InputIterator, class _ForwardIterator>
+_ForwardIterator uninitialized_copy(_InputIterator __ifirst, _InputIterator __ilast,
+                                    _ForwardIterator __ofirst) {
+  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+  auto __result = _VSTD::__uninitialized_copy<_ValueType>(_VSTD::move(__ifirst), _VSTD::move(__ilast),
+                                                          _VSTD::move(__ofirst), __unreachable_sentinel());
+  return _VSTD::move(__result.second);
+}
+
+// uninitialized_copy_n
+
+template <class _ValueType, class _InputIterator, class _Size, class _ForwardIterator, class _Sentinel>
+inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
+__uninitialized_copy_n(_InputIterator __ifirst, _Size __n,
+                       _ForwardIterator __ofirst, _Sentinel __olast) {
+  _ForwardIterator __idx = __ofirst;
 #ifndef _LIBCPP_NO_EXCEPTIONS
-    _ForwardIterator __s = __r;
-    try
-    {
+  try {
 #endif
-        for (; __n > 0; ++__f, (void) ++__r, (void) --__n)
-            ::new ((void*)_VSTD::addressof(*__r)) value_type(*__f);
+    for (; __n > 0 && __idx != __olast; ++__ifirst, (void)++__idx, (void)--__n)
+      ::new (_VSTD::__voidify(*__idx)) _ValueType(*__ifirst);
 #ifndef _LIBCPP_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        for (; __s != __r; ++__s)
-            __s->~value_type();
-        throw;
-    }
+  } catch (...) {
+    _VSTD::__destroy(__ofirst, __idx);
 #endif
-    return __r;
+
+  return pair<_InputIterator, _ForwardIterator>(_VSTD::move(__ifirst), _VSTD::move(__idx));
+}
+
+template <class _InputIterator, class _Size, class _ForwardIterator>
+inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator uninitialized_copy_n(_InputIterator __ifirst, _Size __n,
+                                                                   _ForwardIterator __ofirst) {
+  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+  auto __result = _VSTD::__uninitialized_copy_n<_ValueType>(_VSTD::move(__ifirst), __n, _VSTD::move(__ofirst),
+                                                            __unreachable_sentinel());
+  return _VSTD::move(__result.second);
 }
 
 // uninitialized_fill
 
 template <class _ValueType, class _ForwardIterator, class _Sentinel, class _Tp>
 inline _LIBCPP_HIDE_FROM_ABI
 _ForwardIterator __uninitialized_fill(_ForwardIterator __first, _Sentinel __last, const _Tp& __x)
 {

 
 template <class _ForwardIterator, class _Size>
 inline _LIBCPP_HIDE_FROM_ABI
 _ForwardIterator uninitialized_value_construct_n(_ForwardIterator __first, _Size __n) {
     using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
     return __uninitialized_value_construct_n<_ValueType>(_VSTD::move(__first), __n);
 }
 
-template <class _InputIt, class _ForwardIt>
-inline _LIBCPP_INLINE_VISIBILITY
-_ForwardIt uninitialized_move(_InputIt __first, _InputIt __last, _ForwardIt __first_res) {
-    using _Vt = typename iterator_traits<_ForwardIt>::value_type;
-    auto __idx = __first_res;
+// uninitialized_move
+
+template <class _ValueType, class _InputIterator, class _Sentinel1, class _ForwardIterator, class _Sentinel2,
+          class _IterMove>
+inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
+__uninitialized_move(_InputIterator __ifirst, _Sentinel1 __ilast,
+                     _ForwardIterator __ofirst, _Sentinel2 __olast, _IterMove __iter_move) {
+  auto __idx = __ofirst;
 #ifndef _LIBCPP_NO_EXCEPTIONS
-    try {
 #endif
-    for (; __first != __last; ++__idx, (void) ++__first)
-        ::new ((void*)_VSTD::addressof(*__idx)) _Vt(_VSTD::move(*__first));
-    return __idx;
+    for (; __ifirst != __ilast && __idx != __olast; ++__idx, (void)++__ifirst) {
+      ::new (_VSTD::__voidify(*__idx)) _ValueType(__iter_move(__ifirst));
+    }
 #ifndef _LIBCPP_NO_EXCEPTIONS
-    } catch (...) {
-        _VSTD::destroy(__first_res, __idx);
-        throw;
-    }
+    _VSTD::__destroy(__ofirst, __idx);
 #endif
+
+  return {_VSTD::move(__ifirst), _VSTD::move(__idx)};
+}
+
+template <class _InputIterator, class _ForwardIterator>
+inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator uninitialized_move(_InputIterator __ifirst, _InputIterator __ilast,
+                                                                 _ForwardIterator __ofirst) {
+  using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
+  auto __iter_move = [](auto&& __iter) -> decltype(auto) { return _VSTD::move(*__iter); };
+
+  auto __result = _VSTD::__uninitialized_move<_ValueType>(_VSTD::move(__ifirst), _VSTD::move(__ilast),
+                                                          _VSTD::move(__ofirst), __unreachable_sentinel(), __iter_move);
+  return _VSTD::move(__result.second);
 }
 
-template <class _InputIt, class _Size, class _ForwardIt>
-inline _LIBCPP_INLINE_VISIBILITY
-pair<_InputIt, _ForwardIt>
-uninitialized_move_n(_InputIt __first, _Size __n, _ForwardIt __first_res) {
-    using _Vt = typename iterator_traits<_ForwardIt>::value_type;
-    auto __idx = __first_res;
+// uninitialized_move_n
+
+template <class _ValueType, class _InputIterator, class _Size, class _ForwardIterator, class _Sentinel, class _IterMove>
+inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
+__uninitialized_move_n(_InputIterator __ifirst, _Size __n,
+                       _ForwardIterator __ofirst, _Sentinel __olast, _IterMove __iter_move) {
+  auto __idx = __ofirst;
 #ifndef _LIBCPP_NO_EXCEPTIONS
-    try {
 #endif
-    for (; __n > 0; ++__idx, (void) ++__first, --__n)
-        ::new ((void*)_VSTD::addressof(*__idx)) _Vt(_VSTD::move(*__first));
-    return {__first, __idx};
+    for (; __n > 0 && __idx != __olast; ++__idx, (void)++__ifirst, --__n)
+      ::new (_VSTD::__voidify(*__idx)) _ValueType(__iter_move(__ifirst));
 #ifndef _LIBCPP_NO_EXCEPTIONS
-    } catch (...) {
-        _VSTD::destroy(__first_res, __idx);
-        throw;
-    }
+    _VSTD::__destroy(__ofirst, __idx);
 #endif
+
+  return {_VSTD::move(__ifirst), _VSTD::move(__idx)};
+}
+
+template <class _InputIterator, class _Size, class _ForwardIterator>
+inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
+uninitialized_move_n(_InputIterator __ifirst, _Size __n, _ForwardIterator __ofirst) {
+  using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
+  auto __iter_move = [](auto&& __iter) -> decltype(auto) { return _VSTD::move(*__iter); };
+
+  return _VSTD::__uninitialized_move_n<_ValueType>(_VSTD::move(__ifirst), __n, _VSTD::move(__ofirst),
+                                                   __unreachable_sentinel(), __iter_move);
 }
 
 #endif // _LIBCPP_STD_VER > 14
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MEMORY_UNINITIALIZED_ALGORITHMS_H

libcxx/include/algorithm

 template <class BidirectionalIterator>
     constexpr bool     // constexpr in C++20
     prev_permutation(BidirectionalIterator first, BidirectionalIterator last);
 
 template <class BidirectionalIterator, class Compare>
     constexpr bool     // constexpr in C++20
     prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
 
+namespace ranges {
+// [algorithms.results], algorithm result types
+template<class InputIterator, class OutputIterator>
+    struct in_out_result;
+}
+
 }  // std
 
 */
 
 #include <__bits> // __libcpp_clz
 #include <__config>
 #include <__debug>
 #include <cstddef>

 #include <__algorithm/find_first_of.h>
 #include <__algorithm/find_if.h>
 #include <__algorithm/find_if_not.h>
 #include <__algorithm/for_each.h>
 #include <__algorithm/for_each_n.h>
 #include <__algorithm/generate.h>
 #include <__algorithm/generate_n.h>
 #include <__algorithm/half_positive.h>
+#include <__algorithm/in_out_result.h>
 #include <__algorithm/includes.h>
 #include <__algorithm/inplace_merge.h>
 #include <__algorithm/is_heap.h>
 #include <__algorithm/is_heap_until.h>
 #include <__algorithm/is_partitioned.h>
 #include <__algorithm/is_permutation.h>
 #include <__algorithm/is_sorted.h>
 #include <__algorithm/is_sorted_until.h>

libcxx/include/memory

 
 template <class T> T* addressof(T& r) noexcept;
 template <class T> T* addressof(const T&& r) noexcept = delete;
 
 template <class InputIterator, class ForwardIterator>
 ForwardIterator
 uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator result);
 
+namespace ranges {
+
+template<class InputIterator, class OutputIterator>
+using uninitialized_copy_result = in_out_result<InputIterator, OutputIterator>; // since C++20
+
+template<input_iterator InputIterator, sentinel-for<InputIterator> Sentinel1, nothrow-forward-iterator OutputIterator, nothrow-sentinel-for<OutputIterator> Sentinel2>
+  requires constructible_from<iter_value_t<OutputIterator>, iter_reference_t<InputIterator>>
+uninitialized_copy_result<InputIterator, OutputIterator>
+uninitialized_copy(InputIterator ifirst, Sentinel1 ilast, OutputIterator ofirst, Sentinel2 olast); // since C++20
+
+template<input_range InputRange, nothrow-forward-range OutputRange>
+  requires constructible_from<range_value_t<OutputRange>, range_reference_t<InputRange>>
+uninitialized_copy_result<borrowed_iterator_t<InputRange>, borrowed_iterator_t<OutputRange>>
+uninitialized_copy(InputRange&& in_range, OutputRange&& out_range); // since C++20
+
+}
+
 template <class InputIterator, class Size, class ForwardIterator>
 ForwardIterator
 uninitialized_copy_n(InputIterator first, Size n, ForwardIterator result);
 
+namespace ranges {
+
+template<class InputIterator, class OutputIterator>
+using uninitialized_copy_n_result = in_out_result<InputIterator, OutputIterator>; // since C++20
+
+template<input_iterator InputIterator, nothrow-forward-iterator OutputIterator, nothrow-sentinel-for<OutputIterator> Sentinel>
+  requires constructible_from<iter_value_t<OutputIterator>, iter_reference_t<InputIterator>>
+uninitialized_copy_n_result<InputIterator, OutputIterator>
+uninitialized_copy_n(InputIterator ifirst, iter_difference_t<InputIterator> n, OutputIterator ofirst, Sentinel olast); // since C++20
+
+}
+
 template <class ForwardIterator, class T>
 void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x);
 
+namespace ranges {
+
 template <nothrow-forward-iterator ForwardIterator, nothrow-sentinel-for<ForwardIterator> Sentinel, class T>
   requires constructible_from<iter_value_t<ForwardIterator>, const T&>
-ForwardIterator ranges::uninitialized_fill(ForwardIterator first, Sentinel last, const T& x); // since C++20
+ForwardIterator uninitialized_fill(ForwardIterator first, Sentinel last, const T& x); // since C++20
 
 template <nothrow-forward-range ForwardRange, class T>
   requires constructible_from<range_value_t<ForwardRange>, const T&>
-borrowed_iterator_t<ForwardRange> ranges::uninitialized_fill(ForwardRange&& range, const T& x); // since C++20
+borrowed_iterator_t<ForwardRange> uninitialized_fill(ForwardRange&& range, const T& x); // since C++20
+
+}
 
 template <class ForwardIterator, class Size, class T>
 ForwardIterator
 uninitialized_fill_n(ForwardIterator first, Size n, const T& x);
 
+namespace ranges {
+
 template <nothrow-forward-iterator ForwardIterator, class T>
   requires constructible_from<iter_value_t<ForwardIterator>, const T&>
-ForwardIterator ranges::uninitialized_fill_n(ForwardIterator first, iter_difference_t<ForwardIterator> n); // since C++20
+ForwardIterator uninitialized_fill_n(ForwardIterator first, iter_difference_t<ForwardIterator> n); // since C++20
+
+}
 
 template <class T, class ...Args>
 constexpr T* construct_at(T* location, Args&& ...args); // since C++20
 
 template <class T>
 void destroy_at(T* location); // constexpr in C++20
 
 template <class ForwardIterator>
 void destroy(ForwardIterator first, ForwardIterator last); // constexpr in C++20
 
 template <class ForwardIterator, class Size>
 ForwardIterator destroy_n(ForwardIterator first, Size n); // constexpr in C++20
 
 template <class InputIterator, class ForwardIterator>
  ForwardIterator uninitialized_move(InputIterator first, InputIterator last, ForwardIterator result);
 
+namespace ranges {
+
+template<class InputIterator, class OutputIterator>
+using uninitialized_move_result = in_out_result<InputIterator, OutputIterator>; // since C++20
+
+template <input_iterator InputIterator, sentinel_for<InputIterator> Sentinel1, nothrow-forward-iterator OutputIterator, nothrow-sentinel-for<O> Sentinel2>
+  requires constructible_from<iter_value_t<OutputIterator>, iter_rvalue_reference_t<InputIterator>>
+uninitialized_move_result<InputIterator, OutputIterator>
+uninitialized_move(InputIterator ifirst, Sentinel1 ilast, OutputIterator ofirst, Sentinel2 olast); // since C++20
+
+template<input_range InputRange, nothrow-forward-range OutputRange>
+  requires constructible_from<range_value_t<OutputRange>, range_rvalue_reference_t<InputRange>>
+uninitialized_move_result<borrowed_iterator_t<InputRange>, borrowed_iterator_t<OutputRange>>
+uninitialized_move(InputRange&& in_range, OutputRange&& out_range); // since C++20
+
+}
+
 template <class InputIterator, class Size, class ForwardIterator>
  pair<InputIterator,ForwardIterator> uninitialized_move_n(InputIterator first, Size n, ForwardIterator result);
 
+namespace ranges {
+
+template<class InputIterator, class OutputIterator>
+using uninitialized_move_n_result = in_out_result<InputIterator, OutputIterator>; // since C++20
+
+template<input_iterator InputIterator, nothrow-forward-iterator OutputIterator, nothrow-sentinel-for<OutputIterator> Sentinel>
+  requires constructible_from<iter_value_t<OutputIterator>, iter_rvalue_reference_t<InputIterator>>
+uninitialized_move_n_result<InputIterator, OutputIterator>
+uninitialized_move_n(InputIterator ifirst, iter_difference_t<InputIterator> n, OutputIterator ofirst, Sentinel olast); // since C++20
+
+}
+
 template <class ForwardIterator>
  void uninitialized_value_construct(ForwardIterator first, ForwardIterator last);
 
+namespace ranges {
+
 template <nothrow-forward-iterator ForwardIterator, nothrow-sentinel-for<ForwardIterator> Sentinel>
   requires default_initializable<iter_value_t<ForwardIterator>>
- ForwardIterator ranges::uninitialized_value_construct(ForwardIterator first, Sentinel last); // since C++20
+ ForwardIterator uninitialized_value_construct(ForwardIterator first, Sentinel last); // since C++20
 
 template <nothrow-forward-range ForwardRange>
   requires default_initializable<range_value_t<ForwardRange>>
- borrowed_iterator_t<ForwardRange> ranges::uninitialized_value_construct(ForwardRange&& r); // since C++20
+ borrowed_iterator_t<ForwardRange> uninitialized_value_construct(ForwardRange&& r); // since C++20
+
+}
 
 template <class ForwardIterator, class Size>
  ForwardIterator uninitialized_value_construct_n(ForwardIterator first, Size n);
 
+namespace ranges {
+
 template <nothrow-forward-iterator ForwardIterator>
   requires default_initializable<iter_value_t<ForwardIterator>>
- ForwardIterator ranges::uninitialized_value_construct_n(ForwardIterator first, iter_difference_t<ForwardIterator> n); // since C++20
+ ForwardIterator uninitialized_value_construct_n(ForwardIterator first, iter_difference_t<ForwardIterator> n); // since C++20
+
+}
 
 template <class ForwardIterator>
  void uninitialized_default_construct(ForwardIterator first, ForwardIterator last);
 
+namespace ranges {
+
 template <nothrow-forward-iterator ForwardIterator, nothrow-sentinel-for<ForwardIterator> Sentinel>
   requires default_initializable<iter_value_t<ForwardIterator>>
- ForwardIterator ranges::uninitialized_default_construct(ForwardIterator first, Sentinel last); // since C++20
+ ForwardIterator uninitialized_default_construct(ForwardIterator first, Sentinel last); // since C++20
 
 template <nothrow-forward-range ForwardRange>
   requires default_initializable<range_value_t<ForwardRange>>
- borrowed_iterator_t<ForwardRange> ranges::uninitialized_default_construct(ForwardRange&& r); // since C++20
+ borrowed_iterator_t<ForwardRange> uninitialized_default_construct(ForwardRange&& r); // since C++20
+
+}
 
 template <class ForwardIterator, class Size>
  ForwardIterator uninitialized_default_construct_n(ForwardIterator first, Size n);
 
+namespace ranges {
+
 template <nothrow-forward-iterator ForwardIterator>
   requires default_initializable<iter_value_t<ForwardIterator>>
- ForwardIterator ranges::uninitialized_default_construct_n(ForwardIterator first, iter_difference_t<ForwardIterator> n); // since C++20
+ ForwardIterator uninitialized_default_construct_n(ForwardIterator first, iter_difference_t<ForwardIterator> n); // since C++20
+
+}
 
 template <class Y> struct auto_ptr_ref {};      // deprecated in C++11, removed in C++17
 
 template<class X>
 class auto_ptr                                  // deprecated in C++11, removed in C++17
 {
 public:
     typedef X element_type;

libcxx/include/module.modulemap

module std [system] {
 
   module algorithm {
     header "algorithm"
     export initializer_list
     export *
 
     module __algorithm {
       module adjacent_find            { private header "__algorithm/adjacent_find.h" }
       module all_of                   { private header "__algorithm/all_of.h" }
       module any_of                   { private header "__algorithm/any_of.h" }
       module binary_search            { private header "__algorithm/binary_search.h" }
       module clamp                    { private header "__algorithm/clamp.h" }
       module comp                     { private header "__algorithm/comp.h" }
       module comp_ref_type            { private header "__algorithm/comp_ref_type.h" }
       module copy                     { private header "__algorithm/copy.h" }
       module copy_backward            { private header "__algorithm/copy_backward.h" }
       module copy_if                  { private header "__algorithm/copy_if.h" }
module __algorithm {
       module find_first_of            { private header "__algorithm/find_first_of.h" }
       module find_if                  { private header "__algorithm/find_if.h" }
       module find_if_not              { private header "__algorithm/find_if_not.h" }
       module for_each                 { private header "__algorithm/for_each.h" }
       module for_each_n               { private header "__algorithm/for_each_n.h" }
       module generate                 { private header "__algorithm/generate.h" }
       module generate_n               { private header "__algorithm/generate_n.h" }
       module half_positive            { private header "__algorithm/half_positive.h" }
+      module in_out_result            { private header "__algorithm/in_out_result.h" }
       module includes                 { private header "__algorithm/includes.h" }
       module inplace_merge            { private header "__algorithm/inplace_merge.h" }
       module is_heap                  { private header "__algorithm/is_heap.h" }
       module is_heap_until            { private header "__algorithm/is_heap_until.h" }
       module is_partitioned           { private header "__algorithm/is_partitioned.h" }
       module is_permutation           { private header "__algorithm/is_permutation.h" }
       module is_sorted                { private header "__algorithm/is_sorted.h" }
       module is_sorted_until          { private header "__algorithm/is_sorted_until.h" }

libcxx/test/libcxx/diagnostics/detail.headers/algorithm/in_out_result.module.verify.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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__algorithm/in_out_result.h'}}
+#include <__algorithm/in_out_result.h>

libcxx/test/std/algorithms/algorithms.results/in_out_result.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, libcpp-has-no-incomplete-ranges
+//
+// clang-cl and cl currently don't support [[no_unique_address]]
+// XFAIL: msvc
+
+// namespace ranges {
+//   template<class InputIterator, class OutputIterator>
+//     struct in_out_result;
+// }
+
+#include <algorithm>
+
+// Size optimization.
+struct Empty {};
+struct Empty2 {};
+
+static_assert(sizeof(std::ranges::in_out_result<Empty, int>) == sizeof(int));
+static_assert(sizeof(std::ranges::in_out_result<int, Empty>) == sizeof(int));
+static_assert(sizeof(std::ranges::in_out_result<Empty, Empty2>) == sizeof(char));

libcxx/test/std/algorithms/algorithms.results/in_out_result.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, libcpp-has-no-incomplete-ranges
+
+// <algorithm>
+//
+// namespace ranges {
+//   template<class InputIterator, class OutputIterator>
+//     struct in_out_result;
+// }
+
+#include <algorithm>
+#include <cassert>
+#include <type_traits>
+
+struct A {
+  A(int&);
+};
+static_assert(!std::is_constructible_v<std::ranges::in_out_result<A, A>, std::ranges::in_out_result<int, int>&>);
+
+static_assert(std::is_convertible_v<std::ranges::in_out_result<int, int>&,
+    std::ranges::in_out_result<long, long>>);
+static_assert(!std::is_nothrow_convertible_v<std::ranges::in_out_result<int, int>&,
+    std::ranges::in_out_result<long, long>>);
+static_assert(std::is_convertible_v<const std::ranges::in_out_result<int, int>&,
+    std::ranges::in_out_result<long, long>>);
+static_assert(!std::is_nothrow_convertible_v<const std::ranges::in_out_result<int, int>&,
+    std::ranges::in_out_result<long, long>>);
+static_assert(std::is_convertible_v<std::ranges::in_out_result<int, int>&&,
+    std::ranges::in_out_result<long, long>>);
+static_assert(!std::is_nothrow_convertible_v<std::ranges::in_out_result<int, int>&&,
+    std::ranges::in_out_result<long, long>>);
+static_assert(std::is_convertible_v<const std::ranges::in_out_result<int, int>&&,
+    std::ranges::in_out_result<long, long>>);
+static_assert(!std::is_nothrow_convertible_v<const std::ranges::in_out_result<int, int>&&,
+    std::ranges::in_out_result<long, long>>);
+
+int main(int, char**) {
+  // Conversion, fundamental types.
+  {
+    std::ranges::in_out_result<int, bool> x = {2, false};
+    std::ranges::in_out_result<double, char> y = x;
+    assert(y.in == 2.0);
+    assert(y.out == '\0');
+  }
+
+  // Conversion, user-defined types.
+  {
+    struct From1 {
+      int value = 0;
+      From1(int v) : value(v) {}
+    };
+
+    struct To1 {
+      int value = 0;
+      To1(int v) : value(v) {}
+
+      To1(const From1& f) : value(f.value) {};
+    };
+
+    struct To2 {
+      int value = 0;
+      To2(int v) : value(v) {}
+    };
+    struct From2 {
+      int value = 0;
+      From2(int v) : value(v) {}
+
+      operator To2() const { return To2(value); }
+    };
+
+    std::ranges::in_out_result<From1, From2> x{42, 99};
+    std::ranges::in_out_result<To1, To2> y = x;
+    assert(y.in.value == 42);
+    assert(y.out.value == 99);
+  }
+
+  // Copy-only type.
+  {
+    struct CopyOnly {
+      int value = 0;
+      CopyOnly() = default;
+      CopyOnly(int v) : value(v) {}
+
+      CopyOnly(const CopyOnly&) = default;
+      CopyOnly(CopyOnly&&) = delete;
+    };
+
+    std::ranges::in_out_result<CopyOnly, CopyOnly> x;
+    x.in.value = 42;
+    x.out.value = 99;
+
+    auto y = x;
+    assert(y.in.value == 42);
+    assert(y.out.value == 99);
+  }
+
+  // Move-only type.
+  {
+    struct MoveOnly {
+      int value = 0;
+      MoveOnly(int v) : value(v) {}
+
+      MoveOnly(MoveOnly&&) = default;
+      MoveOnly(const MoveOnly&) = delete;
+    };
+
+    std::ranges::in_out_result<MoveOnly, MoveOnly> x{42, 99};
+    auto y = std::move(x);
+    assert(y.in.value == 42);
+    assert(y.out.value == 99);
+  }
+
+  // Unsuccessful conversion.
+  {
+    struct Foo1 {};
+    struct Foo2 {};
+    struct Bar1 {};
+    struct Bar2 {};
+    static_assert(
+        !std::is_convertible_v<std::ranges::in_out_result<Foo1, Foo2>, std::ranges::in_out_result<Bar1, Bar2>>);
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/memory/specialized.algorithms/counted.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LIBCPP_TEST_STD_UTILITIES_MEMORY_SPECIALIZED_ALGORITHMS_COUNTED_H
 #define LIBCPP_TEST_STD_UTILITIES_MEMORY_SPECIALIZED_ALGORITHMS_COUNTED_H
 
 #include "test_macros.h"
 
 struct Counted {
   static int current_objects;
   static int total_objects;
+  static int total_copies;
+  static int total_moves;
   static int throw_on;
 
   int value;
+  bool moved_from = false;
 
   explicit Counted() {
     check_throw();
     increase_counters();
   }
 
   explicit Counted(int v) : value(v) {
     check_throw();
     increase_counters();
   }
 
   ~Counted() { --current_objects; }
 
   static void reset() {
     current_objects = total_objects = 0;
+    total_copies = total_moves = 0;
     throw_on = -1;
   }
 
   Counted(const Counted& rhs) : value(rhs.value) {
     check_throw();
     increase_counters();
+    ++total_copies;
+  }
+
+  Counted(Counted&& rhs) : value(rhs.value) {
+    check_throw();
+    increase_counters();
+
+    rhs.moved_from = true;
+    ++total_moves;
+  }
+
+  friend bool operator==(const Counted& l, const Counted& r) {
+    return l.value == r.value;
+  }
+
+  friend bool operator!=(const Counted& l, const Counted& r) {
+    return !(l == r);
   }
 
   friend void operator&(Counted) = delete;
 
 private:
   void check_throw() {
     if (throw_on == total_objects) {
       TEST_THROW(1);
     }
   }
 
   void increase_counters() {
     ++current_objects;
     ++total_objects;
   }
 };
 int Counted::current_objects = 0;
 int Counted::total_objects = 0;
+int Counted::total_copies = 0;
+int Counted::total_moves = 0;
 int Counted::throw_on = -1;
 
 #endif // LIBCPP_TEST_STD_UTILITIES_MEMORY_SPECIALIZED_ALGORITHMS_COUNTED_H

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/ranges_uninitialized_default_construct.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
 //
 //===----------------------------------------------------------------------===//
 

 #include <ranges>
 #include <type_traits>
 
 #include "../buffer.h"
 #include "../counted.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
+// TODO(varconst): consolidate the ADL checks into a single file.
 // Because this is a variable and not a function, it's guaranteed that ADL won't be used. However,
 // implementations are allowed to use a different mechanism to achieve this effect, so this check is
 // libc++-specific.
 LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::uninitialized_default_construct)>);
 
 struct NotDefaultCtrable { NotDefaultCtrable() = delete; };
 static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_default_construct),
     NotDefaultCtrable*, NotDefaultCtrable*>);
#ifndef TEST_HAS_NO_EXCEPTIONS
 
   // An exception is thrown while objects are being created -- the existing objects should stay
   // valid. (range) overload.
   {
     Buffer<Counted, 5> buf;
 
     Counted::throw_on = 3; // When constructing the fourth object.
     try {
-      auto range = std::ranges::subrange(buf.begin(), buf.end());
-      std::ranges::uninitialized_default_construct(range);
+      std::ranges::uninitialized_default_construct(buf);
     } catch(...) {}
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 3);
     std::destroy(buf.begin(), buf.begin() + Counted::total_objects);
     Counted::reset();
   }
 #endif  // TEST_HAS_NO_EXCEPTIONS
 

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/ranges_uninitialized_default_construct_n.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
 //
 //===----------------------------------------------------------------------===//
 

 #include <memory>
 #include <ranges>
 
 #include "../buffer.h"
 #include "../counted.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
+// TODO(varconst): consolidate the ADL checks into a single file.
 // Because this is a variable and not a function, it's guaranteed that ADL won't be used. However,
 // implementations are allowed to use a different mechanism to achieve this effect, so this check is
 // libc++-specific.
 LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::uninitialized_default_construct_n)>);
 
 struct NotDefaultCtrable { NotDefaultCtrable() = delete; };
 static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_default_construct_n),
     NotDefaultCtrable*, int>);

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct_n.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
 //
 //===----------------------------------------------------------------------===//
 
#ifndef TEST_HAS_NO_EXCEPTIONS
     alignas(ThrowsCounted) char pool[sizeof(ThrowsCounted)*N] = {};
     ThrowsCounted* p = (ThrowsCounted*)pool;
     try {
         ThrowsCounted::throw_after = 4;
         std::uninitialized_default_construct_n(It(p), N);
         assert(false);
     } catch (...) {}
     assert(ThrowsCounted::count == 0);
-    assert(ThrowsCounted::constructed == 4); // forth construction throws
+    assert(ThrowsCounted::constructed == 4); // Fourth construction throws
 #endif
 }
 
 void test_counted()
 {
     using It = forward_iterator<Counted*>;
     const int N = 5;
     alignas(Counted) char pool[sizeof(Counted)*N] = {};

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/ranges_uninitialized_value_construct.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
 //
 //===----------------------------------------------------------------------===//
 

 #include <ranges>
 #include <type_traits>
 
 #include "../buffer.h"
 #include "../counted.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
+// TODO(varconst): consolidate the ADL checks into a single file.
 // Because this is a variable and not a function, it's guaranteed that ADL won't be used. However,
 // implementations are allowed to use a different mechanism to achieve this effect, so this check is
 // libc++-specific.
 LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::uninitialized_value_construct)>);
 
 struct NotDefaultCtrable {
   NotDefaultCtrable() = delete;
 };
#ifndef TEST_HAS_NO_EXCEPTIONS
 
   // An exception is thrown while objects are being created -- the existing objects should stay
   // valid. (range) overload.
   {
     Buffer<Counted, 5> buf;
 
     Counted::throw_on = 3; // When constructing the fourth object.
     try {
-      auto range = std::ranges::subrange(buf.begin(), buf.end());
-      std::ranges::uninitialized_value_construct(range);
+      std::ranges::uninitialized_value_construct(buf);
     } catch (...) {
     }
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == 3);
     std::destroy(buf.begin(), buf.begin() + Counted::total_objects);
     Counted::reset();
   }
 #endif // TEST_HAS_NO_EXCEPTIONS

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/ranges_uninitialized_value_construct_n.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
 //
 //===----------------------------------------------------------------------===//
 

 #include <memory>
 #include <ranges>
 
 #include "../buffer.h"
 #include "../counted.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
+// TODO(varconst): consolidate the ADL checks into a single file.
 // Because this is a variable and not a function, it's guaranteed that ADL won't be used. However,
 // implementations are allowed to use a different mechanism to achieve this effect, so this check is
 // libc++-specific.
 LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::uninitialized_value_construct_n)>);
 
 struct NotDefaultCtrable {
   NotDefaultCtrable() = delete;
 };

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/ranges_uninitialized_copy.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, libcpp-has-no-incomplete-ranges
+
+// <memory>
+//
+// template<input_iterator I, sentinel-for<I> S1, nothrow-forward-iterator O, nothrow-sentinel-for<O> S2>
+//   requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
+// uninitialized_copy_result<I, O> ranges::uninitialized_copy(I ifirst, S1 ilast, O ofirst, S2 olast); // since C++20
+//
+// template<input_range IR, nothrow-forward-range OR>
+//   requires constructible_from<range_value_t<OR>, range_reference_t<IR>>
+// uninitialized_copy_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>> ranges::uninitialized_copy(IR&& in_range, OR&& out_range); // since C++20
+
+#include <algorithm>
+#include <cassert>
+#include <iterator>
+#include <memory>
+#include <ranges>
+#include <type_traits>
+
+#include "../buffer.h"
+#include "../counted.h"
+#include "test_macros.h"
+#include "test_iterators.h"
+
+// TODO(varconst): consolidate the ADL checks into a single file.
+// Because this is a variable and not a function, it's guaranteed that ADL won't be used. However,
+// implementations are allowed to use a different mechanism to achieve this effect, so this check is
+// libc++-specific.
+LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::uninitialized_copy)>);
+
+static_assert(std::is_invocable_v<decltype(std::ranges::uninitialized_copy), int*, int*, long*, long*>);
+struct NotConvertibleFromInt {};
+static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_copy), int*, int*, NotConvertibleFromInt*,
+                                   NotConvertibleFromInt*>);
+
+int main(int, char**) {
+  // An empty range -- no default constructors should be invoked.
+  {
+    Counted in[] = {Counted()};
+    Buffer<Counted, 1> out;
+    Counted::reset();
+
+    {
+      auto result = std::ranges::uninitialized_copy(in, in, out.begin(), out.end());
+      assert(Counted::current_objects == 0);
+      assert(Counted::total_objects == 0);
+      assert(Counted::total_copies == 0);
+      assert(result.in == in);
+      assert(result.out == out.begin());
+    }
+
+    {
+      std::ranges::empty_view<Counted> view;
+      auto result = std::ranges::uninitialized_copy(view, out);
+      assert(Counted::current_objects == 0);
+      assert(Counted::total_objects == 0);
+      assert(Counted::total_copies == 0);
+      assert(result.in == view.begin());
+      assert(result.out == out.begin());
+    }
+
+    {
+      forward_iterator<Counted*> it(in);
+      std::ranges::subrange range(it, sentinel_wrapper<forward_iterator<Counted*>>(it));
+
+      auto result = std::ranges::uninitialized_copy(range.begin(), range.end(), out.begin(), out.end());
+      assert(Counted::current_objects == 0);
+      assert(Counted::total_objects == 0);
+      assert(Counted::total_copies == 0);
+      assert(result.in == it);
+      assert(result.out == out.begin());
+    }
+
+    {
+      forward_iterator<Counted*> it(in);
+      std::ranges::subrange range(it, sentinel_wrapper<forward_iterator<Counted*>>(it));
+
+      auto result = std::ranges::uninitialized_copy(range, out);
+      assert(Counted::current_objects == 0);
+      assert(Counted::total_objects == 0);
+      assert(Counted::total_copies == 0);
+      assert(result.in == it);
+      assert(result.out == out.begin());
+    }
+    Counted::reset();
+  }
+
+  // A range containing several objects, (iter, sentinel) overload.
+  {
+    constexpr int N = 5;
+    Counted in[N] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, N> out;
+    Counted::reset();
+
+    auto result = std::ranges::uninitialized_copy(in, in + N, out.begin(), out.end());
+    ASSERT_SAME_TYPE(decltype(result), std::ranges::uninitialized_copy_result<Counted*, Counted*>);
+
+    assert(Counted::current_objects == N);
+    assert(Counted::total_objects == N);
+    assert(Counted::total_copies == N);
+    assert(Counted::total_moves == 0);
+
+    assert(std::equal(in, in + N, out.begin(), out.end()));
+    assert(result.in == in + N);
+    assert(result.out == out.end());
+
+    std::destroy(out.begin(), out.end());
+  }
+  Counted::reset();
+
+  // A range containing several objects, (range) overload.
+  {
+    constexpr int N = 5;
+    Counted in[N] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, N> out;
+    Counted::reset();
+
+    std::ranges::subrange range(in, in + N);
+    auto result = std::ranges::uninitialized_copy(range, out);
+    ASSERT_SAME_TYPE(decltype(result), std::ranges::uninitialized_copy_result<Counted*, Counted*>);
+
+    assert(Counted::current_objects == N);
+    assert(Counted::total_objects == N);
+    assert(Counted::total_copies == N);
+    assert(Counted::total_moves == 0);
+
+    assert(std::equal(in, in + N, out.begin(), out.end()));
+    assert(result.in == in + N);
+    assert(result.out == out.end());
+
+    std::destroy(out.begin(), out.end());
+  }
+  Counted::reset();
+
+  // Using `counted_iterator`.
+  {
+    constexpr int N = 3;
+    Counted in[] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, 5> out;
+    Counted::reset();
+
+    std::counted_iterator iter(in, N);
+    auto result = std::ranges::uninitialized_copy(iter, std::default_sentinel, out.begin(), out.end());
+
+    assert(Counted::current_objects == N);
+    assert(Counted::total_objects == N);
+    assert(Counted::total_copies == N);
+    assert(Counted::total_moves == 0);
+    assert(std::equal(in, in + N, out.begin(), out.begin() + N));
+
+    assert(result.in == iter + N);
+    assert(result.out == out.begin() + N);
+
+    std::destroy(out.begin(), out.begin() + N);
+  }
+  Counted::reset();
+
+  // Using `views::counted`.
+  {
+    constexpr int N = 3;
+    Counted in[] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, 5> out;
+    Counted::reset();
+
+    auto view = std::views::counted(in, N);
+    auto result = std::ranges::uninitialized_copy(view, out);
+
+    assert(Counted::current_objects == N);
+    assert(Counted::total_objects == N);
+    assert(Counted::total_copies == N);
+    assert(Counted::total_moves == 0);
+    assert(std::equal(in, in + N, out.begin(), out.begin() + N));
+
+    assert(result.in == view.begin() + N);
+    assert(result.out == out.begin() + N);
+
+    std::destroy(out.begin(), out.begin() + N);
+  }
+  Counted::reset();
+
+  // Using `reverse_view`.
+  {
+    constexpr int N = 3;
+    Counted in[] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, 5> out;
+    Counted::reset();
+
+    std::ranges::subrange range(in, in + N);
+    auto view = std::ranges::views::reverse(range);
+    auto result = std::ranges::uninitialized_copy(view, out);
+
+    assert(Counted::current_objects == N);
+    assert(Counted::total_objects == N);
+    assert(Counted::total_copies == N);
+    assert(Counted::total_moves == 0);
+
+    Counted expected[N] = {Counted(3), Counted(2), Counted(1)};
+    assert(std::equal(out.begin(), out.begin() + N, expected, expected + N));
+
+    assert(result.in == view.begin() + N);
+    assert(result.out == out.begin() + N);
+
+    std::destroy(out.begin(), out.begin() + N);
+  }
+  Counted::reset();
+
+  // Any existing values should be overwritten by copy constructors.
+  {
+    constexpr int N = 5;
+    int in[N] = {1, 2, 3, 4, 5};
+    int out[N] = {6, 7, 8, 9, 10};
+    assert(!std::equal(in, in + N, in, out + N));
+
+    std::ranges::uninitialized_copy(in, in + 1, out, out + N);
+    assert(out[0] == 1);
+    assert(out[1] == 7);
+
+    std::ranges::uninitialized_copy(in, in + N, out, out + N);
+    assert(std::equal(in, in + N, out, out + N));
+  }
+
+  // An exception is thrown while objects are being created -- objects not yet overwritten should
+  // stay valid. (iterator, sentinel) overload.
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  {
+    constexpr int M = 3;
+    constexpr int N = 5;
+    Counted in[N] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Counted out[N] = {Counted(6), Counted(7), Counted(8), Counted(9), Counted(10)};
+    Counted::reset();
+
+    Counted::throw_on = M; // When constructing out[3].
+    try {
+      std::ranges::uninitialized_copy(in, in + N, out, out + N);
+      assert(false);
+    } catch (...) {
+    }
+    assert(Counted::current_objects == 0);
+    assert(Counted::total_objects == M);
+    assert(Counted::total_copies == M);
+    assert(Counted::total_moves == 0);
+
+    assert(out[4].value == 10);
+  }
+  Counted::reset();
+
+  // An exception is thrown while objects are being created -- objects not yet overwritten should
+  // stay valid. (range) overload.
+  {
+    constexpr int M = 3;
+    constexpr int N = 5;
+    Counted in[N] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Counted out[N] = {Counted(6), Counted(7), Counted(8), Counted(9), Counted(10)};
+    Counted::reset();
+
+    Counted::throw_on = M; // When constructing out[3].
+    try {
+      std::ranges::uninitialized_copy(in, out);
+      assert(false);
+    } catch (...) {
+    }
+    assert(Counted::current_objects == 0);
+    assert(Counted::total_objects == M);
+    assert(Counted::total_copies == M);
+    assert(Counted::total_moves == 0);
+
+    assert(out[4].value == 10);
+  }
+  Counted::reset();
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+  // Works with const iterators, (iter, sentinel) overload.
+  {
+    constexpr int N = 5;
+    Counted in[N] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, N> out;
+    Counted::reset();
+
+    std::ranges::uninitialized_copy(in, in + N, out.cbegin(), out.cend());
+    assert(Counted::current_objects == N);
+    assert(Counted::total_objects == N);
+    assert(std::equal(in, in + N, out.begin(), out.end()));
+
+    std::destroy(out.begin(), out.end());
+  }
+  Counted::reset();
+
+  // Works with const iterators, (range) overload.
+  {
+    constexpr int N = 5;
+    Counted in[N] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, N> out;
+    Counted::reset();
+
+    std::ranges::subrange out_range(out.cbegin(), out.cend());
+    std::ranges::uninitialized_copy(in, out_range);
+    assert(Counted::current_objects == N);
+    assert(Counted::total_objects == N);
+    assert(std::equal(in, in + N, out.begin(), out.end()));
+
+    std::destroy(out.begin(), out.end());
+  }
+  Counted::reset();
+
+  // Conversions, (iter, sentinel) overload.
+  {
+    constexpr int N = 3;
+    double in[N] = {1.0, 2.0, 3.0};
+    Buffer<int, N> out;
+
+    std::ranges::uninitialized_copy(in, in + N, out.begin(), out.end());
+    assert(std::equal(in, in + N, out.begin(), out.end()));
+  }
+
+  // Conversions, (range) overload.
+  {
+    constexpr int N = 3;
+    double in[N] = {1.0, 2.0, 3.0};
+    Buffer<int, N> out;
+
+    std::ranges::uninitialized_copy(in, out);
+    assert(std::equal(in, in + N, out.begin(), out.end()));
+  }
+
+  // Destination range is shorter than the source range, (iter, sentinel) overload.
+  {
+    constexpr int M = 3;
+    constexpr int N = 5;
+    Counted in[N] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, M> out;
+    Counted::reset();
+
+    auto result = std::ranges::uninitialized_copy(in, in + N, out.begin(), out.end());
+    assert(Counted::current_objects == M);
+    assert(Counted::total_objects == M);
+    assert(Counted::total_copies == M);
+    assert(Counted::total_moves == 0);
+
+    assert(std::equal(in, in + M, out.begin(), out.end()));
+    assert(result.in == in + M);
+    assert(result.out == out.end());
+  }
+
+  // Destination range is shorter than the source range, (range) overload.
+  {
+    constexpr int M = 3;
+    constexpr int N = 5;
+    Counted in[N] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, M> out;
+    Counted::reset();
+
+    std::ranges::subrange range(in, in + N);
+    auto result = std::ranges::uninitialized_copy(range, out);
+    assert(Counted::current_objects == M);
+    assert(Counted::total_objects == M);
+    assert(Counted::total_copies == M);
+    assert(Counted::total_moves == 0);
+
+    assert(std::equal(in, in + M, out.begin(), out.end()));
+    assert(result.in == in + M);
+    assert(result.out == out.end());
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/ranges_uninitialized_copy_n.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, libcpp-has-no-incomplete-ranges
+
+// <memory>
+//
+// template<input_iterator I, nothrow-forward-iterator O, nothrow-sentinel-for<O> S>
+//   requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
+// uninitialized_copy_n_result<I, O> uninitialized_copy_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast); // since C++20
+
+#include <algorithm>
+#include <cassert>
+#include <iterator>
+#include <memory>
+#include <ranges>
+#include <type_traits>
+
+#include "../buffer.h"
+#include "../counted.h"
+#include "test_macros.h"
+#include "test_iterators.h"
+
+// TODO(varconst): consolidate the ADL checks into a single file.
+// Because this is a variable and not a function, it's guaranteed that ADL won't be used. However,
+// implementations are allowed to use a different mechanism to achieve this effect, so this check is
+// libc++-specific.
+LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::uninitialized_copy_n)>);
+
+static_assert(std::is_invocable_v<decltype(std::ranges::uninitialized_copy_n), int*, size_t, long*, long*>);
+struct NotConvertibleFromInt {};
+static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_copy_n), int*, size_t, NotConvertibleFromInt*,
+                                   NotConvertibleFromInt*>);
+
+int main(int, char**) {
+  // An empty range -- no default constructors should be invoked.
+  {
+    Counted in[] = {Counted()};
+    Buffer<Counted, 1> out;
+    Counted::reset();
+
+    auto result = std::ranges::uninitialized_copy_n(in, 0, out.begin(), out.end());
+    assert(Counted::current_objects == 0);
+    assert(Counted::total_objects == 0);
+    assert(Counted::total_copies == 0);
+    assert(result.in == in);
+    assert(result.out == out.begin());
+  }
+  Counted::reset();
+
+  // A range containing several objects.
+  {
+    constexpr int N = 5;
+    Counted in[N] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, N> out;
+    Counted::reset();
+
+    auto result = std::ranges::uninitialized_copy_n(in, N, out.begin(), out.end());
+    ASSERT_SAME_TYPE(decltype(result), std::ranges::uninitialized_copy_n_result<Counted*, Counted*>);
+
+    assert(Counted::current_objects == N);
+    assert(Counted::total_objects == N);
+    assert(Counted::total_copies == N);
+    assert(Counted::total_moves == 0);
+    assert(std::equal(in, in + N, out.begin(), out.end()));
+    assert(result.in == in + N);
+    assert(result.out == out.end());
+
+    std::destroy(out.begin(), out.end());
+  }
+  Counted::reset();
+
+  // An exception is thrown while objects are being created -- the existing objects should stay
+  // valid. (iterator, sentinel) overload.
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  {
+    constexpr int M = 3;
+    constexpr int N = 5;
+    Counted in[N] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Counted out[N] = {Counted(6), Counted(7), Counted(8), Counted(9), Counted(10)};
+    Counted::reset();
+
+    Counted::throw_on = M; // When constructing out[3].
+    try {
+      std::ranges::uninitialized_copy_n(in, N, out, out + N);
+      assert(false);
+    } catch (...) {
+    }
+    assert(Counted::current_objects == 0);
+    assert(Counted::total_objects == M);
+    assert(Counted::total_copies == M);
+    assert(Counted::total_moves == 0);
+
+    assert(out[4].value == 10);
+  }
+  Counted::reset();
+
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+  // Works with const iterators.
+  {
+    constexpr int N = 5;
+    Counted in[N] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, N> out;
+    Counted::reset();
+
+    std::ranges::uninitialized_copy_n(in, N, out.cbegin(), out.cend());
+    assert(Counted::current_objects == N);
+    assert(Counted::total_objects == N);
+    assert(std::equal(in, in + N, out.begin(), out.end()));
+
+    std::destroy(out.begin(), out.end());
+  }
+  Counted::reset();
+
+  // Conversions.
+  {
+    constexpr int N = 3;
+    double in[N] = {1.0, 2.0, 3.0};
+    Buffer<int, N> out;
+
+    std::ranges::uninitialized_copy_n(in, N, out.begin(), out.end());
+    assert(std::equal(in, in + N, out.begin(), out.end()));
+  }
+
+  // Destination range is shorter than the source range.
+  {
+    constexpr int M = 3;
+    constexpr int N = 5;
+    Counted in[N] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, M> out;
+    Counted::reset();
+
+    auto result = std::ranges::uninitialized_copy_n(in, N, out.begin(), out.end());
+    assert(Counted::current_objects == M);
+    assert(Counted::total_objects == M);
+    assert(Counted::total_copies == M);
+    assert(Counted::total_moves == 0);
+
+    assert(std::equal(in, in + M, out.begin(), out.end()));
+    assert(result.in == in + M);
+    assert(result.out == out.end());
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.fill.n/ranges_uninitialized_fill_n.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
 //
 //===----------------------------------------------------------------------===//
 

 #include <ranges>
 #include <type_traits>
 
 #include "../buffer.h"
 #include "../counted.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
+// TODO(varconst): consolidate the ADL checks into a single file.
 // Because this is a variable and not a function, it's guaranteed that ADL won't be used. However,
 // implementations are allowed to use a different mechanism to achieve this effect, so this check is
 // libc++-specific.
 LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::uninitialized_fill_n)>);
 
 struct NotConvertibleFromInt {};
-static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_fill_n), NotConvertibleFromInt*,
-                                   NotConvertibleFromInt*, int>);
+static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_fill_n), NotConvertibleFromInt*, size_t, int>);
 
 int main(int, char**) {
   constexpr int value = 42;
   Counted x(value);
   Counted::reset();
   auto pred = [](const Counted& e) { return e.value == value; };
 
   // An empty range -- no default constructors should be invoked.

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.fill/ranges_uninitialized_fill.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
 //
 //===----------------------------------------------------------------------===//
 

 #include <ranges>
 #include <type_traits>
 
 #include "../buffer.h"
 #include "../counted.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
+// TODO(varconst): consolidate the ADL checks into a single file.
 // Because this is a variable and not a function, it's guaranteed that ADL won't be used. However,
 // implementations are allowed to use a different mechanism to achieve this effect, so this check is
 // libc++-specific.
 LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::uninitialized_fill)>);
 
 struct NotConvertibleFromInt {};
 static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_fill), NotConvertibleFromInt*,
                                    NotConvertibleFromInt*, int>);
#ifndef TEST_HAS_NO_EXCEPTIONS
   // An exception is thrown while objects are being created -- the existing objects should stay
   // valid. (range) overload.
   {
     constexpr int N = 3;
     Buffer<Counted, 5> buf;
 
     Counted::throw_on = N; // When constructing the fourth object.
     try {
-      auto range = std::ranges::subrange(buf.begin(), buf.end());
-      std::ranges::uninitialized_fill(range, x);
+      std::ranges::uninitialized_fill(buf, x);
     } catch (...) {
     }
     assert(Counted::current_objects == 0);
     assert(Counted::total_objects == N);
 
     std::destroy(buf.begin(), buf.begin() + N);
     Counted::reset();
   }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/ranges_uninitialized_move.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, libcpp-has-no-incomplete-ranges
+
+// <memory>
+//
+// template<input_iterator InputIterator, nothrow-forward-iterator OutputIterator, nothrow-sentinel-for<OutputIterator> Sentinel>
+// requires constructible_from<iter_value_t<OutputIterator>, iter_rvalue_reference_t<InputIterator>>
+// ranges::uninitialized_move_n_result<InputIterator, OutputIterator>
+// ranges::uninitialized_move_n(InputIterator ifirst, iter_difference_t<InputIterator> n, OutputIterator ofirst, Sentinel olast); // since C++20
+
+
+#include <algorithm>
+#include <cassert>
+#include <iterator>
+#include <memory>
+#include <ranges>
+#include <type_traits>
+#include <utility>
+
+#include "../buffer.h"
+#include "../counted.h"
+#include "test_macros.h"
+#include "test_iterators.h"
+
+// TODO(varconst): consolidate the ADL checks into a single file.
+// Because this is a variable and not a function, it's guaranteed that ADL won't be used. However,
+// implementations are allowed to use a different mechanism to achieve this effect, so this check is
+// libc++-specific.
+LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::uninitialized_move)>);
+
+static_assert(std::is_invocable_v<decltype(std::ranges::uninitialized_move), int*, int*, long*, long*>);
+struct NotConvertibleFromInt {};
+static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_move), int*, int*, NotConvertibleFromInt*,
+                                   NotConvertibleFromInt*>);
+
+namespace adl {
+
+static int iter_move_invocations = 0;
+
+template <class T>
+struct Iterator {
+  using value_type = T;
+  using difference_type = int;
+  using iterator_concept = std::input_iterator_tag;
+
+  T* ptr = nullptr;
+
+  Iterator() = default;
+  explicit Iterator(int* p) : ptr(p) {}
+
+  T& operator*() const { return *ptr; }
+
+  Iterator& operator++() { ++ptr; return *this; }
+  Iterator operator++(int) {
+    Iterator prev = *this;
+    ++ptr;
+    return prev;
+  }
+
+  friend T&& iter_move(Iterator iter) {
+    ++iter_move_invocations;
+    return std::move(*iter);
+  }
+
+  friend bool operator==(const Iterator& lhs, const Iterator& rhs) { return lhs.ptr == rhs.ptr; }
+};
+
+} // namespace adl
+
+int main(int, char**) {
+  // An empty range -- no default constructors should be invoked.
+  {
+    Counted in[] = {Counted()};
+    Buffer<Counted, 1> out;
+    Counted::reset();
+
+    {
+      auto result = std::ranges::uninitialized_move(in, in, out.begin(), out.end());
+      assert(Counted::current_objects == 0);
+      assert(Counted::total_objects == 0);
+      assert(Counted::total_copies == 0);
+      assert(result.in == in);
+      assert(result.out == out.begin());
+    }
+
+    {
+      std::ranges::empty_view<Counted> view;
+      auto result = std::ranges::uninitialized_move(view, out);
+      assert(Counted::current_objects == 0);
+      assert(Counted::total_objects == 0);
+      assert(Counted::total_copies == 0);
+      assert(result.in == view.begin());
+      assert(result.out == out.begin());
+    }
+
+    {
+      forward_iterator<Counted*> it(in);
+      std::ranges::subrange range(it, sentinel_wrapper<forward_iterator<Counted*>>(it));
+
+      auto result = std::ranges::uninitialized_move(range.begin(), range.end(), out.begin(), out.end());
+      assert(Counted::current_objects == 0);
+      assert(Counted::total_objects == 0);
+      assert(Counted::total_copies == 0);
+      assert(result.in == it);
+      assert(result.out == out.begin());
+    }
+
+    {
+      forward_iterator<Counted*> it(in);
+      std::ranges::subrange range(it, sentinel_wrapper<forward_iterator<Counted*>>(it));
+
+      auto result = std::ranges::uninitialized_move(range, out);
+      assert(Counted::current_objects == 0);
+      assert(Counted::total_objects == 0);
+      assert(Counted::total_copies == 0);
+      assert(result.in == it);
+      assert(result.out == out.begin());
+    }
+    Counted::reset();
+  }
+
+  // A range containing several objects, (iter, sentinel) overload.
+  {
+    constexpr int N = 5;
+    Counted in[N] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, N> out;
+    Counted::reset();
+
+    auto result = std::ranges::uninitialized_move(in, in + N, out.begin(), out.end());
+    ASSERT_SAME_TYPE(decltype(result), std::ranges::uninitialized_move_result<Counted*, Counted*>);
+    assert(Counted::current_objects == N);
+    assert(Counted::total_objects == N);
+    assert(Counted::total_moves == N);
+    assert(Counted::total_copies == 0);
+
+    assert(std::equal(in, in + N, out.begin(), out.end()));
+    assert(result.in == in + N);
+    assert(result.out == out.end());
+
+    std::destroy(out.begin(), out.end());
+  }
+  Counted::reset();
+
+  // A range containing several objects, (range) overload.
+  {
+    constexpr int N = 5;
+    Counted in[N] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, N> out;
+    Counted::reset();
+
+    std::ranges::subrange range(in, in + N);
+    auto result = std::ranges::uninitialized_move(range, out);
+    ASSERT_SAME_TYPE(decltype(result), std::ranges::uninitialized_move_result<Counted*, Counted*>);
+
+    assert(Counted::current_objects == N);
+    assert(Counted::total_objects == N);
+    assert(Counted::total_moves == N);
+    assert(Counted::total_copies == 0);
+    assert(std::equal(in, in + N, out.begin(), out.end()));
+
+    assert(result.in == in + N);
+    assert(result.out == out.end());
+
+    std::destroy(out.begin(), out.end());
+  }
+  Counted::reset();
+
+  // Using `counted_iterator`.
+  {
+    constexpr int N = 3;
+    Counted in[] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, 5> out;
+    Counted::reset();
+
+    std::counted_iterator iter(in, N);
+    auto result = std::ranges::uninitialized_move(iter, std::default_sentinel, out.begin(), out.end());
+
+    assert(Counted::current_objects == N);
+    assert(Counted::total_objects == N);
+    assert(Counted::total_moves == N);
+    assert(Counted::total_copies == 0);
+    assert(std::equal(in, in + N, out.begin(), out.begin() + N));
+
+    assert(result.in == iter + N);
+    assert(result.out == out.begin() + N);
+
+    std::destroy(out.begin(), out.begin() + N);
+  }
+  Counted::reset();
+
+  // Using `views::counted`.
+  {
+    constexpr int N = 3;
+    Counted in[] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, 5> out;
+    Counted::reset();
+
+    auto view = std::views::counted(in, N);
+    auto result = std::ranges::uninitialized_move(view, out);
+
+    assert(Counted::current_objects == N);
+    assert(Counted::total_objects == N);
+    assert(Counted::total_moves == N);
+    assert(Counted::total_copies == 0);
+    assert(std::equal(in, in + N, out.begin(), out.begin() + N));
+
+    assert(result.in == view.begin() + N);
+    assert(result.out == out.begin() + N);
+
+    std::destroy(out.begin(), out.begin() + N);
+  }
+  Counted::reset();
+
+  // Using `reverse_view`.
+  {
+    constexpr int N = 3;
+    Counted in[] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, 5> out;
+    Counted::reset();
+
+    std::ranges::subrange range(in, in + N);
+    auto view = std::ranges::views::reverse(range);
+    auto result = std::ranges::uninitialized_move(view, out);
+
+    assert(Counted::current_objects == N);
+    assert(Counted::total_objects == N);
+    assert(Counted::total_moves == N);
+    assert(Counted::total_copies == 0);
+
+    Counted expected[N] = {Counted(3), Counted(2), Counted(1)};
+    assert(std::equal(out.begin(), out.begin() + N, expected, expected + N));
+
+    assert(result.in == view.begin() + N);
+    assert(result.out == out.begin() + N);
+
+    std::destroy(out.begin(), out.begin() + N);
+  }
+  Counted::reset();
+
+  // Any existing values should be overwritten by move constructors.
+  {
+    constexpr int N = 5;
+    int in[N] = {1, 2, 3, 4, 5};
+    int out[N] = {6, 7, 8, 9, 10};
+    assert(!std::equal(in, in + N, in, out + N));
+
+    std::ranges::uninitialized_move(in, in + 1, out, out + N);
+    assert(out[0] == 1);
+    assert(out[1] == 7);
+
+    std::ranges::uninitialized_move(in, in + N, out, out + N);
+    assert(std::equal(in, in + N, out, out + N));
+  }
+
+  // An exception is thrown while objects are being created -- check that the objects in the source
+  // range have been moved from. (iterator, sentinel) overload.
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  {
+    constexpr int N = 3;
+    Counted in[] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, 5> out;
+    Counted::reset();
+
+    Counted::throw_on = N; // When constructing out[3].
+    try {
+      std::ranges::uninitialized_move(in, in + 5, out.begin(), out.end());
+      assert(false);
+    } catch (...) {
+    }
+    assert(Counted::current_objects == 0);
+    assert(Counted::total_objects == N);
+    assert(Counted::total_moves == N);
+    assert(Counted::total_copies == 0);
+
+    assert(std::all_of(in, in + 1, [](const auto& e) { return e.moved_from; }));
+    assert(std::none_of(in + N, in + 5, [](const auto& e) { return e.moved_from; }));
+
+    std::destroy(out.begin(), out.begin() + N);
+  }
+  Counted::reset();
+
+  // An exception is thrown while objects are being created -- check that the objects in the source
+  // range have been moved from. (range) overload.
+  {
+    constexpr int N = 3;
+    Counted in[] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, 5> out;
+    Counted::reset();
+
+    Counted::throw_on = N; // When constructing out[3].
+    try {
+      std::ranges::uninitialized_move(in, out);
+      assert(false);
+    } catch (...) {
+    }
+    assert(Counted::current_objects == 0);
+    assert(Counted::total_objects == N);
+    assert(Counted::total_moves == N);
+    assert(Counted::total_copies == 0);
+
+    assert(std::all_of(in, in + 1, [](const auto& e) { return e.moved_from; }));
+    assert(std::none_of(in + N, in + 5, [](const auto& e) { return e.moved_from; }));
+
+    std::destroy(out.begin(), out.begin() + N);
+  }
+  Counted::reset();
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+  // Works with const iterators, (iter, sentinel) overload.
+  {
+    constexpr int N = 5;
+    Counted in[N] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, N> out;
+    Counted::reset();
+
+    std::ranges::uninitialized_move(in, in + N, out.cbegin(), out.cend());
+    assert(Counted::current_objects == N);
+    assert(Counted::total_objects == N);
+    assert(std::equal(in, in + N, out.begin(), out.end()));
+
+    std::destroy(out.begin(), out.end());
+  }
+  Counted::reset();
+
+  // Works with const iterators, (range) overload.
+  {
+    constexpr int N = 5;
+    Counted in[N] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, N> out;
+    Counted::reset();
+
+    std::ranges::subrange out_range (out.cbegin(), out.cend());
+    std::ranges::uninitialized_move(in, out_range);
+    assert(Counted::current_objects == N);
+    assert(Counted::total_objects == N);
+    assert(std::equal(in, in + N, out.begin(), out.end()));
+
+    std::destroy(out.begin(), out.end());
+  }
+  Counted::reset();
+
+  // Conversions, (iter, sentinel) overload.
+  {
+    constexpr int N = 3;
+    double in[N] = {1.0, 2.0, 3.0};
+    Buffer<int, N> out;
+
+    std::ranges::uninitialized_move(in, in + N, out.begin(), out.end());
+    assert(std::equal(in, in + N, out.begin(), out.end()));
+  }
+
+  // Conversions, (range) overload.
+  {
+    constexpr int N = 3;
+    double in[N] = {1.0, 2.0, 3.0};
+    Buffer<int, N> out;
+
+    std::ranges::uninitialized_move(in, out);
+    assert(std::equal(in, in + N, out.begin(), out.end()));
+  }
+
+  // Destination range is shorter than the source range, (iter, sentinel) overload.
+  {
+    constexpr int M = 3;
+    constexpr int N = 5;
+    Counted in[N] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, M> out;
+    Counted::reset();
+
+    auto result = std::ranges::uninitialized_move(in, in + N, out.begin(), out.end());
+    assert(Counted::current_objects == M);
+    assert(Counted::total_objects == M);
+    assert(Counted::total_moves == M);
+    assert(Counted::total_copies == 0);
+
+    assert(std::equal(in, in + M, out.begin(), out.end()));
+    assert(result.in == in + M);
+    assert(result.out == out.end());
+  }
+
+  // Destination range is shorter than the source range, (range) overload.
+  {
+    constexpr int M = 3;
+    constexpr int N = 5;
+    Counted in[N] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, M> out;
+    Counted::reset();
+
+    std::ranges::subrange range(in, in + N);
+    auto result = std::ranges::uninitialized_move(range, out);
+    assert(Counted::current_objects == M);
+    assert(Counted::total_objects == M);
+    assert(Counted::total_moves == M);
+    assert(Counted::total_copies == 0);
+
+    assert(std::equal(in, in + M, out.begin(), out.end()));
+    assert(result.in == in + M);
+    assert(result.out == out.end());
+  }
+
+  // Ensure the `iter_move` customization point is being used.
+  {
+    constexpr int N = 3;
+    int in[N] = {1, 2, 3};
+    Buffer<int, N> out;
+    adl::Iterator<int> begin(in);
+    adl::Iterator<int> end(in + N);
+
+    std::ranges::uninitialized_move(begin, end, out.begin(), out.end());
+    assert(adl::iter_move_invocations == 3);
+    adl::iter_move_invocations = 0;
+
+    std::ranges::subrange range(begin, end);
+    std::ranges::uninitialized_move(range, out);
+    assert(adl::iter_move_invocations == 3);
+    adl::iter_move_invocations = 0;
+  }
+
+  return 0;
+}

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/ranges_uninitialized_move_n.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, libcpp-has-no-incomplete-ranges
+
+// <memory>
+//
+// template<input_iterator I, nothrow-forward-iterator O, nothrow-sentinel-for<O> S>
+//   requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
+// uninitialized_copy_n_result<I, O> uninitialized_copy_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast); // since C++20
+
+#include <algorithm>
+#include <cassert>
+#include <iterator>
+#include <memory>
+#include <ranges>
+#include <type_traits>
+
+#include "../buffer.h"
+#include "../counted.h"
+#include "test_macros.h"
+#include "test_iterators.h"
+
+// TODO(varconst): consolidate the ADL checks into a single file.
+// Because this is a variable and not a function, it's guaranteed that ADL won't be used. However,
+// implementations are allowed to use a different mechanism to achieve this effect, so this check is
+// libc++-specific.
+LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::uninitialized_move_n)>);
+
+static_assert(std::is_invocable_v<decltype(std::ranges::uninitialized_move_n), int*, size_t, long*, long*>);
+struct NotConvertibleFromInt {};
+static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_move_n), int*, size_t, NotConvertibleFromInt*,
+                                   NotConvertibleFromInt*>);
+
+namespace adl {
+
+static int iter_move_invocations = 0;
+
+template <class T>
+struct Iterator {
+  using value_type = T;
+  using difference_type = int;
+  using iterator_concept = std::input_iterator_tag;
+
+  T* ptr = nullptr;
+
+  Iterator() = default;
+  explicit Iterator(int* p) : ptr(p) {}
+
+  T& operator*() const { return *ptr; }
+
+  Iterator& operator++() { ++ptr; return *this; }
+  Iterator operator++(int) {
+    Iterator prev = *this;
+    ++ptr;
+    return prev;
+  }
+
+  friend T&& iter_move(Iterator iter) {
+    ++iter_move_invocations;
+    return std::move(*iter);
+  }
+
+  friend bool operator==(const Iterator& lhs, const Iterator& rhs) { return lhs.ptr == rhs.ptr; }
+};
+
+} // namespace adl
+
+int main(int, char**) {
+  // An empty range -- no default constructors should be invoked.
+  {
+    Counted in[] = {Counted()};
+    Buffer<Counted, 1> out;
+    Counted::reset();
+
+    auto result = std::ranges::uninitialized_move_n(in, 0, out.begin(), out.end());
+    assert(Counted::current_objects == 0);
+    assert(Counted::total_objects == 0);
+    assert(Counted::total_copies == 0);
+    assert(result.in == in);
+    assert(result.out == out.begin());
+  }
+  Counted::reset();
+
+  // A range containing several objects.
+  {
+    constexpr int N = 5;
+    Counted in[N] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, N> out;
+    Counted::reset();
+
+    auto result = std::ranges::uninitialized_move_n(in, N, out.begin(), out.end());
+    ASSERT_SAME_TYPE(decltype(result), std::ranges::uninitialized_move_n_result<Counted*, Counted*>);
+
+    assert(Counted::current_objects == N);
+    assert(Counted::total_objects == N);
+    assert(Counted::total_moves == N);
+    assert(Counted::total_copies == 0);
+
+    assert(std::equal(in, in + N, out.begin(), out.end()));
+    assert(result.in == in + N);
+    assert(result.out == out.end());
+
+    std::destroy(out.begin(), out.end());
+  }
+  Counted::reset();
+
+  // An exception is thrown while objects are being created -- the existing objects should stay
+  // valid. (iterator, sentinel) overload.
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  {
+    constexpr int N = 3;
+    Counted in[] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, 5> out;
+    Counted::reset();
+
+    Counted::throw_on = N; // When constructing out[3].
+    try {
+      std::ranges::uninitialized_move_n(in, 5, out.begin(), out.end());
+      assert(false);
+    } catch (...) {
+    }
+    assert(Counted::current_objects == 0);
+    assert(Counted::total_objects == N);
+    assert(Counted::total_moves == N);
+    assert(Counted::total_copies == 0);
+
+    std::destroy(out.begin(), out.begin() + N);
+  }
+  Counted::reset();
+
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+  // Works with const iterators.
+  {
+    constexpr int N = 5;
+    Counted in[N] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, N> out;
+    Counted::reset();
+
+    std::ranges::uninitialized_move_n(in, N, out.cbegin(), out.cend());
+    assert(Counted::current_objects == N);
+    assert(Counted::total_objects == N);
+    assert(std::equal(in, in + N, out.begin(), out.end()));
+
+    std::destroy(out.begin(), out.end());
+  }
+  Counted::reset();
+
+  // Conversions.
+  {
+    constexpr int N = 3;
+    double in[N] = {1.0, 2.0, 3.0};
+    Buffer<int, N> out;
+
+    std::ranges::uninitialized_move_n(in, N, out.begin(), out.end());
+    assert(std::equal(in, in + N, out.begin(), out.end()));
+  }
+
+  // Destination range is shorter than the source range.
+  {
+    constexpr int M = 3;
+    constexpr int N = 5;
+    Counted in[N] = {Counted(1), Counted(2), Counted(3), Counted(4), Counted(5)};
+    Buffer<Counted, M> out;
+    Counted::reset();
+
+    auto result = std::ranges::uninitialized_move_n(in, N, out.begin(), out.end());
+    assert(Counted::current_objects == M);
+    assert(Counted::total_objects == M);
+    assert(Counted::total_moves == M);
+    assert(Counted::total_copies == 0);
+
+    assert(std::equal(in, in + M, out.begin(), out.end()));
+    assert(result.in == in + M);
+    assert(result.out == out.end());
+  }
+
+  // Ensure the `iter_move` customization point is being used.
+  {
+    constexpr int N = 3;
+    int in[N] = {1, 2, 3};
+    Buffer<int, N> out;
+    adl::Iterator<int> begin(in);
+    adl::Iterator<int> end(in + N);
+
+    std::ranges::uninitialized_move(begin, end, out.begin(), out.end());
+    assert(adl::iter_move_invocations == 3);
+    adl::iter_move_invocations = 0;
+
+    std::ranges::subrange range(begin, end);
+    std::ranges::uninitialized_move(range, out);
+    assert(adl::iter_move_invocations == 3);
+    adl::iter_move_invocations = 0;
+  }
+
+  return 0;
+}