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_PRECEDENCE(FormatTok, Prec) \ 42 EXPECT_EQ((FormatTok)->getPrecedence(), Prec) << *(FormatTok) 43 #define EXPECT_TOKEN(FormatTok, Kind, Type) \ 44 do { \ 45 EXPECT_TOKEN_KIND(FormatTok, Kind); \ 46 EXPECT_TOKEN_TYPE(FormatTok, Type); \ 47 } while (false) 48 49 TEST_F(TokenAnnotatorTest, UnderstandsUsesOfStarAndAmp) { 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 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 Tokens = annotate("#define lambda [](const decltype(x) &ptr) {}"); 64 EXPECT_EQ(Tokens.size(), 17u) << Tokens; 65 EXPECT_TOKEN(Tokens[7], tok::kw_decltype, TT_Unknown); 66 EXPECT_TOKEN(Tokens[8], tok::l_paren, TT_TypeDeclarationParen); 67 EXPECT_TOKEN(Tokens[9], tok::identifier, TT_Unknown); 68 EXPECT_TOKEN(Tokens[10], tok::r_paren, TT_TypeDeclarationParen); 69 EXPECT_TOKEN(Tokens[11], tok::amp, TT_PointerOrReference); 70 71 Tokens = annotate("#define lambda [](const decltype(x) *ptr) {}"); 72 EXPECT_EQ(Tokens.size(), 17u) << Tokens; 73 EXPECT_TOKEN(Tokens[10], tok::r_paren, TT_TypeDeclarationParen); 74 EXPECT_TOKEN(Tokens[11], tok::star, TT_PointerOrReference); 75 76 Tokens = annotate("void f() {\n" 77 " while (p < a && *p == 'a')\n" 78 " p++;\n" 79 "}"); 80 EXPECT_EQ(Tokens.size(), 21u) << Tokens; 81 EXPECT_TOKEN(Tokens[10], tok::ampamp, TT_BinaryOperator); 82 EXPECT_TOKEN(Tokens[11], tok::star, TT_UnaryOperator); 83 84 Tokens = annotate("case *x:"); 85 EXPECT_EQ(Tokens.size(), 5u) << Tokens; 86 EXPECT_TOKEN(Tokens[1], tok::star, TT_UnaryOperator); 87 Tokens = annotate("case &x:"); 88 EXPECT_EQ(Tokens.size(), 5u) << Tokens; 89 EXPECT_TOKEN(Tokens[1], tok::amp, TT_UnaryOperator); 90 91 Tokens = annotate("bool b = 3 == int{3} && true;\n"); 92 EXPECT_EQ(Tokens.size(), 13u) << Tokens; 93 EXPECT_TOKEN(Tokens[9], tok::ampamp, TT_BinaryOperator); 94 95 Tokens = annotate("struct {\n" 96 "} *ptr;"); 97 EXPECT_EQ(Tokens.size(), 7u) << Tokens; 98 EXPECT_TOKEN(Tokens[3], tok::star, TT_PointerOrReference); 99 Tokens = annotate("union {\n" 100 "} *ptr;"); 101 EXPECT_EQ(Tokens.size(), 7u) << Tokens; 102 EXPECT_TOKEN(Tokens[3], tok::star, TT_PointerOrReference); 103 Tokens = annotate("class {\n" 104 "} *ptr;"); 105 EXPECT_EQ(Tokens.size(), 7u) << Tokens; 106 EXPECT_TOKEN(Tokens[3], tok::star, TT_PointerOrReference); 107 108 Tokens = annotate("struct {\n" 109 "} &&ptr = {};"); 110 EXPECT_EQ(Tokens.size(), 10u) << Tokens; 111 EXPECT_TOKEN(Tokens[3], tok::ampamp, TT_PointerOrReference); 112 Tokens = annotate("union {\n" 113 "} &&ptr = {};"); 114 EXPECT_EQ(Tokens.size(), 10u) << Tokens; 115 EXPECT_TOKEN(Tokens[3], tok::ampamp, TT_PointerOrReference); 116 Tokens = annotate("class {\n" 117 "} &&ptr = {};"); 118 EXPECT_EQ(Tokens.size(), 10u) << Tokens; 119 EXPECT_TOKEN(Tokens[3], tok::ampamp, TT_PointerOrReference); 120 Tokens = annotate("int i = int{42} * 2;"); 121 EXPECT_EQ(Tokens.size(), 11u) << Tokens; 122 EXPECT_TOKEN(Tokens[7], tok::star, TT_BinaryOperator); 123 124 Tokens = annotate("delete[] *ptr;"); 125 EXPECT_EQ(Tokens.size(), 7u) << Tokens; 126 EXPECT_TOKEN(Tokens[3], tok::star, TT_UnaryOperator); 127 Tokens = annotate("delete[] **ptr;"); 128 EXPECT_EQ(Tokens.size(), 8u) << Tokens; 129 EXPECT_TOKEN(Tokens[3], tok::star, TT_UnaryOperator); 130 EXPECT_TOKEN(Tokens[4], tok::star, TT_UnaryOperator); 131 Tokens = annotate("delete[] *(ptr);"); 132 EXPECT_EQ(Tokens.size(), 9u) << Tokens; 133 EXPECT_TOKEN(Tokens[3], tok::star, TT_UnaryOperator); 134 135 Tokens = annotate("void f() { void (*fnptr)(char* foo); }"); 136 EXPECT_EQ(Tokens.size(), 18u) << Tokens; 137 EXPECT_TOKEN(Tokens[6], tok::l_paren, TT_FunctionTypeLParen); 138 // FIXME: The star of a function pointer probably makes more sense as 139 // TT_PointerOrReference. 140 EXPECT_TOKEN(Tokens[7], tok::star, TT_UnaryOperator); 141 EXPECT_TOKEN(Tokens[12], tok::star, TT_PointerOrReference); 142 143 Tokens = annotate("void f() { void (*fnptr)(t* foo); }"); 144 EXPECT_EQ(Tokens.size(), 18u) << Tokens; 145 EXPECT_TOKEN(Tokens[6], tok::l_paren, TT_FunctionTypeLParen); 146 EXPECT_TOKEN(Tokens[7], tok::star, TT_UnaryOperator); 147 EXPECT_TOKEN(Tokens[12], tok::star, TT_PointerOrReference); 148 149 Tokens = annotate("if (Foo * Bar / Test)"); 150 ASSERT_EQ(Tokens.size(), 9u) << Tokens; 151 EXPECT_TOKEN(Tokens[3], tok::star, TT_BinaryOperator); 152 153 Tokens = annotate("if (Class* obj {getObj()})"); 154 ASSERT_EQ(Tokens.size(), 12u) << Tokens; 155 EXPECT_TOKEN(Tokens[3], tok::star, TT_PointerOrReference); 156 157 Tokens = annotate("if (Foo* Bar = getObj())"); 158 ASSERT_EQ(Tokens.size(), 11u) << Tokens; 159 EXPECT_TOKEN(Tokens[3], tok::star, TT_PointerOrReference); 160 161 Tokens = annotate("int f3() { return sizeof(Foo&); }"); 162 ASSERT_EQ(Tokens.size(), 14u) << Tokens; 163 EXPECT_TOKEN(Tokens[9], tok::amp, TT_PointerOrReference); 164 165 Tokens = annotate("int f4() { return sizeof(Foo&&); }"); 166 ASSERT_EQ(Tokens.size(), 14u) << Tokens; 167 EXPECT_TOKEN(Tokens[9], tok::ampamp, TT_PointerOrReference); 168 169 Tokens = annotate("void f5() { int f6(Foo&, Bar&); }"); 170 ASSERT_EQ(Tokens.size(), 17u) << Tokens; 171 EXPECT_TOKEN(Tokens[9], tok::amp, TT_PointerOrReference); 172 EXPECT_TOKEN(Tokens[12], tok::amp, TT_PointerOrReference); 173 174 Tokens = annotate("void f7() { int f8(Foo&&, Bar&&); }"); 175 ASSERT_EQ(Tokens.size(), 17u) << Tokens; 176 EXPECT_TOKEN(Tokens[9], tok::ampamp, TT_PointerOrReference); 177 EXPECT_TOKEN(Tokens[12], tok::ampamp, TT_PointerOrReference); 178 179 Tokens = annotate("Type1 &val1 = val2;"); 180 ASSERT_EQ(Tokens.size(), 7u) << Tokens; 181 EXPECT_TOKEN(Tokens[1], tok::amp, TT_PointerOrReference); 182 183 Tokens = annotate("Type1 *val1 = &val2;"); 184 ASSERT_EQ(Tokens.size(), 8u) << Tokens; 185 EXPECT_TOKEN(Tokens[1], tok::star, TT_PointerOrReference); 186 EXPECT_TOKEN(Tokens[4], tok::amp, TT_UnaryOperator); 187 188 Tokens = annotate("val1 & val2;"); 189 ASSERT_EQ(Tokens.size(), 5u) << Tokens; 190 EXPECT_TOKEN(Tokens[1], tok::amp, TT_BinaryOperator); 191 192 Tokens = annotate("val1 & val2.member;"); 193 ASSERT_EQ(Tokens.size(), 7u) << Tokens; 194 EXPECT_TOKEN(Tokens[1], tok::amp, TT_BinaryOperator); 195 196 Tokens = annotate("val1 & val2.*member;"); 197 ASSERT_EQ(Tokens.size(), 7u) << Tokens; 198 EXPECT_TOKEN(Tokens[1], tok::amp, TT_BinaryOperator); 199 200 Tokens = annotate("val1.*member & val2;"); 201 ASSERT_EQ(Tokens.size(), 7u) << Tokens; 202 EXPECT_TOKEN(Tokens[3], tok::amp, TT_BinaryOperator); 203 204 Tokens = annotate("val1 & val2->*member;"); 205 ASSERT_EQ(Tokens.size(), 7u) << Tokens; 206 EXPECT_TOKEN(Tokens[1], tok::amp, TT_BinaryOperator); 207 208 Tokens = annotate("val1->member & val2;"); 209 ASSERT_EQ(Tokens.size(), 7u) << Tokens; 210 EXPECT_TOKEN(Tokens[3], tok::amp, TT_BinaryOperator); 211 212 Tokens = annotate("val1 & val2 & val3;"); 213 ASSERT_EQ(Tokens.size(), 7u) << Tokens; 214 EXPECT_TOKEN(Tokens[1], tok::amp, TT_BinaryOperator); 215 EXPECT_TOKEN(Tokens[3], tok::amp, TT_BinaryOperator); 216 217 Tokens = annotate("val1 & val2 // comment\n" 218 " & val3;"); 219 ASSERT_EQ(Tokens.size(), 8u) << Tokens; 220 EXPECT_TOKEN(Tokens[1], tok::amp, TT_BinaryOperator); 221 EXPECT_TOKEN(Tokens[4], tok::amp, TT_BinaryOperator); 222 223 Tokens = 224 annotate("val1 & val2.member & val3.member() & val4 & val5->member;"); 225 ASSERT_EQ(Tokens.size(), 19u) << Tokens; 226 EXPECT_TOKEN(Tokens[1], tok::amp, TT_BinaryOperator); 227 EXPECT_TOKEN(Tokens[5], tok::amp, TT_BinaryOperator); 228 EXPECT_TOKEN(Tokens[11], tok::amp, TT_BinaryOperator); 229 EXPECT_TOKEN(Tokens[13], tok::amp, TT_BinaryOperator); 230 231 Tokens = annotate("class c {\n" 232 " void func(type &a) { a & member; }\n" 233 " anotherType &member;\n" 234 "}"); 235 ASSERT_EQ(Tokens.size(), 22u) << Tokens; 236 EXPECT_TOKEN(Tokens[7], tok::amp, TT_PointerOrReference); 237 EXPECT_TOKEN(Tokens[12], tok::amp, TT_BinaryOperator); 238 EXPECT_TOKEN(Tokens[17], tok::amp, TT_PointerOrReference); 239 240 Tokens = annotate("struct S {\n" 241 " auto Mem = C & D;\n" 242 "}"); 243 ASSERT_EQ(Tokens.size(), 12u) << Tokens; 244 EXPECT_TOKEN(Tokens[7], tok::amp, TT_BinaryOperator); 245 246 Tokens = 247 annotate("template <typename T> void swap() noexcept(Bar<T> && Foo<T>);"); 248 ASSERT_EQ(Tokens.size(), 23u) << Tokens; 249 EXPECT_TOKEN(Tokens[15], tok::ampamp, TT_BinaryOperator); 250 251 Tokens = annotate("template <typename T> struct S {\n" 252 " explicit(Bar<T> && Foo<T>) S(const S &);\n" 253 "};"); 254 ASSERT_EQ(Tokens.size(), 30u) << Tokens; 255 EXPECT_TOKEN(Tokens[14], tok::ampamp, TT_BinaryOperator); 256 } 257 258 TEST_F(TokenAnnotatorTest, UnderstandsUsesOfPlusAndMinus) { 259 auto Tokens = annotate("x - 0"); 260 ASSERT_EQ(Tokens.size(), 4u) << Tokens; 261 EXPECT_TOKEN(Tokens[1], tok::minus, TT_BinaryOperator); 262 Tokens = annotate("0 + 0"); 263 ASSERT_EQ(Tokens.size(), 4u) << Tokens; 264 EXPECT_TOKEN(Tokens[1], tok::plus, TT_BinaryOperator); 265 Tokens = annotate("x + +0"); 266 ASSERT_EQ(Tokens.size(), 5u) << Tokens; 267 EXPECT_TOKEN(Tokens[2], tok::plus, TT_UnaryOperator); 268 Tokens = annotate("x ? -0 : +0"); 269 ASSERT_EQ(Tokens.size(), 8u) << Tokens; 270 EXPECT_TOKEN(Tokens[2], tok::minus, TT_UnaryOperator); 271 EXPECT_TOKEN(Tokens[5], tok::plus, TT_UnaryOperator); 272 Tokens = annotate("(-0)"); 273 ASSERT_EQ(Tokens.size(), 5u) << Tokens; 274 EXPECT_TOKEN(Tokens[1], tok::minus, TT_UnaryOperator); 275 Tokens = annotate("0, -0"); 276 ASSERT_EQ(Tokens.size(), 5u) << Tokens; 277 EXPECT_TOKEN(Tokens[2], tok::minus, TT_UnaryOperator); 278 Tokens = annotate("for (; -1;) {\n}"); 279 ASSERT_EQ(Tokens.size(), 10u) << Tokens; 280 EXPECT_TOKEN(Tokens[3], tok::minus, TT_UnaryOperator); 281 Tokens = annotate("x = -1;"); 282 ASSERT_EQ(Tokens.size(), 6u) << Tokens; 283 EXPECT_TOKEN(Tokens[2], tok::minus, TT_UnaryOperator); 284 Tokens = annotate("x[-1]"); 285 ASSERT_EQ(Tokens.size(), 6u) << Tokens; 286 EXPECT_TOKEN(Tokens[2], tok::minus, TT_UnaryOperator); 287 Tokens = annotate("x = {-1};"); 288 ASSERT_EQ(Tokens.size(), 8u) << Tokens; 289 EXPECT_TOKEN(Tokens[3], tok::minus, TT_UnaryOperator); 290 Tokens = annotate("case -x:"); 291 ASSERT_EQ(Tokens.size(), 5u) << Tokens; 292 EXPECT_TOKEN(Tokens[1], tok::minus, TT_UnaryOperator); 293 Tokens = annotate("co_await -x;"); 294 ASSERT_EQ(Tokens.size(), 5u) << Tokens; 295 EXPECT_TOKEN(Tokens[1], tok::minus, TT_UnaryOperator); 296 Tokens = annotate("co_return -x;"); 297 ASSERT_EQ(Tokens.size(), 5u) << Tokens; 298 EXPECT_TOKEN(Tokens[1], tok::minus, TT_UnaryOperator); 299 Tokens = annotate("co_yield -x;"); 300 ASSERT_EQ(Tokens.size(), 5u) << Tokens; 301 EXPECT_TOKEN(Tokens[1], tok::minus, TT_UnaryOperator); 302 Tokens = annotate("delete -x;"); 303 ASSERT_EQ(Tokens.size(), 5u) << Tokens; 304 EXPECT_TOKEN(Tokens[1], tok::minus, TT_UnaryOperator); 305 Tokens = annotate("return -x;"); 306 ASSERT_EQ(Tokens.size(), 5u) << Tokens; 307 EXPECT_TOKEN(Tokens[1], tok::minus, TT_UnaryOperator); 308 Tokens = annotate("throw -x;"); 309 ASSERT_EQ(Tokens.size(), 5u) << Tokens; 310 EXPECT_TOKEN(Tokens[1], tok::minus, TT_UnaryOperator); 311 Tokens = annotate("sizeof -x"); 312 ASSERT_EQ(Tokens.size(), 4u) << Tokens; 313 EXPECT_TOKEN(Tokens[1], tok::minus, TT_UnaryOperator); 314 Tokens = annotate("co_await +x;"); 315 ASSERT_EQ(Tokens.size(), 5u) << Tokens; 316 EXPECT_TOKEN(Tokens[1], tok::plus, TT_UnaryOperator); 317 Tokens = annotate("co_return +x;"); 318 ASSERT_EQ(Tokens.size(), 5u) << Tokens; 319 EXPECT_TOKEN(Tokens[1], tok::plus, TT_UnaryOperator); 320 Tokens = annotate("co_yield +x;"); 321 ASSERT_EQ(Tokens.size(), 5u) << Tokens; 322 EXPECT_TOKEN(Tokens[1], tok::plus, TT_UnaryOperator); 323 Tokens = annotate("delete +x;"); 324 ASSERT_EQ(Tokens.size(), 5u) << Tokens; 325 EXPECT_TOKEN(Tokens[1], tok::plus, TT_UnaryOperator); 326 Tokens = annotate("return +x;"); 327 ASSERT_EQ(Tokens.size(), 5u) << Tokens; 328 EXPECT_TOKEN(Tokens[1], tok::plus, TT_UnaryOperator); 329 Tokens = annotate("throw +x;"); 330 ASSERT_EQ(Tokens.size(), 5u) << Tokens; 331 EXPECT_TOKEN(Tokens[1], tok::plus, TT_UnaryOperator); 332 Tokens = annotate("sizeof +x"); 333 ASSERT_EQ(Tokens.size(), 4u) << Tokens; 334 EXPECT_TOKEN(Tokens[1], tok::plus, TT_UnaryOperator); 335 Tokens = annotate("(int)-x"); 336 ASSERT_EQ(Tokens.size(), 6u) << Tokens; 337 EXPECT_TOKEN(Tokens[3], tok::minus, TT_UnaryOperator); 338 Tokens = annotate("(-x)"); 339 ASSERT_EQ(Tokens.size(), 5u) << Tokens; 340 EXPECT_TOKEN(Tokens[1], tok::minus, TT_UnaryOperator); 341 Tokens = annotate("!+x"); 342 ASSERT_EQ(Tokens.size(), 4u) << Tokens; 343 EXPECT_TOKEN(Tokens[0], tok::exclaim, TT_UnaryOperator); 344 EXPECT_TOKEN(Tokens[1], tok::plus, TT_UnaryOperator); 345 } 346 347 TEST_F(TokenAnnotatorTest, UnderstandsClasses) { 348 auto Tokens = annotate("class C {};"); 349 EXPECT_EQ(Tokens.size(), 6u) << Tokens; 350 EXPECT_TOKEN(Tokens[2], tok::l_brace, TT_ClassLBrace); 351 352 Tokens = annotate("const class C {} c;"); 353 EXPECT_EQ(Tokens.size(), 8u) << Tokens; 354 EXPECT_TOKEN(Tokens[3], tok::l_brace, TT_ClassLBrace); 355 356 Tokens = annotate("const class {} c;"); 357 EXPECT_EQ(Tokens.size(), 7u) << Tokens; 358 EXPECT_TOKEN(Tokens[2], tok::l_brace, TT_ClassLBrace); 359 360 Tokens = annotate("class [[deprecated(\"\")]] C { int i; };"); 361 EXPECT_EQ(Tokens.size(), 17u) << Tokens; 362 EXPECT_TOKEN(Tokens[10], tok::l_brace, TT_ClassLBrace); 363 } 364 365 TEST_F(TokenAnnotatorTest, UnderstandsStructs) { 366 auto Tokens = annotate("struct S {};"); 367 EXPECT_EQ(Tokens.size(), 6u) << Tokens; 368 EXPECT_TOKEN(Tokens[2], tok::l_brace, TT_StructLBrace); 369 } 370 371 TEST_F(TokenAnnotatorTest, UnderstandsUnions) { 372 auto Tokens = annotate("union U {};"); 373 EXPECT_EQ(Tokens.size(), 6u) << Tokens; 374 EXPECT_TOKEN(Tokens[2], tok::l_brace, TT_UnionLBrace); 375 376 Tokens = annotate("union U { void f() { return; } };"); 377 EXPECT_EQ(Tokens.size(), 14u) << Tokens; 378 EXPECT_TOKEN(Tokens[2], tok::l_brace, TT_UnionLBrace); 379 EXPECT_TOKEN(Tokens[7], tok::l_brace, TT_FunctionLBrace); 380 } 381 382 TEST_F(TokenAnnotatorTest, UnderstandsEnums) { 383 auto Tokens = annotate("enum E {};"); 384 EXPECT_EQ(Tokens.size(), 6u) << Tokens; 385 EXPECT_TOKEN(Tokens[2], tok::l_brace, TT_EnumLBrace); 386 } 387 388 TEST_F(TokenAnnotatorTest, UnderstandsDefaultedAndDeletedFunctions) { 389 auto Tokens = annotate("auto operator<=>(const T &) const & = default;"); 390 EXPECT_EQ(Tokens.size(), 14u) << Tokens; 391 EXPECT_TOKEN(Tokens[9], tok::amp, TT_PointerOrReference); 392 393 Tokens = annotate("template <typename T> void F(T) && = delete;"); 394 EXPECT_EQ(Tokens.size(), 15u) << Tokens; 395 EXPECT_TOKEN(Tokens[10], tok::ampamp, TT_PointerOrReference); 396 } 397 398 TEST_F(TokenAnnotatorTest, UnderstandsVariables) { 399 auto Tokens = 400 annotate("inline bool var = is_integral_v<int> && is_signed_v<int>;"); 401 EXPECT_EQ(Tokens.size(), 15u) << Tokens; 402 EXPECT_TOKEN(Tokens[8], tok::ampamp, TT_BinaryOperator); 403 } 404 405 TEST_F(TokenAnnotatorTest, UnderstandsVariableTemplates) { 406 auto Tokens = 407 annotate("template <typename T> " 408 "inline bool var = is_integral_v<int> && is_signed_v<int>;"); 409 EXPECT_EQ(Tokens.size(), 20u) << Tokens; 410 EXPECT_TOKEN(Tokens[13], tok::ampamp, TT_BinaryOperator); 411 } 412 413 TEST_F(TokenAnnotatorTest, UnderstandsTemplatesInMacros) { 414 auto Tokens = 415 annotate("#define FOO(typeName) \\\n" 416 " { #typeName, foo<FooType>(new foo<realClass>(#typeName)) }"); 417 ASSERT_EQ(Tokens.size(), 27u) << Tokens; 418 EXPECT_TOKEN(Tokens[11], tok::less, TT_TemplateOpener); 419 EXPECT_TOKEN(Tokens[13], tok::greater, TT_TemplateCloser); 420 EXPECT_TOKEN(Tokens[17], tok::less, TT_TemplateOpener); 421 EXPECT_TOKEN(Tokens[19], tok::greater, TT_TemplateCloser); 422 } 423 424 TEST_F(TokenAnnotatorTest, UnderstandsGreaterAfterTemplateCloser) { 425 auto Tokens = annotate("if (std::tuple_size_v<T> > 0)"); 426 ASSERT_EQ(Tokens.size(), 12u) << Tokens; 427 EXPECT_TOKEN(Tokens[5], tok::less, TT_TemplateOpener); 428 EXPECT_TOKEN(Tokens[7], tok::greater, TT_TemplateCloser); 429 EXPECT_TOKEN(Tokens[8], tok::greater, TT_BinaryOperator); 430 } 431 432 TEST_F(TokenAnnotatorTest, UnderstandsWhitespaceSensitiveMacros) { 433 FormatStyle Style = getLLVMStyle(); 434 Style.WhitespaceSensitiveMacros.push_back("FOO"); 435 436 auto Tokens = annotate("FOO(1+2 )\n", Style); 437 EXPECT_EQ(Tokens.size(), 7u) << Tokens; 438 EXPECT_TOKEN(Tokens[0], tok::identifier, TT_UntouchableMacroFunc); 439 440 Tokens = annotate("FOO(a:b:c)\n", Style); 441 EXPECT_EQ(Tokens.size(), 9u) << Tokens; 442 EXPECT_TOKEN(Tokens[0], tok::identifier, TT_UntouchableMacroFunc); 443 } 444 445 TEST_F(TokenAnnotatorTest, UnderstandsDelete) { 446 auto Tokens = annotate("delete (void *)p;"); 447 EXPECT_EQ(Tokens.size(), 8u) << Tokens; 448 EXPECT_TOKEN(Tokens[4], tok::r_paren, TT_CastRParen); 449 450 Tokens = annotate("delete[] (void *)p;"); 451 EXPECT_EQ(Tokens.size(), 10u) << Tokens; 452 EXPECT_TOKEN(Tokens[6], tok::r_paren, TT_CastRParen); 453 454 Tokens = annotate("delete[] /*comment*/ (void *)p;"); 455 EXPECT_EQ(Tokens.size(), 11u) << Tokens; 456 EXPECT_TOKEN(Tokens[7], tok::r_paren, TT_CastRParen); 457 458 Tokens = annotate("delete[/*comment*/] (void *)p;"); 459 EXPECT_EQ(Tokens.size(), 11u) << Tokens; 460 EXPECT_TOKEN(Tokens[7], tok::r_paren, TT_CastRParen); 461 462 Tokens = annotate("delete/*comment*/[] (void *)p;"); 463 EXPECT_EQ(Tokens.size(), 11u) << Tokens; 464 EXPECT_TOKEN(Tokens[7], tok::r_paren, TT_CastRParen); 465 } 466 467 TEST_F(TokenAnnotatorTest, UnderstandsCasts) { 468 auto Tokens = annotate("(void)p;"); 469 EXPECT_EQ(Tokens.size(), 6u) << Tokens; 470 EXPECT_TOKEN(Tokens[2], tok::r_paren, TT_CastRParen); 471 472 Tokens = annotate("auto x = (Foo)p;"); 473 EXPECT_EQ(Tokens.size(), 9u) << Tokens; 474 EXPECT_TOKEN(Tokens[5], tok::r_paren, TT_CastRParen); 475 476 Tokens = annotate("(std::vector<int>)p;"); 477 EXPECT_EQ(Tokens.size(), 11u) << Tokens; 478 EXPECT_TOKEN(Tokens[7], tok::r_paren, TT_CastRParen); 479 480 Tokens = annotate("return (Foo)p;"); 481 EXPECT_EQ(Tokens.size(), 7u) << Tokens; 482 EXPECT_TOKEN(Tokens[3], tok::r_paren, TT_CastRParen); 483 484 Tokens = annotate("throw (Foo)p;"); 485 EXPECT_EQ(Tokens.size(), 7u) << Tokens; 486 EXPECT_TOKEN(Tokens[3], tok::r_paren, TT_CastRParen); 487 } 488 489 TEST_F(TokenAnnotatorTest, UnderstandsDynamicExceptionSpecifier) { 490 auto Tokens = annotate("void f() throw(int);"); 491 EXPECT_EQ(Tokens.size(), 10u) << Tokens; 492 EXPECT_TOKEN(Tokens[4], tok::kw_throw, TT_Unknown); 493 } 494 495 TEST_F(TokenAnnotatorTest, UnderstandsFunctionRefQualifiers) { 496 auto Tokens = annotate("void f() &;"); 497 EXPECT_EQ(Tokens.size(), 7u) << Tokens; 498 EXPECT_TOKEN(Tokens[4], tok::amp, TT_PointerOrReference); 499 500 Tokens = annotate("void operator=(T) &&;"); 501 EXPECT_EQ(Tokens.size(), 9u) << Tokens; 502 EXPECT_TOKEN(Tokens[6], tok::ampamp, TT_PointerOrReference); 503 504 Tokens = annotate("template <typename T> void f() &;"); 505 EXPECT_EQ(Tokens.size(), 12u) << Tokens; 506 EXPECT_TOKEN(Tokens[9], tok::amp, TT_PointerOrReference); 507 508 Tokens = annotate("template <typename T> void operator=(T) &;"); 509 EXPECT_EQ(Tokens.size(), 14u) << Tokens; 510 EXPECT_TOKEN(Tokens[11], tok::amp, TT_PointerOrReference); 511 } 512 513 TEST_F(TokenAnnotatorTest, UnderstandsOverloadedOperators) { 514 auto Tokens = annotate("x.operator+()"); 515 ASSERT_EQ(Tokens.size(), 7u) << Tokens; 516 EXPECT_TOKEN(Tokens[2], tok::kw_operator, TT_FunctionDeclarationName); 517 EXPECT_TOKEN(Tokens[3], tok::plus, TT_OverloadedOperator); 518 EXPECT_TOKEN(Tokens[4], tok::l_paren, TT_OverloadedOperatorLParen); 519 Tokens = annotate("x.operator=()"); 520 ASSERT_EQ(Tokens.size(), 7u) << Tokens; 521 EXPECT_TOKEN(Tokens[2], tok::kw_operator, TT_FunctionDeclarationName); 522 EXPECT_TOKEN(Tokens[3], tok::equal, TT_OverloadedOperator); 523 EXPECT_TOKEN(Tokens[4], tok::l_paren, TT_OverloadedOperatorLParen); 524 Tokens = annotate("x.operator+=()"); 525 ASSERT_EQ(Tokens.size(), 7u) << Tokens; 526 EXPECT_TOKEN(Tokens[2], tok::kw_operator, TT_FunctionDeclarationName); 527 EXPECT_TOKEN(Tokens[3], tok::plusequal, TT_OverloadedOperator); 528 EXPECT_TOKEN(Tokens[4], tok::l_paren, TT_OverloadedOperatorLParen); 529 Tokens = annotate("x.operator,()"); 530 ASSERT_EQ(Tokens.size(), 7u) << Tokens; 531 EXPECT_TOKEN(Tokens[2], tok::kw_operator, TT_FunctionDeclarationName); 532 EXPECT_TOKEN(Tokens[3], tok::comma, TT_OverloadedOperator); 533 EXPECT_TOKEN(Tokens[4], tok::l_paren, TT_OverloadedOperatorLParen); 534 Tokens = annotate("x.operator()()"); 535 ASSERT_EQ(Tokens.size(), 8u) << Tokens; 536 EXPECT_TOKEN(Tokens[2], tok::kw_operator, TT_FunctionDeclarationName); 537 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_OverloadedOperator); 538 EXPECT_TOKEN(Tokens[4], tok::r_paren, TT_OverloadedOperator); 539 EXPECT_TOKEN(Tokens[5], tok::l_paren, TT_OverloadedOperatorLParen); 540 Tokens = annotate("x.operator[]()"); 541 ASSERT_EQ(Tokens.size(), 8u) << Tokens; 542 EXPECT_TOKEN(Tokens[2], tok::kw_operator, TT_FunctionDeclarationName); 543 // EXPECT_TOKEN(Tokens[3], tok::l_square, TT_OverloadedOperator); 544 // EXPECT_TOKEN(Tokens[4], tok::r_square, TT_OverloadedOperator); 545 EXPECT_TOKEN(Tokens[5], tok::l_paren, TT_OverloadedOperatorLParen); 546 Tokens = annotate("x.operator\"\"_a()"); 547 ASSERT_EQ(Tokens.size(), 7u) << Tokens; 548 EXPECT_TOKEN(Tokens[2], tok::kw_operator, TT_FunctionDeclarationName); 549 EXPECT_TOKEN(Tokens[3], tok::string_literal, TT_OverloadedOperator); 550 EXPECT_TOKEN(Tokens[4], tok::l_paren, TT_OverloadedOperatorLParen); 551 Tokens = annotate("x.operator\"\" _a()"); 552 ASSERT_EQ(Tokens.size(), 8u) << Tokens; 553 // FIXME 554 // EXPECT_TOKEN(Tokens[2], tok::kw_operator, TT_FunctionDeclarationName); 555 EXPECT_TOKEN(Tokens[3], tok::string_literal, TT_OverloadedOperator); 556 EXPECT_TOKEN(Tokens[5], tok::l_paren, TT_OverloadedOperatorLParen); 557 Tokens = annotate("x.operator\"\"if()"); 558 ASSERT_EQ(Tokens.size(), 7u) << Tokens; 559 EXPECT_TOKEN(Tokens[2], tok::kw_operator, TT_FunctionDeclarationName); 560 EXPECT_TOKEN(Tokens[3], tok::string_literal, TT_OverloadedOperator); 561 EXPECT_TOKEN(Tokens[4], tok::l_paren, TT_OverloadedOperatorLParen); 562 Tokens = annotate("x.operator\"\"s()"); 563 ASSERT_EQ(Tokens.size(), 7u) << Tokens; 564 EXPECT_TOKEN(Tokens[2], tok::kw_operator, TT_FunctionDeclarationName); 565 EXPECT_TOKEN(Tokens[3], tok::string_literal, TT_OverloadedOperator); 566 EXPECT_TOKEN(Tokens[4], tok::l_paren, TT_OverloadedOperatorLParen); 567 Tokens = annotate("x.operator\"\" s()"); 568 ASSERT_EQ(Tokens.size(), 8u) << Tokens; 569 // FIXME 570 // EXPECT_TOKEN(Tokens[2], tok::kw_operator, TT_FunctionDeclarationName); 571 EXPECT_TOKEN(Tokens[3], tok::string_literal, TT_OverloadedOperator); 572 EXPECT_TOKEN(Tokens[5], tok::l_paren, TT_OverloadedOperatorLParen); 573 574 Tokens = annotate("int operator+(int);"); 575 ASSERT_EQ(Tokens.size(), 8u) << Tokens; 576 EXPECT_TOKEN(Tokens[1], tok::kw_operator, TT_FunctionDeclarationName); 577 EXPECT_TOKEN(Tokens[2], tok::plus, TT_OverloadedOperator); 578 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_OverloadedOperatorLParen); 579 Tokens = annotate("auto operator=(T&) {}"); 580 ASSERT_EQ(Tokens.size(), 10u) << Tokens; 581 EXPECT_TOKEN(Tokens[1], tok::kw_operator, TT_FunctionDeclarationName); 582 EXPECT_TOKEN(Tokens[2], tok::equal, TT_OverloadedOperator); 583 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_OverloadedOperatorLParen); 584 Tokens = annotate("auto operator()() {}"); 585 ASSERT_EQ(Tokens.size(), 9u) << Tokens; 586 EXPECT_TOKEN(Tokens[1], tok::kw_operator, TT_FunctionDeclarationName); 587 EXPECT_TOKEN(Tokens[2], tok::l_paren, TT_OverloadedOperator); 588 EXPECT_TOKEN(Tokens[3], tok::r_paren, TT_OverloadedOperator); 589 EXPECT_TOKEN(Tokens[4], tok::l_paren, TT_OverloadedOperatorLParen); 590 } 591 592 TEST_F(TokenAnnotatorTest, OverloadedOperatorInTemplate) { 593 struct { 594 const char *Text; 595 tok::TokenKind Kind; 596 } Operators[] = {{"+", tok::plus}, 597 {"-", tok::minus}, 598 // FIXME: 599 // {"*", tok::star}, 600 {"/", tok::slash}, 601 {"%", tok::percent}, 602 {"^", tok::caret}, 603 // FIXME: 604 // {"&", tok::amp}, 605 {"|", tok::pipe}, 606 {"~", tok::tilde}, 607 {"!", tok::exclaim}, 608 {"=", tok::equal}, 609 // FIXME: 610 // {"<", tok::less}, 611 {">", tok::greater}, 612 {"+=", tok::plusequal}, 613 {"-=", tok::minusequal}, 614 {"*=", tok::starequal}, 615 {"/=", tok::slashequal}, 616 {"%=", tok::percentequal}, 617 {"^=", tok::caretequal}, 618 {"&=", tok::ampequal}, 619 {"|=", tok::pipeequal}, 620 {"<<", tok::lessless}, 621 {">>", tok::greatergreater}, 622 {">>=", tok::greatergreaterequal}, 623 {"<<=", tok::lesslessequal}, 624 {"==", tok::equalequal}, 625 {"!=", tok::exclaimequal}, 626 {"<=", tok::lessequal}, 627 {">=", tok::greaterequal}, 628 {"<=>", tok::spaceship}, 629 {"&&", tok::ampamp}, 630 {"||", tok::pipepipe}, 631 {"++", tok::plusplus}, 632 {"--", tok::minusminus}, 633 {",", tok::comma}, 634 {"->*", tok::arrowstar}, 635 {"->", tok::arrow}}; 636 637 for (const auto &Operator : Operators) { 638 std::string Input("C<&operator"); 639 Input += Operator.Text; 640 Input += " > a;"; 641 auto Tokens = annotate(std::string(Input)); 642 ASSERT_EQ(Tokens.size(), 9u) << Tokens; 643 EXPECT_TOKEN(Tokens[1], tok::less, TT_TemplateOpener); 644 EXPECT_TOKEN(Tokens[4], Operator.Kind, TT_OverloadedOperator); 645 EXPECT_TOKEN(Tokens[5], tok::greater, TT_TemplateCloser); 646 } 647 648 auto Tokens = annotate("C<&operator< <X>> lt;"); 649 ASSERT_EQ(Tokens.size(), 12u) << Tokens; 650 EXPECT_TOKEN(Tokens[1], tok::less, TT_TemplateOpener); 651 EXPECT_TOKEN(Tokens[4], tok::less, TT_OverloadedOperator); 652 EXPECT_TOKEN(Tokens[5], tok::less, TT_TemplateOpener); 653 EXPECT_TOKEN(Tokens[7], tok::greater, TT_TemplateCloser); 654 EXPECT_TOKEN(Tokens[8], tok::greater, TT_TemplateCloser); 655 } 656 657 TEST_F(TokenAnnotatorTest, UnderstandsRequiresClausesAndConcepts) { 658 auto Tokens = annotate("template <typename T>\n" 659 "concept C = (Foo && Bar) && (Bar && Baz);"); 660 661 ASSERT_EQ(Tokens.size(), 21u) << Tokens; 662 EXPECT_TOKEN(Tokens[10], tok::ampamp, TT_BinaryOperator); 663 EXPECT_TOKEN(Tokens[13], tok::ampamp, TT_BinaryOperator); 664 EXPECT_TOKEN(Tokens[16], tok::ampamp, TT_BinaryOperator); 665 666 Tokens = annotate("template <typename T>\n" 667 "concept C = Foo && !Bar;"); 668 669 ASSERT_EQ(Tokens.size(), 14u) << Tokens; 670 EXPECT_TOKEN(Tokens[9], tok::ampamp, TT_BinaryOperator); 671 EXPECT_TOKEN(Tokens[10], tok::exclaim, TT_UnaryOperator); 672 673 Tokens = annotate("template <typename T>\n" 674 "concept C = requires(T t) {\n" 675 " { t.foo() };\n" 676 "} && Bar<T> && Baz<T>;"); 677 ASSERT_EQ(Tokens.size(), 35u) << Tokens; 678 EXPECT_TOKEN(Tokens[8], tok::kw_requires, TT_RequiresExpression); 679 EXPECT_TOKEN(Tokens[9], tok::l_paren, TT_RequiresExpressionLParen); 680 EXPECT_TOKEN(Tokens[13], tok::l_brace, TT_RequiresExpressionLBrace); 681 EXPECT_TOKEN(Tokens[23], tok::ampamp, TT_BinaryOperator); 682 EXPECT_TOKEN(Tokens[28], tok::ampamp, TT_BinaryOperator); 683 684 Tokens = annotate("template<typename T>\n" 685 "requires C1<T> && (C21<T> || C22<T> && C2e<T>) && C3<T>\n" 686 "struct Foo;"); 687 ASSERT_EQ(Tokens.size(), 36u) << Tokens; 688 EXPECT_TOKEN(Tokens[5], tok::kw_requires, TT_RequiresClause); 689 EXPECT_TOKEN(Tokens[6], tok::identifier, TT_Unknown); 690 EXPECT_EQ(Tokens[6]->FakeLParens.size(), 1u); 691 EXPECT_TOKEN(Tokens[10], tok::ampamp, TT_BinaryOperator); 692 EXPECT_TOKEN(Tokens[16], tok::pipepipe, TT_BinaryOperator); 693 EXPECT_TOKEN(Tokens[21], tok::ampamp, TT_BinaryOperator); 694 EXPECT_TOKEN(Tokens[27], tok::ampamp, TT_BinaryOperator); 695 EXPECT_TOKEN(Tokens[31], tok::greater, TT_TemplateCloser); 696 EXPECT_EQ(Tokens[31]->FakeRParens, 1u); 697 EXPECT_TRUE(Tokens[31]->ClosesRequiresClause); 698 699 Tokens = 700 annotate("template<typename T>\n" 701 "requires (C1<T> && (C21<T> || C22<T> && C2e<T>) && C3<T>)\n" 702 "struct Foo;"); 703 ASSERT_EQ(Tokens.size(), 38u) << Tokens; 704 EXPECT_TOKEN(Tokens[5], tok::kw_requires, TT_RequiresClause); 705 EXPECT_TOKEN(Tokens[7], tok::identifier, TT_Unknown); 706 EXPECT_EQ(Tokens[7]->FakeLParens.size(), 1u); 707 EXPECT_TOKEN(Tokens[11], tok::ampamp, TT_BinaryOperator); 708 EXPECT_TOKEN(Tokens[17], tok::pipepipe, TT_BinaryOperator); 709 EXPECT_TOKEN(Tokens[22], tok::ampamp, TT_BinaryOperator); 710 EXPECT_TOKEN(Tokens[28], tok::ampamp, TT_BinaryOperator); 711 EXPECT_TOKEN(Tokens[32], tok::greater, TT_TemplateCloser); 712 EXPECT_EQ(Tokens[32]->FakeRParens, 1u); 713 EXPECT_TOKEN(Tokens[33], tok::r_paren, TT_Unknown); 714 EXPECT_TRUE(Tokens[33]->ClosesRequiresClause); 715 716 Tokens = annotate("template <typename T>\n" 717 "void foo(T) noexcept requires Bar<T>;"); 718 ASSERT_EQ(Tokens.size(), 18u) << Tokens; 719 EXPECT_TOKEN(Tokens[11], tok::kw_requires, TT_RequiresClause); 720 721 Tokens = annotate("template <typename T>\n" 722 "requires Bar<T> || Baz<T>\n" 723 "auto foo(T) -> int;"); 724 ASSERT_EQ(Tokens.size(), 24u) << Tokens; 725 EXPECT_TOKEN(Tokens[5], tok::kw_requires, TT_RequiresClause); 726 EXPECT_EQ(Tokens[11]->FakeLParens.size(), 0u); 727 EXPECT_TRUE(Tokens[14]->ClosesRequiresClause); 728 EXPECT_TOKEN(Tokens[20], tok::arrow, TT_TrailingReturnArrow); 729 730 Tokens = annotate("template <typename T>\n" 731 "requires Bar<T>\n" 732 "bool foo(T) { return false; }"); 733 ASSERT_EQ(Tokens.size(), 21u) << Tokens; 734 EXPECT_TOKEN(Tokens[5], tok::kw_requires, TT_RequiresClause); 735 EXPECT_TRUE(Tokens[9]->ClosesRequiresClause); 736 EXPECT_TOKEN(Tokens[11], tok::identifier, TT_FunctionDeclarationName); 737 738 Tokens = annotate("template <typename T>\n" 739 "requires Bar<T>\n" 740 "decltype(auto) foo(T) { return false; }"); 741 ASSERT_EQ(Tokens.size(), 24u) << Tokens; 742 EXPECT_TOKEN(Tokens[5], tok::kw_requires, TT_RequiresClause); 743 EXPECT_TRUE(Tokens[9]->ClosesRequiresClause); 744 EXPECT_TOKEN(Tokens[14], tok::identifier, TT_FunctionDeclarationName); 745 746 Tokens = annotate("template <typename T>\n" 747 "struct S {\n" 748 " void foo() const requires Bar<T>;\n" 749 " void bar() const & requires Baz<T>;\n" 750 " void bar() && requires Baz2<T>;\n" 751 " void baz() const & noexcept requires Baz<T>;\n" 752 " void baz() && noexcept requires Baz2<T>;\n" 753 "};\n" 754 "\n" 755 "void S::bar() const & requires Baz<T> { }"); 756 ASSERT_EQ(Tokens.size(), 85u) << Tokens; 757 EXPECT_TOKEN(Tokens[13], tok::kw_requires, TT_RequiresClause); 758 EXPECT_TOKEN(Tokens[24], tok::amp, TT_PointerOrReference); 759 EXPECT_TOKEN(Tokens[25], tok::kw_requires, TT_RequiresClause); 760 EXPECT_TOKEN(Tokens[35], tok::ampamp, TT_PointerOrReference); 761 EXPECT_TOKEN(Tokens[36], tok::kw_requires, TT_RequiresClause); 762 EXPECT_TOKEN(Tokens[47], tok::amp, TT_PointerOrReference); 763 EXPECT_TOKEN(Tokens[49], tok::kw_requires, TT_RequiresClause); 764 EXPECT_TOKEN(Tokens[59], tok::ampamp, TT_PointerOrReference); 765 EXPECT_TOKEN(Tokens[61], tok::kw_requires, TT_RequiresClause); 766 EXPECT_TOKEN(Tokens[76], tok::amp, TT_PointerOrReference); 767 EXPECT_TOKEN(Tokens[77], tok::kw_requires, TT_RequiresClause); 768 769 Tokens = annotate("void Class::member() && requires(Constant) {}"); 770 ASSERT_EQ(Tokens.size(), 14u) << Tokens; 771 EXPECT_TOKEN(Tokens[7], tok::kw_requires, TT_RequiresClause); 772 773 Tokens = annotate("void Class::member() && requires(Constant<T>) {}"); 774 ASSERT_EQ(Tokens.size(), 17u) << Tokens; 775 EXPECT_TOKEN(Tokens[7], tok::kw_requires, TT_RequiresClause); 776 777 Tokens = 778 annotate("void Class::member() && requires(Namespace::Constant<T>) {}"); 779 ASSERT_EQ(Tokens.size(), 19u) << Tokens; 780 EXPECT_TOKEN(Tokens[7], tok::kw_requires, TT_RequiresClause); 781 782 Tokens = annotate("void Class::member() && requires(typename " 783 "Namespace::Outer<T>::Inner::Constant) {}"); 784 ASSERT_EQ(Tokens.size(), 24u) << Tokens; 785 EXPECT_TOKEN(Tokens[7], tok::kw_requires, TT_RequiresClause); 786 787 Tokens = annotate("struct [[nodiscard]] zero_t {\n" 788 " template<class T>\n" 789 " requires requires { number_zero_v<T>; }\n" 790 " [[nodiscard]] constexpr operator T() const { " 791 "return number_zero_v<T>; }\n" 792 "};"); 793 ASSERT_EQ(Tokens.size(), 44u); 794 EXPECT_TOKEN(Tokens[13], tok::kw_requires, TT_RequiresClause); 795 EXPECT_TOKEN(Tokens[14], tok::kw_requires, TT_RequiresExpression); 796 EXPECT_TOKEN(Tokens[15], tok::l_brace, TT_RequiresExpressionLBrace); 797 EXPECT_TOKEN(Tokens[21], tok::r_brace, TT_Unknown); 798 EXPECT_EQ(Tokens[21]->MatchingParen, Tokens[15]); 799 EXPECT_TRUE(Tokens[21]->ClosesRequiresClause); 800 801 Tokens = 802 annotate("template <class A, class B> concept C =" 803 "std::same_as<std::iter_value_t<A>, std::iter_value_t<B>>;"); 804 ASSERT_EQ(Tokens.size(), 31u) << Tokens; 805 EXPECT_TOKEN(Tokens[8], tok::kw_concept, TT_Unknown); 806 EXPECT_TOKEN(Tokens[14], tok::less, TT_TemplateOpener); 807 EXPECT_TOKEN(Tokens[18], tok::less, TT_TemplateOpener); 808 EXPECT_TOKEN(Tokens[20], tok::greater, TT_TemplateCloser); 809 EXPECT_TOKEN(Tokens[25], tok::less, TT_TemplateOpener); 810 EXPECT_TOKEN(Tokens[27], tok::greater, TT_TemplateCloser); 811 EXPECT_TOKEN(Tokens[28], tok::greater, TT_TemplateCloser); 812 813 Tokens = annotate("auto bar() -> int requires(is_integral_v<T>) {}"); 814 ASSERT_EQ(Tokens.size(), 16u) << Tokens; 815 EXPECT_TOKEN(Tokens[6], tok::kw_requires, TT_RequiresClause); 816 817 Tokens = annotate("auto bar() -> void requires(is_integral_v<T>) {}"); 818 ASSERT_EQ(Tokens.size(), 16u) << Tokens; 819 EXPECT_TOKEN(Tokens[6], tok::kw_requires, TT_RequiresClause); 820 821 Tokens = annotate("auto bar() -> MyType requires(is_integral_v<T>) {}"); 822 ASSERT_EQ(Tokens.size(), 16u) << Tokens; 823 EXPECT_TOKEN(Tokens[6], tok::kw_requires, TT_RequiresClause); 824 825 Tokens = 826 annotate("auto bar() -> SOME_MACRO_TYPE requires(is_integral_v<T>) {}"); 827 ASSERT_EQ(Tokens.size(), 16u) << Tokens; 828 EXPECT_TOKEN(Tokens[6], tok::kw_requires, TT_RequiresClause); 829 830 Tokens = 831 annotate("auto bar() -> qualified::type requires(is_integral_v<T>) {}"); 832 ASSERT_EQ(Tokens.size(), 18u) << Tokens; 833 EXPECT_TOKEN(Tokens[8], tok::kw_requires, TT_RequiresClause); 834 835 Tokens = 836 annotate("auto bar() -> Template<type> requires(is_integral_v<T>) {}"); 837 ASSERT_EQ(Tokens.size(), 19u) << Tokens; 838 EXPECT_TOKEN(Tokens[9], tok::kw_requires, TT_RequiresClause); 839 } 840 841 TEST_F(TokenAnnotatorTest, UnderstandsRequiresExpressions) { 842 auto Tokens = annotate("bool b = requires(int i) { i + 5; };"); 843 ASSERT_EQ(Tokens.size(), 16u) << Tokens; 844 EXPECT_TOKEN(Tokens[3], tok::kw_requires, TT_RequiresExpression); 845 EXPECT_TOKEN(Tokens[4], tok::l_paren, TT_RequiresExpressionLParen); 846 EXPECT_TOKEN(Tokens[8], tok::l_brace, TT_RequiresExpressionLBrace); 847 848 Tokens = annotate("if (requires(int i) { i + 5; }) return;"); 849 ASSERT_EQ(Tokens.size(), 17u) << Tokens; 850 EXPECT_TOKEN(Tokens[2], tok::kw_requires, TT_RequiresExpression); 851 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_RequiresExpressionLParen); 852 EXPECT_TOKEN(Tokens[7], tok::l_brace, TT_RequiresExpressionLBrace); 853 854 Tokens = annotate("if (func() && requires(int i) { i + 5; }) return;"); 855 ASSERT_EQ(Tokens.size(), 21u) << Tokens; 856 EXPECT_TOKEN(Tokens[6], tok::kw_requires, TT_RequiresExpression); 857 EXPECT_TOKEN(Tokens[7], tok::l_paren, TT_RequiresExpressionLParen); 858 EXPECT_TOKEN(Tokens[11], tok::l_brace, TT_RequiresExpressionLBrace); 859 860 Tokens = annotate("foo(requires(const T t) {});"); 861 ASSERT_EQ(Tokens.size(), 13u) << Tokens; 862 EXPECT_TOKEN(Tokens[2], tok::kw_requires, TT_RequiresExpression); 863 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_RequiresExpressionLParen); 864 EXPECT_TOKEN(Tokens[8], tok::l_brace, TT_RequiresExpressionLBrace); 865 866 Tokens = annotate("foo(requires(const int t) {});"); 867 ASSERT_EQ(Tokens.size(), 13u) << Tokens; 868 EXPECT_TOKEN(Tokens[2], tok::kw_requires, TT_RequiresExpression); 869 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_RequiresExpressionLParen); 870 EXPECT_TOKEN(Tokens[8], tok::l_brace, TT_RequiresExpressionLBrace); 871 872 Tokens = annotate("foo(requires(const T t) {});"); 873 ASSERT_EQ(Tokens.size(), 13u) << Tokens; 874 EXPECT_TOKEN(Tokens[2], tok::kw_requires, TT_RequiresExpression); 875 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_RequiresExpressionLParen); 876 EXPECT_TOKEN(Tokens[8], tok::l_brace, TT_RequiresExpressionLBrace); 877 878 Tokens = annotate("foo(requires(int const* volatile t) {});"); 879 ASSERT_EQ(Tokens.size(), 15u) << Tokens; 880 EXPECT_TOKEN(Tokens[2], tok::kw_requires, TT_RequiresExpression); 881 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_RequiresExpressionLParen); 882 EXPECT_TOKEN(Tokens[6], tok::star, TT_PointerOrReference); 883 EXPECT_TOKEN(Tokens[10], tok::l_brace, TT_RequiresExpressionLBrace); 884 885 Tokens = annotate("foo(requires(T const* volatile t) {});"); 886 ASSERT_EQ(Tokens.size(), 15u) << Tokens; 887 EXPECT_TOKEN(Tokens[2], tok::kw_requires, TT_RequiresExpression); 888 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_RequiresExpressionLParen); 889 EXPECT_TOKEN(Tokens[6], tok::star, TT_PointerOrReference); 890 EXPECT_TOKEN(Tokens[10], tok::l_brace, TT_RequiresExpressionLBrace); 891 892 Tokens = annotate("foo(requires(T& t) {});"); 893 ASSERT_EQ(Tokens.size(), 13u) << Tokens; 894 EXPECT_TOKEN(Tokens[2], tok::kw_requires, TT_RequiresExpression); 895 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_RequiresExpressionLParen); 896 EXPECT_TOKEN(Tokens[5], tok::amp, TT_PointerOrReference); 897 EXPECT_TOKEN(Tokens[8], tok::l_brace, TT_RequiresExpressionLBrace); 898 899 Tokens = annotate("foo(requires(T&& t) {});"); 900 ASSERT_EQ(Tokens.size(), 13u) << Tokens; 901 EXPECT_TOKEN(Tokens[2], tok::kw_requires, TT_RequiresExpression); 902 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_RequiresExpressionLParen); 903 EXPECT_TOKEN(Tokens[5], tok::ampamp, TT_PointerOrReference); 904 EXPECT_TOKEN(Tokens[8], tok::l_brace, TT_RequiresExpressionLBrace); 905 906 Tokens = annotate("bool foo = requires(T& t) {};"); 907 ASSERT_EQ(Tokens.size(), 13u) << Tokens; 908 EXPECT_TOKEN(Tokens[3], tok::kw_requires, TT_RequiresExpression); 909 EXPECT_TOKEN(Tokens[4], tok::l_paren, TT_RequiresExpressionLParen); 910 EXPECT_TOKEN(Tokens[6], tok::amp, TT_PointerOrReference); 911 EXPECT_TOKEN(Tokens[9], tok::l_brace, TT_RequiresExpressionLBrace); 912 913 Tokens = annotate("bool foo = requires(T&& t) {};"); 914 ASSERT_EQ(Tokens.size(), 13u) << Tokens; 915 EXPECT_TOKEN(Tokens[3], tok::kw_requires, TT_RequiresExpression); 916 EXPECT_TOKEN(Tokens[4], tok::l_paren, TT_RequiresExpressionLParen); 917 EXPECT_TOKEN(Tokens[6], tok::ampamp, TT_PointerOrReference); 918 EXPECT_TOKEN(Tokens[9], tok::l_brace, TT_RequiresExpressionLBrace); 919 920 Tokens = 921 annotate("foo(requires(const typename Outer<T>::Inner * const t) {});"); 922 ASSERT_EQ(Tokens.size(), 21u) << Tokens; 923 EXPECT_TOKEN(Tokens[2], tok::kw_requires, TT_RequiresExpression); 924 EXPECT_TOKEN(Tokens[3], tok::l_paren, TT_RequiresExpressionLParen); 925 EXPECT_TOKEN(Tokens[12], tok::star, TT_PointerOrReference); 926 EXPECT_TOKEN(Tokens[16], tok::l_brace, TT_RequiresExpressionLBrace); 927 928 Tokens = annotate("template <typename T>\n" 929 "concept C = requires(T T) {\n" 930 " requires Bar<T> && Foo<T>;\n" 931 "};"); 932 ASSERT_EQ(Tokens.size(), 28u) << Tokens; 933 EXPECT_TOKEN(Tokens[8], tok::kw_requires, TT_RequiresExpression); 934 EXPECT_TOKEN(Tokens[9], tok::l_paren, TT_RequiresExpressionLParen); 935 EXPECT_TOKEN(Tokens[13], tok::l_brace, TT_RequiresExpressionLBrace); 936 EXPECT_TOKEN(Tokens[14], tok::kw_requires, 937 TT_RequiresClauseInARequiresExpression); 938 939 Tokens = annotate("template <typename T>\n" 940 "concept C = requires(T T) {\n" 941 " { t.func() } -> std::same_as<int>;" 942 " requires Bar<T> && Foo<T>;\n" 943 "};"); 944 ASSERT_EQ(Tokens.size(), 43u) << Tokens; 945 EXPECT_TOKEN(Tokens[8], tok::kw_requires, TT_RequiresExpression); 946 EXPECT_TOKEN(Tokens[9], tok::l_paren, TT_RequiresExpressionLParen); 947 EXPECT_TOKEN(Tokens[13], tok::l_brace, TT_RequiresExpressionLBrace); 948 EXPECT_TOKEN(Tokens[29], tok::kw_requires, 949 TT_RequiresClauseInARequiresExpression); 950 951 // Invalid Code, but we don't want to crash. See http://llvm.org/PR54350. 952 Tokens = annotate("bool r10 = requires (struct new_struct { int x; } s) { " 953 "requires true; };"); 954 ASSERT_EQ(Tokens.size(), 21u) << Tokens; 955 EXPECT_TOKEN(Tokens[3], tok::kw_requires, TT_RequiresExpression); 956 EXPECT_TOKEN(Tokens[4], tok::l_paren, TT_RequiresExpressionLParen); 957 EXPECT_TOKEN(Tokens[14], tok::l_brace, TT_RequiresExpressionLBrace); 958 } 959 960 TEST_F(TokenAnnotatorTest, UnderstandsPragmaRegion) { 961 // Everything after #pragma region should be ImplicitStringLiteral 962 auto Tokens = annotate("#pragma region Foo(Bar: Hello)"); 963 ASSERT_EQ(Tokens.size(), 10u) << Tokens; 964 EXPECT_TOKEN(Tokens[5], tok::identifier, TT_ImplicitStringLiteral); 965 EXPECT_TOKEN(Tokens[6], tok::colon, TT_ImplicitStringLiteral); 966 EXPECT_TOKEN(Tokens[7], tok::identifier, TT_ImplicitStringLiteral); 967 968 // Make sure it's annotated correctly inside a function as well 969 Tokens = annotate("void test(){\n#pragma region Foo(Bar: Hello)\n}"); 970 ASSERT_EQ(Tokens.size(), 16u) << Tokens; 971 EXPECT_TOKEN(Tokens[10], tok::identifier, TT_ImplicitStringLiteral); 972 EXPECT_TOKEN(Tokens[11], tok::colon, TT_ImplicitStringLiteral); 973 EXPECT_TOKEN(Tokens[12], tok::identifier, TT_ImplicitStringLiteral); 974 } 975 976 TEST_F(TokenAnnotatorTest, RequiresDoesNotChangeParsingOfTheRest) { 977 const char *BaseCode = nullptr; 978 const char *ConstrainedCode = nullptr; 979 auto BaseTokenCount = 0u; 980 auto RequiresTokenCount = 0u; 981 auto PrefixTokenCount = 0u; 982 983 auto TestRequires = [&](int Line) { 984 const auto BaseTokens = annotate(BaseCode); 985 const auto ConstrainedTokens = annotate(ConstrainedCode); 986 987 #define LINE " (Line " << Line << ')' 988 989 ASSERT_EQ(BaseTokens.size(), BaseTokenCount) << BaseTokens << LINE; 990 ASSERT_EQ(ConstrainedTokens.size(), BaseTokenCount + RequiresTokenCount) 991 << LINE; 992 993 for (auto I = 0u; I < BaseTokenCount; ++I) { 994 EXPECT_EQ( 995 *BaseTokens[I], 996 *ConstrainedTokens[I < PrefixTokenCount ? I : I + RequiresTokenCount]) 997 << I << LINE; 998 } 999 1000 #undef LINE 1001 }; 1002 1003 BaseCode = "template<typename T>\n" 1004 "T Pi = 3.14;"; 1005 ConstrainedCode = "template<typename T>\n" 1006 " requires Foo<T>\n" 1007 "T Pi = 3.14;"; 1008 BaseTokenCount = 11; 1009 RequiresTokenCount = 5; 1010 PrefixTokenCount = 5; 1011 TestRequires(__LINE__); 1012 1013 BaseCode = "template<typename T>\n" 1014 "struct Bar;"; 1015 ConstrainedCode = "template<typename T>\n" 1016 " requires Foo<T>\n" 1017 "struct Bar;"; 1018 BaseTokenCount = 9; 1019 TestRequires(__LINE__); 1020 1021 BaseCode = "template<typename T>\n" 1022 "struct Bar {\n" 1023 " T foo();\n" 1024 " T bar();\n" 1025 "};"; 1026 ConstrainedCode = "template<typename T>\n" 1027 " requires Foo<T>\n" 1028 "struct Bar {\n" 1029 " T foo();\n" 1030 " T bar();\n" 1031 "};"; 1032 BaseTokenCount = 21; 1033 TestRequires(__LINE__); 1034 1035 BaseCode = "template<typename T>\n" 1036 "Bar(T) -> Bar<T>;"; 1037 ConstrainedCode = "template<typename T>\n" 1038 " requires Foo<T>\n" 1039 "Bar(T) -> Bar<T>;"; 1040 BaseTokenCount = 16; 1041 TestRequires(__LINE__); 1042 1043 BaseCode = "template<typename T>\n" 1044 "T foo();"; 1045 ConstrainedCode = "template<typename T>\n" 1046 " requires Foo<T>\n" 1047 "T foo();"; 1048 BaseTokenCount = 11; 1049 TestRequires(__LINE__); 1050 1051 BaseCode = "template<typename T>\n" 1052 "T foo() {\n" 1053 " auto bar = baz();\n" 1054 " return bar + T{};\n" 1055 "}"; 1056 ConstrainedCode = "template<typename T>\n" 1057 " requires Foo<T>\n" 1058 "T foo() {\n" 1059 " auto bar = baz();\n" 1060 " return bar + T{};\n" 1061 "}"; 1062 BaseTokenCount = 26; 1063 TestRequires(__LINE__); 1064 1065 BaseCode = "template<typename T>\n" 1066 "T foo();"; 1067 ConstrainedCode = "template<typename T>\n" 1068 "T foo() requires Foo<T>;"; 1069 BaseTokenCount = 11; 1070 PrefixTokenCount = 9; 1071 TestRequires(__LINE__); 1072 1073 BaseCode = "template<typename T>\n" 1074 "T foo() {\n" 1075 " auto bar = baz();\n" 1076 " return bar + T{};\n" 1077 "}"; 1078 ConstrainedCode = "template<typename T>\n" 1079 "T foo() requires Foo<T> {\n" 1080 " auto bar = baz();\n" 1081 " return bar + T{};\n" 1082 "}"; 1083 BaseTokenCount = 26; 1084 TestRequires(__LINE__); 1085 1086 BaseCode = "template<typename T>\n" 1087 "T foo();"; 1088 ConstrainedCode = "template<typename T>\n" 1089 " requires(Foo<T>)\n" 1090 "T foo();"; 1091 BaseTokenCount = 11; 1092 RequiresTokenCount = 7; 1093 PrefixTokenCount = 5; 1094 TestRequires(__LINE__); 1095 1096 BaseCode = "template<typename T>\n" 1097 "Bar(T) -> Bar<typename T::I>;"; 1098 ConstrainedCode = "template<typename T>\n" 1099 " requires requires(T &&t) {\n" 1100 " typename T::I;\n" 1101 " }\n" 1102 "Bar(T) -> Bar<typename T::I>;"; 1103 BaseTokenCount = 19; 1104 RequiresTokenCount = 14; 1105 PrefixTokenCount = 5; 1106 TestRequires(__LINE__); 1107 1108 BaseCode = "struct [[nodiscard]] zero_t {\n" 1109 " template<class T>\n" 1110 " [[nodiscard]] constexpr operator T() const { return v<T>; }\n" 1111 "};"; 1112 ConstrainedCode = 1113 "struct [[nodiscard]] zero_t {\n" 1114 " template<class T>\n" 1115 " requires requires { v<T>; }\n" 1116 " [[nodiscard]] constexpr operator T() const { return v<T>; }\n" 1117 "};"; 1118 BaseTokenCount = 35; 1119 RequiresTokenCount = 9; 1120 PrefixTokenCount = 13; 1121 TestRequires(__LINE__); 1122 1123 BaseCode = "constexpr Foo(Foo const &other)\n" 1124 " : value{other.value} {\n" 1125 " do_magic();\n" 1126 " do_more_magic();\n" 1127 "}"; 1128 ConstrainedCode = "constexpr Foo(Foo const &other)\n" 1129 " requires std::is_copy_constructible<T>\n" 1130 " : value{other.value} {\n" 1131 " do_magic();\n" 1132 " do_more_magic();\n" 1133 "}"; 1134 BaseTokenCount = 26; 1135 RequiresTokenCount = 7; 1136 PrefixTokenCount = 8; 1137 TestRequires(__LINE__); 1138 1139 BaseCode = "constexpr Foo(Foo const &other)\n" 1140 " : value{other.value} {\n" 1141 " do_magic();\n" 1142 " do_more_magic();\n" 1143 "}"; 1144 ConstrainedCode = "constexpr Foo(Foo const &other)\n" 1145 " requires (std::is_copy_constructible<T>)\n" 1146 " : value{other.value} {\n" 1147 " do_magic();\n" 1148 " do_more_magic();\n" 1149 "}"; 1150 RequiresTokenCount = 9; 1151 TestRequires(__LINE__); 1152 } 1153 1154 TEST_F(TokenAnnotatorTest, UnderstandsAsm) { 1155 auto Tokens = annotate("__asm{\n" 1156 "a:\n" 1157 "};"); 1158 ASSERT_EQ(Tokens.size(), 7u) << Tokens; 1159 EXPECT_TOKEN(Tokens[0], tok::kw_asm, TT_Unknown); 1160 EXPECT_TOKEN(Tokens[1], tok::l_brace, TT_InlineASMBrace); 1161 EXPECT_TOKEN(Tokens[4], tok::r_brace, TT_InlineASMBrace); 1162 } 1163 1164 TEST_F(TokenAnnotatorTest, UnderstandsObjCBlock) { 1165 auto Tokens = annotate("int (^)() = ^ ()\n" 1166 " external_source_symbol() { //\n" 1167 " return 1;\n" 1168 "};"); 1169 ASSERT_EQ(Tokens.size(), 21u) << Tokens; 1170 EXPECT_TOKEN(Tokens[1], tok::l_paren, TT_ObjCBlockLParen); 1171 EXPECT_TOKEN(Tokens[13], tok::l_brace, TT_ObjCBlockLBrace); 1172 1173 Tokens = annotate("int *p = ^int*(){ //\n" 1174 " return nullptr;\n" 1175 "}();"); 1176 ASSERT_EQ(Tokens.size(), 19u) << Tokens; 1177 EXPECT_TOKEN(Tokens[9], tok::l_brace, TT_ObjCBlockLBrace); 1178 } 1179 1180 TEST_F(TokenAnnotatorTest, UnderstandsLambdas) { 1181 auto Tokens = annotate("[]() constexpr {}"); 1182 ASSERT_EQ(Tokens.size(), 8u) << Tokens; 1183 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1184 EXPECT_TOKEN(Tokens[5], tok::l_brace, TT_LambdaLBrace); 1185 1186 Tokens = annotate("[]() consteval {}"); 1187 ASSERT_EQ(Tokens.size(), 8u) << Tokens; 1188 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1189 EXPECT_TOKEN(Tokens[5], tok::l_brace, TT_LambdaLBrace); 1190 1191 Tokens = annotate("[]() mutable {}"); 1192 ASSERT_EQ(Tokens.size(), 8u) << Tokens; 1193 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1194 EXPECT_TOKEN(Tokens[5], tok::l_brace, TT_LambdaLBrace); 1195 1196 Tokens = annotate("[]() static {}"); 1197 ASSERT_EQ(Tokens.size(), 8u) << Tokens; 1198 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1199 EXPECT_TOKEN(Tokens[5], tok::l_brace, TT_LambdaLBrace); 1200 1201 Tokens = annotate("[]() -> auto {}"); 1202 ASSERT_EQ(Tokens.size(), 9u) << Tokens; 1203 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1204 EXPECT_TOKEN(Tokens[4], tok::arrow, TT_LambdaArrow); 1205 EXPECT_TOKEN(Tokens[6], tok::l_brace, TT_LambdaLBrace); 1206 1207 Tokens = annotate("[]() -> auto & {}"); 1208 ASSERT_EQ(Tokens.size(), 10u) << Tokens; 1209 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1210 EXPECT_TOKEN(Tokens[4], tok::arrow, TT_LambdaArrow); 1211 EXPECT_TOKEN(Tokens[7], tok::l_brace, TT_LambdaLBrace); 1212 1213 Tokens = annotate("[]() -> auto * {}"); 1214 ASSERT_EQ(Tokens.size(), 10u) << Tokens; 1215 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1216 EXPECT_TOKEN(Tokens[4], tok::arrow, TT_LambdaArrow); 1217 EXPECT_TOKEN(Tokens[7], tok::l_brace, TT_LambdaLBrace); 1218 1219 Tokens = annotate("[] {}"); 1220 ASSERT_EQ(Tokens.size(), 5u) << Tokens; 1221 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1222 EXPECT_TOKEN(Tokens[2], tok::l_brace, TT_LambdaLBrace); 1223 1224 Tokens = annotate("[] noexcept {}"); 1225 ASSERT_EQ(Tokens.size(), 6u) << Tokens; 1226 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1227 EXPECT_TOKEN(Tokens[3], tok::l_brace, TT_LambdaLBrace); 1228 1229 Tokens = annotate("[] -> auto {}"); 1230 ASSERT_EQ(Tokens.size(), 7u) << Tokens; 1231 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1232 EXPECT_TOKEN(Tokens[2], tok::arrow, TT_LambdaArrow); 1233 EXPECT_TOKEN(Tokens[4], tok::l_brace, TT_LambdaLBrace); 1234 1235 Tokens = annotate("[] <typename T> () {}"); 1236 ASSERT_EQ(Tokens.size(), 11u) << Tokens; 1237 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1238 EXPECT_TOKEN(Tokens[2], tok::less, TT_TemplateOpener); 1239 EXPECT_TOKEN(Tokens[8], tok::l_brace, TT_LambdaLBrace); 1240 1241 Tokens = annotate("[] <typename T> {}"); 1242 ASSERT_EQ(Tokens.size(), 9u) << Tokens; 1243 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1244 EXPECT_TOKEN(Tokens[2], tok::less, TT_TemplateOpener); 1245 EXPECT_TOKEN(Tokens[6], tok::l_brace, TT_LambdaLBrace); 1246 1247 Tokens = annotate("[] <typename... T> () {}"); 1248 ASSERT_EQ(Tokens.size(), 12u) << Tokens; 1249 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1250 EXPECT_TOKEN(Tokens[2], tok::less, TT_TemplateOpener); 1251 EXPECT_TOKEN(Tokens[9], tok::l_brace, TT_LambdaLBrace); 1252 1253 Tokens = annotate("[] <typename... T> {}"); 1254 ASSERT_EQ(Tokens.size(), 10u) << Tokens; 1255 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1256 EXPECT_TOKEN(Tokens[2], tok::less, TT_TemplateOpener); 1257 EXPECT_TOKEN(Tokens[7], tok::l_brace, TT_LambdaLBrace); 1258 1259 Tokens = annotate("[] <int... T> () {}"); 1260 ASSERT_EQ(Tokens.size(), 12u) << Tokens; 1261 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1262 EXPECT_TOKEN(Tokens[2], tok::less, TT_TemplateOpener); 1263 EXPECT_TOKEN(Tokens[9], tok::l_brace, TT_LambdaLBrace); 1264 1265 Tokens = annotate("[] <int... T> {}"); 1266 ASSERT_EQ(Tokens.size(), 10u) << Tokens; 1267 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1268 EXPECT_TOKEN(Tokens[2], tok::less, TT_TemplateOpener); 1269 EXPECT_TOKEN(Tokens[7], tok::l_brace, TT_LambdaLBrace); 1270 1271 Tokens = annotate("[] <Foo... T> () {}"); 1272 ASSERT_EQ(Tokens.size(), 12u) << Tokens; 1273 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1274 EXPECT_TOKEN(Tokens[2], tok::less, TT_TemplateOpener); 1275 EXPECT_TOKEN(Tokens[9], tok::l_brace, TT_LambdaLBrace); 1276 1277 Tokens = annotate("[] <Foo... T> {}"); 1278 ASSERT_EQ(Tokens.size(), 10u) << Tokens; 1279 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1280 EXPECT_TOKEN(Tokens[2], tok::less, TT_TemplateOpener); 1281 EXPECT_TOKEN(Tokens[7], tok::l_brace, TT_LambdaLBrace); 1282 1283 // Lambdas with a requires-clause 1284 Tokens = annotate("[] <typename T> (T t) requires Bar<T> {}"); 1285 ASSERT_EQ(Tokens.size(), 18u) << Tokens; 1286 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1287 EXPECT_TOKEN(Tokens[2], tok::less, TT_TemplateOpener); 1288 EXPECT_TOKEN(Tokens[10], tok::kw_requires, TT_RequiresClause); 1289 EXPECT_TRUE(Tokens[14]->ClosesRequiresClause); 1290 EXPECT_TOKEN(Tokens[15], tok::l_brace, TT_LambdaLBrace); 1291 1292 Tokens = annotate("[] <typename T> (T &&t) requires Bar<T> {}"); 1293 ASSERT_EQ(Tokens.size(), 19u) << Tokens; 1294 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1295 EXPECT_TOKEN(Tokens[2], tok::less, TT_TemplateOpener); 1296 EXPECT_TOKEN(Tokens[8], tok::ampamp, TT_PointerOrReference); 1297 EXPECT_TOKEN(Tokens[11], tok::kw_requires, TT_RequiresClause); 1298 EXPECT_TRUE(Tokens[15]->ClosesRequiresClause); 1299 EXPECT_TOKEN(Tokens[16], tok::l_brace, TT_LambdaLBrace); 1300 1301 Tokens = annotate("[] <typename T> (T t) requires Foo<T> || Bar<T> {}"); 1302 ASSERT_EQ(Tokens.size(), 23u) << Tokens; 1303 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1304 EXPECT_TOKEN(Tokens[2], tok::less, TT_TemplateOpener); 1305 EXPECT_TOKEN(Tokens[10], tok::kw_requires, TT_RequiresClause); 1306 EXPECT_TRUE(Tokens[19]->ClosesRequiresClause); 1307 EXPECT_TOKEN(Tokens[20], tok::l_brace, TT_LambdaLBrace); 1308 1309 Tokens = annotate("[] <typename T> (T t) -> T requires Bar<T> {}"); 1310 ASSERT_EQ(Tokens.size(), 20u) << Tokens; 1311 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1312 EXPECT_TOKEN(Tokens[2], tok::less, TT_TemplateOpener); 1313 EXPECT_TOKEN(Tokens[10], tok::arrow, TT_LambdaArrow); 1314 EXPECT_TOKEN(Tokens[12], tok::kw_requires, TT_RequiresClause); 1315 EXPECT_TRUE(Tokens[16]->ClosesRequiresClause); 1316 EXPECT_TOKEN(Tokens[17], tok::l_brace, TT_LambdaLBrace); 1317 1318 Tokens = annotate("[] <typename T> requires Bar<T> (T t) {}"); 1319 ASSERT_EQ(Tokens.size(), 18u) << Tokens; 1320 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1321 EXPECT_TOKEN(Tokens[2], tok::less, TT_TemplateOpener); 1322 EXPECT_TOKEN(Tokens[6], tok::kw_requires, TT_RequiresClause); 1323 EXPECT_TRUE(Tokens[10]->ClosesRequiresClause); 1324 EXPECT_TOKEN(Tokens[15], tok::l_brace, TT_LambdaLBrace); 1325 1326 Tokens = annotate("[] <typename T> requires Bar<T> (T &&t) {}"); 1327 ASSERT_EQ(Tokens.size(), 19u) << Tokens; 1328 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1329 EXPECT_TOKEN(Tokens[2], tok::less, TT_TemplateOpener); 1330 EXPECT_TOKEN(Tokens[6], tok::kw_requires, TT_RequiresClause); 1331 EXPECT_TRUE(Tokens[10]->ClosesRequiresClause); 1332 EXPECT_TOKEN(Tokens[13], tok::ampamp, TT_PointerOrReference); 1333 EXPECT_TOKEN(Tokens[16], tok::l_brace, TT_LambdaLBrace); 1334 1335 Tokens = annotate("[] <typename T> requires Foo<T> || Bar<T> (T t) {}"); 1336 ASSERT_EQ(Tokens.size(), 23u) << Tokens; 1337 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1338 EXPECT_TOKEN(Tokens[2], tok::less, TT_TemplateOpener); 1339 EXPECT_TOKEN(Tokens[6], tok::kw_requires, TT_RequiresClause); 1340 EXPECT_TRUE(Tokens[15]->ClosesRequiresClause); 1341 EXPECT_TOKEN(Tokens[20], tok::l_brace, TT_LambdaLBrace); 1342 1343 Tokens = annotate("[] <typename T> requires true (T&& t) {}"); 1344 ASSERT_EQ(Tokens.size(), 16u) << Tokens; 1345 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1346 EXPECT_TOKEN(Tokens[2], tok::less, TT_TemplateOpener); 1347 EXPECT_TOKEN(Tokens[6], tok::kw_requires, TT_RequiresClause); 1348 EXPECT_TRUE(Tokens[7]->ClosesRequiresClause); 1349 EXPECT_TOKEN(Tokens[10], tok::ampamp, TT_PointerOrReference); 1350 EXPECT_TOKEN(Tokens[13], tok::l_brace, TT_LambdaLBrace); 1351 1352 Tokens = annotate("[] <typename T> requires Bar<T> {}"); 1353 ASSERT_EQ(Tokens.size(), 14u) << Tokens; 1354 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1355 EXPECT_TOKEN(Tokens[2], tok::less, TT_TemplateOpener); 1356 EXPECT_TOKEN(Tokens[6], tok::kw_requires, TT_RequiresClause); 1357 EXPECT_TRUE(Tokens[10]->ClosesRequiresClause); 1358 EXPECT_TOKEN(Tokens[11], tok::l_brace, TT_LambdaLBrace); 1359 1360 Tokens = annotate("[] <typename T> requires Bar<T> noexcept {}"); 1361 ASSERT_EQ(Tokens.size(), 15u) << Tokens; 1362 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1363 EXPECT_TOKEN(Tokens[2], tok::less, TT_TemplateOpener); 1364 EXPECT_TOKEN(Tokens[6], tok::kw_requires, TT_RequiresClause); 1365 EXPECT_TRUE(Tokens[10]->ClosesRequiresClause); 1366 EXPECT_TOKEN(Tokens[12], tok::l_brace, TT_LambdaLBrace); 1367 1368 Tokens = annotate("[] <typename T> requires Bar<T> -> T {}"); 1369 ASSERT_EQ(Tokens.size(), 16u) << Tokens; 1370 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1371 EXPECT_TOKEN(Tokens[2], tok::less, TT_TemplateOpener); 1372 EXPECT_TOKEN(Tokens[6], tok::kw_requires, TT_RequiresClause); 1373 EXPECT_TRUE(Tokens[10]->ClosesRequiresClause); 1374 EXPECT_TOKEN(Tokens[11], tok::arrow, TT_LambdaArrow); 1375 EXPECT_TOKEN(Tokens[13], tok::l_brace, TT_LambdaLBrace); 1376 1377 Tokens = annotate("[] <typename T> requires Foo<T> (T t) requires Bar<T> {}"); 1378 ASSERT_EQ(Tokens.size(), 23u) << Tokens; 1379 EXPECT_TOKEN(Tokens[0], tok::l_square, TT_LambdaLSquare); 1380 EXPECT_TOKEN(Tokens[2], tok::less, TT_TemplateOpener); 1381 EXPECT_TOKEN(Tokens[6], tok::kw_requires, TT_RequiresClause); 1382 EXPECT_TRUE(Tokens[10]->ClosesRequiresClause); 1383 EXPECT_TOKEN(Tokens[15], tok::kw_requires, TT_RequiresClause); 1384 EXPECT_TRUE(Tokens[19]->ClosesRequiresClause); 1385 EXPECT_TOKEN(Tokens[20], tok::l_brace, TT_LambdaLBrace); 1386 } 1387 1388 TEST_F(TokenAnnotatorTest, UnderstandsFunctionAnnotations) { 1389 auto Tokens = annotate("template <typename T>\n" 1390 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 1391 "string OldFunction(const string ¶meter) {}"); 1392 ASSERT_EQ(Tokens.size(), 20u) << Tokens; 1393 EXPECT_TOKEN(Tokens[8], tok::r_paren, TT_FunctionAnnotationRParen); 1394 1395 Tokens = annotate("template <typename T>\n" 1396 "A(T) noexcept;"); 1397 ASSERT_EQ(Tokens.size(), 12u) << Tokens; 1398 EXPECT_TOKEN(Tokens[8], tok::r_paren, TT_Unknown); 1399 } 1400 1401 TEST_F(TokenAnnotatorTest, UnderstandsFunctionDeclarationNames) { 1402 auto Tokens = annotate("void f [[noreturn]] ();"); 1403 ASSERT_EQ(Tokens.size(), 11u) << Tokens; 1404 EXPECT_TOKEN(Tokens[1], tok::identifier, TT_FunctionDeclarationName); 1405 1406 Tokens = annotate("void f [[noreturn]] () {}"); 1407 ASSERT_EQ(Tokens.size(), 12u) << Tokens; 1408 EXPECT_TOKEN(Tokens[1], tok::identifier, TT_FunctionDeclarationName); 1409 } 1410 1411 TEST_F(TokenAnnotatorTest, UnderstandsC11GenericSelection) { 1412 auto Tokens = annotate("_Generic(x, int: 1, default: 0)"); 1413 ASSERT_EQ(Tokens.size(), 13u) << Tokens; 1414 EXPECT_TOKEN(Tokens[0], tok::kw__Generic, TT_Unknown); 1415 EXPECT_TOKEN(Tokens[5], tok::colon, TT_GenericSelectionColon); 1416 EXPECT_TOKEN(Tokens[9], tok::colon, TT_GenericSelectionColon); 1417 } 1418 1419 TEST_F(TokenAnnotatorTest, UnderstandsVerilogOperators) { 1420 auto Annotate = [this](llvm::StringRef Code) { 1421 return annotate(Code, getLLVMStyle(FormatStyle::LK_Verilog)); 1422 }; 1423 // Test that unary operators get labeled as such and that operators like '++' 1424 // don't get split. 1425 tok::TokenKind Unary[] = {tok::plus, tok::minus, tok::exclaim, 1426 tok::tilde, tok::amp, tok::pipe, 1427 tok::caret, tok::plusplus, tok::minusminus}; 1428 for (auto Kind : Unary) { 1429 auto Tokens = 1430 Annotate(std::string("x = ") + tok::getPunctuatorSpelling(Kind) + "x;"); 1431 ASSERT_EQ(Tokens.size(), 6u) << Tokens; 1432 EXPECT_TOKEN(Tokens[2], Kind, TT_UnaryOperator); 1433 } 1434 // Operators formed by joining two operators like '^~'. For some of these 1435 // joined operators, we don't have a separate type, so we only test for their 1436 // precedence. 1437 std::pair<prec::Level, std::string> JoinedBinary[] = { 1438 {prec::Comma, "<->"}, {prec::Assignment, "+="}, 1439 {prec::Assignment, "-="}, {prec::Assignment, "*="}, 1440 {prec::Assignment, "/="}, {prec::Assignment, "%="}, 1441 {prec::Assignment, "&="}, {prec::Assignment, "^="}, 1442 {prec::Assignment, "<<="}, {prec::Assignment, ">>="}, 1443 {prec::Assignment, "<<<="}, {prec::Assignment, ">>>="}, 1444 {prec::LogicalOr, "||"}, {prec::LogicalAnd, "&&"}, 1445 {prec::Equality, "=="}, {prec::Equality, "!="}, 1446 {prec::Equality, "==="}, {prec::Equality, "!=="}, 1447 {prec::Equality, "==?"}, {prec::Equality, "!=?"}, 1448 {prec::ExclusiveOr, "~^"}, {prec::ExclusiveOr, "^~"}, 1449 }; 1450 for (auto Operator : JoinedBinary) { 1451 auto Tokens = Annotate(std::string("x = x ") + Operator.second + " x;"); 1452 ASSERT_EQ(Tokens.size(), 7u) << Tokens; 1453 EXPECT_TOKEN_TYPE(Tokens[3], TT_BinaryOperator); 1454 EXPECT_TOKEN_PRECEDENCE(Tokens[3], Operator.first); 1455 } 1456 // '~^' and '^~' can be unary as well as binary operators. 1457 auto Tokens = Annotate("x = ~^x;"); 1458 ASSERT_EQ(Tokens.size(), 6u) << Tokens; 1459 EXPECT_TOKEN_TYPE(Tokens[2], TT_UnaryOperator); 1460 Tokens = Annotate("x = ^~x;"); 1461 ASSERT_EQ(Tokens.size(), 6u) << Tokens; 1462 EXPECT_TOKEN_TYPE(Tokens[2], TT_UnaryOperator); 1463 // The unary operators '~&' and '~|' can only be unary operators. The current 1464 // implementation treats each of them as separate unary '~' and '&' or '|' 1465 // operators, which is enough for formatting purposes. In FormatTestVerilog, 1466 // there is a test that there is no space in between. And even if a new line 1467 // is inserted between the '~' and '|', the semantic meaning is the same as 1468 // the joined operator, so the CanBreakBefore property doesn't need to be 1469 // false for the second operator. 1470 Tokens = Annotate("x = ~&x;"); 1471 ASSERT_EQ(Tokens.size(), 7u) << Tokens; 1472 EXPECT_TOKEN(Tokens[2], tok::tilde, TT_UnaryOperator); 1473 EXPECT_TOKEN(Tokens[3], tok::amp, TT_UnaryOperator); 1474 Tokens = Annotate("x = ~|x;"); 1475 ASSERT_EQ(Tokens.size(), 7u) << Tokens; 1476 EXPECT_TOKEN(Tokens[2], tok::tilde, TT_UnaryOperator); 1477 EXPECT_TOKEN(Tokens[3], tok::pipe, TT_UnaryOperator); 1478 // Test for block label colons. 1479 Tokens = Annotate("begin : x\n" 1480 "end : x"); 1481 ASSERT_EQ(Tokens.size(), 7u); 1482 EXPECT_TOKEN(Tokens[1], tok::colon, TT_VerilogBlockLabelColon); 1483 EXPECT_TOKEN(Tokens[4], tok::colon, TT_VerilogBlockLabelColon); 1484 // Test that the dimension colon is annotated correctly. 1485 Tokens = Annotate("var [1 : 0] x;"); 1486 ASSERT_EQ(Tokens.size(), 9u) << Tokens; 1487 EXPECT_TOKEN(Tokens[3], tok::colon, TT_BitFieldColon); 1488 Tokens = Annotate("extern function [1 : 0] x;"); 1489 ASSERT_EQ(Tokens.size(), 10u) << Tokens; 1490 EXPECT_TOKEN(Tokens[4], tok::colon, TT_BitFieldColon); 1491 // Test case labels and ternary operators. 1492 Tokens = Annotate("case (x)\n" 1493 " x:\n" 1494 " x;\n" 1495 "endcase\n"); 1496 ASSERT_EQ(Tokens.size(), 10u) << Tokens; 1497 EXPECT_TOKEN(Tokens[5], tok::colon, TT_GotoLabelColon); 1498 Tokens = Annotate("case (x)\n" 1499 " x ? x : x:\n" 1500 " x;\n" 1501 "endcase\n"); 1502 ASSERT_EQ(Tokens.size(), 14u) << Tokens; 1503 EXPECT_TOKEN(Tokens[5], tok::question, TT_ConditionalExpr); 1504 EXPECT_TOKEN(Tokens[7], tok::colon, TT_ConditionalExpr); 1505 EXPECT_TOKEN(Tokens[9], tok::colon, TT_GotoLabelColon); 1506 // Non-blocking assignments. 1507 Tokens = Annotate("a <= b;"); 1508 ASSERT_EQ(Tokens.size(), 5u); 1509 EXPECT_TOKEN(Tokens[1], tok::lessequal, TT_BinaryOperator); 1510 EXPECT_TOKEN_PRECEDENCE(Tokens[1], prec::Assignment); 1511 Tokens = Annotate("if (a <= b) break;"); 1512 ASSERT_EQ(Tokens.size(), 9u); 1513 EXPECT_TOKEN(Tokens[3], tok::lessequal, TT_BinaryOperator); 1514 EXPECT_TOKEN_PRECEDENCE(Tokens[3], prec::Relational); 1515 Tokens = Annotate("a <= b <= a;"); 1516 ASSERT_EQ(Tokens.size(), 7u); 1517 EXPECT_TOKEN(Tokens[1], tok::lessequal, TT_BinaryOperator); 1518 EXPECT_TOKEN_PRECEDENCE(Tokens[1], prec::Assignment); 1519 EXPECT_TOKEN(Tokens[3], tok::lessequal, TT_BinaryOperator); 1520 EXPECT_TOKEN_PRECEDENCE(Tokens[3], prec::Relational); 1521 } 1522 1523 TEST_F(TokenAnnotatorTest, UnderstandConstructors) { 1524 auto Tokens = annotate("Class::Class() : BaseClass(), Member() {}"); 1525 1526 // The TT_Unknown is clearly not binding for the future, please adapt if those 1527 // tokens get annotated. 1528 ASSERT_EQ(Tokens.size(), 16u) << Tokens; 1529 EXPECT_TOKEN(Tokens[5], tok::colon, TT_CtorInitializerColon); 1530 EXPECT_TOKEN(Tokens[6], tok::identifier, TT_Unknown); 1531 EXPECT_TOKEN(Tokens[7], tok::l_paren, TT_Unknown); 1532 EXPECT_TOKEN(Tokens[8], tok::r_paren, TT_Unknown); 1533 EXPECT_TOKEN(Tokens[9], tok::comma, TT_CtorInitializerComma); 1534 EXPECT_TOKEN(Tokens[10], tok::identifier, TT_Unknown); 1535 EXPECT_TOKEN(Tokens[11], tok::l_paren, TT_Unknown); 1536 EXPECT_TOKEN(Tokens[12], tok::r_paren, TT_Unknown); 1537 EXPECT_TOKEN(Tokens[13], tok::l_brace, TT_FunctionLBrace); 1538 1539 Tokens = annotate("Class::Class() : BaseClass{}, Member{} {}"); 1540 ASSERT_EQ(Tokens.size(), 16u) << Tokens; 1541 EXPECT_TOKEN(Tokens[5], tok::colon, TT_CtorInitializerColon); 1542 EXPECT_TOKEN(Tokens[6], tok::identifier, TT_Unknown); 1543 EXPECT_TOKEN(Tokens[7], tok::l_brace, TT_Unknown); 1544 EXPECT_TOKEN(Tokens[8], tok::r_brace, TT_Unknown); 1545 EXPECT_TOKEN(Tokens[9], tok::comma, TT_CtorInitializerComma); 1546 EXPECT_TOKEN(Tokens[10], tok::identifier, TT_Unknown); 1547 EXPECT_TOKEN(Tokens[11], tok::l_brace, TT_Unknown); 1548 EXPECT_TOKEN(Tokens[12], tok::r_brace, TT_Unknown); 1549 EXPECT_TOKEN(Tokens[13], tok::l_brace, TT_FunctionLBrace); 1550 } 1551 1552 } // namespace 1553 } // namespace format 1554 } // namespace clang 1555