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