Skip to content

Style cleanup of requires\s*\( #999

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
CaseyCarter merged 2 commits into from
Jul 7, 2020
Merged

Style cleanup of requires\s*\( #999

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
3a89c49
Style cleanup of `requires\s*\(`
CaseyCarter Jul 5, 2020
a01ac43
Review comment
CaseyCarter Jul 6, 2020
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion stl/inc/concepts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -199,7 +199,7 @@ concept _Boolean_testable_impl = convertible_to<_Ty, bool>;

template <class _Ty>
concept _Boolean_testable = _Boolean_testable_impl<_Ty>
&& requires (_Ty&& __t) {
&& requires(_Ty&& __t) {
{ !static_cast<_Ty&&>(__t) } -> _Boolean_testable_impl;
};

Expand Down
4 changes: 3 additions & 1 deletion stl/inc/xutility
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1909,8 +1909,9 @@ public:
}

#ifdef __cpp_lib_concepts
// clang-format off
_NODISCARD constexpr pointer operator->() const
requires(is_pointer_v<_BidIt> || requires(const _BidIt __i) { __i.operator->(); }) {
requires (is_pointer_v<_BidIt> || requires(const _BidIt __i) { __i.operator->(); }) {
_BidIt _Tmp = current;
--_Tmp;
if constexpr (is_pointer_v<_BidIt>) {
Expand All @@ -1919,6 +1920,7 @@ public:
return _Tmp.operator->();
}
}
// clang-format on
#else // ^^^ __cpp_lib_concepts / !__cpp_lib_concepts vvv
_NODISCARD _CONSTEXPR17 pointer operator->() const {
_BidIt _Tmp = current;
Expand Down
8 changes: 6 additions & 2 deletions tests/std/include/range_algorithm_support.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -109,15 +109,19 @@ namespace test {

using unwrap = sentinel<Element, IsWrapped::no>;

[[nodiscard]] constexpr auto _Unwrapped() const noexcept requires(to_bool(Wrapped)) {
// clang-format off
[[nodiscard]] constexpr auto _Unwrapped() const noexcept requires (to_bool(Wrapped)) {
return unwrap{ptr_};
}
// clang-format on

static constexpr bool _Unwrap_when_unverified = true;

constexpr void _Seek_to(unwrap const& s) noexcept requires(to_bool(Wrapped)) {
// clang-format off
constexpr void _Seek_to(unwrap const& s) noexcept requires (to_bool(Wrapped)) {
ptr_ = s.peek();
}
// clang-format on
};

// clang-format off
Expand Down
20 changes: 11 additions & 9 deletions tests/std/tests/P0896R4_P1614R2_comparisons/test.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -83,19 +83,21 @@ struct three_way_archetype {
three_way_archetype(three_way_archetype const&) = delete;
three_way_archetype& operator=(three_way_archetype const&) = delete;
~three_way_archetype() = delete;
// clang-format off
// 0: not equality_comparable
bool operator==(three_way_archetype const&) const requires(I == 0) = delete;
bool operator==(three_way_archetype const&) const requires(I != 0);
bool operator==(three_way_archetype const&) const requires (I == 0) = delete;
bool operator==(three_way_archetype const&) const requires (I != 0);
// 1: not totally_ordered
bool operator<(three_way_archetype const&) const requires(I == 1) = delete;
bool operator<(three_way_archetype const&) const requires(I != 1);
bool operator>(three_way_archetype const&) const requires(I != 1);
bool operator<=(three_way_archetype const&) const requires(I != 1);
bool operator>=(three_way_archetype const&) const requires(I != 1);
bool operator<(three_way_archetype const&) const requires (I == 1) = delete;
bool operator<(three_way_archetype const&) const requires (I != 1);
bool operator>(three_way_archetype const&) const requires (I != 1);
bool operator<=(three_way_archetype const&) const requires (I != 1);
bool operator>=(three_way_archetype const&) const requires (I != 1);
// 2: <=> isn't defined
Category operator<=>(three_way_archetype const&) const requires(I != 2 && I != 3);
Category operator<=>(three_way_archetype const&) const requires (I != 2 && I != 3);
// 3: <=> doesn't return a comparison category type
int operator<=>(three_way_archetype const&) const requires(I == 3);
int operator<=>(three_way_archetype const&) const requires (I == 3);
// clang-format on
};
constexpr int three_way_archetype_max = 4;

Expand Down
129 changes: 73 additions & 56 deletions tests/std/tests/P0896R4_ranges_algorithm_machinery/test.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -61,8 +61,9 @@ template <int I, class T = int>
struct simple_iter_archetype {
using value_type = T;

simple_reference<T> operator*() const requires(I != 0); // 0: not indirectly_readable

// clang-format off
simple_reference<T> operator*() const requires (I != 0); // 0: not indirectly_readable
// clang-format on
friend void iter_swap(simple_iter_archetype const&, simple_iter_archetype const&) {}
};
STATIC_ASSERT(!std::indirectly_readable<simple_iter_archetype<0>>);
Expand Down Expand Up @@ -92,21 +93,23 @@ namespace indirectly_unary_invocable_test {

template <int I>
struct Fn : base<I> {
// clang-format off
// 1: not invocable<Fn&, iter_value_t<simple_iter_archetype>&>
void operator()(int&) const requires(I == 1) = delete;
void operator()(int&) const requires (I == 1) = delete;
// 2: not invocable<Fn&, iter_reference_t<simple_iter_archetype>>
void operator()(simple_reference<int>) const requires(I == 2) = delete;
void operator()(simple_reference<int>) const requires (I == 2) = delete;
// 3: not invocable<Fn&, iter_common_reference_t<simple_iter_archetype>>
void operator()(simple_common_reference<int>) const requires(I == 3) = delete;
void operator()(simple_common_reference<int>) const requires (I == 3) = delete;

// 4 : not common_reference_with<invoke_result_t<Fn&, iter_value_t<simple_iter_archetype>&>,
// invoke_result_t<Fn&, iter_reference_t<simple_iter_archetype>>>;
void operator()(int&) const requires(I == 4);
int operator()(simple_reference<int>) const requires(I == 4);
void operator()(int&) const requires (I == 4);
int operator()(simple_reference<int>) const requires (I == 4);

int operator()(int&) const requires(I != 1 && I != 4);
int operator()(simple_reference<int>) const requires(I != 2 && I != 4);
int operator()(simple_common_reference<int>) const requires(I != 3 && I != 4);
int operator()(int&) const requires (I != 1 && I != 4);
int operator()(simple_reference<int>) const requires (I != 2 && I != 4);
int operator()(simple_common_reference<int>) const requires (I != 3 && I != 4);
// clang-format on
};

template <class F, class I>
Expand Down Expand Up @@ -141,17 +144,19 @@ namespace indirect_unary_predicate_test {

template <int I>
struct Fn : base<I> {
// clang-format off
// 1: not predicate<Fn&, iter_value_t<simple_iter_archetype>&>
void operator()(int&) const requires(I == 1);
void operator()(int&) const requires (I == 1);
// 2: not predicate<Fn&, iter_reference_t<simple_iter_archetype>>
void operator()(simple_reference<int>) const requires(I == 2) = delete;
void operator()(simple_reference<int>) const requires (I == 2) = delete;
// 3: not predicate<Fn&, iter_common_reference_t<simple_iter_archetype>>
void operator()(simple_common_reference<int>) const requires(I == 3) = delete;
void operator()(simple_common_reference<int>) const requires (I == 3) = delete;

// 4: all of the above
int operator()(int&) const requires(I != 1 && I != 4);
int operator()(simple_reference<int>) const requires(I != 2 && I != 4);
int operator()(simple_common_reference<int>) const requires(I != 3 && I != 4);
int operator()(int&) const requires (I != 1 && I != 4);
int operator()(simple_reference<int>) const requires (I != 2 && I != 4);
int operator()(simple_common_reference<int>) const requires (I != 3 && I != 4);
// clang-format on
};

STATIC_ASSERT(!indirect_unary_predicate<Fn<0>, simple_iter_archetype<1>>);
Expand Down Expand Up @@ -179,22 +184,24 @@ namespace indirect_binary_predicate_test {

template <int I>
struct Fn : base<I> {
// clang-format off
// 1: not predicate<Fn&, iter_value_t<simple_iter_archetype>&, iter_value_t<simple_iter_archetype>&>
void operator()(int&, int&) const requires(I == 1);
void operator()(int&, int&) const requires (I == 1);
// 2: not predicate<Fn&, iter_value_t<simple_iter_archetype>&, iter_reference_t<simple_iter_archetype>>
void operator()(int&, simple_reference<int>) const requires(I == 2);
void operator()(int&, simple_reference<int>) const requires (I == 2);
// 3: not predicate<Fn&, iter_reference_t<simple_iter_archetype>, iter_value_t<simple_iter_archetype>&>
void operator()(simple_reference<int>, int&) const requires(I == 3);
void operator()(simple_reference<int>, int&) const requires (I == 3);
// 4: not predicate<Fn&, iter_reference_t<simple_iter_archetype>, iter_reference_t<simple_iter_archetype>>
void operator()(simple_reference<int>, simple_reference<int>) const requires(I == 4);
void operator()(simple_reference<int>, simple_reference<int>) const requires (I == 4);
// 5: not predicate<Fn&, iter_common_reference_t</**/>, iter_common_reference_t</**/>>
void operator()(simple_common_reference<int>, simple_common_reference<int>) const requires(I == 5);
void operator()(simple_common_reference<int>, simple_common_reference<int>) const requires (I == 5);

bool operator()(int&, int&) const requires(I != 1);
int operator()(int&, simple_reference<int>) const requires(I != 2);
int* operator()(simple_reference<int>, int&) const requires(I != 3);
std::true_type operator()(simple_reference<int>, simple_reference<int>) const requires(I != 4);
std::false_type operator()(simple_common_reference<int>, simple_common_reference<int>) const requires(I != 5);
bool operator()(int&, int&) const requires (I != 1);
int operator()(int&, simple_reference<int>) const requires (I != 2);
int* operator()(simple_reference<int>, int&) const requires (I != 3);
std::true_type operator()(simple_reference<int>, simple_reference<int>) const requires (I != 4);
std::false_type operator()(simple_common_reference<int>, simple_common_reference<int>) const requires (I != 5);
// clang-format on
};

template <int FuncSelector, int IterSelector1, int IterSelector2>
Expand Down Expand Up @@ -260,17 +267,19 @@ namespace indirectly_movable_test { // also covers indirectly_movable_storable

template <int I>
struct value_type {
// clang-format off
value_type() = default;
value_type(value_type&&) = default;
value_type& operator=(value_type&&) requires(I != 0) = default; // 0: not movable
value_type& operator=(value_type&&) requires (I != 0) = default; // 0: not movable
// 1: not constructible_from<iter_rvalue_reference_t<In>>:
template <class T>
value_type(simple_reference<T>) requires(I == 1) = delete;
value_type(simple_reference<T>) requires (I == 1) = delete;
// 2: not assignable_from<iter_rvalue_reference_t<In>>:
template <class T>
value_type& operator=(simple_reference<T>) requires(I != 2);
value_type& operator=(simple_reference<T>) requires (I != 2);
template <class T>
void operator=(simple_reference<T>) requires(I == 2) = delete;
void operator=(simple_reference<T>) requires (I == 2) = delete;
// clang-format on
};
// Ensure specializations of value_type have the intended properties
STATIC_ASSERT(!movable<value_type<0>>);
Expand All @@ -291,11 +300,11 @@ namespace indirectly_movable_test { // also covers indirectly_movable_storable
// clang-format off
out_archetype& operator*() const;
// 0: not indirectly_writable<simple_reference>
void operator=(simple_reference<value_type<J>>&&) const requires(I == 0) = delete;
void operator=(simple_reference<value_type<J>>&&) const requires(I != 0);
void operator=(simple_reference<value_type<J>>&&) const requires (I == 0) = delete;
void operator=(simple_reference<value_type<J>>&&) const requires (I != 0);
// 1: not indirectly_writable<value_type>
void operator=(value_type<J>&&) const requires(I == 1) = delete;
void operator=(value_type<J>&&) const requires(I != 1);
void operator=(value_type<J>&&) const requires (I == 1) = delete;
void operator=(value_type<J>&&) const requires (I != 1);
// clang-format on
};
// Ensure specializations of out_archetype have the intended properties
Expand Down Expand Up @@ -328,15 +337,17 @@ namespace indirectly_copyable_test { // also covers indirectly_copyable_storable
struct value_type {
value_type() = default;
value_type(value_type const&) = default;
value_type& operator=(value_type const&) requires(I != 0) = default; // 0: not copyable
// clang-format off
value_type& operator=(value_type const&) requires (I != 0) = default; // 0: not copyable
// 1: not constructible_from<iter_reference_t<In>>:
template <class T>
value_type(simple_reference<T>) requires(I == 1) = delete;
value_type(simple_reference<T>) requires (I == 1) = delete;
// 2: not assignable_from<iter_reference_t<In>>:
template <class T>
value_type& operator=(simple_reference<T>) requires(I != 2);
value_type& operator=(simple_reference<T>) requires (I != 2);
template <class T>
void operator=(simple_reference<T>) requires(I == 2) = delete;
void operator=(simple_reference<T>) requires (I == 2) = delete;
// clang-format on
};
// Ensure specializations of value_type have the intended properties
STATIC_ASSERT(!copyable<value_type<0>>);
Expand All @@ -357,20 +368,20 @@ namespace indirectly_copyable_test { // also covers indirectly_copyable_storable
// clang-format off
out_archetype& operator*() const;
// 0: not indirectly_writable<simple_reference>
void operator=(simple_reference<value_type<J>>&&) const requires(I == 0) = delete;
void operator=(simple_reference<value_type<J>>&&) const requires(I != 0);
void operator=(simple_reference<value_type<J>>&&) const requires (I == 0) = delete;
void operator=(simple_reference<value_type<J>>&&) const requires (I != 0);
// 1: not indirectly_writable<value_type&>
void operator=(value_type<J>&) const requires(I == 1) = delete;
void operator=(value_type<J>&) const requires(I != 1);
void operator=(value_type<J>&) const requires (I == 1) = delete;
void operator=(value_type<J>&) const requires (I != 1);
// 2: not indirectly_writable<value_type&&>
void operator=(value_type<J>&&) const requires(I == 2) = delete;
void operator=(value_type<J>&&) const requires(I != 2);
void operator=(value_type<J>&&) const requires (I == 2) = delete;
void operator=(value_type<J>&&) const requires (I != 2);
// 3: not indirectly_writable<const value_type&&>
void operator=(value_type<J> const&&) const requires(I == 3) = delete;
void operator=(value_type<J> const&&) const requires(I != 3);
void operator=(value_type<J> const&&) const requires (I == 3) = delete;
void operator=(value_type<J> const&&) const requires (I != 3);
// 4: not indirectly_writable<const value_type&>
void operator=(value_type<J> const&) const requires(I == 4) = delete;
void operator=(value_type<J> const&) const requires(I != 4);
void operator=(value_type<J> const&) const requires (I == 4) = delete;
void operator=(value_type<J> const&) const requires (I != 4);
// clang-format on
};
// Ensure specializations of out_archetype have the intended properties
Expand Down Expand Up @@ -439,13 +450,13 @@ namespace indirectly_swappable_test {
operator int() const;
};

reference operator*() const noexcept requires(I != 0);
// clang-format off
reference operator*() const noexcept requires (I != 0);

friend constexpr void iter_swap(archetype const&, archetype const&) requires(I != 1) {}
friend constexpr void iter_swap(archetype const&, archetype const&) requires (I != 1) {}

// clang-format off
template <int J>
requires(I != J && I != 2 && J != 2)
requires (I != J && I != 2 && J != 2)
friend constexpr void iter_swap(archetype const&, archetype<J> const&) {}
// clang-format on
};
Expand Down Expand Up @@ -503,9 +514,11 @@ namespace indirectly_comparable_test {

template <int I>
struct Fn : base<I> {
// clang-format off
// 1: not predicate
void operator()(int, int) const requires(I == 1);
void* operator()(int, int) const requires(I != 1);
void operator()(int, int) const requires (I == 1);
void* operator()(int, int) const requires (I != 1);
// clang-format on
};

STATIC_ASSERT(!indirectly_comparable<simple_iter_archetype<1>, simple_iter_archetype<1>, Fn<0>, Proj, Proj>);
Expand Down Expand Up @@ -711,16 +724,20 @@ namespace permutable_test {

operator int() const;
// 1: not indirectly_movable_storable<archetype, archetype>
void operator=(int) const requires(I != 1);
// clang-format off
void operator=(int) const requires (I != 1);
// clang-format on
};

proxy operator*() const;

archetype& operator++();
archetype operator++(int);

// clang-format off
// 0: not forward_iterator (input only)
bool operator==(archetype const&) const requires(I != 0) = default;
bool operator==(archetype const&) const requires (I != 0) = default;
// clang-format on

friend int iter_move(archetype const&) {
return 42;
Expand Down
Loading