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, UnderstandsUsesOfStarAndAmpInMacroDefinition) { 48 // This is a regression test for mis-parsing the & after decltype as a binary 49 // operator instead of a reference (when inside a macro definition). 50 auto Tokens = annotate("auto x = [](const decltype(x) &ptr) {};"); 51 EXPECT_EQ(Tokens.size(), 18u) << Tokens; 52 EXPECT_TOKEN(Tokens[7], tok::kw_decltype, TT_Unknown); 53 EXPECT_TOKEN(Tokens[8], tok::l_paren, TT_TypeDeclarationParen); 54 EXPECT_TOKEN(Tokens[9], tok::identifier, TT_Unknown); 55 EXPECT_TOKEN(Tokens[10], tok::r_paren, TT_TypeDeclarationParen); 56 EXPECT_TOKEN(Tokens[11], tok::amp, TT_PointerOrReference); 57 // Same again with * instead of &: 58 Tokens = annotate("auto x = [](const decltype(x) *ptr) {};"); 59 EXPECT_EQ(Tokens.size(), 18u) << Tokens; 60 EXPECT_TOKEN(Tokens[10], tok::r_paren, TT_TypeDeclarationParen); 61 EXPECT_TOKEN(Tokens[11], tok::star, TT_PointerOrReference); 62 63 // Also check that we parse correctly within a macro definition: 64 Tokens = annotate("#define lambda [](const decltype(x) &ptr) {}"); 65 EXPECT_EQ(Tokens.size(), 17u) << Tokens; 66 EXPECT_TOKEN(Tokens[7], tok::kw_decltype, TT_Unknown); 67 EXPECT_TOKEN(Tokens[8], tok::l_paren, TT_TypeDeclarationParen); 68 EXPECT_TOKEN(Tokens[9], tok::identifier, TT_Unknown); 69 EXPECT_TOKEN(Tokens[10], tok::r_paren, TT_TypeDeclarationParen); 70 EXPECT_TOKEN(Tokens[11], tok::amp, TT_PointerOrReference); 71 // Same again with * instead of &: 72 Tokens = annotate("#define lambda [](const decltype(x) *ptr) {}"); 73 EXPECT_EQ(Tokens.size(), 17u) << Tokens; 74 EXPECT_TOKEN(Tokens[10], tok::r_paren, TT_TypeDeclarationParen); 75 EXPECT_TOKEN(Tokens[11], tok::star, TT_PointerOrReference); 76 } 77 78 TEST_F(TokenAnnotatorTest, UnderstandsClasses) { 79 auto Tokens = annotate("class C {};"); 80 EXPECT_EQ(Tokens.size(), 6u) << Tokens; 81 EXPECT_TOKEN(Tokens[2], tok::l_brace, TT_RecordLBrace); 82 } 83 84 TEST_F(TokenAnnotatorTest, UnderstandsStructs) { 85 auto Tokens = annotate("struct S {};"); 86 EXPECT_EQ(Tokens.size(), 6u) << Tokens; 87 EXPECT_TOKEN(Tokens[2], tok::l_brace, TT_RecordLBrace); 88 } 89 90 TEST_F(TokenAnnotatorTest, UnderstandsUnions) { 91 auto Tokens = annotate("union U {};"); 92 EXPECT_EQ(Tokens.size(), 6u) << Tokens; 93 EXPECT_TOKEN(Tokens[2], tok::l_brace, TT_RecordLBrace); 94 } 95 96 TEST_F(TokenAnnotatorTest, UnderstandsEnums) { 97 auto Tokens = annotate("enum E {};"); 98 EXPECT_EQ(Tokens.size(), 6u) << Tokens; 99 EXPECT_TOKEN(Tokens[2], tok::l_brace, TT_RecordLBrace); 100 } 101 102 TEST_F(TokenAnnotatorTest, UnderstandsLBracesInMacroDefinition) { 103 auto Tokens = annotate("#define BEGIN NS {"); 104 EXPECT_EQ(Tokens.size(), 6u) << Tokens; 105 EXPECT_TOKEN(Tokens[4], tok::l_brace, TT_Unknown); 106 } 107 108 TEST_F(TokenAnnotatorTest, UnderstandsDelete) { 109 auto Tokens = annotate("delete (void *)p;"); 110 EXPECT_EQ(Tokens.size(), 8u) << Tokens; 111 EXPECT_TOKEN(Tokens[4], tok::r_paren, TT_CastRParen); 112 113 Tokens = annotate("delete[] (void *)p;"); 114 EXPECT_EQ(Tokens.size(), 10u) << Tokens; 115 EXPECT_TOKEN(Tokens[6], tok::r_paren, TT_CastRParen); 116 117 Tokens = annotate("delete[] /*comment*/ (void *)p;"); 118 EXPECT_EQ(Tokens.size(), 11u) << Tokens; 119 EXPECT_TOKEN(Tokens[7], tok::r_paren, TT_CastRParen); 120 121 Tokens = annotate("delete[/*comment*/] (void *)p;"); 122 EXPECT_EQ(Tokens.size(), 11u) << Tokens; 123 EXPECT_TOKEN(Tokens[7], tok::r_paren, TT_CastRParen); 124 125 Tokens = annotate("delete/*comment*/[] (void *)p;"); 126 EXPECT_EQ(Tokens.size(), 11u) << Tokens; 127 EXPECT_TOKEN(Tokens[7], tok::r_paren, TT_CastRParen); 128 } 129 130 TEST_F(TokenAnnotatorTest, UnderstandsRequiresClausesAndConcepts) { 131 auto Tokens = annotate("template <typename T>\n" 132 "concept C = (Foo && Bar) && (Bar && Baz);"); 133 134 ASSERT_EQ(Tokens.size(), 21u) << Tokens; 135 EXPECT_TOKEN(Tokens[10], tok::ampamp, TT_BinaryOperator); 136 EXPECT_TOKEN(Tokens[13], tok::ampamp, TT_BinaryOperator); 137 EXPECT_TOKEN(Tokens[16], tok::ampamp, TT_BinaryOperator); 138 139 Tokens = annotate("template <typename T>\n" 140 "concept C = requires(T t) {\n" 141 " { t.foo() };\n" 142 "} && Bar<T> && Baz<T>;"); 143 ASSERT_EQ(Tokens.size(), 35u) << Tokens; 144 EXPECT_TOKEN(Tokens[8], tok::kw_requires, TT_RequiresExpression); 145 EXPECT_TOKEN(Tokens[9], tok::l_paren, TT_RequiresExpressionLParen); 146 EXPECT_TOKEN(Tokens[13], tok::l_brace, TT_RequiresExpressionLBrace); 147 EXPECT_TOKEN(Tokens[23], tok::ampamp, TT_BinaryOperator); 148 EXPECT_TOKEN(Tokens[28], tok::ampamp, TT_BinaryOperator); 149 150 Tokens = annotate("template<typename T>\n" 151 "requires C1<T> && (C21<T> || C22<T> && C2e<T>) && C3<T>\n" 152 "struct Foo;"); 153 ASSERT_EQ(Tokens.size(), 36u) << Tokens; 154 EXPECT_TOKEN(Tokens[5], tok::kw_requires, TT_RequiresClause); 155 EXPECT_TOKEN(Tokens[6], tok::identifier, TT_Unknown); 156 EXPECT_EQ(Tokens[6]->FakeLParens.size(), 1u); 157 EXPECT_TOKEN(Tokens[10], tok::ampamp, TT_BinaryOperator); 158 EXPECT_TOKEN(Tokens[16], tok::pipepipe, TT_BinaryOperator); 159 EXPECT_TOKEN(Tokens[21], tok::ampamp, TT_BinaryOperator); 160 EXPECT_TOKEN(Tokens[27], tok::ampamp, TT_BinaryOperator); 161 EXPECT_TOKEN(Tokens[31], tok::greater, TT_TemplateCloser); 162 EXPECT_EQ(Tokens[31]->FakeRParens, 1u); 163 EXPECT_TRUE(Tokens[31]->ClosesRequiresClause); 164 165 Tokens = 166 annotate("template<typename T>\n" 167 "requires (C1<T> && (C21<T> || C22<T> && C2e<T>) && C3<T>)\n" 168 "struct Foo;"); 169 ASSERT_EQ(Tokens.size(), 38u) << Tokens; 170 EXPECT_TOKEN(Tokens[5], tok::kw_requires, TT_RequiresClause); 171 EXPECT_TOKEN(Tokens[7], tok::identifier, TT_Unknown); 172 EXPECT_EQ(Tokens[7]->FakeLParens.size(), 1u); 173 EXPECT_TOKEN(Tokens[11], tok::ampamp, TT_BinaryOperator); 174 EXPECT_TOKEN(Tokens[17], tok::pipepipe, TT_BinaryOperator); 175 EXPECT_TOKEN(Tokens[22], tok::ampamp, TT_BinaryOperator); 176 EXPECT_TOKEN(Tokens[28], tok::ampamp, TT_BinaryOperator); 177 EXPECT_TOKEN(Tokens[32], tok::greater, TT_TemplateCloser); 178 EXPECT_EQ(Tokens[32]->FakeRParens, 1u); 179 EXPECT_TOKEN(Tokens[33], tok::r_paren, TT_Unknown); 180 EXPECT_TRUE(Tokens[33]->ClosesRequiresClause); 181 182 Tokens = annotate("template <typename T>\n" 183 "void foo(T) noexcept requires Bar<T>;"); 184 ASSERT_EQ(Tokens.size(), 18u) << Tokens; 185 EXPECT_TOKEN(Tokens[11], tok::kw_requires, TT_RequiresClause); 186 187 Tokens = annotate("template <typename T>\n" 188 "struct S {\n" 189 " void foo() const requires Bar<T>;\n" 190 " void bar() const & requires Baz<T>;\n" 191 " void bar() && requires Baz2<T>;\n" 192 " void baz() const & noexcept requires Baz<T>;\n" 193 " void baz() && noexcept requires Baz2<T>;\n" 194 "};\n" 195 "\n" 196 "void S::bar() const & requires Baz<T> { }"); 197 ASSERT_EQ(Tokens.size(), 85u) << Tokens; 198 EXPECT_TOKEN(Tokens[13], tok::kw_requires, TT_RequiresClause); 199 EXPECT_TOKEN(Tokens[25], tok::kw_requires, TT_RequiresClause); 200 EXPECT_TOKEN(Tokens[36], tok::kw_requires, TT_RequiresClause); 201 EXPECT_TOKEN(Tokens[49], tok::kw_requires, TT_RequiresClause); 202 EXPECT_TOKEN(Tokens[61], tok::kw_requires, TT_RequiresClause); 203 EXPECT_TOKEN(Tokens[77], tok::kw_requires, TT_RequiresClause); 204 205 Tokens = annotate("void Class::member() && requires(Constant) {}"); 206 ASSERT_EQ(Tokens.size(), 14u) << Tokens; 207 EXPECT_TOKEN(Tokens[7], tok::kw_requires, TT_RequiresClause); 208 209 Tokens = annotate("void Class::member() && requires(Constant<T>) {}"); 210 ASSERT_EQ(Tokens.size(), 17u) << Tokens; 211 EXPECT_TOKEN(Tokens[7], tok::kw_requires, TT_RequiresClause); 212 213 Tokens = 214 annotate("void Class::member() && requires(Namespace::Constant<T>) {}"); 215 ASSERT_EQ(Tokens.size(), 19u) << Tokens; 216 EXPECT_TOKEN(Tokens[7], tok::kw_requires, TT_RequiresClause); 217 218 Tokens = annotate("void Class::member() && requires(typename " 219 "Namespace::Outer<T>::Inner::Constant) {}"); 220 ASSERT_EQ(Tokens.size(), 24u) << Tokens; 221 EXPECT_TOKEN(Tokens[7], tok::kw_requires, TT_RequiresClause); 222 } 223 224 TEST_F(TokenAnnotatorTest, UnderstandsRequiresExpressions) { 225 auto Tokens = annotate("bool b = requires(int i) { i + 5; };"); 226 ASSERT_EQ(Tokens.size(), 16u) << Tokens; 227 EXPECT_TOKEN(Tokens[3], tok::kw_requires, TT_RequiresExpression); 228 EXPECT_TOKEN(Tokens[4], tok::l_paren, TT_RequiresExpressionLParen); 229 EXPECT_TOKEN(Tokens[8], tok::l_brace, TT_RequiresExpressionLBrace); 230 231 Tokens = annotate("if (requires(int i) { i + 5; }) return;"); 232 ASSERT_EQ(Tokens.size(), 17u) << Tokens; 233 EXPECT_TOKEN(Tokens[2], tok::kw_requires, TT_RequiresExpression); 234 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_RequiresExpressionLParen); 235 EXPECT_TOKEN(Tokens[7], tok::l_brace, TT_RequiresExpressionLBrace); 236 237 Tokens = annotate("if (func() && requires(int i) { i + 5; }) return;"); 238 ASSERT_EQ(Tokens.size(), 21u) << Tokens; 239 EXPECT_TOKEN(Tokens[6], tok::kw_requires, TT_RequiresExpression); 240 EXPECT_TOKEN(Tokens[7], tok::l_paren, TT_RequiresExpressionLParen); 241 EXPECT_TOKEN(Tokens[11], tok::l_brace, TT_RequiresExpressionLBrace); 242 243 Tokens = annotate("foo(requires(const T t) {});"); 244 ASSERT_EQ(Tokens.size(), 13u) << Tokens; 245 EXPECT_TOKEN(Tokens[2], tok::kw_requires, TT_RequiresExpression); 246 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_RequiresExpressionLParen); 247 EXPECT_TOKEN(Tokens[8], tok::l_brace, TT_RequiresExpressionLBrace); 248 249 Tokens = annotate("foo(requires(const int t) {});"); 250 ASSERT_EQ(Tokens.size(), 13u) << Tokens; 251 EXPECT_TOKEN(Tokens[2], tok::kw_requires, TT_RequiresExpression); 252 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_RequiresExpressionLParen); 253 EXPECT_TOKEN(Tokens[8], tok::l_brace, TT_RequiresExpressionLBrace); 254 255 Tokens = annotate("foo(requires(const T t) {});"); 256 ASSERT_EQ(Tokens.size(), 13u) << 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[8], tok::l_brace, TT_RequiresExpressionLBrace); 260 261 Tokens = annotate("foo(requires(int const* volatile t) {});"); 262 ASSERT_EQ(Tokens.size(), 15u) << Tokens; 263 EXPECT_TOKEN(Tokens[2], tok::kw_requires, TT_RequiresExpression); 264 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_RequiresExpressionLParen); 265 EXPECT_TOKEN(Tokens[10], tok::l_brace, TT_RequiresExpressionLBrace); 266 267 Tokens = annotate("foo(requires(T const* volatile t) {});"); 268 ASSERT_EQ(Tokens.size(), 15u) << 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[10], tok::l_brace, TT_RequiresExpressionLBrace); 272 273 Tokens = 274 annotate("foo(requires(const typename Outer<T>::Inner * const t) {});"); 275 ASSERT_EQ(Tokens.size(), 21u) << Tokens; 276 EXPECT_TOKEN(Tokens[2], tok::kw_requires, TT_RequiresExpression); 277 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_RequiresExpressionLParen); 278 EXPECT_TOKEN(Tokens[16], tok::l_brace, TT_RequiresExpressionLBrace); 279 280 Tokens = annotate("template <typename T>\n" 281 "concept C = requires(T T) {\n" 282 " requires Bar<T> && Foo<T>;\n" 283 "};"); 284 ASSERT_EQ(Tokens.size(), 28u) << Tokens; 285 EXPECT_TOKEN(Tokens[8], tok::kw_requires, TT_RequiresExpression); 286 EXPECT_TOKEN(Tokens[9], tok::l_paren, TT_RequiresExpressionLParen); 287 EXPECT_TOKEN(Tokens[13], tok::l_brace, TT_RequiresExpressionLBrace); 288 EXPECT_TOKEN(Tokens[14], tok::kw_requires, 289 TT_RequiresClauseInARequiresExpression); 290 291 Tokens = annotate("template <typename T>\n" 292 "concept C = requires(T T) {\n" 293 " { t.func() } -> std::same_as<int>;" 294 " requires Bar<T> && Foo<T>;\n" 295 "};"); 296 ASSERT_EQ(Tokens.size(), 43u) << Tokens; 297 EXPECT_TOKEN(Tokens[8], tok::kw_requires, TT_RequiresExpression); 298 EXPECT_TOKEN(Tokens[9], tok::l_paren, TT_RequiresExpressionLParen); 299 EXPECT_TOKEN(Tokens[13], tok::l_brace, TT_RequiresExpressionLBrace); 300 EXPECT_TOKEN(Tokens[29], tok::kw_requires, 301 TT_RequiresClauseInARequiresExpression); 302 } 303 304 TEST_F(TokenAnnotatorTest, RequiresDoesNotChangeParsingOfTheRest) { 305 auto NumberOfAdditionalRequiresClauseTokens = 5u; 306 auto NumberOfTokensBeforeRequires = 5u; 307 308 auto BaseTokens = annotate("template<typename T>\n" 309 "T Pi = 3.14;"); 310 auto ConstrainedTokens = annotate("template<typename T>\n" 311 " requires Foo<T>\n" 312 "T Pi = 3.14;"); 313 314 auto NumberOfBaseTokens = 11u; 315 316 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 317 ASSERT_EQ(ConstrainedTokens.size(), 318 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 319 << ConstrainedTokens; 320 321 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 322 if (I < NumberOfTokensBeforeRequires) 323 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 324 else 325 EXPECT_EQ(*BaseTokens[I], 326 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 327 << I; 328 329 BaseTokens = annotate("template<typename T>\n" 330 "struct Bar;"); 331 ConstrainedTokens = annotate("template<typename T>\n" 332 " requires Foo<T>\n" 333 "struct Bar;"); 334 NumberOfBaseTokens = 9u; 335 336 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 337 ASSERT_EQ(ConstrainedTokens.size(), 338 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 339 << ConstrainedTokens; 340 341 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 342 if (I < NumberOfTokensBeforeRequires) 343 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 344 else 345 EXPECT_EQ(*BaseTokens[I], 346 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 347 << I; 348 349 BaseTokens = annotate("template<typename T>\n" 350 "struct Bar {" 351 " T foo();\n" 352 " T bar();\n" 353 "};"); 354 ConstrainedTokens = annotate("template<typename T>\n" 355 " requires Foo<T>\n" 356 "struct Bar {" 357 " T foo();\n" 358 " T bar();\n" 359 "};"); 360 NumberOfBaseTokens = 21u; 361 362 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 363 ASSERT_EQ(ConstrainedTokens.size(), 364 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 365 << ConstrainedTokens; 366 367 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 368 if (I < NumberOfTokensBeforeRequires) 369 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 370 else 371 EXPECT_EQ(*BaseTokens[I], 372 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 373 << I; 374 375 BaseTokens = annotate("template<typename T>\n" 376 "Bar(T) -> Bar<T>;"); 377 ConstrainedTokens = annotate("template<typename T>\n" 378 " requires Foo<T>\n" 379 "Bar(T) -> Bar<T>;"); 380 NumberOfBaseTokens = 16u; 381 382 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 383 ASSERT_EQ(ConstrainedTokens.size(), 384 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 385 << ConstrainedTokens; 386 387 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 388 if (I < NumberOfTokensBeforeRequires) 389 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 390 else 391 EXPECT_EQ(*BaseTokens[I], 392 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 393 << I; 394 395 BaseTokens = annotate("template<typename T>\n" 396 "T foo();"); 397 ConstrainedTokens = annotate("template<typename T>\n" 398 " requires Foo<T>\n" 399 "T foo();"); 400 NumberOfBaseTokens = 11u; 401 402 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 403 ASSERT_EQ(ConstrainedTokens.size(), 404 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 405 << ConstrainedTokens; 406 407 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 408 if (I < NumberOfTokensBeforeRequires) 409 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 410 else 411 EXPECT_EQ(*BaseTokens[I], 412 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 413 << I; 414 415 BaseTokens = annotate("template<typename T>\n" 416 "T foo() {\n" 417 " auto bar = baz();\n" 418 " return bar + T{};\n" 419 "}"); 420 ConstrainedTokens = annotate("template<typename T>\n" 421 " requires Foo<T>\n" 422 "T foo() {\n" 423 " auto bar = baz();\n" 424 " return bar + T{};\n" 425 "}"); 426 NumberOfBaseTokens = 26u; 427 428 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 429 ASSERT_EQ(ConstrainedTokens.size(), 430 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 431 << ConstrainedTokens; 432 433 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 434 if (I < NumberOfTokensBeforeRequires) 435 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 436 else 437 EXPECT_EQ(*BaseTokens[I], 438 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 439 << I; 440 441 BaseTokens = annotate("template<typename T>\n" 442 "T foo();"); 443 ConstrainedTokens = annotate("template<typename T>\n" 444 "T foo() requires Foo<T>;"); 445 NumberOfBaseTokens = 11u; 446 NumberOfTokensBeforeRequires = 9u; 447 448 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 449 ASSERT_EQ(ConstrainedTokens.size(), 450 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 451 << ConstrainedTokens; 452 453 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 454 if (I < NumberOfTokensBeforeRequires) 455 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 456 else 457 EXPECT_EQ(*BaseTokens[I], 458 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 459 << I; 460 461 BaseTokens = annotate("template<typename T>\n" 462 "T foo() {\n" 463 " auto bar = baz();\n" 464 " return bar + T{};\n" 465 "}"); 466 ConstrainedTokens = annotate("template<typename T>\n" 467 "T foo() requires Foo<T> {\n" 468 " auto bar = baz();\n" 469 " return bar + T{};\n" 470 "}"); 471 NumberOfBaseTokens = 26u; 472 473 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 474 ASSERT_EQ(ConstrainedTokens.size(), 475 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 476 << ConstrainedTokens; 477 478 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 479 if (I < NumberOfTokensBeforeRequires) 480 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 481 else 482 EXPECT_EQ(*BaseTokens[I], 483 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 484 << I; 485 486 BaseTokens = annotate("template<typename T>\n" 487 "Bar(T) -> Bar<typename T::I>;"); 488 ConstrainedTokens = annotate("template<typename T>\n" 489 " requires requires(T &&t) {\n" 490 " typename T::I;\n" 491 " }\n" 492 "Bar(T) -> Bar<typename T::I>;"); 493 NumberOfBaseTokens = 19u; 494 NumberOfAdditionalRequiresClauseTokens = 14u; 495 NumberOfTokensBeforeRequires = 5u; 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 511 } // namespace 512 } // namespace format 513 } // namespace clang 514