1 //===- unittest/Format/TokenAnnotatorTest.cpp - Formatting unit tests -----===// 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 #include "clang/Format/Format.h" 10 11 #include "FormatTestUtils.h" 12 #include "TestLexer.h" 13 #include "gtest/gtest.h" 14 15 namespace clang { 16 namespace format { 17 18 // Not really the equality, but everything we need. 19 static bool operator==(const FormatToken &LHS, 20 const FormatToken &RHS) noexcept { 21 return LHS.Tok.getKind() == RHS.Tok.getKind() && 22 LHS.getType() == RHS.getType(); 23 } 24 25 namespace { 26 27 class TokenAnnotatorTest : public ::testing::Test { 28 protected: 29 TokenList annotate(llvm::StringRef Code, 30 const FormatStyle &Style = getLLVMStyle()) { 31 return TestLexer(Allocator, Buffers, Style).annotate(Code); 32 } 33 llvm::SpecificBumpPtrAllocator<FormatToken> Allocator; 34 std::vector<std::unique_ptr<llvm::MemoryBuffer>> Buffers; 35 }; 36 37 #define EXPECT_TOKEN_KIND(FormatTok, Kind) \ 38 EXPECT_EQ((FormatTok)->Tok.getKind(), Kind) << *(FormatTok) 39 #define EXPECT_TOKEN_TYPE(FormatTok, Type) \ 40 EXPECT_EQ((FormatTok)->getType(), Type) << *(FormatTok) 41 #define EXPECT_TOKEN(FormatTok, Kind, Type) \ 42 do { \ 43 EXPECT_TOKEN_KIND(FormatTok, Kind); \ 44 EXPECT_TOKEN_TYPE(FormatTok, Type); \ 45 } while (false) 46 47 TEST_F(TokenAnnotatorTest, UnderstandsUsesOfStarAndAmp) { 48 auto Tokens = annotate("auto x = [](const decltype(x) &ptr) {};"); 49 EXPECT_EQ(Tokens.size(), 18u) << Tokens; 50 EXPECT_TOKEN(Tokens[7], tok::kw_decltype, TT_Unknown); 51 EXPECT_TOKEN(Tokens[8], tok::l_paren, TT_TypeDeclarationParen); 52 EXPECT_TOKEN(Tokens[9], tok::identifier, TT_Unknown); 53 EXPECT_TOKEN(Tokens[10], tok::r_paren, TT_TypeDeclarationParen); 54 EXPECT_TOKEN(Tokens[11], tok::amp, TT_PointerOrReference); 55 56 Tokens = annotate("auto x = [](const decltype(x) *ptr) {};"); 57 EXPECT_EQ(Tokens.size(), 18u) << Tokens; 58 EXPECT_TOKEN(Tokens[10], tok::r_paren, TT_TypeDeclarationParen); 59 EXPECT_TOKEN(Tokens[11], tok::star, TT_PointerOrReference); 60 61 Tokens = annotate("#define lambda [](const decltype(x) &ptr) {}"); 62 EXPECT_EQ(Tokens.size(), 17u) << Tokens; 63 EXPECT_TOKEN(Tokens[7], tok::kw_decltype, TT_Unknown); 64 EXPECT_TOKEN(Tokens[8], tok::l_paren, TT_TypeDeclarationParen); 65 EXPECT_TOKEN(Tokens[9], tok::identifier, TT_Unknown); 66 EXPECT_TOKEN(Tokens[10], tok::r_paren, TT_TypeDeclarationParen); 67 EXPECT_TOKEN(Tokens[11], tok::amp, TT_PointerOrReference); 68 69 Tokens = annotate("#define lambda [](const decltype(x) *ptr) {}"); 70 EXPECT_EQ(Tokens.size(), 17u) << Tokens; 71 EXPECT_TOKEN(Tokens[10], tok::r_paren, TT_TypeDeclarationParen); 72 EXPECT_TOKEN(Tokens[11], tok::star, TT_PointerOrReference); 73 } 74 75 TEST_F(TokenAnnotatorTest, UnderstandsClasses) { 76 auto Tokens = annotate("class C {};"); 77 EXPECT_EQ(Tokens.size(), 6u) << Tokens; 78 EXPECT_TOKEN(Tokens[2], tok::l_brace, TT_ClassLBrace); 79 80 Tokens = annotate("const class C {} c;"); 81 EXPECT_EQ(Tokens.size(), 8u) << Tokens; 82 EXPECT_TOKEN(Tokens[3], tok::l_brace, TT_ClassLBrace); 83 84 Tokens = annotate("const class {} c;"); 85 EXPECT_EQ(Tokens.size(), 7u) << Tokens; 86 EXPECT_TOKEN(Tokens[2], tok::l_brace, TT_ClassLBrace); 87 } 88 89 TEST_F(TokenAnnotatorTest, UnderstandsStructs) { 90 auto Tokens = annotate("struct S {};"); 91 EXPECT_EQ(Tokens.size(), 6u) << Tokens; 92 EXPECT_TOKEN(Tokens[2], tok::l_brace, TT_StructLBrace); 93 } 94 95 TEST_F(TokenAnnotatorTest, UnderstandsUnions) { 96 auto Tokens = annotate("union U {};"); 97 EXPECT_EQ(Tokens.size(), 6u) << Tokens; 98 EXPECT_TOKEN(Tokens[2], tok::l_brace, TT_UnionLBrace); 99 100 Tokens = annotate("union U { void f() { return; } };"); 101 EXPECT_EQ(Tokens.size(), 14u) << Tokens; 102 EXPECT_TOKEN(Tokens[2], tok::l_brace, TT_UnionLBrace); 103 EXPECT_TOKEN(Tokens[7], tok::l_brace, TT_FunctionLBrace); 104 } 105 106 TEST_F(TokenAnnotatorTest, UnderstandsEnums) { 107 auto Tokens = annotate("enum E {};"); 108 EXPECT_EQ(Tokens.size(), 6u) << Tokens; 109 EXPECT_TOKEN(Tokens[2], tok::l_brace, TT_EnumLBrace); 110 } 111 112 TEST_F(TokenAnnotatorTest, UnderstandsLBracesInMacroDefinition) { 113 auto Tokens = annotate("#define BEGIN NS {"); 114 EXPECT_EQ(Tokens.size(), 6u) << Tokens; 115 EXPECT_TOKEN(Tokens[4], tok::l_brace, TT_Unknown); 116 } 117 118 TEST_F(TokenAnnotatorTest, UnderstandsDelete) { 119 auto Tokens = annotate("delete (void *)p;"); 120 EXPECT_EQ(Tokens.size(), 8u) << Tokens; 121 EXPECT_TOKEN(Tokens[4], tok::r_paren, TT_CastRParen); 122 123 Tokens = annotate("delete[] (void *)p;"); 124 EXPECT_EQ(Tokens.size(), 10u) << Tokens; 125 EXPECT_TOKEN(Tokens[6], tok::r_paren, TT_CastRParen); 126 127 Tokens = annotate("delete[] /*comment*/ (void *)p;"); 128 EXPECT_EQ(Tokens.size(), 11u) << Tokens; 129 EXPECT_TOKEN(Tokens[7], tok::r_paren, TT_CastRParen); 130 131 Tokens = annotate("delete[/*comment*/] (void *)p;"); 132 EXPECT_EQ(Tokens.size(), 11u) << Tokens; 133 EXPECT_TOKEN(Tokens[7], tok::r_paren, TT_CastRParen); 134 135 Tokens = annotate("delete/*comment*/[] (void *)p;"); 136 EXPECT_EQ(Tokens.size(), 11u) << Tokens; 137 EXPECT_TOKEN(Tokens[7], tok::r_paren, TT_CastRParen); 138 } 139 140 TEST_F(TokenAnnotatorTest, UnderstandsRequiresClausesAndConcepts) { 141 auto Tokens = annotate("template <typename T>\n" 142 "concept C = (Foo && Bar) && (Bar && Baz);"); 143 144 ASSERT_EQ(Tokens.size(), 21u) << Tokens; 145 EXPECT_TOKEN(Tokens[10], tok::ampamp, TT_BinaryOperator); 146 EXPECT_TOKEN(Tokens[13], tok::ampamp, TT_BinaryOperator); 147 EXPECT_TOKEN(Tokens[16], tok::ampamp, TT_BinaryOperator); 148 149 Tokens = annotate("template <typename T>\n" 150 "concept C = requires(T t) {\n" 151 " { t.foo() };\n" 152 "} && Bar<T> && Baz<T>;"); 153 ASSERT_EQ(Tokens.size(), 35u) << Tokens; 154 EXPECT_TOKEN(Tokens[8], tok::kw_requires, TT_RequiresExpression); 155 EXPECT_TOKEN(Tokens[9], tok::l_paren, TT_RequiresExpressionLParen); 156 EXPECT_TOKEN(Tokens[13], tok::l_brace, TT_RequiresExpressionLBrace); 157 EXPECT_TOKEN(Tokens[23], tok::ampamp, TT_BinaryOperator); 158 EXPECT_TOKEN(Tokens[28], tok::ampamp, TT_BinaryOperator); 159 160 Tokens = annotate("template<typename T>\n" 161 "requires C1<T> && (C21<T> || C22<T> && C2e<T>) && C3<T>\n" 162 "struct Foo;"); 163 ASSERT_EQ(Tokens.size(), 36u) << Tokens; 164 EXPECT_TOKEN(Tokens[5], tok::kw_requires, TT_RequiresClause); 165 EXPECT_TOKEN(Tokens[6], tok::identifier, TT_Unknown); 166 EXPECT_EQ(Tokens[6]->FakeLParens.size(), 1u); 167 EXPECT_TOKEN(Tokens[10], tok::ampamp, TT_BinaryOperator); 168 EXPECT_TOKEN(Tokens[16], tok::pipepipe, TT_BinaryOperator); 169 EXPECT_TOKEN(Tokens[21], tok::ampamp, TT_BinaryOperator); 170 EXPECT_TOKEN(Tokens[27], tok::ampamp, TT_BinaryOperator); 171 EXPECT_TOKEN(Tokens[31], tok::greater, TT_TemplateCloser); 172 EXPECT_EQ(Tokens[31]->FakeRParens, 1u); 173 EXPECT_TRUE(Tokens[31]->ClosesRequiresClause); 174 175 Tokens = 176 annotate("template<typename T>\n" 177 "requires (C1<T> && (C21<T> || C22<T> && C2e<T>) && C3<T>)\n" 178 "struct Foo;"); 179 ASSERT_EQ(Tokens.size(), 38u) << Tokens; 180 EXPECT_TOKEN(Tokens[5], tok::kw_requires, TT_RequiresClause); 181 EXPECT_TOKEN(Tokens[7], tok::identifier, TT_Unknown); 182 EXPECT_EQ(Tokens[7]->FakeLParens.size(), 1u); 183 EXPECT_TOKEN(Tokens[11], tok::ampamp, TT_BinaryOperator); 184 EXPECT_TOKEN(Tokens[17], tok::pipepipe, TT_BinaryOperator); 185 EXPECT_TOKEN(Tokens[22], tok::ampamp, TT_BinaryOperator); 186 EXPECT_TOKEN(Tokens[28], tok::ampamp, TT_BinaryOperator); 187 EXPECT_TOKEN(Tokens[32], tok::greater, TT_TemplateCloser); 188 EXPECT_EQ(Tokens[32]->FakeRParens, 1u); 189 EXPECT_TOKEN(Tokens[33], tok::r_paren, TT_Unknown); 190 EXPECT_TRUE(Tokens[33]->ClosesRequiresClause); 191 192 Tokens = annotate("template <typename T>\n" 193 "void foo(T) noexcept requires Bar<T>;"); 194 ASSERT_EQ(Tokens.size(), 18u) << Tokens; 195 EXPECT_TOKEN(Tokens[11], tok::kw_requires, TT_RequiresClause); 196 197 Tokens = annotate("template <typename T>\n" 198 "struct S {\n" 199 " void foo() const requires Bar<T>;\n" 200 " void bar() const & requires Baz<T>;\n" 201 " void bar() && requires Baz2<T>;\n" 202 " void baz() const & noexcept requires Baz<T>;\n" 203 " void baz() && noexcept requires Baz2<T>;\n" 204 "};\n" 205 "\n" 206 "void S::bar() const & requires Baz<T> { }"); 207 ASSERT_EQ(Tokens.size(), 85u) << Tokens; 208 EXPECT_TOKEN(Tokens[13], tok::kw_requires, TT_RequiresClause); 209 EXPECT_TOKEN(Tokens[25], tok::kw_requires, TT_RequiresClause); 210 EXPECT_TOKEN(Tokens[36], tok::kw_requires, TT_RequiresClause); 211 EXPECT_TOKEN(Tokens[49], tok::kw_requires, TT_RequiresClause); 212 EXPECT_TOKEN(Tokens[61], tok::kw_requires, TT_RequiresClause); 213 EXPECT_TOKEN(Tokens[77], tok::kw_requires, TT_RequiresClause); 214 215 Tokens = annotate("void Class::member() && requires(Constant) {}"); 216 ASSERT_EQ(Tokens.size(), 14u) << Tokens; 217 EXPECT_TOKEN(Tokens[7], tok::kw_requires, TT_RequiresClause); 218 219 Tokens = annotate("void Class::member() && requires(Constant<T>) {}"); 220 ASSERT_EQ(Tokens.size(), 17u) << Tokens; 221 EXPECT_TOKEN(Tokens[7], tok::kw_requires, TT_RequiresClause); 222 223 Tokens = 224 annotate("void Class::member() && requires(Namespace::Constant<T>) {}"); 225 ASSERT_EQ(Tokens.size(), 19u) << Tokens; 226 EXPECT_TOKEN(Tokens[7], tok::kw_requires, TT_RequiresClause); 227 228 Tokens = annotate("void Class::member() && requires(typename " 229 "Namespace::Outer<T>::Inner::Constant) {}"); 230 ASSERT_EQ(Tokens.size(), 24u) << Tokens; 231 EXPECT_TOKEN(Tokens[7], tok::kw_requires, TT_RequiresClause); 232 233 Tokens = annotate("struct [[nodiscard]] zero_t {\n" 234 " template<class T>\n" 235 " requires requires { number_zero_v<T>; }\n" 236 " [[nodiscard]] constexpr operator T() const { " 237 "return number_zero_v<T>; }\n" 238 "};"); 239 ASSERT_EQ(Tokens.size(), 44u); 240 EXPECT_TOKEN(Tokens[13], tok::kw_requires, TT_RequiresClause); 241 EXPECT_TOKEN(Tokens[14], tok::kw_requires, TT_RequiresExpression); 242 EXPECT_TOKEN(Tokens[15], tok::l_brace, TT_RequiresExpressionLBrace); 243 EXPECT_TOKEN(Tokens[21], tok::r_brace, TT_Unknown); 244 EXPECT_EQ(Tokens[21]->MatchingParen, Tokens[15]); 245 EXPECT_TRUE(Tokens[21]->ClosesRequiresClause); 246 } 247 248 TEST_F(TokenAnnotatorTest, UnderstandsRequiresExpressions) { 249 auto Tokens = annotate("bool b = requires(int i) { i + 5; };"); 250 ASSERT_EQ(Tokens.size(), 16u) << Tokens; 251 EXPECT_TOKEN(Tokens[3], tok::kw_requires, TT_RequiresExpression); 252 EXPECT_TOKEN(Tokens[4], tok::l_paren, TT_RequiresExpressionLParen); 253 EXPECT_TOKEN(Tokens[8], tok::l_brace, TT_RequiresExpressionLBrace); 254 255 Tokens = annotate("if (requires(int i) { i + 5; }) return;"); 256 ASSERT_EQ(Tokens.size(), 17u) << Tokens; 257 EXPECT_TOKEN(Tokens[2], tok::kw_requires, TT_RequiresExpression); 258 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_RequiresExpressionLParen); 259 EXPECT_TOKEN(Tokens[7], tok::l_brace, TT_RequiresExpressionLBrace); 260 261 Tokens = annotate("if (func() && requires(int i) { i + 5; }) return;"); 262 ASSERT_EQ(Tokens.size(), 21u) << Tokens; 263 EXPECT_TOKEN(Tokens[6], tok::kw_requires, TT_RequiresExpression); 264 EXPECT_TOKEN(Tokens[7], tok::l_paren, TT_RequiresExpressionLParen); 265 EXPECT_TOKEN(Tokens[11], tok::l_brace, TT_RequiresExpressionLBrace); 266 267 Tokens = annotate("foo(requires(const T t) {});"); 268 ASSERT_EQ(Tokens.size(), 13u) << Tokens; 269 EXPECT_TOKEN(Tokens[2], tok::kw_requires, TT_RequiresExpression); 270 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_RequiresExpressionLParen); 271 EXPECT_TOKEN(Tokens[8], tok::l_brace, TT_RequiresExpressionLBrace); 272 273 Tokens = annotate("foo(requires(const int t) {});"); 274 ASSERT_EQ(Tokens.size(), 13u) << Tokens; 275 EXPECT_TOKEN(Tokens[2], tok::kw_requires, TT_RequiresExpression); 276 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_RequiresExpressionLParen); 277 EXPECT_TOKEN(Tokens[8], tok::l_brace, TT_RequiresExpressionLBrace); 278 279 Tokens = annotate("foo(requires(const T t) {});"); 280 ASSERT_EQ(Tokens.size(), 13u) << Tokens; 281 EXPECT_TOKEN(Tokens[2], tok::kw_requires, TT_RequiresExpression); 282 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_RequiresExpressionLParen); 283 EXPECT_TOKEN(Tokens[8], tok::l_brace, TT_RequiresExpressionLBrace); 284 285 Tokens = annotate("foo(requires(int const* volatile t) {});"); 286 ASSERT_EQ(Tokens.size(), 15u) << Tokens; 287 EXPECT_TOKEN(Tokens[2], tok::kw_requires, TT_RequiresExpression); 288 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_RequiresExpressionLParen); 289 EXPECT_TOKEN(Tokens[10], tok::l_brace, TT_RequiresExpressionLBrace); 290 291 Tokens = annotate("foo(requires(T const* volatile t) {});"); 292 ASSERT_EQ(Tokens.size(), 15u) << Tokens; 293 EXPECT_TOKEN(Tokens[2], tok::kw_requires, TT_RequiresExpression); 294 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_RequiresExpressionLParen); 295 EXPECT_TOKEN(Tokens[10], tok::l_brace, TT_RequiresExpressionLBrace); 296 297 Tokens = 298 annotate("foo(requires(const typename Outer<T>::Inner * const t) {});"); 299 ASSERT_EQ(Tokens.size(), 21u) << Tokens; 300 EXPECT_TOKEN(Tokens[2], tok::kw_requires, TT_RequiresExpression); 301 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_RequiresExpressionLParen); 302 EXPECT_TOKEN(Tokens[16], tok::l_brace, TT_RequiresExpressionLBrace); 303 304 Tokens = annotate("template <typename T>\n" 305 "concept C = requires(T T) {\n" 306 " requires Bar<T> && Foo<T>;\n" 307 "};"); 308 ASSERT_EQ(Tokens.size(), 28u) << Tokens; 309 EXPECT_TOKEN(Tokens[8], tok::kw_requires, TT_RequiresExpression); 310 EXPECT_TOKEN(Tokens[9], tok::l_paren, TT_RequiresExpressionLParen); 311 EXPECT_TOKEN(Tokens[13], tok::l_brace, TT_RequiresExpressionLBrace); 312 EXPECT_TOKEN(Tokens[14], tok::kw_requires, 313 TT_RequiresClauseInARequiresExpression); 314 315 Tokens = annotate("template <typename T>\n" 316 "concept C = requires(T T) {\n" 317 " { t.func() } -> std::same_as<int>;" 318 " requires Bar<T> && Foo<T>;\n" 319 "};"); 320 ASSERT_EQ(Tokens.size(), 43u) << Tokens; 321 EXPECT_TOKEN(Tokens[8], tok::kw_requires, TT_RequiresExpression); 322 EXPECT_TOKEN(Tokens[9], tok::l_paren, TT_RequiresExpressionLParen); 323 EXPECT_TOKEN(Tokens[13], tok::l_brace, TT_RequiresExpressionLBrace); 324 EXPECT_TOKEN(Tokens[29], tok::kw_requires, 325 TT_RequiresClauseInARequiresExpression); 326 } 327 328 TEST_F(TokenAnnotatorTest, RequiresDoesNotChangeParsingOfTheRest) { 329 auto NumberOfAdditionalRequiresClauseTokens = 5u; 330 auto NumberOfTokensBeforeRequires = 5u; 331 332 auto BaseTokens = annotate("template<typename T>\n" 333 "T Pi = 3.14;"); 334 auto ConstrainedTokens = annotate("template<typename T>\n" 335 " requires Foo<T>\n" 336 "T Pi = 3.14;"); 337 338 auto NumberOfBaseTokens = 11u; 339 340 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 341 ASSERT_EQ(ConstrainedTokens.size(), 342 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 343 << ConstrainedTokens; 344 345 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 346 if (I < NumberOfTokensBeforeRequires) 347 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 348 else 349 EXPECT_EQ(*BaseTokens[I], 350 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 351 << I; 352 353 BaseTokens = annotate("template<typename T>\n" 354 "struct Bar;"); 355 ConstrainedTokens = annotate("template<typename T>\n" 356 " requires Foo<T>\n" 357 "struct Bar;"); 358 NumberOfBaseTokens = 9u; 359 360 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 361 ASSERT_EQ(ConstrainedTokens.size(), 362 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 363 << ConstrainedTokens; 364 365 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 366 if (I < NumberOfTokensBeforeRequires) 367 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 368 else 369 EXPECT_EQ(*BaseTokens[I], 370 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 371 << I; 372 373 BaseTokens = annotate("template<typename T>\n" 374 "struct Bar {" 375 " T foo();\n" 376 " T bar();\n" 377 "};"); 378 ConstrainedTokens = annotate("template<typename T>\n" 379 " requires Foo<T>\n" 380 "struct Bar {" 381 " T foo();\n" 382 " T bar();\n" 383 "};"); 384 NumberOfBaseTokens = 21u; 385 386 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 387 ASSERT_EQ(ConstrainedTokens.size(), 388 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 389 << ConstrainedTokens; 390 391 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 392 if (I < NumberOfTokensBeforeRequires) 393 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 394 else 395 EXPECT_EQ(*BaseTokens[I], 396 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 397 << I; 398 399 BaseTokens = annotate("template<typename T>\n" 400 "Bar(T) -> Bar<T>;"); 401 ConstrainedTokens = annotate("template<typename T>\n" 402 " requires Foo<T>\n" 403 "Bar(T) -> Bar<T>;"); 404 NumberOfBaseTokens = 16u; 405 406 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 407 ASSERT_EQ(ConstrainedTokens.size(), 408 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 409 << ConstrainedTokens; 410 411 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 412 if (I < NumberOfTokensBeforeRequires) 413 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 414 else 415 EXPECT_EQ(*BaseTokens[I], 416 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 417 << I; 418 419 BaseTokens = annotate("template<typename T>\n" 420 "T foo();"); 421 ConstrainedTokens = annotate("template<typename T>\n" 422 " requires Foo<T>\n" 423 "T foo();"); 424 NumberOfBaseTokens = 11u; 425 426 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 427 ASSERT_EQ(ConstrainedTokens.size(), 428 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 429 << ConstrainedTokens; 430 431 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 432 if (I < NumberOfTokensBeforeRequires) 433 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 434 else 435 EXPECT_EQ(*BaseTokens[I], 436 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 437 << I; 438 439 BaseTokens = annotate("template<typename T>\n" 440 "T foo() {\n" 441 " auto bar = baz();\n" 442 " return bar + T{};\n" 443 "}"); 444 ConstrainedTokens = annotate("template<typename T>\n" 445 " requires Foo<T>\n" 446 "T foo() {\n" 447 " auto bar = baz();\n" 448 " return bar + T{};\n" 449 "}"); 450 NumberOfBaseTokens = 26u; 451 452 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 453 ASSERT_EQ(ConstrainedTokens.size(), 454 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 455 << ConstrainedTokens; 456 457 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 458 if (I < NumberOfTokensBeforeRequires) 459 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 460 else 461 EXPECT_EQ(*BaseTokens[I], 462 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 463 << I; 464 465 BaseTokens = annotate("template<typename T>\n" 466 "T foo();"); 467 ConstrainedTokens = annotate("template<typename T>\n" 468 "T foo() requires Foo<T>;"); 469 NumberOfBaseTokens = 11u; 470 NumberOfTokensBeforeRequires = 9u; 471 472 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 473 ASSERT_EQ(ConstrainedTokens.size(), 474 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 475 << ConstrainedTokens; 476 477 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 478 if (I < NumberOfTokensBeforeRequires) 479 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 480 else 481 EXPECT_EQ(*BaseTokens[I], 482 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 483 << I; 484 485 BaseTokens = annotate("template<typename T>\n" 486 "T foo() {\n" 487 " auto bar = baz();\n" 488 " return bar + T{};\n" 489 "}"); 490 ConstrainedTokens = annotate("template<typename T>\n" 491 "T foo() requires Foo<T> {\n" 492 " auto bar = baz();\n" 493 " return bar + T{};\n" 494 "}"); 495 NumberOfBaseTokens = 26u; 496 497 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 498 ASSERT_EQ(ConstrainedTokens.size(), 499 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 500 << ConstrainedTokens; 501 502 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 503 if (I < NumberOfTokensBeforeRequires) 504 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 505 else 506 EXPECT_EQ(*BaseTokens[I], 507 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 508 << I; 509 510 BaseTokens = annotate("template<typename T>\n" 511 "Bar(T) -> Bar<typename T::I>;"); 512 ConstrainedTokens = annotate("template<typename T>\n" 513 " requires requires(T &&t) {\n" 514 " typename T::I;\n" 515 " }\n" 516 "Bar(T) -> Bar<typename T::I>;"); 517 NumberOfBaseTokens = 19u; 518 NumberOfAdditionalRequiresClauseTokens = 14u; 519 NumberOfTokensBeforeRequires = 5u; 520 521 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 522 ASSERT_EQ(ConstrainedTokens.size(), 523 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 524 << ConstrainedTokens; 525 526 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 527 if (I < NumberOfTokensBeforeRequires) 528 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 529 else 530 EXPECT_EQ(*BaseTokens[I], 531 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 532 << I; 533 534 BaseTokens = annotate("struct [[nodiscard]] zero_t {\n" 535 " template<class T>\n" 536 " [[nodiscard]] constexpr operator T() const { " 537 "return number_zero_v<T>; }\n" 538 "};"); 539 540 ConstrainedTokens = annotate("struct [[nodiscard]] zero_t {\n" 541 " template<class T>\n" 542 " requires requires { number_zero_v<T>; }\n" 543 " [[nodiscard]] constexpr operator T() const { " 544 "return number_zero_v<T>; }\n" 545 "};"); 546 NumberOfBaseTokens = 35u; 547 NumberOfAdditionalRequiresClauseTokens = 9u; 548 NumberOfTokensBeforeRequires = 13u; 549 550 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 551 ASSERT_EQ(ConstrainedTokens.size(), 552 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 553 << ConstrainedTokens; 554 555 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 556 if (I < NumberOfTokensBeforeRequires) 557 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 558 else 559 EXPECT_EQ(*BaseTokens[I], 560 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 561 << I; 562 } 563 564 } // namespace 565 } // namespace format 566 } // namespace clang 567