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