[libc++][ranges] Implement std::ranges::swap_ranges()

[philnik]

Summary

Implement std::ranges::swap_ranges()

[• Quuxplusone]

The code looks pretty solid to me (although I am still requesting to reorganize it). The tests need more fleshing out.

Part of the reason for this PR is to experiment and see whether we want {__algorithm/in_in_result.h, etc} or {__algorithm/results.h}. I would say that AFAICT it provides no interesting evidence for either option, but it's definitely not evidence against my hypothesis that {__algorithm/in_in_result.h, etc} is the right choice. :) The use of in_in_result.h here feels pretty natural and self-documenting.

libcxx/include/__algorithm/swap_ranges.h

12–19

The includes needed by std::swap_ranges and std::ranges::swap_ranges practically don't overlap at all, nor are they ever used together, nor is there any circular dependency between them. Therefore (and for other pre-existing prejudices about code organization ;)) I think ranges::swap_ranges should be moved into a new file __algorithm/ranges_swap_ranges.h.

16

Please leave the spacing here consistent with every other header file. (I know, clang-format strikes again; but we have hundreds of header files that use the old spacing, and we shouldn't change them one at a time (or, IMHO, at all).)

40–41

43–44

48

libcxx/include/algorithm

669–676

These changes LGTM, and also IIUC you should remove the comment on line 673 as well. But please make these changes in a separate trivial PR (which I'll "LGTM" as soon as I see it).

libcxx/test/std/algorithms/alg.modifying.operations/alg.swap/ranges.swap_ranges.pass.cpp

76–77

I suspect that in the process of adding all the below-requested tests, you'll realize that either the templated test2 should go away entirely, or it needs a few more template parameters. Whatever happens, I'd prefer to stay away from circular-looking assertions like this, where we depend on metaprogramming to tell us the answer to some other metaprogramming. Ideally, the tests would be as simple and self-evident as possible, e.g.

{
std::list<int> r1 = {1, 2, 3};
std::vector<int> r2 = {4, 5, 6};
using It1 = std::list<int>::iterator;
using It2 = std::vector<int>::iterator;
std::same_as<std::ranges::in_in_result<It1, It2>> auto r =
    std::ranges::swap_ranges(r1, r2);
// Or: auto r = std::ranges::swap_ranges(r1, r2);
//     ASSERT_SAME_TYPE(decltype(r), std::ranges::in_in_result<It1, It2>);
assert(r.in1 == r1.end());
assert(r.in2 == r2.end());
assert((r1 == std::list<int>{4, 5, 6}));
assert((r2 == std::vector<int>{1, 2, 3}));
}

96–102

(1) I'm not thrilled by the test1, test2, tests1, tests2 naming scheme. I'd prefer a very minor modification: keep test1 and test2, but combine tests[12] into a new constexpr bool test() that does all of the calls to test[12], and then main just does the usual test() / static_assert(test()). Alternatively, maybe the templated test[12] disappear, and then you just rename tests[12] to test_iterator_sentinel and test_range.

(2) I don't see any tests for

• non-contiguous range types
• non-iterator sentinel types
• two inputs that aren't of the same length
• non-forward iterators (e.g. cpp20_input_iterator and cpp17_input_iterator), and ranges thereof
• borrowed range types e.g. subrange (right?)
• non-borrowed range types as rvalues, which IIUC should return swap_ranges_result<dangling, Iter2> or swap_ranges_result<Iter1, dangling> so let's test that
• SFINAE-friendliness (I believe you can-and-should just add a line to @jloser's cpo.compile.pass.cpp, or optionally start a new sibling file specifically for the ranges algorithms)
• the non-constrainedness of swap_ranges_result, e.g. swap_ranges_result<int, int> p; is a perfectly fine declaration (Admittedly this is basically implied by the fact that swap_ranges_result<dangling, dangling> is OK — dangling is not an iterator either — but IMO let's test it anyway just for the record. It's the least important of these items by far, though)

[philnik]

• Moved ranges::swap_range into its own header and style changes
• Updated test

[philnik]

libcxx/test/std/algorithms/alg.modifying.operations/alg.swap/ranges.swap_ranges.pass.cpp

96–102

What non-iterator sentinel types are there? Is somewhere a list of them? I looked at https://en.cppreference.com/w/cpp/header/ranges but didn't see anything of interest there.

[• Quuxplusone]

libcxx/test/std/algorithms/alg.modifying.operations/alg.swap/ranges.swap_ranges.pass.cpp

96–102

For our purposes, use sentinel_wrapper<T> from "test_iterators.h". So for example something like this:

struct NonCommon {
  int data_[3] = {};
  auto begin() { return forward_iterator<int*>(data_); }
  auto end() { return sentinel_wrapper<forward_iterator<int*>>(forward_iterator<int*>(data_ + 3)); }
};
test_ranges<std::array<int, 3>, NonCommon>();
test_ranges<NonCommon, std::array<int, 3>>();

Just FYI, there are some standard sentinel types: std::default_sentinel and std::unreachable_sentinel, and then there are harder-to-name ones such as std::ranges::sentinel_t<std::ranges::take_while_view<std::string_view, bool(*)(int)>> (actually there's nothing normative to stop that type from also being some kind of iterator, but in practice it never is).

[• Quuxplusone]

libcxx/test/std/library/description/conventions/customization.point.object/cpo.compile.pass.cpp

46 ↗

(On Diff #396976)

48 ↗

(On Diff #396976)

Utter nit, but let's make this a + 10 in both cases, since this signifies an "end" iterator. :)

[philnik]

• rebased
• Addressed comments and renamed some stuff

[philnik]

• Added module tests

[philnik]

• Removed 0-length whitespaces

[philnik]

• Removed another whitespace

[philnik]

• rebased
• Added UNSUPPORTED comments

[philnik]

Rebased

[philnik]

• Rebased
• Add include

[• Quuxplusone]

LGTM % nits!

libcxx/include/__algorithm/ranges_swap_ranges.h

26

35–36

Nit: Consider the following alternatives, either of which feels preferable to me (and the first feels the most "libc++ style":

_LIBCPP_HIDE_FROM_ABI constexpr ranges::swap_ranges_result<_I1, _I2>
operator()(_I1 __first1, _S1 __last1, _I2 __first2, _S2 __last2) const

_LIBCPP_HIDE_FROM_ABI constexpr
ranges::swap_ranges_result<_I1, _I2> operator()(_I1 __first1, _S1 __last1,
                                                _I2 __first2, _S2 __last2) const

libcxx/test/std/algorithms/alg.modifying.operations/alg.swap/ranges.swap_ranges.pass.cpp

39

(ditto throughout, just to keep line lengths manageable)

53

Can we get tests here for swap_ranges(j, i) and swap_ranges(j, j+1, i, i+3) as well?

157

Here and line 158-159, please don't line-break between auto and a! Line-break after = would be a good place. Maybe using Expected = std::ranges::swap_ranges_result<...> would be useful.
Also, please std::vector<int> rather than just std::vector. (I'm unusually anti-CTAD by nature, but) let's not introduce additional complexity if we don't have to.

168

Nit: struct S {};
Or just use int on line 168 and then you don't need S.

libcxx/test/std/library/description/conventions/customization.point.object/cpo.compile.pass.cpp

48 ↗

(On Diff #396976)

This is relevant to @ldionne's interests re that LWG (write-a-paper-not-an-)issue. @ldionne, should we start testing our niebloids in here? start a new test file? none of the above?
This might be a blocking/controversial point.

[philnik]

• Rebased
• Addredd comments

[philnik]

Rebased

[• Quuxplusone]

libcxx/test/std/algorithms/alg.modifying.operations/alg.swap/ranges.swap_ranges.pass.cpp

85

IIUC, the special thing about borrowed input ranges is that their iterators don't dangle. So this test should be testing with std::move(b1), not just b1. And that means that it should simply be merged into test_rval_range(), something like

std::vector<int> x = {1, 2, 3};
using It = std::vector<int>::iterator;
std::same_as<std::ranges::swap_ranges_result<It, It>> auto c =
  std::ranges::swap_ranges(std::views::all(x), r);
assert(c.in1 == x.end());
assert(c.in2 == r.end());
assert((r == std::vector<int>{1, 2, 3}));
assert((x == std::vector<int>{4, 5, 6}));

where std::views::all(x) is our rvalue, borrowed, range.

Going further down this rabbit hole... Notice that both subrange and all_t (i.e. ref_view in this case) are both not only borrowed ranges, but also views. We don't have test coverage for a borrowed non-view. However, such things seem vanishingly rare? I think the trick is to make it immobile:

struct BorrowedNonView : std::view_base {
    BorrowedNonView(BorrowedNonView&&) = delete;
    int *begin() const;
    int *end() const;
};

I would say that this is not worth it (especially since swap_ranges doesn't do anything surprising w.r.t. dangling).

173

Instead of [[maybe_unused]], let's assert(a.in1 == r.end()). Likewise throughout.

179–184

The only reason this is split out is because vector isn't constexpr yet, right?
Could you see whether it's easy to use the constexpr deque from libcxx/test/support/test_constexpr_container.h instead?

libcxx/test/std/library/description/conventions/customization.point.object/cpo.compile.pass.cpp

48 ↗

(On Diff #396976)

This has changed thanks to D116570; please move this diff into libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp, where it will be a one-line diff.

Actually, now I feel a little guilty for not adding all the iterator-sentinel signatures into niebloid.compile.pass.cpp. I think my original logic was that basically all we were catching with that test was if you did something bizarre with the implementation of the object itself, or if you forgot the const on operator() — but the former doesn't require testing more than one signature, and the latter should be caught immediately by ordinary testing because the object itself is constexpr.

[philnik]

• Rebased
• Address comments

[• Quuxplusone]

libcxx/include/__algorithm/ranges_swap_ranges.h

33–36

Ditto below.

42

I believe you're missing _VSTD::move on both operands, which means there's some test coverage missing. Please investigate and add regression tests involving cpp20_input_iterator.

libcxx/test/std/algorithms/alg.modifying.operations/alg.swap/ranges.swap_ranges.pass.cpp

85

On the ranges::mismatch review you pointed out that views::all(x) i.e. ref_view is not a borrowed range, and it looks like you're right w.r.t. libc++, but that seems to be a libc++ bug.
https://en.cppreference.com/w/cpp/ranges/borrowed_range
I'll fix it, and then views::all(x) should be acceptable as a borrowed range in these tests.

I think std::ranges::subrange(x) is also acceptable, but it's slightly longer and less idiomatic than views::all.
Actually perhaps we should make a new dedicated test type, in support/test_range.h:

template<class R>
struct BorrowedRange {
    explicit BorrowedRange(const R& r) : r_(&r) {}
    BorrowedRange(BorrowedRange&&) = delete; // immobile
    auto begin() const { return std::ranges::begin(*r_); }
    auto end() const { return std::ranges::end(*r_); }
    const R *r_;
};
static_assert( std::ranges::borrowed_range<BorrowedRange<int[10]>>);
static_assert(!std::ranges::view<BorrowedRange<int[10]>>);

template<class R>
BorrowedRange<R> make_borrowed_range(const R& r) {
    static_assert(std::ranges::range<const R>);
    return BorrowedRange<R>(r);
}

Then line 87 becomes

std::ranges::swap_ranges(make_borrowed_range(r1), r2);

and it's more self-documenting.
However, the existing support/test_range.h [sic] looks a little messy, so maybe I'll tackle that at some point this week myself, unless you really want to tackle it.

123–127

Consider s/Iter/It/g, s/Sentinel/Sent/g, to shorten these lines.

155–163

Awesome constexprification! But please put each of the two tests in its own { } scope as usual, so Expected2 is defined closer to its point of use. (This requires re-defining r in each scope; I have no problem with that.)

[philnik]

• Rebased
• Address comments

[• Quuxplusone]

Please git grep swap_ranges ../libcxx/; I believe there's a TODO in iter_swap related to swap_ranges.
Or if you're planning a followup PR for that, that's also OK.

libcxx/include/__algorithm/ranges_swap_ranges.h

35

Here and line 48, we could remove ranges:: from the return type. Should we?
Let's be consistent with whatever you're doing in ranges::mismatch and any other open (or closed) PRs.

libcxx/test/std/algorithms/alg.modifying.operations/alg.swap/ranges.swap_ranges.pass.cpp

27

I think the dependency on std::list is gone? Please check whether any other headers can be removed now.

142

Consider linebreaking.

211

s/int, int/int, char/g so we see we're not accidentally swapping the arguments' order or anything crazy like that. Obviously that bug isn't likely, but it's also trivial to test for.

[philnik]

• Address nits

[philnik]

• Fix CI

[ldionne]

I looked at the implementation, which LGTM. Deferring to @Quuxplusone for the tests.

[• Quuxplusone]

LGTM modulo a few last test nits.

It might also be nice to

static_assert(!std::is_invocable_v<decltype(std::ranges::swap_ranges), cpp17_output_iterator<int*>, int*>);
static_assert(!std::is_invocable_v<decltype(std::ranges::swap_ranges), int*, cpp17_output_iterator<int*>>);

But that's technically non-portable, in that it depends on the ability to take decltype(std::ranges::swap_ranges), which is guaranteed-in-practice-but-not-in-theory because niebloids. So I'm neutral on whether to include those lines somewhere.

libcxx/test/std/algorithms/alg.modifying.operations/alg.swap/ranges.swap_ranges.pass.cpp

97

Nit, throughout: I'd prefer to see std::views::all(rx) instead of std::ranges::subrange(rx). Advantages: shorter, more idiomatic, no CTAD.

171

Above, I'd suggested something involving test_ranges<NonCommon, std::array<int, 3>>(). I no longer particularly care about testing multiple kinds of ranges, because we get some additional coverage in the named tests (e.g. test_borrowed_input_range()). So, let's leave test_range() as testing only std::array alone — but then, please remove its template parameters Range1 and Range2.
Also consider using C arrays instead of std::array, just to keep things simple.

216

[• Quuxplusone]

In D116303#3307974, @Quuxplusone wrote:

It might also be nice to

static_assert(!std::is_invocable_v<decltype(std::ranges::swap_ranges), cpp17_output_iterator<int*>, int*>);
static_assert(!std::is_invocable_v<decltype(std::ranges::swap_ranges), int*, cpp17_output_iterator<int*>>);

Bah, naturally I meant

static_assert(!std::is_invocable_v<decltype(std::ranges::swap_ranges), std::ranges::subrange<cpp17_output_iterator<int*>>, std::ranges::subrange<int*>>);
static_assert(!std::is_invocable_v<decltype(std::ranges::swap_ranges), std::ranges::subrange<int*>, std::ranges::subrange<cpp17_output_iterator<int*>>>);

[philnik]

• Rebased
• Address comments

[philnik]

• Add pragma system_header

[philnik]

• Fix CI

libcxx/docs/Status/RangesAlgorithms.csv

 Write,generate,Not assigned,n/a,Not started
 Write,generate_nNot assigned,n/a,Not started
 Write,remove_copy,Not assigned,n/a,Not started
 Write,remove_copy_if,Not assigned,n/a,Not started
 Write,replace,Not assigned,n/a,Not started
 Write,replace_if,Not assigned,n/a,Not started
 Write,replace_copy,Not assigned,n/a,Not started
 Write,replace_copy_if,Not assigned,n/a,Not started
-Write,swap_ranges,Not assigned,n/a,Not started
+Write,swap_ranges,Nikolas Klauser,`D116303 <https://llvm.org/D116303>`_,Complete
 Write,reverse_copy,Not assigned,n/a,Not started
 Write,rotate_copy,Not assigned,n/a,Not started
 Write,sample,Not assigned,n/a,Not started
 Write,unique_copy,Not assigned,n/a,Not started
 Write,partition_copy,Not assigned,n/a,Not started
 Write,partial_sort_copy,Not assigned,n/a,Not started
 Merge,merge,Not assigned,n/a,Not started
 Merge,set_difference,Not assigned,n/a,Not started

libcxx/include/CMakeLists.txt

set(files
   __algorithm/partial_sort.h
   __algorithm/partial_sort_copy.h
   __algorithm/partition.h
   __algorithm/partition_copy.h
   __algorithm/partition_point.h
   __algorithm/pop_heap.h
   __algorithm/prev_permutation.h
   __algorithm/push_heap.h
+  __algorithm/ranges_swap_ranges.h
   __algorithm/remove.h
   __algorithm/remove_copy.h
   __algorithm/remove_copy_if.h
   __algorithm/remove_if.h
   __algorithm/replace.h
   __algorithm/replace_copy.h
   __algorithm/replace_copy_if.h
   __algorithm/replace_if.h

libcxx/include/__algorithm/ranges_swap_ranges.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ALGORITHM_RANGES_SWAP_RANGES_H
+#define _LIBCPP___ALGORITHM_RANGES_SWAP_RANGES_H
+
+#include <__algorithm/in_in_result.h>
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__iterator/iter_swap.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
+#include <type_traits>
+
+#ifndef _LIBCPP_HAS_NO_RANGES
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+
+template <class _I1, class _I2>
+using swap_ranges_result = in_in_result<_I1, _I2>;
+
+namespace __swap_ranges {
+struct __fn {
+  template <input_iterator _I1, sentinel_for<_I1> _S1,
+            input_iterator _I2, sentinel_for<_I2> _S2>
+    requires indirectly_swappable<_I1, _I2>
+  _LIBCPP_HIDE_FROM_ABI constexpr ranges::swap_ranges_result<_I1, _I2>
+  operator()(_I1 __first1, _S1 __last1, _I2 __first2, _S2 __last2) const {
+    while (__first1 != __last1 && __first2 != __last2) {
+      ranges::iter_swap(__first1, __first2);
+      ++__first1;
+      ++__first2;
+    }
+    return {_VSTD::move(__first1), _VSTD::move(__first2)};
+  }
+
+  template <input_range _R1, input_range _R2>
+    requires indirectly_swappable<iterator_t<_R1>, iterator_t<_R2>>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  ranges::swap_ranges_result<borrowed_iterator_t<_R1>, borrowed_iterator_t<_R2>>
+  operator()(_R1&& __r1, _R2&& __r2) const {
+    return operator()(ranges::begin(__r1), ranges::end(__r1),
+                      ranges::begin(__r2), ranges::end(__r2));
+  }
+};
+} // namespace __swap_ranges
+
+inline namespace __cpo {
+  inline constexpr auto swap_ranges = __swap_ranges::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_HAS_NO_RANGES
+
+#endif // _LIBCPP___ALGORITHM_RANGES_SWAP_RANGES_H

libcxx/include/__algorithm/swap_ranges.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_SWAP_RANGES_H
 #define _LIBCPP___ALGORITHM_SWAP_RANGES_H
 
 #include <__config>
 #include <__utility/swap.h>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ForwardIterator1, class _ForwardIterator2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator2
 swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
   for (; __first1 != __last1; ++__first1, (void)++__first2)
     swap(*__first1, *__first2);
   return __first2;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_SWAP_RANGES_H

libcxx/include/algorithm

template <class BidirectionalIterator1, class BidirectionalIterator2>
     constexpr BidirectionalIterator2      // constexpr in C++20
     copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
                   BidirectionalIterator2 result);
 
 template <class ForwardIterator1, class ForwardIterator2>
     constexpr ForwardIterator2    // constexpr in C++20
     swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2);
 
+template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2>
+        requires indirectly_swappable<I1, I2>
+    constexpr ranges::swap_ranges_result<I1, I2>
+        ranges::swap_ranges(I1 first1, S1 last1, I2 first2, S2 last2);
+
+template<input_range R1, input_range R2>
+        requires indirectly_swappable<iterator_t<R1>, iterator_t<R2>>
+    constexpr ranges::swap_ranges_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
+        ranges::swap_ranges(R1&& r1, R2&& r2);
+
 template <class ForwardIterator1, class ForwardIterator2>
     constexpr void                // constexpr in C++20
     iter_swap(ForwardIterator1 a, ForwardIterator2 b);
 
 template <class InputIterator, class OutputIterator, class UnaryOperation>
     constexpr OutputIterator      // constexpr in C++20
     transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op);
 

 template<class InputIterator, class OutputIterator>
     struct in_out_result;
 }
 
 }  // std
 
 */
 
 #include <__bits> // __libcpp_clz
 #include <__config>
 #include <__debug>
 #include <cstddef>
 #include <cstring>
 #include <functional>
 #include <initializer_list>
 #include <iterator>
 #include <memory>
 #include <type_traits>
 #include <utility> // swap_ranges
 #include <version>
 
 #include <__algorithm/adjacent_find.h>
 #include <__algorithm/all_of.h>
 #include <__algorithm/any_of.h>

 #include <__algorithm/partial_sort.h>
 #include <__algorithm/partial_sort_copy.h>
 #include <__algorithm/partition.h>
 #include <__algorithm/partition_copy.h>
 #include <__algorithm/partition_point.h>
 #include <__algorithm/pop_heap.h>
 #include <__algorithm/prev_permutation.h>
 #include <__algorithm/push_heap.h>
+#include <__algorithm/ranges_swap_ranges.h>
 #include <__algorithm/remove.h>
 #include <__algorithm/remove_copy.h>
 #include <__algorithm/remove_copy_if.h>
 #include <__algorithm/remove_if.h>
 #include <__algorithm/replace.h>
 #include <__algorithm/replace_copy.h>
 #include <__algorithm/replace_copy_if.h>
 #include <__algorithm/replace_if.h>

libcxx/include/module.modulemap

module __algorithm {
       module partial_sort             { private header "__algorithm/partial_sort.h" }
       module partial_sort_copy        { private header "__algorithm/partial_sort_copy.h" }
       module partition                { private header "__algorithm/partition.h" }
       module partition_copy           { private header "__algorithm/partition_copy.h" }
       module partition_point          { private header "__algorithm/partition_point.h" }
       module pop_heap                 { private header "__algorithm/pop_heap.h" }
       module prev_permutation         { private header "__algorithm/prev_permutation.h" }
       module push_heap                { private header "__algorithm/push_heap.h" }
+      module ranges_swap_ranges       { private header "__algorithm/ranges_swap_ranges.h" }
       module remove                   { private header "__algorithm/remove.h" }
       module remove_copy              { private header "__algorithm/remove_copy.h" }
       module remove_copy_if           { private header "__algorithm/remove_copy_if.h" }
       module remove_if                { private header "__algorithm/remove_if.h" }
       module replace                  { private header "__algorithm/replace.h" }
       module replace_copy             { private header "__algorithm/replace_copy.h" }
       module replace_copy_if          { private header "__algorithm/replace_copy_if.h" }
       module replace_if               { private header "__algorithm/replace_if.h" }

libcxx/test/libcxx/diagnostics/detail.headers/algorithm/ranges_swap_ranges.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/ranges_swap_ranges.h'}}
+#include <__algorithm/ranges_swap_ranges.h>

libcxx/test/std/algorithms/alg.modifying.operations/alg.swap/ranges.swap_ranges.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
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<input_­iterator I1, sentinel_­for<I1> S1, input_­iterator I2, sentinel_­for<I2> S2>
+//   requires indirectly_­swappable<I1, I2>
+//   constexpr ranges::swap_ranges_result<I1, I2>
+//     ranges::swap_ranges(I1 first1, S1 last1, I2 first2, S2 last2);
+// template<input_­range R1, input_range R2>
+//   requires indirectly_­swappable<iterator_t<R1>, iterator_t<R2>>
+//   constexpr ranges::swap_ranges_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
+//     ranges::swap_ranges(R1&& r1, R2&& r2);
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <list>
+#include <memory>
+#include <ranges>
+
+#include "test_iterators.h"
+
+constexpr void test_different_lengths() {
+  using Expected = std::ranges::swap_ranges_result<int*, int*>;
+  int i[3] = {1, 2, 3};
+  int j[1] = {4};
+  std::same_as<Expected> auto r = std::ranges::swap_ranges(i, i + 3, j, j + 1);
+  assert(r.in1 == i + 1);
+  assert(r.in2 == j + 1);
+  assert(i[0] == 4);
+  assert(i[1] == 2);
+  assert(i[2] == 3);
+  assert(j[0] == 1);
+  std::same_as<Expected> auto r2 = std::ranges::swap_ranges(i, j);
+  assert(r2.in1 == i + 1);
+  assert(r2.in2 == j + 1);
+  assert(i[0] == 1);
+  assert(i[1] == 2);
+  assert(i[2] == 3);
+  assert(j[0] == 4);
+  std::same_as<Expected> auto r3 = std::ranges::swap_ranges(j, j + 1, i, i + 3);
+  assert(r3.in1 == j + 1);
+  assert(r3.in2 == i + 1);
+  assert(i[0] == 4);
+  assert(i[1] == 2);
+  assert(i[2] == 3);
+  assert(j[0] == 1);
+  std::same_as<Expected> auto r4 = std::ranges::swap_ranges(j, i);
+  assert(r4.in1 == j + 1);
+  assert(r4.in2 == i + 1);
+  assert(i[0] == 1);
+  assert(i[1] == 2);
+  assert(i[2] == 3);
+  assert(j[0] == 4);
+}
+
+template <class Range1, class Range2>
+constexpr void test_range() {
+  Range1 r1 = {1, 2, 3};
+  Range2 r2 = {4, 5, 6};
+
+  using It1 = typename Range1::iterator;
+  using It2 = typename Range2::iterator;
+
+  std::same_as<std::ranges::in_in_result<It1, It2>> auto r = std::ranges::swap_ranges(r1, r2);
+  assert(r.in1 == std::ranges::end(r1));
+  assert(r.in2 == std::ranges::end(r2));
+
+  assert((r1 == Range1{4, 5, 6}));
+  assert((r2 == Range2{1, 2, 3}));
+}
+
+constexpr void test_borrowed_input_range() {
+  {
+    int r1[] = {1, 2, 3};
+    int r2[] = {4, 5, 6};
+    std::ranges::swap_ranges(std::ranges::subrange(r1), r2);
+    assert(r1[0] == 4);
+    assert(r1[1] == 5);
+    assert(r1[2] == 6);
+    assert(r2[0] == 1);
+    assert(r2[1] == 2);
+    assert(r2[2] == 3);
+  }
+  {
+    int r1[] = {1, 2, 3};
+    int r2[] = {4, 5, 6};
+    std::ranges::swap_ranges(r1, std::ranges::subrange(r2));
+    assert(r1[0] == 4);
+    assert(r1[1] == 5);
+    assert(r1[2] == 6);
+    assert(r2[0] == 1);
+    assert(r2[1] == 2);
+    assert(r2[2] == 3);
+  }
+  {
+    int r1[] = {1, 2, 3};
+    int r2[] = {4, 5, 6};
+    std::ranges::swap_ranges(std::ranges::subrange(r1), std::ranges::subrange(r2));
+    assert(r1[0] == 4);
+    assert(r1[1] == 5);
+    assert(r1[2] == 6);
+    assert(r2[0] == 1);
+    assert(r2[1] == 2);
+    assert(r2[2] == 3);
+  }
+}
+
+constexpr void test_sentinel() {
+  int i[3] = {1, 2, 3};
+  int j[3] = {4, 5, 6};
+  using It = cpp17_input_iterator<int*>;
+  using Sent = sentinel_wrapper<It>;
+  using Expected = std::ranges::swap_ranges_result<It, It>;
+  std::same_as<Expected> auto r =
+      std::ranges::swap_ranges(It(i), Sent(It(i + 3)), It(j), Sent(It(j + 3)));
+  assert(base(r.in1) == i + 3);
+  assert(base(r.in2) == j + 3);
+  assert(i[0] == 4);
+  assert(i[1] == 5);
+  assert(i[2] == 6);
+  assert(j[0] == 1);
+  assert(j[1] == 2);
+  assert(j[2] == 3);
+}
+
+template <class Iter1, class Iter2>
+constexpr void test_iterators() {
+  using Expected = std::ranges::swap_ranges_result<Iter1, Iter2>;
+  int i[3] = {1, 2, 3};
+  int j[3] = {4, 5, 6};
+  std::same_as<Expected> auto r = std::ranges::swap_ranges(Iter1(i), sentinel_wrapper(Iter1(i + 3)), Iter2(j), sentinel_wrapper(Iter2(j + 3)));
+  assert(base(r.in1) == i + 3);
+  assert(base(r.in2) == j + 3);
+  assert(i[0] == 4);
+  assert(i[1] == 5);
+  assert(i[2] == 6);
+  assert(j[0] == 1);
+  assert(j[1] == 2);
+  assert(j[2] == 3);
+}
+
+constexpr void test_rval_range() {
+  {
+    using Expected = std::ranges::swap_ranges_result<int*, std::ranges::dangling>;
+    std::array<int, 3> r = {1, 2, 3};
+    std::same_as<Expected> auto a = std::ranges::swap_ranges(r, std::array{4, 5, 6});
+    assert((r == std::array{4, 5, 6}));
+    assert(a.in1 == r.begin() + 3);
+  }
+  {
+    std::array<int, 3> r = {1, 2, 3};
+    using Expected = std::ranges::swap_ranges_result<std::ranges::dangling, int*>;
+    std::same_as<Expected> auto b = std::ranges::swap_ranges(std::array{4, 5, 6}, r);
+    assert((r == std::array{4, 5, 6}));
+    assert(b.in2 == r.begin() + 3);
+  }
+}
+
+constexpr bool test() {
+  test_range<std::array<int, 3>, std::array<int, 3>>();
+
+  test_iterators<cpp20_input_iterator<int*>, cpp20_input_iterator<int*>>();
+  test_iterators<cpp20_input_iterator<int*>, forward_iterator<int*>>();
+  test_iterators<cpp20_input_iterator<int*>, bidirectional_iterator<int*>>();
+  test_iterators<cpp20_input_iterator<int*>, random_access_iterator<int*>>();
+  test_iterators<cpp20_input_iterator<int*>, int*>();
+
+  test_iterators<forward_iterator<int*>, cpp20_input_iterator<int*>>();
+  test_iterators<forward_iterator<int*>, forward_iterator<int*>>();
+  test_iterators<forward_iterator<int*>, bidirectional_iterator<int*>>();
+  test_iterators<forward_iterator<int*>, random_access_iterator<int*>>();
+  test_iterators<forward_iterator<int*>, int*>();
+
+  test_iterators<bidirectional_iterator<int*>, cpp20_input_iterator<int*>>();
+  test_iterators<bidirectional_iterator<int*>, forward_iterator<int*>>();
+  test_iterators<bidirectional_iterator<int*>, bidirectional_iterator<int*>>();
+  test_iterators<bidirectional_iterator<int*>, random_access_iterator<int*>>();
+  test_iterators<bidirectional_iterator<int*>, int*>();
+
+  test_iterators<random_access_iterator<int*>, cpp20_input_iterator<int*>>();
+  test_iterators<random_access_iterator<int*>, forward_iterator<int*>>();
+  test_iterators<random_access_iterator<int*>, bidirectional_iterator<int*>>();
+  test_iterators<random_access_iterator<int*>, random_access_iterator<int*>>();
+  test_iterators<random_access_iterator<int*>, int*>();
+
+  test_iterators<int*, cpp20_input_iterator<int*>>();
+  test_iterators<int*, forward_iterator<int*>>();
+  test_iterators<int*, bidirectional_iterator<int*>>();
+  test_iterators<int*, random_access_iterator<int*>>();
+  test_iterators<int*, int*>();
+
+  test_sentinel();
+  test_different_lengths();
+  test_borrowed_input_range();
+  test_rval_range();
+
+  return true;
+}
+
+static_assert(std::same_as<std::ranges::swap_ranges_result<int, int>, std::ranges::in_in_result<int, int>>);
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp

 //static_assert(test(std::ranges::set_symmetric_difference, a, a, a));
 //static_assert(test(std::ranges::set_union, a, a, a));
 //static_assert(test(std::ranges::shuffle, a, g));
 //static_assert(test(std::ranges::sort, a));
 //static_assert(test(std::ranges::sort_heap, a));
 //static_assert(test(std::ranges::stable_partition, a, odd));
 //static_assert(test(std::ranges::stable_sort, a));
 //static_assert(test(std::ranges::starts_with, a, a));
-//static_assert(test(std::ranges::swap_ranges, a, a));
+static_assert(test(std::ranges::swap_ranges, a, a));
 //static_assert(test(std::ranges::transform, a, a, triple));
 //static_assert(test(std::ranges::unique, a));
 //static_assert(test(std::ranges::unique_copy, a, a));
 //static_assert(test(std::ranges::upper_bound, a, 42));
 
 // [memory.syn]
 
 static_assert(test(std::ranges::construct_at, a, 42));