1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 // UNSUPPORTED: c++03, c++11, c++14, c++17
10 // UNSUPPORTED: libcpp-no-concepts
11 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
12 
13 // std::ranges::size
14 
15 #include <ranges>
16 
17 #include <cassert>
18 #include "test_macros.h"
19 #include "test_iterators.h"
20 
21 using RangeSizeT = decltype(std::ranges::size);
22 
23 static_assert(!std::is_invocable_v<RangeSizeT, int[]>);
24 static_assert( std::is_invocable_v<RangeSizeT, int[1]>);
25 static_assert( std::is_invocable_v<RangeSizeT, int (&&)[1]>);
26 static_assert( std::is_invocable_v<RangeSizeT, int (&)[1]>);
27 
28 struct Incomplete;
29 static_assert(!std::is_invocable_v<RangeSizeT, Incomplete[]>);
30 static_assert(!std::is_invocable_v<RangeSizeT, Incomplete(&)[]>);
31 static_assert(!std::is_invocable_v<RangeSizeT, Incomplete(&&)[]>);
32 
33 extern Incomplete array_of_incomplete[42];
34 static_assert(std::ranges::size(array_of_incomplete) == 42);
35 static_assert(std::ranges::size(std::move(array_of_incomplete)) == 42);
36 static_assert(std::ranges::size(std::as_const(array_of_incomplete)) == 42);
37 static_assert(std::ranges::size(static_cast<const Incomplete(&&)[42]>(array_of_incomplete)) == 42);
38 
39 struct SizeMember {
40   constexpr size_t size() { return 42; }
41 };
42 
43 struct StaticSizeMember {
44   constexpr static size_t size() { return 42; }
45 };
46 
47 static_assert(!std::is_invocable_v<RangeSizeT, const SizeMember>);
48 
49 struct SizeFunction {
50   friend constexpr size_t size(SizeFunction) { return 42; }
51 };
52 
53 // Make sure the size member is preferred.
54 struct SizeMemberAndFunction {
55   constexpr size_t size() { return 42; }
56   friend constexpr size_t size(SizeMemberAndFunction) { return 0; }
57 };
58 
59 bool constexpr testArrayType() {
60   int a[4];
61   int b[1];
62   SizeMember c[4];
63   SizeFunction d[4];
64 
65   assert(std::ranges::size(a) == 4);
66   ASSERT_SAME_TYPE(decltype(std::ranges::size(a)), size_t);
67   assert(std::ranges::size(b) == 1);
68   ASSERT_SAME_TYPE(decltype(std::ranges::size(b)), size_t);
69   assert(std::ranges::size(c) == 4);
70   ASSERT_SAME_TYPE(decltype(std::ranges::size(c)), size_t);
71   assert(std::ranges::size(d) == 4);
72   ASSERT_SAME_TYPE(decltype(std::ranges::size(d)), size_t);
73 
74   return true;
75 }
76 
77 struct SizeMemberConst {
78   constexpr size_t size() const { return 42; }
79 };
80 
81 struct SizeMemberSigned {
82   constexpr long size() { return 42; }
83 };
84 
85 bool constexpr testHasSizeMember() {
86   assert(std::ranges::size(SizeMember()) == 42);
87   ASSERT_SAME_TYPE(decltype(std::ranges::size(SizeMember())), size_t);
88 
89   const SizeMemberConst sizeMemberConst;
90   assert(std::ranges::size(sizeMemberConst) == 42);
91 
92   assert(std::ranges::size(SizeMemberAndFunction()) == 42);
93 
94   assert(std::ranges::size(SizeMemberSigned()) == 42);
95   ASSERT_SAME_TYPE(decltype(std::ranges::size(SizeMemberSigned())), long);
96 
97   assert(std::ranges::size(StaticSizeMember()) == 42);
98   ASSERT_SAME_TYPE(decltype(std::ranges::size(StaticSizeMember())), size_t);
99 
100   return true;
101 }
102 
103 struct MoveOnlySizeFunction {
104   MoveOnlySizeFunction() = default;
105   MoveOnlySizeFunction(MoveOnlySizeFunction &&) = default;
106   MoveOnlySizeFunction(MoveOnlySizeFunction const&) = delete;
107 
108   friend constexpr size_t size(MoveOnlySizeFunction) { return 42; }
109 };
110 
111 enum EnumSizeFunction {
112   a, b
113 };
114 
115 constexpr size_t size(EnumSizeFunction) { return 42; }
116 
117 struct SizeFunctionConst {
118   friend constexpr size_t size(const SizeFunctionConst) { return 42; }
119 };
120 
121 struct SizeFunctionRef {
122   friend constexpr size_t size(SizeFunctionRef&) { return 42; }
123 };
124 
125 struct SizeFunctionConstRef {
126   friend constexpr size_t size(SizeFunctionConstRef const&) { return 42; }
127 };
128 
129 struct SizeFunctionSigned {
130   friend constexpr long size(SizeFunctionSigned) { return 42; }
131 };
132 
133 bool constexpr testHasSizeFunction() {
134   assert(std::ranges::size(SizeFunction()) == 42);
135   ASSERT_SAME_TYPE(decltype(std::ranges::size(SizeFunction())), size_t);
136   static_assert(!std::is_invocable_v<RangeSizeT, MoveOnlySizeFunction>);
137   assert(std::ranges::size(EnumSizeFunction()) == 42);
138   assert(std::ranges::size(SizeFunctionConst()) == 42);
139 
140   SizeFunctionRef a;
141   assert(std::ranges::size(a) == 42);
142 
143   const SizeFunctionConstRef b;
144   assert(std::ranges::size(b) == 42);
145 
146   assert(std::ranges::size(SizeFunctionSigned()) == 42);
147   ASSERT_SAME_TYPE(decltype(std::ranges::size(SizeFunctionSigned())), long);
148 
149   return true;
150 }
151 
152 struct Empty { };
153 static_assert(!std::is_invocable_v<RangeSizeT, Empty>);
154 
155 struct InvalidReturnTypeMember {
156   Empty size();
157 };
158 
159 struct InvalidReturnTypeFunction {
160   friend Empty size(InvalidReturnTypeFunction);
161 };
162 
163 struct Convertible {
164   operator size_t();
165 };
166 
167 struct ConvertibleReturnTypeMember {
168   Convertible size();
169 };
170 
171 struct ConvertibleReturnTypeFunction {
172   friend Convertible size(ConvertibleReturnTypeFunction);
173 };
174 
175 struct BoolReturnTypeMember {
176   bool size() const;
177 };
178 
179 struct BoolReturnTypeFunction {
180   friend bool size(BoolReturnTypeFunction const&);
181 };
182 
183 static_assert(!std::is_invocable_v<RangeSizeT, InvalidReturnTypeMember>);
184 static_assert(!std::is_invocable_v<RangeSizeT, InvalidReturnTypeFunction>);
185 static_assert( std::is_invocable_v<RangeSizeT, InvalidReturnTypeMember (&)[4]>);
186 static_assert( std::is_invocable_v<RangeSizeT, InvalidReturnTypeFunction (&)[4]>);
187 static_assert(!std::is_invocable_v<RangeSizeT, ConvertibleReturnTypeMember>);
188 static_assert(!std::is_invocable_v<RangeSizeT, ConvertibleReturnTypeFunction>);
189 static_assert(!std::is_invocable_v<RangeSizeT, BoolReturnTypeMember const&>);
190 static_assert(!std::is_invocable_v<RangeSizeT, BoolReturnTypeFunction const&>);
191 
192 struct SizeMemberDisabled {
193   size_t size() { return 42; }
194 };
195 
196 template <>
197 inline constexpr bool std::ranges::disable_sized_range<SizeMemberDisabled> = true;
198 
199 struct ImproperlyDisabledMember {
200   size_t size() const { return 42; }
201 };
202 
203 // Intentionally disabling "const ConstSizeMemberDisabled". This doesn't disable anything
204 // because T is always uncvrefed before being checked.
205 template <>
206 inline constexpr bool std::ranges::disable_sized_range<const ImproperlyDisabledMember> = true;
207 
208 struct SizeFunctionDisabled {
209   friend size_t size(SizeFunctionDisabled) { return 42; }
210 };
211 
212 template <>
213 inline constexpr bool std::ranges::disable_sized_range<SizeFunctionDisabled> = true;
214 
215 struct ImproperlyDisabledFunction {
216   friend size_t size(ImproperlyDisabledFunction const&) { return 42; }
217 };
218 
219 template <>
220 inline constexpr bool std::ranges::disable_sized_range<const ImproperlyDisabledFunction> = true;
221 
222 static_assert( std::is_invocable_v<RangeSizeT, ImproperlyDisabledMember&>);
223 static_assert( std::is_invocable_v<RangeSizeT, const ImproperlyDisabledMember&>);
224 static_assert(!std::is_invocable_v<RangeSizeT, ImproperlyDisabledFunction&>);
225 static_assert( std::is_invocable_v<RangeSizeT, const ImproperlyDisabledFunction&>);
226 
227 // No begin end.
228 struct HasMinusOperator {
229   friend constexpr size_t operator-(HasMinusOperator, HasMinusOperator) { return 2; }
230 };
231 static_assert(!std::is_invocable_v<RangeSizeT, HasMinusOperator>);
232 
233 struct HasMinusBeginEnd {
234   struct sentinel {
235     friend bool operator==(sentinel, forward_iterator<int*>);
236     friend constexpr std::ptrdiff_t operator-(const sentinel, const forward_iterator<int*>) { return 2; }
237     friend constexpr std::ptrdiff_t operator-(const forward_iterator<int*>, const sentinel) { return 2; }
238   };
239 
240   friend constexpr forward_iterator<int*> begin(HasMinusBeginEnd) { return {}; }
241   friend constexpr sentinel end(HasMinusBeginEnd) { return {}; }
242 };
243 
244 struct other_forward_iterator : forward_iterator<int*> { };
245 
246 struct InvalidMinusBeginEnd {
247   struct sentinel {
248     friend bool operator==(sentinel, other_forward_iterator);
249     friend constexpr std::ptrdiff_t operator-(const sentinel, const other_forward_iterator) { return 2; }
250     friend constexpr std::ptrdiff_t operator-(const other_forward_iterator, const sentinel) { return 2; }
251   };
252 
253   friend constexpr other_forward_iterator begin(InvalidMinusBeginEnd) { return {}; }
254   friend constexpr sentinel end(InvalidMinusBeginEnd) { return {}; }
255 };
256 
257 // short is integer-like, but it is not other_forward_iterator's difference_type.
258 static_assert(!std::same_as<other_forward_iterator::difference_type, short>);
259 static_assert(!std::is_invocable_v<RangeSizeT, InvalidMinusBeginEnd>);
260 
261 struct RandomAccessRange {
262   struct sentinel {
263     friend bool operator==(sentinel, random_access_iterator<int*>);
264     friend constexpr std::ptrdiff_t operator-(const sentinel, const random_access_iterator<int*>) { return 2; }
265     friend constexpr std::ptrdiff_t operator-(const random_access_iterator<int*>, const sentinel) { return 2; }
266   };
267 
268   constexpr random_access_iterator<int*> begin() { return {}; }
269   constexpr sentinel end() { return {}; }
270 };
271 
272 struct IntPtrBeginAndEnd {
273   int buff[8];
274   constexpr int* begin() { return buff; }
275   constexpr int* end() { return buff + 8; }
276 };
277 
278 struct DisabledSizeRangeWithBeginEnd {
279   int buff[8];
280   constexpr int* begin() { return buff; }
281   constexpr int* end() { return buff + 8; }
282   constexpr size_t size() { return 1; }
283 };
284 
285 template <>
286 inline constexpr bool std::ranges::disable_sized_range<DisabledSizeRangeWithBeginEnd> = true;
287 
288 struct SizeBeginAndEndMembers {
289   int buff[8];
290   constexpr int* begin() { return buff; }
291   constexpr int* end() { return buff + 8; }
292   constexpr size_t size() { return 1; }
293 };
294 
295 constexpr bool testRanges() {
296   HasMinusBeginEnd a;
297   assert(std::ranges::size(a) == 2);
298   // Ensure that this is converted to an *unsigned* type.
299   ASSERT_SAME_TYPE(decltype(std::ranges::size(a)), size_t);
300 
301   IntPtrBeginAndEnd b;
302   assert(std::ranges::size(b) == 8);
303 
304   DisabledSizeRangeWithBeginEnd c;
305   assert(std::ranges::size(c) == 8);
306 
307   RandomAccessRange d;
308   assert(std::ranges::size(d) == 2);
309   ASSERT_SAME_TYPE(decltype(std::ranges::size(d)), size_t);
310 
311   SizeBeginAndEndMembers e;
312   assert(std::ranges::size(e) == 1);
313 
314   return true;
315 }
316 
317 // Test ADL-proofing.
318 struct Incomplete;
319 template<class T> struct Holder { T t; };
320 static_assert(!std::is_invocable_v<RangeSizeT, Holder<Incomplete>*>);
321 static_assert(!std::is_invocable_v<RangeSizeT, Holder<Incomplete>*&>);
322 
323 int main(int, char**) {
324   testArrayType();
325   static_assert(testArrayType());
326 
327   testHasSizeMember();
328   static_assert(testHasSizeMember());
329 
330   testHasSizeFunction();
331   static_assert(testHasSizeFunction());
332 
333   testRanges();
334   static_assert(testRanges());
335 
336   return 0;
337 }
338