This is an archive of the discontinued LLVM Phabricator instance.

Differential D118213

[libc++] [ranges] ADL-proof ranges::iter_{swap,move}.
ClosedPublic

Authored by • Quuxplusone on Jan 25 2022, 8:41 PM.

Details

Reviewers
ldionne
philnik
var-const
Mordante
Group Reviewers
Restricted Project
Commits
rGbf150e8dabb1: [libc++] [ranges] ADL-proof ranges::iter_{swap,move}.
Summary

As discovered in D117817, std::ranges::input_range<Holder<Incomplete>*[10]>
hard-errored before this patch. That's because input_range requires
iter_rvalue_reference_t, which requires iter_move, which was
not ADL-proofed.

Add ADL-proofing tests to all the range refinements.
output_range and common_range shouldn't be affected,
and all the others subsume input_range anyway, but we might as
well be thorough.

Diff Detail

Event Timeline

• Quuxplusone requested review of this revision.Jan 25 2022, 8:41 PM
• Quuxplusone created this revision.
Herald added 1 blocking reviewer(s): Restricted Project. · View Herald TranscriptJan 25 2022, 8:41 PM
Herald added a subscriber: libcxx-commits. · View Herald Transcript
• Quuxplusone mentioned this in D117817: [libc++][ranges] Implement ranges::mismatch.Jan 25 2022, 8:43 PM
Harbormaster completed remote builds in B145667: Diff 403125.Jan 25 2022, 9:35 PM
• Quuxplusone updated this revision to Diff 403489.EditedJan 26 2022, 9:02 PM

Restore a (void) I'd removed; turns out it is needed in order to suppress a user-provided iter_swap's [[nodiscard]] attribute. (Fun.)
https://buildkite.com/llvm-project/libcxx-ci/builds/8158

Harbormaster completed remote builds in B145912: Diff 403489.Jan 26 2022, 9:51 PM
• Quuxplusone updated this revision to Diff 404275.Jan 29 2022, 8:19 AM

Rebase, and remove refactoring that doesn't affect this particular bug. Ping @ldionne!

Harbormaster completed remote builds in B146462: Diff 404275.Jan 29 2022, 10:03 AM
ldionne accepted this revision.Jan 31 2022, 8:25 AM
This revision is now accepted and ready to land.Jan 31 2022, 8:25 AM
Closed by commit rGbf150e8dabb1: [libc++] [ranges] ADL-proof ranges::iter_{swap,move}. (authored by • arthur.j.odwyer). · Explain WhyJan 31 2022, 11:15 AM
This revision was automatically updated to reflect the committed changes.
• arthur.j.odwyer added a commit: rGbf150e8dabb1: [libc++] [ranges] ADL-proof ranges::iter_{swap,move}..

Revision Contents

PathSize
libcxx/
include/
__iterator/
10 lines
8 lines
test/
std/
iterators/
iterator.requirements/
iterator.cust/
iterator.cust.move/
25 lines
iterator.cust.swap/
52 lines
ranges/
range.req/
range.refinements/
20 lines
18 lines
18 lines
20 lines
20 lines
18 lines
18 lines
18 lines

Diff 404629

libcxx/include/__iterator/iter_move.h

Show All 26 Lines
// [iterator.cust.move] // [iterator.cust.move]
namespace ranges { namespace ranges {
namespace __iter_move { namespace __iter_move {
void iter_move(); void iter_move();
template<class _Ip> template <class _Tp>
concept __unqualified_iter_move = requires(_Ip&& __i) { concept __unqualified_iter_move =
iter_move(_VSTD::forward<_Ip>(__i)); __class_or_enum<remove_cvref_t<_Tp>> &&
requires (_Tp&& __t) {
iter_move(_VSTD::forward<_Tp>(__t));
}; };
// [iterator.cust.move]/1 // [iterator.cust.move]/1
// The name ranges::iter_move denotes a customization point object. // The name ranges::iter_move denotes a customization point object.
// The expression ranges::iter_move(E) for a subexpression E is // The expression ranges::iter_move(E) for a subexpression E is
// expression-equivalent to: // expression-equivalent to:
struct __fn { struct __fn {
// [iterator.cust.move]/1.1 // [iterator.cust.move]/1.1
// iter_move(E), if E has class or enumeration type and iter_move(E) is a // iter_move(E), if E has class or enumeration type and iter_move(E) is a
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libcxx/include/__iterator/iter_swap.h

Show All 30 Lines
// [iter.cust.swap] // [iter.cust.swap]
namespace ranges { namespace ranges {
namespace __iter_swap { namespace __iter_swap {
template<class _I1, class _I2> template<class _I1, class _I2>
void iter_swap(_I1, _I2) = delete; void iter_swap(_I1, _I2) = delete;
template<class _T1, class _T2> template<class _T1, class _T2>
concept __unqualified_iter_swap = requires(_T1&& __x, _T2&& __y) { concept __unqualified_iter_swap =
(__class_or_enum<remove_cvref_t<_T1>> || __class_or_enum<remove_cvref_t<_T2>>) &&
requires (_T1&& __x, _T2&& __y) {
iter_swap(_VSTD::forward<_T1>(__x), _VSTD::forward<_T2>(__y)); iter_swap(_VSTD::forward<_T1>(__x), _VSTD::forward<_T2>(__y));
}; };
template<class _T1, class _T2> template<class _T1, class _T2>
concept __readable_swappable = concept __readable_swappable =
indirectly_readable<_T1> && indirectly_readable<_T2> && indirectly_readable<_T1> && indirectly_readable<_T2> &&
swappable_with<iter_reference_t<_T1>, iter_reference_t<_T2>>; swappable_with<iter_reference_t<_T1>, iter_reference_t<_T2>>;
struct __fn { struct __fn {
template <class _T1, class _T2> template <class _T1, class _T2>
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

libcxx/test/std/iterators/iterator.requirements/iterator.cust/iterator.cust.move/iter_move.pass.cpp

Show All 15 Lines
#include <array> #include <array>
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
#include <utility> #include <utility>
#include "../unqualified_lookup_wrapper.h" #include "../unqualified_lookup_wrapper.h"
using IterMoveT = decltype(std::ranges::iter_move);
// Wrapper around an iterator for testing `iter_move` when an unqualified call to `iter_move` isn't // Wrapper around an iterator for testing `iter_move` when an unqualified call to `iter_move` isn't
// possible. // possible.
template <typename I> template <typename I>
class iterator_wrapper { class iterator_wrapper {
public: public:
iterator_wrapper() = default; iterator_wrapper() = default;
constexpr explicit iterator_wrapper(I i) noexcept : base_(std::move(i)) {} constexpr explicit iterator_wrapper(I i) noexcept : base_(std::move(i)) {}
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines
struct WithoutADL { struct WithoutADL {
WithoutADL() = default; WithoutADL() = default;
constexpr int operator*() const noexcept(NoExcept) { return 0; } constexpr int operator*() const noexcept(NoExcept) { return 0; }
constexpr WithoutADL& operator++(); constexpr WithoutADL& operator++();
constexpr void operator++(int); constexpr void operator++(int);
constexpr bool operator==(WithoutADL const&) const; constexpr bool operator==(WithoutADL const&) const;
}; };
constexpr bool check_iter_move() { constexpr bool test() {
constexpr int full_size = 100; constexpr int full_size = 100;
constexpr int half_size = full_size / 2; constexpr int half_size = full_size / 2;
constexpr int reset = 0; constexpr int reset = 0;
auto v1 = std::array<move_tracker, full_size>{}; auto v1 = std::array<move_tracker, full_size>{};
auto move_counter_is = [](auto const n) { return [n](auto const& x) { return x.moves() == n; }; }; auto move_counter_is = [](auto const n) { return [n](auto const& x) { return x.moves() == n; }; };
auto v2 = std::array<move_tracker, half_size>{}; auto v2 = std::array<move_tracker, half_size>{};
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Linesconstexpr bool test() {
static_assert(noexcept(std::ranges::iter_move(std::declval<WithADL<true>>()))); static_assert(noexcept(std::ranges::iter_move(std::declval<WithADL<true>>())));
static_assert(!noexcept(std::ranges::iter_move(std::declval<WithADL<false>>()))); static_assert(!noexcept(std::ranges::iter_move(std::declval<WithADL<false>>())));
static_assert(noexcept(std::ranges::iter_move(std::declval<WithoutADL<true>>()))); static_assert(noexcept(std::ranges::iter_move(std::declval<WithoutADL<true>>())));
static_assert(!noexcept(std::ranges::iter_move(std::declval<WithoutADL<false>>()))); static_assert(!noexcept(std::ranges::iter_move(std::declval<WithoutADL<false>>())));
return true; return true;
} }
template <typename T> static_assert(!std::is_invocable_v<IterMoveT, int*, int*>); // too many arguments
concept can_iter_move = requires (T t) { std::ranges::iter_move(t); }; static_assert(!std::is_invocable_v<IterMoveT, int>);
int main(int, char**) { // Test ADL-proofing.
static_assert(check_iter_move()); struct Incomplete;
check_iter_move(); template<class T> struct Holder { T t; };
static_assert(std::is_invocable_v<IterMoveT, Holder<Incomplete>**>);
static_assert(std::is_invocable_v<IterMoveT, Holder<Incomplete>**&>);
// Make sure that `iter_move` SFINAEs away when the type can't be iter_move'd int main(int, char**)
{ {
struct NoIterMove { }; test();
static_assert(!can_iter_move<NoIterMove>); static_assert(test());
}
return 0; return 0;
} }

libcxx/test/std/iterators/iterator.requirements/iterator.cust/iterator.cust.swap/iter_swap.pass.cpp

Show All 18 Lines
#include "../unqualified_lookup_wrapper.h" #include "../unqualified_lookup_wrapper.h"
#include "test_iterators.h" #include "test_iterators.h"
using IterSwapT = decltype(std::ranges::iter_swap); using IterSwapT = decltype(std::ranges::iter_swap);
struct HasIterSwap { struct HasIterSwap {
int &value_; int &value_;
explicit HasIterSwap(int &value) : value_(value) { assert(value == 0); } constexpr explicit HasIterSwap(int &value) : value_(value) { assert(value == 0); }
friend constexpr void iter_swap(HasIterSwap& a, HasIterSwap& b) { friend constexpr void iter_swap(HasIterSwap& a, HasIterSwap& b) {
a.value_ = 1; a.value_ = 1;
b.value_ = 1; b.value_ = 1;
} }
friend constexpr void iter_swap(HasIterSwap& a, int& b) { friend constexpr void iter_swap(HasIterSwap& a, int& b) {
a.value_ = 2; a.value_ = 2;
b = 2; b = 2;
Show All 15 Lines
struct NodiscardIterSwap { struct NodiscardIterSwap {
[[nodiscard]] friend int iter_swap(NodiscardIterSwap&, NodiscardIterSwap&) { return 0; } [[nodiscard]] friend int iter_swap(NodiscardIterSwap&, NodiscardIterSwap&) { return 0; }
}; };
void ensureVoidCast(NodiscardIterSwap& a, NodiscardIterSwap& b) { std::ranges::iter_swap(a, b); } void ensureVoidCast(NodiscardIterSwap& a, NodiscardIterSwap& b) { std::ranges::iter_swap(a, b); }
struct HasRangesSwap { struct HasRangesSwap {
int &value_; int &value_;
explicit HasRangesSwap(int &value) : value_(value) { assert(value == 0); } constexpr explicit HasRangesSwap(int &value) : value_(value) { assert(value == 0); }
friend constexpr void swap(HasRangesSwap& a, HasRangesSwap& b) { friend constexpr void swap(HasRangesSwap& a, HasRangesSwap& b) {
a.value_ = 1; a.value_ = 1;
b.value_ = 1; b.value_ = 1;
} }
friend constexpr void swap(HasRangesSwap& a, int& b) { friend constexpr void swap(HasRangesSwap& a, int& b) {
a.value_ = 2; a.value_ = 2;
b = 2; b = 2;
} }
}; };
struct HasRangesSwapWrapper { struct HasRangesSwapWrapper {
using value_type = HasRangesSwap; using value_type = HasRangesSwap;
HasRangesSwap &value_; HasRangesSwap &value_;
explicit HasRangesSwapWrapper(HasRangesSwap &value) : value_(value) {} constexpr explicit HasRangesSwapWrapper(HasRangesSwap &value) : value_(value) {}
HasRangesSwap& operator*() const { return value_; } constexpr HasRangesSwap& operator*() const { return value_; }
}; };
static_assert( std::is_invocable_v<IterSwapT, HasRangesSwapWrapper&, HasRangesSwapWrapper&>); static_assert( std::is_invocable_v<IterSwapT, HasRangesSwapWrapper&, HasRangesSwapWrapper&>);
// Does not satisfy swappable_with, even though swap(X, Y) is valid. // Does not satisfy swappable_with, even though swap(X, Y) is valid.
static_assert(!std::is_invocable_v<IterSwapT, HasRangesSwapWrapper&, int&>); static_assert(!std::is_invocable_v<IterSwapT, HasRangesSwapWrapper&, int&>);
static_assert(!std::is_invocable_v<IterSwapT, int&, HasRangesSwapWrapper&>); static_assert(!std::is_invocable_v<IterSwapT, int&, HasRangesSwapWrapper&>);
struct B; struct B;
struct A { struct A {
bool value = false; bool value = false;
A& operator=(const B&) { constexpr A& operator=(const B&) {
value = true; value = true;
return *this; return *this;
}; };
}; };
struct B { struct B {
bool value = false; bool value = false;
B& operator=(const A&) { constexpr B& operator=(const A&) {
value = true; value = true;
return *this; return *this;
}; };
}; };
struct MoveOnly2; struct MoveOnly2;
struct MoveOnly1 { struct MoveOnly1 {
bool value = false; bool value = false;
MoveOnly1() = default; MoveOnly1() = default;
MoveOnly1(MoveOnly1&&) = default; MoveOnly1(MoveOnly1&&) = default;
MoveOnly1& operator=(MoveOnly1&&) = default; MoveOnly1& operator=(MoveOnly1&&) = default;
MoveOnly1(const MoveOnly1&) = delete; MoveOnly1(const MoveOnly1&) = delete;
MoveOnly1& operator=(const MoveOnly1&) = delete; MoveOnly1& operator=(const MoveOnly1&) = delete;
MoveOnly1& operator=(MoveOnly2 &&) { constexpr MoveOnly1& operator=(MoveOnly2 &&) {
value = true; value = true;
return *this; return *this;
}; };
}; };
struct MoveOnly2 { struct MoveOnly2 {
bool value = false; bool value = false;
MoveOnly2() = default; MoveOnly2() = default;
MoveOnly2(MoveOnly2&&) = default; MoveOnly2(MoveOnly2&&) = default;
MoveOnly2& operator=(MoveOnly2&&) = default; MoveOnly2& operator=(MoveOnly2&&) = default;
MoveOnly2(const MoveOnly2&) = delete; MoveOnly2(const MoveOnly2&) = delete;
MoveOnly2& operator=(const MoveOnly2&) = delete; MoveOnly2& operator=(const MoveOnly2&) = delete;
MoveOnly2& operator=(MoveOnly1 &&) { constexpr MoveOnly2& operator=(MoveOnly1 &&) {
value = true; value = true;
return *this; return *this;
}; };
}; };
int main(int, char**) { constexpr bool test()
{
{ {
int value1 = 0; int value1 = 0;
int value2 = 0; int value2 = 0;
HasIterSwap a(value1), b(value2); HasIterSwap a(value1), b(value2);
std::ranges::iter_swap(a, b); std::ranges::iter_swap(a, b);
assert(value1 == 1 && value2 == 1); assert(value1 == 1 && value2 == 1);
} }
{ {
int value1 = 0; int value1 = 0;
int value2 = 0; int value2 = 0;
HasRangesSwap c(value1), d(value2); HasRangesSwap c(value1), d(value2);
HasRangesSwapWrapper cWrapper(c), dWrapper(d); HasRangesSwapWrapper cWrapper(c), dWrapper(d);
std::ranges::iter_swap(cWrapper, dWrapper); std::ranges::iter_swap(cWrapper, dWrapper);
assert(value1 == 1 && value2 == 1); assert(value1 == 1 && value2 == 1);
} }
{ {
int value1 = 0; int value1 = 0;
int value2 = 0; int value2 = 0;
HasRangesSwap c(value1), d(value2); HasRangesSwap c(value1), d(value2);
std::ranges::iter_swap(HasRangesSwapWrapper(c), HasRangesSwapWrapper(d)); std::ranges::iter_swap(HasRangesSwapWrapper(c), HasRangesSwapWrapper(d));
assert(value1 == 1 && value2 == 1); assert(value1 == 1 && value2 == 1);
} }
{ {
A e; B f; A e; B f;
A *ePtr = &e; A *ePtr = &e;
B *fPtr = &f; B *fPtr = &f;
std::ranges::iter_swap(ePtr, fPtr); std::ranges::iter_swap(ePtr, fPtr);
assert(e.value && f.value); assert(e.value && f.value);
} }
{ {
MoveOnly1 g; MoveOnly2 h; MoveOnly1 g; MoveOnly2 h;
std::ranges::iter_swap(&g, &h); std::ranges::iter_swap(&g, &h);
assert(g.value && h.value); assert(g.value && h.value);
} }
{ {
auto arr = std::array<move_tracker, 2>(); auto arr = std::array<move_tracker, 2>();
std::ranges::iter_swap(arr.begin(), arr.begin() + 1); std::ranges::iter_swap(arr.begin(), arr.begin() + 1);
if (std::is_constant_evaluated()) {
assert(arr[0].moves() == 1 && arr[1].moves() == 3);
} else {
assert(arr[0].moves() == 1 && arr[1].moves() == 2); assert(arr[0].moves() == 1 && arr[1].moves() == 2);
} }
}
{ {
int buff[2] = {1, 2}; int buff[2] = {1, 2};
std::ranges::iter_swap(buff + 0, buff + 1); std::ranges::iter_swap(buff + 0, buff + 1);
assert(buff[0] == 2 && buff[1] == 1); assert(buff[0] == 2 && buff[1] == 1);
std::ranges::iter_swap(cpp20_input_iterator(buff), cpp20_input_iterator(buff + 1)); std::ranges::iter_swap(cpp20_input_iterator(buff), cpp20_input_iterator(buff + 1));
assert(buff[0] == 1 && buff[1] == 2); assert(buff[0] == 1 && buff[1] == 2);
std::ranges::iter_swap(cpp17_input_iterator(buff), cpp17_input_iterator(buff + 1)); std::ranges::iter_swap(cpp17_input_iterator(buff), cpp17_input_iterator(buff + 1));
assert(buff[0] == 2 && buff[1] == 1); assert(buff[0] == 2 && buff[1] == 1);
std::ranges::iter_swap(forward_iterator(buff), forward_iterator(buff + 1)); std::ranges::iter_swap(forward_iterator(buff), forward_iterator(buff + 1));
assert(buff[0] == 1 && buff[1] == 2); assert(buff[0] == 1 && buff[1] == 2);
std::ranges::iter_swap(bidirectional_iterator(buff), bidirectional_iterator(buff + 1)); std::ranges::iter_swap(bidirectional_iterator(buff), bidirectional_iterator(buff + 1));
assert(buff[0] == 2 && buff[1] == 1); assert(buff[0] == 2 && buff[1] == 1);
std::ranges::iter_swap(random_access_iterator(buff), random_access_iterator(buff + 1)); std::ranges::iter_swap(random_access_iterator(buff), random_access_iterator(buff + 1));
assert(buff[0] == 1 && buff[1] == 2); assert(buff[0] == 1 && buff[1] == 2);
std::ranges::iter_swap(contiguous_iterator(buff), contiguous_iterator(buff + 1)); std::ranges::iter_swap(contiguous_iterator(buff), contiguous_iterator(buff + 1));
assert(buff[0] == 2 && buff[1] == 1); assert(buff[0] == 2 && buff[1] == 1);
} }
return true;
}
static_assert(!std::is_invocable_v<IterSwapT, int*>); // too few arguments
static_assert(!std::is_invocable_v<IterSwapT, int*, int*, int*>); // too many arguments
static_assert(!std::is_invocable_v<IterSwapT, int, int*>);
static_assert(!std::is_invocable_v<IterSwapT, int*, int>);
static_assert(!std::is_invocable_v<IterSwapT, void*, void*>);
// Test ADL-proofing.
struct Incomplete;
template<class T> struct Holder { T t; };
static_assert(std::is_invocable_v<IterSwapT, Holder<Incomplete>**, Holder<Incomplete>**>);
static_assert(std::is_invocable_v<IterSwapT, Holder<Incomplete>**, Holder<Incomplete>**&>);
static_assert(std::is_invocable_v<IterSwapT, Holder<Incomplete>**&, Holder<Incomplete>**>);
static_assert(std::is_invocable_v<IterSwapT, Holder<Incomplete>**&, Holder<Incomplete>**&>);
int main(int, char**)
{
test();
static_assert(test());
return 0; return 0;
} }

libcxx/test/std/ranges/range.req/range.refinements/bidirectional_range.compile.pass.cpp

Show All 11 Lines
// template<class R> // template<class R>
// concept bidirectional_range; // concept bidirectional_range;
#include <ranges> #include <ranges>
#include "test_range.h" #include "test_range.h"
template <template <class...> class I> template <template <class...> class I>
constexpr bool check_bidirectional_range() { constexpr bool check_bidirectional_range() {
constexpr bool result = std::ranges::bidirectional_range<test_range<I> >; constexpr bool result = std::ranges::bidirectional_range<test_range<I> >;
static_assert(std::ranges::bidirectional_range<test_range<I> const> == result); static_assert(std::ranges::bidirectional_range<test_range<I> const> == result);
static_assert(std::ranges::bidirectional_range<test_non_const_common_range<I> > == result); static_assert(std::ranges::bidirectional_range<test_non_const_common_range<I> > == result);
static_assert(std::ranges::bidirectional_range<test_non_const_range<I> > == result); static_assert(std::ranges::bidirectional_range<test_non_const_range<I> > == result);
static_assert(std::ranges::bidirectional_range<test_common_range<I> > == result); static_assert(std::ranges::bidirectional_range<test_common_range<I> > == result);
static_assert(std::ranges::bidirectional_range<test_common_range<I> const> == result); static_assert(std::ranges::bidirectional_range<test_common_range<I> const> == result);
static_assert(!std::ranges::bidirectional_range<test_non_const_common_range<I> const>); static_assert(!std::ranges::bidirectional_range<test_non_const_common_range<I> const>);
static_assert(!std::ranges::bidirectional_range<test_non_const_range<I> const>); static_assert(!std::ranges::bidirectional_range<test_non_const_range<I> const>);
return result; return result;
} }
static_assert(!check_bidirectional_range<cpp17_input_iterator>()); static_assert(!check_bidirectional_range<cpp17_input_iterator>());
static_assert(!check_bidirectional_range<cpp20_input_iterator>()); static_assert(!check_bidirectional_range<cpp20_input_iterator>());
static_assert(!check_bidirectional_range<forward_iterator>()); static_assert(!check_bidirectional_range<forward_iterator>());
static_assert(check_bidirectional_range<bidirectional_iterator>()); static_assert(check_bidirectional_range<bidirectional_iterator>());
static_assert(check_bidirectional_range<random_access_iterator>()); static_assert(check_bidirectional_range<random_access_iterator>());
static_assert(check_bidirectional_range<contiguous_iterator>()); static_assert(check_bidirectional_range<contiguous_iterator>());
// Test ADL-proofing.
struct Incomplete;
template<class T> struct Holder { T t; };
static_assert(!std::ranges::bidirectional_range<Holder<Incomplete>*>);
static_assert(!std::ranges::bidirectional_range<Holder<Incomplete>*&>);
static_assert(!std::ranges::bidirectional_range<Holder<Incomplete>*&&>);
static_assert(!std::ranges::bidirectional_range<Holder<Incomplete>* const>);
static_assert(!std::ranges::bidirectional_range<Holder<Incomplete>* const&>);
static_assert(!std::ranges::bidirectional_range<Holder<Incomplete>* const&&>);
static_assert( std::ranges::bidirectional_range<Holder<Incomplete>*[10]>);
static_assert( std::ranges::bidirectional_range<Holder<Incomplete>*(&)[10]>);
static_assert( std::ranges::bidirectional_range<Holder<Incomplete>*(&&)[10]>);
static_assert( std::ranges::bidirectional_range<Holder<Incomplete>* const[10]>);
static_assert( std::ranges::bidirectional_range<Holder<Incomplete>* const(&)[10]>);
static_assert( std::ranges::bidirectional_range<Holder<Incomplete>* const(&&)[10]>);

libcxx/test/std/ranges/range.req/range.refinements/common_range.compile.pass.cpp

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
// Test with a range that's a common_range only when not const-qualified. // Test with a range that's a common_range only when not const-qualified.
struct Range2 { struct Range2 {
int* begin() const; int* begin() const;
int* end(); int* end();
int const* end() const; int const* end() const;
}; };
static_assert( std::ranges::common_range<Range2>); static_assert( std::ranges::common_range<Range2>);
static_assert(!std::ranges::common_range<Range2 const>); static_assert(!std::ranges::common_range<Range2 const>);
// Test ADL-proofing.
struct Incomplete;
template<class T> struct Holder { T t; };
static_assert(!std::ranges::common_range<Holder<Incomplete>*>);
static_assert(!std::ranges::common_range<Holder<Incomplete>*&>);
static_assert(!std::ranges::common_range<Holder<Incomplete>*&&>);
static_assert(!std::ranges::common_range<Holder<Incomplete>* const>);
static_assert(!std::ranges::common_range<Holder<Incomplete>* const&>);
static_assert(!std::ranges::common_range<Holder<Incomplete>* const&&>);
static_assert( std::ranges::common_range<Holder<Incomplete>*[10]>);
static_assert( std::ranges::common_range<Holder<Incomplete>*(&)[10]>);
static_assert( std::ranges::common_range<Holder<Incomplete>*(&&)[10]>);
static_assert( std::ranges::common_range<Holder<Incomplete>* const[10]>);
static_assert( std::ranges::common_range<Holder<Incomplete>* const(&)[10]>);
static_assert( std::ranges::common_range<Holder<Incomplete>* const(&&)[10]>);

libcxx/test/std/ranges/range.req/range.refinements/contiguous_range.compile.pass.cpp

Show First 20 Lines • Show All 69 Lines • ▼ Show 20 Lines
static_assert(!std::ranges::contiguous_range<DataFunctionWrongReturnType>); static_assert(!std::ranges::contiguous_range<DataFunctionWrongReturnType>);
struct WrongObjectness { struct WrongObjectness {
const int *begin() const; const int *begin() const;
const int *end() const; const int *end() const;
void *data() const; void *data() const;
}; };
static_assert(std::ranges::contiguous_range<WrongObjectness>); static_assert(std::ranges::contiguous_range<WrongObjectness>);
// Test ADL-proofing.
struct Incomplete;
template<class T> struct Holder { T t; };
static_assert(!std::ranges::contiguous_range<Holder<Incomplete>*>);
static_assert(!std::ranges::contiguous_range<Holder<Incomplete>*&>);
static_assert(!std::ranges::contiguous_range<Holder<Incomplete>*&&>);
static_assert(!std::ranges::contiguous_range<Holder<Incomplete>* const>);
static_assert(!std::ranges::contiguous_range<Holder<Incomplete>* const&>);
static_assert(!std::ranges::contiguous_range<Holder<Incomplete>* const&&>);
static_assert( std::ranges::contiguous_range<Holder<Incomplete>*[10]>);
static_assert( std::ranges::contiguous_range<Holder<Incomplete>*(&)[10]>);
static_assert( std::ranges::contiguous_range<Holder<Incomplete>*(&&)[10]>);
static_assert( std::ranges::contiguous_range<Holder<Incomplete>* const[10]>);
static_assert( std::ranges::contiguous_range<Holder<Incomplete>* const(&)[10]>);
static_assert( std::ranges::contiguous_range<Holder<Incomplete>* const(&&)[10]>);

libcxx/test/std/ranges/range.req/range.refinements/forward_range.compile.pass.cpp

Show All 12 Lines
// template<class R> // template<class R>
// concept forward_range; // concept forward_range;
#include <ranges> #include <ranges>
#include "test_iterators.h" #include "test_iterators.h"
#include "test_range.h" #include "test_range.h"
template <template <class...> class I> template <template <class...> class I>
constexpr bool check_forward_range() { constexpr bool check_forward_range() {
constexpr bool result = std::ranges::forward_range<test_range<I> >; constexpr bool result = std::ranges::forward_range<test_range<I> >;
static_assert(std::ranges::forward_range<test_range<I> const> == result); static_assert(std::ranges::forward_range<test_range<I> const> == result);
static_assert(std::ranges::forward_range<test_non_const_common_range<I> > == result); static_assert(std::ranges::forward_range<test_non_const_common_range<I> > == result);
static_assert(std::ranges::forward_range<test_non_const_range<I> > == result); static_assert(std::ranges::forward_range<test_non_const_range<I> > == result);
static_assert(std::ranges::forward_range<test_common_range<I> > == result); static_assert(std::ranges::forward_range<test_common_range<I> > == result);
static_assert(std::ranges::forward_range<test_common_range<I> const> == result); static_assert(std::ranges::forward_range<test_common_range<I> const> == result);
static_assert(!std::ranges::forward_range<test_non_const_common_range<I> const>); static_assert(!std::ranges::forward_range<test_non_const_common_range<I> const>);
static_assert(!std::ranges::forward_range<test_non_const_range<I> const>); static_assert(!std::ranges::forward_range<test_non_const_range<I> const>);
return result; return result;
} }
static_assert(!check_forward_range<cpp17_input_iterator>()); static_assert(!check_forward_range<cpp17_input_iterator>());
static_assert(!check_forward_range<cpp20_input_iterator>()); static_assert(!check_forward_range<cpp20_input_iterator>());
static_assert(check_forward_range<forward_iterator>()); static_assert(check_forward_range<forward_iterator>());
static_assert(check_forward_range<bidirectional_iterator>()); static_assert(check_forward_range<bidirectional_iterator>());
static_assert(check_forward_range<random_access_iterator>()); static_assert(check_forward_range<random_access_iterator>());
static_assert(check_forward_range<contiguous_iterator>()); static_assert(check_forward_range<contiguous_iterator>());
// Test ADL-proofing.
struct Incomplete;
template<class T> struct Holder { T t; };
static_assert(!std::ranges::forward_range<Holder<Incomplete>*>);
static_assert(!std::ranges::forward_range<Holder<Incomplete>*&>);
static_assert(!std::ranges::forward_range<Holder<Incomplete>*&&>);
static_assert(!std::ranges::forward_range<Holder<Incomplete>* const>);
static_assert(!std::ranges::forward_range<Holder<Incomplete>* const&>);
static_assert(!std::ranges::forward_range<Holder<Incomplete>* const&&>);
static_assert( std::ranges::forward_range<Holder<Incomplete>*[10]>);
static_assert( std::ranges::forward_range<Holder<Incomplete>*(&)[10]>);
static_assert( std::ranges::forward_range<Holder<Incomplete>*(&&)[10]>);
static_assert( std::ranges::forward_range<Holder<Incomplete>* const[10]>);
static_assert( std::ranges::forward_range<Holder<Incomplete>* const(&)[10]>);
static_assert( std::ranges::forward_range<Holder<Incomplete>* const(&&)[10]>);

libcxx/test/std/ranges/range.req/range.refinements/input_range.compile.pass.cpp

Show All 12 Lines
// template<class R> // template<class R>
// concept input_range; // concept input_range;
#include <ranges> #include <ranges>
#include "test_iterators.h" #include "test_iterators.h"
#include "test_range.h" #include "test_range.h"
static_assert(std::ranges::input_range<test_range<cpp17_input_iterator> >); static_assert(std::ranges::input_range<test_range<cpp17_input_iterator> >);
static_assert(std::ranges::input_range<test_range<cpp17_input_iterator> const>); static_assert(std::ranges::input_range<test_range<cpp17_input_iterator> const>);
static_assert(std::ranges::input_range<test_range<cpp20_input_iterator> >); static_assert(std::ranges::input_range<test_range<cpp20_input_iterator> >);
static_assert(std::ranges::input_range<test_range<cpp20_input_iterator> const>); static_assert(std::ranges::input_range<test_range<cpp20_input_iterator> const>);
static_assert(std::ranges::input_range<test_non_const_range<cpp17_input_iterator> >); static_assert(std::ranges::input_range<test_non_const_range<cpp17_input_iterator> >);
static_assert(std::ranges::input_range<test_non_const_range<cpp20_input_iterator> >); static_assert(std::ranges::input_range<test_non_const_range<cpp20_input_iterator> >);
static_assert(!std::ranges::input_range<test_non_const_range<cpp17_input_iterator> const>); static_assert(!std::ranges::input_range<test_non_const_range<cpp17_input_iterator> const>);
static_assert(!std::ranges::input_range<test_non_const_range<cpp20_input_iterator> const>); static_assert(!std::ranges::input_range<test_non_const_range<cpp20_input_iterator> const>);
static_assert(std::ranges::input_range<test_common_range<forward_iterator> >); static_assert(std::ranges::input_range<test_common_range<forward_iterator> >);
static_assert(!std::ranges::input_range<test_common_range<cpp20_input_iterator> >); static_assert(!std::ranges::input_range<test_common_range<cpp20_input_iterator> >);
static_assert(std::ranges::input_range<test_common_range<forward_iterator> const>); static_assert(std::ranges::input_range<test_common_range<forward_iterator> const>);
static_assert(!std::ranges::input_range<test_common_range<cpp20_input_iterator> const>); static_assert(!std::ranges::input_range<test_common_range<cpp20_input_iterator> const>);
static_assert(std::ranges::input_range<test_non_const_common_range<forward_iterator> >); static_assert(std::ranges::input_range<test_non_const_common_range<forward_iterator> >);
static_assert(!std::ranges::input_range<test_non_const_common_range<cpp20_input_iterator> >); static_assert(!std::ranges::input_range<test_non_const_common_range<cpp20_input_iterator> >);
static_assert(!std::ranges::input_range<test_non_const_common_range<forward_iterator> const>); static_assert(!std::ranges::input_range<test_non_const_common_range<forward_iterator> const>);
static_assert(!std::ranges::input_range<test_non_const_common_range<cpp20_input_iterator> const>); static_assert(!std::ranges::input_range<test_non_const_common_range<cpp20_input_iterator> const>);
// Test ADL-proofing.
struct Incomplete;
template<class T> struct Holder { T t; };
static_assert(!std::ranges::input_range<Holder<Incomplete>*>);
static_assert(!std::ranges::input_range<Holder<Incomplete>*&>);
static_assert(!std::ranges::input_range<Holder<Incomplete>*&&>);
static_assert(!std::ranges::input_range<Holder<Incomplete>* const>);
static_assert(!std::ranges::input_range<Holder<Incomplete>* const&>);
static_assert(!std::ranges::input_range<Holder<Incomplete>* const&&>);
static_assert( std::ranges::input_range<Holder<Incomplete>*[10]>);
static_assert( std::ranges::input_range<Holder<Incomplete>*(&)[10]>);
static_assert( std::ranges::input_range<Holder<Incomplete>*(&&)[10]>);
static_assert( std::ranges::input_range<Holder<Incomplete>* const[10]>);
static_assert( std::ranges::input_range<Holder<Incomplete>* const(&)[10]>);
static_assert( std::ranges::input_range<Holder<Incomplete>* const(&&)[10]>);

libcxx/test/std/ranges/range.req/range.refinements/output_range.compile.pass.cpp

Show All 40 Lines
// Not satisfied when the iterator is not an output_iterator // Not satisfied when the iterator is not an output_iterator
struct RangeWithBadIterator { struct RangeWithBadIterator {
cpp17_input_iterator<T const*> begin(); cpp17_input_iterator<T const*> begin();
sentinel end(); sentinel end();
}; };
static_assert( std::ranges::range<RangeWithBadIterator>); static_assert( std::ranges::range<RangeWithBadIterator>);
static_assert(!std::output_iterator<std::ranges::iterator_t<RangeWithBadIterator>, T>); static_assert(!std::output_iterator<std::ranges::iterator_t<RangeWithBadIterator>, T>);
static_assert(!std::ranges::output_range<RangeWithBadIterator, T>); static_assert(!std::ranges::output_range<RangeWithBadIterator, T>);
// Test ADL-proofing.
struct Incomplete;
template<class T> struct Holder { T t; };
static_assert(!std::ranges::output_range<Holder<Incomplete>*, Holder<Incomplete>*>);
static_assert(!std::ranges::output_range<Holder<Incomplete>*&, Holder<Incomplete>*>);
static_assert(!std::ranges::output_range<Holder<Incomplete>*&&, Holder<Incomplete>*>);
static_assert(!std::ranges::output_range<Holder<Incomplete>* const, Holder<Incomplete>*>);
static_assert(!std::ranges::output_range<Holder<Incomplete>* const&, Holder<Incomplete>*>);
static_assert(!std::ranges::output_range<Holder<Incomplete>* const&&, Holder<Incomplete>*>);
static_assert( std::ranges::output_range<Holder<Incomplete>*[10], Holder<Incomplete>*>);
static_assert( std::ranges::output_range<Holder<Incomplete>*(&)[10], Holder<Incomplete>*>);
static_assert( std::ranges::output_range<Holder<Incomplete>*(&&)[10], Holder<Incomplete>*>);
static_assert(!std::ranges::output_range<Holder<Incomplete>* const[10], Holder<Incomplete>*>);
static_assert(!std::ranges::output_range<Holder<Incomplete>* const(&)[10], Holder<Incomplete>*>);
static_assert(!std::ranges::output_range<Holder<Incomplete>* const(&&)[10], Holder<Incomplete>*>);

libcxx/test/std/ranges/range.req/range.refinements/random_access_range.compile.pass.cpp

Show All 32 Linesconstexpr bool check_range() {
return result; return result;
} }
static_assert(!check_range<cpp20_input_iterator>()); static_assert(!check_range<cpp20_input_iterator>());
static_assert(!check_range<forward_iterator>()); static_assert(!check_range<forward_iterator>());
static_assert(!check_range<bidirectional_iterator>()); static_assert(!check_range<bidirectional_iterator>());
static_assert(check_range<random_access_iterator>()); static_assert(check_range<random_access_iterator>());
static_assert(check_range<contiguous_iterator>()); static_assert(check_range<contiguous_iterator>());
// Test ADL-proofing.
struct Incomplete;
template<class T> struct Holder { T t; };
static_assert(!std::ranges::random_access_range<Holder<Incomplete>*>);
static_assert(!std::ranges::random_access_range<Holder<Incomplete>*&>);
static_assert(!std::ranges::random_access_range<Holder<Incomplete>*&&>);
static_assert(!std::ranges::random_access_range<Holder<Incomplete>* const>);
static_assert(!std::ranges::random_access_range<Holder<Incomplete>* const&>);
static_assert(!std::ranges::random_access_range<Holder<Incomplete>* const&&>);
static_assert( std::ranges::random_access_range<Holder<Incomplete>*[10]>);
static_assert( std::ranges::random_access_range<Holder<Incomplete>*(&)[10]>);
static_assert( std::ranges::random_access_range<Holder<Incomplete>*(&&)[10]>);
static_assert( std::ranges::random_access_range<Holder<Incomplete>* const[10]>);
static_assert( std::ranges::random_access_range<Holder<Incomplete>* const(&)[10]>);
static_assert( std::ranges::random_access_range<Holder<Incomplete>* const(&&)[10]>);

libcxx/test/std/ranges/range.req/range.refinements/viewable_range.compile.pass.cpp

Show First 20 Lines • Show All 160 Lines • ▼ Show 20 Lines
static_assert(!std::ranges::viewable_range<int>); static_assert(!std::ranges::viewable_range<int>);
static_assert(!std::ranges::viewable_range<int (*)(char)>); static_assert(!std::ranges::viewable_range<int (*)(char)>);
static_assert(!std::ranges::viewable_range<int[]>); static_assert(!std::ranges::viewable_range<int[]>);
static_assert(!std::ranges::viewable_range<int[10]>); static_assert(!std::ranges::viewable_range<int[10]>);
static_assert(!std::ranges::viewable_range<int(&)[]>); // not a range static_assert(!std::ranges::viewable_range<int(&)[]>); // not a range
static_assert( std::ranges::viewable_range<int(&)[10]>); // OK, lvalue static_assert( std::ranges::viewable_range<int(&)[10]>); // OK, lvalue
static_assert(!std::ranges::viewable_range<int(&&)[]>); static_assert(!std::ranges::viewable_range<int(&&)[]>);
static_assert(!std::ranges::viewable_range<int(&&)[10]>); static_assert(!std::ranges::viewable_range<int(&&)[10]>);
// Test ADL-proofing.
struct Incomplete;
template<class T> struct Holder { T t; };
static_assert(!std::ranges::viewable_range<Holder<Incomplete>*>);
static_assert(!std::ranges::viewable_range<Holder<Incomplete>*&>);
static_assert(!std::ranges::viewable_range<Holder<Incomplete>*&&>);
static_assert(!std::ranges::viewable_range<Holder<Incomplete>* const>);
static_assert(!std::ranges::viewable_range<Holder<Incomplete>* const&>);
static_assert(!std::ranges::viewable_range<Holder<Incomplete>* const&&>);
static_assert(!std::ranges::viewable_range<Holder<Incomplete>*[10]>);
static_assert( std::ranges::viewable_range<Holder<Incomplete>*(&)[10]>);
static_assert(!std::ranges::viewable_range<Holder<Incomplete>*(&&)[10]>);
static_assert(!std::ranges::viewable_range<Holder<Incomplete>* const[10]>);
static_assert( std::ranges::viewable_range<Holder<Incomplete>* const(&)[10]>);
static_assert(!std::ranges::viewable_range<Holder<Incomplete>* const(&&)[10]>);