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 // Invalid Code, but we don't want to crash. See http://llvm.org/PR54350. 336 Tokens = annotate("bool r10 = requires (struct new_struct { int x; } s) { " 337 "requires true; };"); 338 ASSERT_EQ(Tokens.size(), 21u) << Tokens; 339 EXPECT_TOKEN(Tokens[3], tok::kw_requires, TT_RequiresExpression); 340 EXPECT_TOKEN(Tokens[4], tok::l_paren, TT_RequiresExpressionLParen); 341 EXPECT_TOKEN(Tokens[14], tok::l_brace, TT_RequiresExpressionLBrace); 342 } 343 344 TEST_F(TokenAnnotatorTest, RequiresDoesNotChangeParsingOfTheRest) { 345 auto NumberOfAdditionalRequiresClauseTokens = 5u; 346 auto NumberOfTokensBeforeRequires = 5u; 347 348 auto BaseTokens = annotate("template<typename T>\n" 349 "T Pi = 3.14;"); 350 auto ConstrainedTokens = annotate("template<typename T>\n" 351 " requires Foo<T>\n" 352 "T Pi = 3.14;"); 353 354 auto NumberOfBaseTokens = 11u; 355 356 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 357 ASSERT_EQ(ConstrainedTokens.size(), 358 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 359 << ConstrainedTokens; 360 361 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 362 if (I < NumberOfTokensBeforeRequires) 363 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 364 else 365 EXPECT_EQ(*BaseTokens[I], 366 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 367 << I; 368 369 BaseTokens = annotate("template<typename T>\n" 370 "struct Bar;"); 371 ConstrainedTokens = annotate("template<typename T>\n" 372 " requires Foo<T>\n" 373 "struct Bar;"); 374 NumberOfBaseTokens = 9u; 375 376 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 377 ASSERT_EQ(ConstrainedTokens.size(), 378 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 379 << ConstrainedTokens; 380 381 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 382 if (I < NumberOfTokensBeforeRequires) 383 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 384 else 385 EXPECT_EQ(*BaseTokens[I], 386 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 387 << I; 388 389 BaseTokens = annotate("template<typename T>\n" 390 "struct Bar {" 391 " T foo();\n" 392 " T bar();\n" 393 "};"); 394 ConstrainedTokens = annotate("template<typename T>\n" 395 " requires Foo<T>\n" 396 "struct Bar {" 397 " T foo();\n" 398 " T bar();\n" 399 "};"); 400 NumberOfBaseTokens = 21u; 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 "Bar(T) -> Bar<T>;"); 417 ConstrainedTokens = annotate("template<typename T>\n" 418 " requires Foo<T>\n" 419 "Bar(T) -> Bar<T>;"); 420 NumberOfBaseTokens = 16u; 421 422 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 423 ASSERT_EQ(ConstrainedTokens.size(), 424 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 425 << ConstrainedTokens; 426 427 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 428 if (I < NumberOfTokensBeforeRequires) 429 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 430 else 431 EXPECT_EQ(*BaseTokens[I], 432 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 433 << I; 434 435 BaseTokens = annotate("template<typename T>\n" 436 "T foo();"); 437 ConstrainedTokens = annotate("template<typename T>\n" 438 " requires Foo<T>\n" 439 "T foo();"); 440 NumberOfBaseTokens = 11u; 441 442 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 443 ASSERT_EQ(ConstrainedTokens.size(), 444 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 445 << ConstrainedTokens; 446 447 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 448 if (I < NumberOfTokensBeforeRequires) 449 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 450 else 451 EXPECT_EQ(*BaseTokens[I], 452 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 453 << I; 454 455 BaseTokens = annotate("template<typename T>\n" 456 "T foo() {\n" 457 " auto bar = baz();\n" 458 " return bar + T{};\n" 459 "}"); 460 ConstrainedTokens = annotate("template<typename T>\n" 461 " requires Foo<T>\n" 462 "T foo() {\n" 463 " auto bar = baz();\n" 464 " return bar + T{};\n" 465 "}"); 466 NumberOfBaseTokens = 26u; 467 468 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 469 ASSERT_EQ(ConstrainedTokens.size(), 470 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 471 << ConstrainedTokens; 472 473 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 474 if (I < NumberOfTokensBeforeRequires) 475 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 476 else 477 EXPECT_EQ(*BaseTokens[I], 478 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 479 << I; 480 481 BaseTokens = annotate("template<typename T>\n" 482 "T foo();"); 483 ConstrainedTokens = annotate("template<typename T>\n" 484 "T foo() requires Foo<T>;"); 485 NumberOfBaseTokens = 11u; 486 NumberOfTokensBeforeRequires = 9u; 487 488 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 489 ASSERT_EQ(ConstrainedTokens.size(), 490 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 491 << ConstrainedTokens; 492 493 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 494 if (I < NumberOfTokensBeforeRequires) 495 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 496 else 497 EXPECT_EQ(*BaseTokens[I], 498 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 499 << I; 500 501 BaseTokens = annotate("template<typename T>\n" 502 "T foo() {\n" 503 " auto bar = baz();\n" 504 " return bar + T{};\n" 505 "}"); 506 ConstrainedTokens = annotate("template<typename T>\n" 507 "T foo() requires Foo<T> {\n" 508 " auto bar = baz();\n" 509 " return bar + T{};\n" 510 "}"); 511 NumberOfBaseTokens = 26u; 512 513 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 514 ASSERT_EQ(ConstrainedTokens.size(), 515 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 516 << ConstrainedTokens; 517 518 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 519 if (I < NumberOfTokensBeforeRequires) 520 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 521 else 522 EXPECT_EQ(*BaseTokens[I], 523 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 524 << I; 525 526 BaseTokens = annotate("template<typename T>\n" 527 "Bar(T) -> Bar<typename T::I>;"); 528 ConstrainedTokens = annotate("template<typename T>\n" 529 " requires requires(T &&t) {\n" 530 " typename T::I;\n" 531 " }\n" 532 "Bar(T) -> Bar<typename T::I>;"); 533 NumberOfBaseTokens = 19u; 534 NumberOfAdditionalRequiresClauseTokens = 14u; 535 NumberOfTokensBeforeRequires = 5u; 536 537 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 538 ASSERT_EQ(ConstrainedTokens.size(), 539 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 540 << ConstrainedTokens; 541 542 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 543 if (I < NumberOfTokensBeforeRequires) 544 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 545 else 546 EXPECT_EQ(*BaseTokens[I], 547 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 548 << I; 549 550 BaseTokens = annotate("struct [[nodiscard]] zero_t {\n" 551 " template<class T>\n" 552 " [[nodiscard]] constexpr operator T() const { " 553 "return number_zero_v<T>; }\n" 554 "};"); 555 556 ConstrainedTokens = annotate("struct [[nodiscard]] zero_t {\n" 557 " template<class T>\n" 558 " requires requires { number_zero_v<T>; }\n" 559 " [[nodiscard]] constexpr operator T() const { " 560 "return number_zero_v<T>; }\n" 561 "};"); 562 NumberOfBaseTokens = 35u; 563 NumberOfAdditionalRequiresClauseTokens = 9u; 564 NumberOfTokensBeforeRequires = 13u; 565 566 ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens; 567 ASSERT_EQ(ConstrainedTokens.size(), 568 NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens) 569 << ConstrainedTokens; 570 571 for (auto I = 0u; I < NumberOfBaseTokens; ++I) 572 if (I < NumberOfTokensBeforeRequires) 573 EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I; 574 else 575 EXPECT_EQ(*BaseTokens[I], 576 *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens]) 577 << I; 578 } 579 580 TEST_F(TokenAnnotatorTest, UnderstandsAsm) { 581 auto Tokens = annotate("__asm{\n" 582 "a:\n" 583 "};"); 584 ASSERT_EQ(Tokens.size(), 7u) << Tokens; 585 EXPECT_TOKEN(Tokens[0], tok::kw_asm, TT_Unknown); 586 EXPECT_TOKEN(Tokens[1], tok::l_brace, TT_InlineASMBrace); 587 EXPECT_TOKEN(Tokens[4], tok::r_brace, TT_InlineASMBrace); 588 } 589 590 } // namespace 591 } // namespace format 592 } // namespace clang 593