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