1 //===- BuildTreeTest.cpp --------------------------------------------------===// 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 // This file tests the syntax tree generation from the ClangAST. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "TreeTestBase.h" 14 15 using namespace clang; 16 using namespace clang::syntax; 17 18 namespace { 19 20 class BuildSyntaxTreeTest : public SyntaxTreeTest { 21 protected: 22 ::testing::AssertionResult treeDumpEqual(StringRef Code, StringRef Tree) { 23 SCOPED_TRACE(llvm::join(GetParam().getCommandLineArgs(), " ")); 24 25 auto *Root = buildTree(Code, GetParam()); 26 auto ErrorOK = errorOK(Code); 27 if (!ErrorOK) 28 return ErrorOK; 29 auto Actual = StringRef(Root->dump(*TM)).trim().str(); 30 // EXPECT_EQ shows the diff between the two strings if they are different. 31 EXPECT_EQ(Tree.trim().str(), Actual); 32 if (Actual != Tree.trim().str()) { 33 return ::testing::AssertionFailure(); 34 } 35 return ::testing::AssertionSuccess(); 36 } 37 38 ::testing::AssertionResult 39 treeDumpEqualOnAnnotations(StringRef CodeWithAnnotations, 40 ArrayRef<StringRef> TreeDumps) { 41 SCOPED_TRACE(llvm::join(GetParam().getCommandLineArgs(), " ")); 42 43 auto AnnotatedCode = llvm::Annotations(CodeWithAnnotations); 44 auto *Root = buildTree(AnnotatedCode.code(), GetParam()); 45 46 auto ErrorOK = errorOK(AnnotatedCode.code()); 47 if (!ErrorOK) 48 return ErrorOK; 49 50 auto AnnotatedRanges = AnnotatedCode.ranges(); 51 if (AnnotatedRanges.size() != TreeDumps.size()) { 52 return ::testing::AssertionFailure() 53 << "The number of annotated ranges in the source code is " 54 "different " 55 "to the number of their corresponding tree dumps."; 56 } 57 bool Failed = false; 58 for (unsigned i = 0; i < AnnotatedRanges.size(); i++) { 59 auto *AnnotatedNode = nodeByRange(AnnotatedRanges[i], Root); 60 assert(AnnotatedNode); 61 auto AnnotatedNodeDump = 62 StringRef(AnnotatedNode->dump(*TM)) 63 .trim() 64 .str(); 65 // EXPECT_EQ shows the diff between the two strings if they are different. 66 EXPECT_EQ(TreeDumps[i].trim().str(), AnnotatedNodeDump) 67 << "Dumps diverged for the code:\n" 68 << AnnotatedCode.code().slice(AnnotatedRanges[i].Begin, 69 AnnotatedRanges[i].End); 70 if (AnnotatedNodeDump != TreeDumps[i].trim().str()) 71 Failed = true; 72 } 73 return Failed ? ::testing::AssertionFailure() 74 : ::testing::AssertionSuccess(); 75 } 76 77 private: 78 ::testing::AssertionResult errorOK(StringRef RawCode) { 79 if (!RawCode.contains("error-ok")) { 80 if (Diags->getClient()->getNumErrors() != 0) { 81 return ::testing::AssertionFailure() 82 << "Source file has syntax errors (suppress with /*error-ok*/), " 83 "they were printed to the " 84 "test log"; 85 } 86 } 87 return ::testing::AssertionSuccess(); 88 } 89 }; 90 91 INSTANTIATE_TEST_SUITE_P(SyntaxTreeTests, BuildSyntaxTreeTest, 92 testing::ValuesIn(allTestClangConfigs()) ); 93 94 TEST_P(BuildSyntaxTreeTest, Simple) { 95 EXPECT_TRUE(treeDumpEqual( 96 R"cpp( 97 int main() {} 98 void foo() {} 99 )cpp", 100 R"txt( 101 TranslationUnit Detached 102 |-SimpleDeclaration 103 | |-'int' 104 | |-DeclaratorList Declarators 105 | | `-SimpleDeclarator ListElement 106 | | |-'main' 107 | | `-ParametersAndQualifiers 108 | | |-'(' OpenParen 109 | | `-')' CloseParen 110 | `-CompoundStatement 111 | |-'{' OpenParen 112 | `-'}' CloseParen 113 `-SimpleDeclaration 114 |-'void' 115 |-DeclaratorList Declarators 116 | `-SimpleDeclarator ListElement 117 | |-'foo' 118 | `-ParametersAndQualifiers 119 | |-'(' OpenParen 120 | `-')' CloseParen 121 `-CompoundStatement 122 |-'{' OpenParen 123 `-'}' CloseParen 124 )txt")); 125 } 126 127 TEST_P(BuildSyntaxTreeTest, SimpleVariable) { 128 EXPECT_TRUE(treeDumpEqual( 129 R"cpp( 130 int a; 131 int b = 42; 132 )cpp", 133 R"txt( 134 TranslationUnit Detached 135 |-SimpleDeclaration 136 | |-'int' 137 | |-DeclaratorList Declarators 138 | | `-SimpleDeclarator ListElement 139 | | `-'a' 140 | `-';' 141 `-SimpleDeclaration 142 |-'int' 143 |-DeclaratorList Declarators 144 | `-SimpleDeclarator ListElement 145 | |-'b' 146 | |-'=' 147 | `-IntegerLiteralExpression 148 | `-'42' LiteralToken 149 `-';' 150 )txt")); 151 } 152 153 TEST_P(BuildSyntaxTreeTest, SimpleFunction) { 154 EXPECT_TRUE(treeDumpEqual( 155 R"cpp( 156 void foo(int a, int b) {} 157 )cpp", 158 R"txt( 159 TranslationUnit Detached 160 `-SimpleDeclaration 161 |-'void' 162 |-DeclaratorList Declarators 163 | `-SimpleDeclarator ListElement 164 | |-'foo' 165 | `-ParametersAndQualifiers 166 | |-'(' OpenParen 167 | |-ParameterDeclarationList Parameters 168 | | |-SimpleDeclaration ListElement 169 | | | |-'int' 170 | | | `-DeclaratorList Declarators 171 | | | `-SimpleDeclarator ListElement 172 | | | `-'a' 173 | | |-',' ListDelimiter 174 | | `-SimpleDeclaration ListElement 175 | | |-'int' 176 | | `-DeclaratorList Declarators 177 | | `-SimpleDeclarator ListElement 178 | | `-'b' 179 | `-')' CloseParen 180 `-CompoundStatement 181 |-'{' OpenParen 182 `-'}' CloseParen 183 )txt")); 184 } 185 186 TEST_P(BuildSyntaxTreeTest, Simple_BackslashInsideToken) { 187 EXPECT_TRUE(treeDumpEqual( 188 R"cpp( 189 in\ 190 t a; 191 )cpp", 192 R"txt( 193 TranslationUnit Detached 194 `-SimpleDeclaration 195 |-'in\ 196 t' 197 |-DeclaratorList Declarators 198 | `-SimpleDeclarator ListElement 199 | `-'a' 200 `-';' 201 )txt")); 202 } 203 204 TEST_P(BuildSyntaxTreeTest, If) { 205 EXPECT_TRUE(treeDumpEqualOnAnnotations( 206 R"cpp( 207 void test() { 208 [[if (1) {}]] 209 [[if (1) {} else if (0) {}]] 210 } 211 )cpp", 212 {R"txt( 213 IfStatement Statement 214 |-'if' IntroducerKeyword 215 |-'(' 216 |-ExpressionStatement Condition 217 | `-IntegerLiteralExpression Expression 218 | `-'1' LiteralToken 219 |-')' 220 `-CompoundStatement ThenStatement 221 |-'{' OpenParen 222 `-'}' CloseParen 223 )txt", 224 R"txt( 225 IfStatement Statement 226 |-'if' IntroducerKeyword 227 |-'(' 228 |-ExpressionStatement Condition 229 | `-IntegerLiteralExpression Expression 230 | `-'1' LiteralToken 231 |-')' 232 |-CompoundStatement ThenStatement 233 | |-'{' OpenParen 234 | `-'}' CloseParen 235 |-'else' ElseKeyword 236 `-IfStatement ElseStatement 237 |-'if' IntroducerKeyword 238 |-'(' 239 |-ExpressionStatement Condition 240 | `-IntegerLiteralExpression Expression 241 | `-'0' LiteralToken 242 |-')' 243 `-CompoundStatement ThenStatement 244 |-'{' OpenParen 245 `-'}' CloseParen 246 )txt"})); 247 } 248 249 TEST_P(BuildSyntaxTreeTest, IfDecl) { 250 if (!GetParam().isCXX17OrLater()) { 251 return; 252 } 253 EXPECT_TRUE(treeDumpEqualOnAnnotations( 254 R"cpp( 255 void test() { 256 [[if (int a = 5) {}]] 257 [[if (int a; a == 5) {}]] 258 } 259 )cpp", 260 {R"txt( 261 IfStatement Statement 262 |-'if' IntroducerKeyword 263 |-'(' 264 |-DeclarationStatement Condition 265 | `-SimpleDeclaration 266 | |-'int' 267 | `-DeclaratorList Declarators 268 | `-SimpleDeclarator ListElement 269 | |-'a' 270 | |-'=' 271 | `-IntegerLiteralExpression 272 | `-'5' LiteralToken 273 |-')' 274 `-CompoundStatement ThenStatement 275 |-'{' OpenParen 276 `-'}' CloseParen 277 )txt", 278 R"txt( 279 IfStatement Statement 280 |-'if' IntroducerKeyword 281 |-'(' 282 |-DeclarationStatement 283 | |-SimpleDeclaration 284 | | |-'int' 285 | | `-DeclaratorList Declarators 286 | | `-SimpleDeclarator ListElement 287 | | `-'a' 288 | `-';' 289 |-ExpressionStatement Condition 290 | `-BinaryOperatorExpression Expression 291 | |-IdExpression LeftHandSide 292 | | `-UnqualifiedId UnqualifiedId 293 | | `-'a' 294 | |-'==' OperatorToken 295 | `-IntegerLiteralExpression RightHandSide 296 | `-'5' LiteralToken 297 |-')' 298 `-CompoundStatement ThenStatement 299 |-'{' OpenParen 300 `-'}' CloseParen 301 )txt"})); 302 } 303 304 TEST_P(BuildSyntaxTreeTest, For) { 305 EXPECT_TRUE(treeDumpEqualOnAnnotations( 306 R"cpp( 307 void test() { 308 [[for (;;) {}]] 309 } 310 )cpp", 311 {R"txt( 312 ForStatement Statement 313 |-'for' IntroducerKeyword 314 |-'(' 315 |-';' 316 |-';' 317 |-')' 318 `-CompoundStatement BodyStatement 319 |-'{' OpenParen 320 `-'}' CloseParen 321 )txt"})); 322 } 323 324 TEST_P(BuildSyntaxTreeTest, RangeBasedFor) { 325 if (!GetParam().isCXX11OrLater()) { 326 return; 327 } 328 EXPECT_TRUE(treeDumpEqualOnAnnotations( 329 R"cpp( 330 void test() { 331 int a[3]; 332 [[for (int x : a) 333 ;]] 334 } 335 )cpp", 336 {R"txt( 337 RangeBasedForStatement Statement 338 |-'for' IntroducerKeyword 339 |-'(' 340 |-SimpleDeclaration 341 | |-'int' 342 | |-DeclaratorList Declarators 343 | | `-SimpleDeclarator ListElement 344 | | `-'x' 345 | `-':' 346 |-IdExpression 347 | `-UnqualifiedId UnqualifiedId 348 | `-'a' 349 |-')' 350 `-EmptyStatement BodyStatement 351 `-';' 352 )txt"})); 353 } 354 355 TEST_P(BuildSyntaxTreeTest, DeclarationStatement) { 356 EXPECT_TRUE(treeDumpEqualOnAnnotations( 357 R"cpp( 358 void test() { 359 [[int a = 10;]] 360 } 361 )cpp", 362 {R"txt( 363 DeclarationStatement Statement 364 |-SimpleDeclaration 365 | |-'int' 366 | `-DeclaratorList Declarators 367 | `-SimpleDeclarator ListElement 368 | |-'a' 369 | |-'=' 370 | `-IntegerLiteralExpression 371 | `-'10' LiteralToken 372 `-';' 373 )txt"})); 374 } 375 376 TEST_P(BuildSyntaxTreeTest, Switch) { 377 EXPECT_TRUE(treeDumpEqualOnAnnotations( 378 R"cpp( 379 void test() { 380 [[switch (1) { 381 case 0: 382 default:; 383 }]] 384 } 385 )cpp", 386 {R"txt( 387 SwitchStatement Statement 388 |-'switch' IntroducerKeyword 389 |-'(' 390 |-IntegerLiteralExpression 391 | `-'1' LiteralToken 392 |-')' 393 `-CompoundStatement BodyStatement 394 |-'{' OpenParen 395 |-CaseStatement Statement 396 | |-'case' IntroducerKeyword 397 | |-IntegerLiteralExpression CaseValue 398 | | `-'0' LiteralToken 399 | |-':' 400 | `-DefaultStatement BodyStatement 401 | |-'default' IntroducerKeyword 402 | |-':' 403 | `-EmptyStatement BodyStatement 404 | `-';' 405 `-'}' CloseParen 406 )txt"})); 407 } 408 409 TEST_P(BuildSyntaxTreeTest, While) { 410 EXPECT_TRUE(treeDumpEqualOnAnnotations( 411 R"cpp( 412 void test() { 413 [[while (1) { continue; break; }]] 414 } 415 )cpp", 416 {R"txt( 417 WhileStatement Statement 418 |-'while' IntroducerKeyword 419 |-'(' 420 |-IntegerLiteralExpression 421 | `-'1' LiteralToken 422 |-')' 423 `-CompoundStatement BodyStatement 424 |-'{' OpenParen 425 |-ContinueStatement Statement 426 | |-'continue' IntroducerKeyword 427 | `-';' 428 |-BreakStatement Statement 429 | |-'break' IntroducerKeyword 430 | `-';' 431 `-'}' CloseParen 432 )txt"})); 433 } 434 435 TEST_P(BuildSyntaxTreeTest, UnhandledStatement) { 436 // Unhandled statements should end up as 'unknown statement'. 437 // This example uses a 'label statement', which does not yet have a syntax 438 // counterpart. 439 EXPECT_TRUE(treeDumpEqualOnAnnotations( 440 R"cpp( 441 int test() { 442 [[foo: return 100;]] 443 } 444 )cpp", 445 {R"txt( 446 UnknownStatement Statement 447 |-'foo' 448 |-':' 449 `-ReturnStatement 450 |-'return' IntroducerKeyword 451 |-IntegerLiteralExpression ReturnValue 452 | `-'100' LiteralToken 453 `-';' 454 )txt"})); 455 } 456 457 TEST_P(BuildSyntaxTreeTest, Expressions) { 458 // expressions should be wrapped in 'ExpressionStatement' when they appear 459 // in a statement position. 460 EXPECT_TRUE(treeDumpEqual( 461 R"cpp( 462 void test() { 463 test(); 464 if (1) test(); else test(); 465 } 466 )cpp", 467 R"txt( 468 TranslationUnit Detached 469 `-SimpleDeclaration 470 |-'void' 471 |-DeclaratorList Declarators 472 | `-SimpleDeclarator ListElement 473 | |-'test' 474 | `-ParametersAndQualifiers 475 | |-'(' OpenParen 476 | `-')' CloseParen 477 `-CompoundStatement 478 |-'{' OpenParen 479 |-ExpressionStatement Statement 480 | |-CallExpression Expression 481 | | |-IdExpression Callee 482 | | | `-UnqualifiedId UnqualifiedId 483 | | | `-'test' 484 | | |-'(' OpenParen 485 | | `-')' CloseParen 486 | `-';' 487 |-IfStatement Statement 488 | |-'if' IntroducerKeyword 489 | |-'(' 490 | |-ExpressionStatement Condition 491 | | `-IntegerLiteralExpression Expression 492 | | `-'1' LiteralToken 493 | |-')' 494 | |-ExpressionStatement ThenStatement 495 | | |-CallExpression Expression 496 | | | |-IdExpression Callee 497 | | | | `-UnqualifiedId UnqualifiedId 498 | | | | `-'test' 499 | | | |-'(' OpenParen 500 | | | `-')' CloseParen 501 | | `-';' 502 | |-'else' ElseKeyword 503 | `-ExpressionStatement ElseStatement 504 | |-CallExpression Expression 505 | | |-IdExpression Callee 506 | | | `-UnqualifiedId UnqualifiedId 507 | | | `-'test' 508 | | |-'(' OpenParen 509 | | `-')' CloseParen 510 | `-';' 511 `-'}' CloseParen 512 )txt")); 513 } 514 515 TEST_P(BuildSyntaxTreeTest, ConditionalOperator) { 516 // FIXME: conditional expression is not modeled yet. 517 EXPECT_TRUE(treeDumpEqualOnAnnotations( 518 R"cpp( 519 void test() { 520 [[1?:2]]; 521 } 522 )cpp", 523 {R"txt( 524 UnknownExpression Expression 525 |-IntegerLiteralExpression 526 | `-'1' LiteralToken 527 |-'?' 528 |-':' 529 `-IntegerLiteralExpression 530 `-'2' LiteralToken 531 )txt"})); 532 } 533 534 TEST_P(BuildSyntaxTreeTest, UnqualifiedId_Identifier) { 535 EXPECT_TRUE(treeDumpEqualOnAnnotations( 536 R"cpp( 537 void test(int a) { 538 [[a]]; 539 } 540 )cpp", 541 {R"txt( 542 IdExpression Expression 543 `-UnqualifiedId UnqualifiedId 544 `-'a' 545 )txt"})); 546 } 547 548 TEST_P(BuildSyntaxTreeTest, UnqualifiedId_OperatorFunctionId) { 549 if (!GetParam().isCXX()) { 550 return; 551 } 552 EXPECT_TRUE(treeDumpEqualOnAnnotations( 553 R"cpp( 554 struct X { 555 friend X operator+(const X&, const X&); 556 }; 557 void test(X x) { 558 [[operator+(x, x)]]; 559 } 560 )cpp", 561 {R"txt( 562 CallExpression Expression 563 |-IdExpression Callee 564 | `-UnqualifiedId UnqualifiedId 565 | |-'operator' 566 | `-'+' 567 |-'(' OpenParen 568 |-CallArguments Arguments 569 | |-IdExpression ListElement 570 | | `-UnqualifiedId UnqualifiedId 571 | | `-'x' 572 | |-',' ListDelimiter 573 | `-IdExpression ListElement 574 | `-UnqualifiedId UnqualifiedId 575 | `-'x' 576 `-')' CloseParen 577 )txt"})); 578 } 579 580 TEST_P(BuildSyntaxTreeTest, UnqualifiedId_ConversionFunctionId) { 581 if (!GetParam().isCXX()) { 582 return; 583 } 584 EXPECT_TRUE(treeDumpEqualOnAnnotations( 585 R"cpp( 586 struct X { 587 operator int(); 588 }; 589 void test(X x) { 590 [[x.operator int()]]; 591 } 592 )cpp", 593 {R"txt( 594 CallExpression Expression 595 |-MemberExpression Callee 596 | |-IdExpression Object 597 | | `-UnqualifiedId UnqualifiedId 598 | | `-'x' 599 | |-'.' AccessToken 600 | `-IdExpression Member 601 | `-UnqualifiedId UnqualifiedId 602 | |-'operator' 603 | `-'int' 604 |-'(' OpenParen 605 `-')' CloseParen 606 )txt"})); 607 } 608 609 TEST_P(BuildSyntaxTreeTest, UnqualifiedId_LiteralOperatorId) { 610 if (!GetParam().isCXX11OrLater()) { 611 return; 612 } 613 EXPECT_TRUE(treeDumpEqualOnAnnotations( 614 R"cpp( 615 unsigned operator "" _w(char); 616 void test() { 617 [[operator "" _w('1')]]; 618 } 619 )cpp", 620 {R"txt( 621 CallExpression Expression 622 |-IdExpression Callee 623 | `-UnqualifiedId UnqualifiedId 624 | |-'operator' 625 | |-'""' 626 | `-'_w' 627 |-'(' OpenParen 628 |-CallArguments Arguments 629 | `-CharacterLiteralExpression ListElement 630 | `-''1'' LiteralToken 631 `-')' CloseParen 632 )txt"})); 633 } 634 635 TEST_P(BuildSyntaxTreeTest, UnqualifiedId_Destructor) { 636 if (!GetParam().isCXX()) { 637 return; 638 } 639 EXPECT_TRUE(treeDumpEqualOnAnnotations( 640 R"cpp( 641 struct X { }; 642 void test(X x) { 643 [[x.~X()]]; 644 } 645 )cpp", 646 {R"txt( 647 CallExpression Expression 648 |-MemberExpression Callee 649 | |-IdExpression Object 650 | | `-UnqualifiedId UnqualifiedId 651 | | `-'x' 652 | |-'.' AccessToken 653 | `-IdExpression Member 654 | `-UnqualifiedId UnqualifiedId 655 | |-'~' 656 | `-'X' 657 |-'(' OpenParen 658 `-')' CloseParen 659 )txt"})); 660 } 661 662 TEST_P(BuildSyntaxTreeTest, UnqualifiedId_DecltypeDestructor) { 663 if (!GetParam().isCXX11OrLater()) { 664 return; 665 } 666 EXPECT_TRUE(treeDumpEqualOnAnnotations( 667 R"cpp( 668 struct X { }; 669 void test(X x) { 670 // FIXME: Make `decltype(x)` a child of `MemberExpression`. It is currently 671 // not because `Expr::getSourceRange()` returns the range of `x.~` for the 672 // `MemberExpr` instead of the expected `x.~decltype(x)`, this is a bug in 673 // clang. 674 [[x.~decltype(x)()]]; 675 } 676 )cpp", 677 {R"txt( 678 CallExpression Expression 679 |-MemberExpression Callee 680 | |-IdExpression Object 681 | | `-UnqualifiedId UnqualifiedId 682 | | `-'x' 683 | |-'.' AccessToken 684 | `-IdExpression Member 685 | `-UnqualifiedId UnqualifiedId 686 | `-'~' 687 |-'decltype' 688 |-'(' 689 |-'x' 690 |-')' 691 |-'(' 692 `-')' CloseParen 693 )txt"})); 694 } 695 696 TEST_P(BuildSyntaxTreeTest, UnqualifiedId_TemplateId) { 697 if (!GetParam().isCXX()) { 698 return; 699 } 700 EXPECT_TRUE(treeDumpEqualOnAnnotations( 701 R"cpp( 702 template<typename T> 703 T f(); 704 void test() { 705 [[f<int>()]]; 706 } 707 )cpp", 708 {R"txt( 709 CallExpression Expression 710 |-IdExpression Callee 711 | `-UnqualifiedId UnqualifiedId 712 | |-'f' 713 | |-'<' 714 | |-'int' 715 | `-'>' 716 |-'(' OpenParen 717 `-')' CloseParen 718 )txt"})); 719 } 720 721 TEST_P(BuildSyntaxTreeTest, QualifiedId_NamespaceSpecifier) { 722 if (!GetParam().isCXX()) { 723 return; 724 } 725 EXPECT_TRUE(treeDumpEqualOnAnnotations( 726 R"cpp( 727 namespace n { 728 struct S { }; 729 } 730 void test() { 731 [[::n::S s1]]; 732 [[n::S s2]]; 733 } 734 )cpp", 735 {R"txt( 736 SimpleDeclaration 737 |-NestedNameSpecifier 738 | |-'::' ListDelimiter 739 | |-IdentifierNameSpecifier ListElement 740 | | `-'n' 741 | `-'::' ListDelimiter 742 |-'S' 743 `-DeclaratorList Declarators 744 `-SimpleDeclarator ListElement 745 `-'s1' 746 )txt", 747 R"txt( 748 SimpleDeclaration 749 |-NestedNameSpecifier 750 | |-IdentifierNameSpecifier ListElement 751 | | `-'n' 752 | `-'::' ListDelimiter 753 |-'S' 754 `-DeclaratorList Declarators 755 `-SimpleDeclarator ListElement 756 `-'s2' 757 )txt"})); 758 } 759 760 TEST_P(BuildSyntaxTreeTest, QualifiedId_TemplateSpecifier) { 761 if (!GetParam().isCXX()) { 762 return; 763 } 764 EXPECT_TRUE(treeDumpEqualOnAnnotations( 765 R"cpp( 766 template<typename T> 767 struct ST { 768 struct S { }; 769 }; 770 void test() { 771 [[::template ST<int>::S s1]]; 772 [[::ST<int>::S s2]]; 773 } 774 )cpp", 775 {R"txt( 776 SimpleDeclaration 777 |-NestedNameSpecifier 778 | |-'::' ListDelimiter 779 | |-SimpleTemplateNameSpecifier ListElement 780 | | |-'template' 781 | | |-'ST' 782 | | |-'<' 783 | | |-'int' 784 | | `-'>' 785 | `-'::' ListDelimiter 786 |-'S' 787 `-DeclaratorList Declarators 788 `-SimpleDeclarator ListElement 789 `-'s1' 790 )txt", 791 R"txt( 792 SimpleDeclaration 793 |-NestedNameSpecifier 794 | |-'::' ListDelimiter 795 | |-SimpleTemplateNameSpecifier ListElement 796 | | |-'ST' 797 | | |-'<' 798 | | |-'int' 799 | | `-'>' 800 | `-'::' ListDelimiter 801 |-'S' 802 `-DeclaratorList Declarators 803 `-SimpleDeclarator ListElement 804 `-'s2' 805 )txt"})); 806 } 807 808 TEST_P(BuildSyntaxTreeTest, QualifiedId_DecltypeSpecifier) { 809 if (!GetParam().isCXX11OrLater()) { 810 return; 811 } 812 EXPECT_TRUE(treeDumpEqualOnAnnotations( 813 R"cpp( 814 struct S { 815 static void f(){} 816 }; 817 void test(S s) { 818 [[decltype(s)::f()]]; 819 } 820 )cpp", 821 {R"txt( 822 CallExpression Expression 823 |-IdExpression Callee 824 | |-NestedNameSpecifier Qualifier 825 | | |-DecltypeNameSpecifier ListElement 826 | | | |-'decltype' 827 | | | |-'(' 828 | | | |-IdExpression 829 | | | | `-UnqualifiedId UnqualifiedId 830 | | | | `-'s' 831 | | | `-')' 832 | | `-'::' ListDelimiter 833 | `-UnqualifiedId UnqualifiedId 834 | `-'f' 835 |-'(' OpenParen 836 `-')' CloseParen 837 )txt"})); 838 } 839 840 TEST_P(BuildSyntaxTreeTest, QualifiedId_OptionalTemplateKw) { 841 if (!GetParam().isCXX()) { 842 return; 843 } 844 EXPECT_TRUE(treeDumpEqualOnAnnotations( 845 R"cpp( 846 struct S { 847 template<typename U> 848 static U f(); 849 }; 850 void test() { 851 [[S::f<int>()]]; 852 [[S::template f<int>()]]; 853 } 854 )cpp", 855 {R"txt( 856 CallExpression Expression 857 |-IdExpression Callee 858 | |-NestedNameSpecifier Qualifier 859 | | |-IdentifierNameSpecifier ListElement 860 | | | `-'S' 861 | | `-'::' ListDelimiter 862 | `-UnqualifiedId UnqualifiedId 863 | |-'f' 864 | |-'<' 865 | |-'int' 866 | `-'>' 867 |-'(' OpenParen 868 `-')' CloseParen 869 )txt", 870 R"txt( 871 CallExpression Expression 872 |-IdExpression Callee 873 | |-NestedNameSpecifier Qualifier 874 | | |-IdentifierNameSpecifier ListElement 875 | | | `-'S' 876 | | `-'::' ListDelimiter 877 | |-'template' TemplateKeyword 878 | `-UnqualifiedId UnqualifiedId 879 | |-'f' 880 | |-'<' 881 | |-'int' 882 | `-'>' 883 |-'(' OpenParen 884 `-')' CloseParen 885 )txt"})); 886 } 887 888 TEST_P(BuildSyntaxTreeTest, QualifiedId_Complex) { 889 if (!GetParam().isCXX()) { 890 return; 891 } 892 EXPECT_TRUE(treeDumpEqualOnAnnotations( 893 R"cpp( 894 namespace n { 895 template<typename T> 896 struct ST { 897 template<typename U> 898 static U f(); 899 }; 900 } 901 void test() { 902 [[::n::template ST<int>::template f<int>()]]; 903 } 904 )cpp", 905 {R"txt( 906 CallExpression Expression 907 |-IdExpression Callee 908 | |-NestedNameSpecifier Qualifier 909 | | |-'::' ListDelimiter 910 | | |-IdentifierNameSpecifier ListElement 911 | | | `-'n' 912 | | |-'::' ListDelimiter 913 | | |-SimpleTemplateNameSpecifier ListElement 914 | | | |-'template' 915 | | | |-'ST' 916 | | | |-'<' 917 | | | |-'int' 918 | | | `-'>' 919 | | `-'::' ListDelimiter 920 | |-'template' TemplateKeyword 921 | `-UnqualifiedId UnqualifiedId 922 | |-'f' 923 | |-'<' 924 | |-'int' 925 | `-'>' 926 |-'(' OpenParen 927 `-')' CloseParen 928 )txt"})); 929 } 930 931 TEST_P(BuildSyntaxTreeTest, QualifiedId_DependentType) { 932 if (!GetParam().isCXX()) { 933 return; 934 } 935 if (GetParam().hasDelayedTemplateParsing()) { 936 // FIXME: Make this test work on Windows by generating the expected syntax 937 // tree when `-fdelayed-template-parsing` is active. 938 return; 939 } 940 EXPECT_TRUE(treeDumpEqualOnAnnotations( 941 R"cpp( 942 template <typename T> 943 void test() { 944 [[T::template U<int>::f()]]; 945 [[T::U::f()]]; 946 [[T::template f<0>()]]; 947 } 948 )cpp", 949 {R"txt( 950 CallExpression Expression 951 |-IdExpression Callee 952 | |-NestedNameSpecifier Qualifier 953 | | |-IdentifierNameSpecifier ListElement 954 | | | `-'T' 955 | | |-'::' ListDelimiter 956 | | |-SimpleTemplateNameSpecifier ListElement 957 | | | |-'template' 958 | | | |-'U' 959 | | | |-'<' 960 | | | |-'int' 961 | | | `-'>' 962 | | `-'::' ListDelimiter 963 | `-UnqualifiedId UnqualifiedId 964 | `-'f' 965 |-'(' OpenParen 966 `-')' CloseParen 967 )txt", 968 R"txt( 969 CallExpression Expression 970 |-IdExpression Callee 971 | |-NestedNameSpecifier Qualifier 972 | | |-IdentifierNameSpecifier ListElement 973 | | | `-'T' 974 | | |-'::' ListDelimiter 975 | | |-IdentifierNameSpecifier ListElement 976 | | | `-'U' 977 | | `-'::' ListDelimiter 978 | `-UnqualifiedId UnqualifiedId 979 | `-'f' 980 |-'(' OpenParen 981 `-')' CloseParen 982 )txt", 983 R"txt( 984 CallExpression Expression 985 |-IdExpression Callee 986 | |-NestedNameSpecifier Qualifier 987 | | |-IdentifierNameSpecifier ListElement 988 | | | `-'T' 989 | | `-'::' ListDelimiter 990 | |-'template' TemplateKeyword 991 | `-UnqualifiedId UnqualifiedId 992 | |-'f' 993 | |-'<' 994 | |-IntegerLiteralExpression 995 | | `-'0' LiteralToken 996 | `-'>' 997 |-'(' OpenParen 998 `-')' CloseParen 999 )txt"})); 1000 } 1001 1002 TEST_P(BuildSyntaxTreeTest, This_Simple) { 1003 if (!GetParam().isCXX()) { 1004 return; 1005 } 1006 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1007 R"cpp( 1008 struct S { 1009 S* test(){ 1010 return [[this]]; 1011 } 1012 }; 1013 )cpp", 1014 {R"txt( 1015 ThisExpression ReturnValue 1016 `-'this' IntroducerKeyword 1017 )txt"})); 1018 } 1019 1020 TEST_P(BuildSyntaxTreeTest, This_ExplicitMemberAccess) { 1021 if (!GetParam().isCXX()) { 1022 return; 1023 } 1024 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1025 R"cpp( 1026 struct S { 1027 int a; 1028 void test(){ 1029 [[this->a]]; 1030 } 1031 }; 1032 )cpp", 1033 {R"txt( 1034 MemberExpression Expression 1035 |-ThisExpression Object 1036 | `-'this' IntroducerKeyword 1037 |-'->' AccessToken 1038 `-IdExpression Member 1039 `-UnqualifiedId UnqualifiedId 1040 `-'a' 1041 )txt"})); 1042 } 1043 1044 TEST_P(BuildSyntaxTreeTest, This_ImplicitMemberAccess) { 1045 if (!GetParam().isCXX()) { 1046 return; 1047 } 1048 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1049 R"cpp( 1050 struct S { 1051 int a; 1052 void test(){ 1053 [[a]]; 1054 } 1055 }; 1056 )cpp", 1057 {R"txt( 1058 IdExpression Expression 1059 `-UnqualifiedId UnqualifiedId 1060 `-'a' 1061 )txt"})); 1062 } 1063 1064 TEST_P(BuildSyntaxTreeTest, ParenExpr) { 1065 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1066 R"cpp( 1067 void test() { 1068 [[(1)]]; 1069 [[((1))]]; 1070 [[(1 + (2))]]; 1071 } 1072 )cpp", 1073 {R"txt( 1074 ParenExpression Expression 1075 |-'(' OpenParen 1076 |-IntegerLiteralExpression SubExpression 1077 | `-'1' LiteralToken 1078 `-')' CloseParen 1079 )txt", 1080 R"txt( 1081 ParenExpression Expression 1082 |-'(' OpenParen 1083 |-ParenExpression SubExpression 1084 | |-'(' OpenParen 1085 | |-IntegerLiteralExpression SubExpression 1086 | | `-'1' LiteralToken 1087 | `-')' CloseParen 1088 `-')' CloseParen 1089 )txt", 1090 R"txt( 1091 ParenExpression Expression 1092 |-'(' OpenParen 1093 |-BinaryOperatorExpression SubExpression 1094 | |-IntegerLiteralExpression LeftHandSide 1095 | | `-'1' LiteralToken 1096 | |-'+' OperatorToken 1097 | `-ParenExpression RightHandSide 1098 | |-'(' OpenParen 1099 | |-IntegerLiteralExpression SubExpression 1100 | | `-'2' LiteralToken 1101 | `-')' CloseParen 1102 `-')' CloseParen 1103 )txt"})); 1104 } 1105 1106 TEST_P(BuildSyntaxTreeTest, UserDefinedLiteral_Char) { 1107 if (!GetParam().isCXX11OrLater()) { 1108 return; 1109 } 1110 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1111 R"cpp( 1112 unsigned operator "" _c(char); 1113 void test() { 1114 [['2'_c]]; 1115 } 1116 )cpp", 1117 {R"txt( 1118 CharUserDefinedLiteralExpression Expression 1119 `-''2'_c' LiteralToken 1120 )txt"})); 1121 } 1122 1123 TEST_P(BuildSyntaxTreeTest, UserDefinedLiteral_String) { 1124 if (!GetParam().isCXX11OrLater()) { 1125 return; 1126 } 1127 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1128 R"cpp( 1129 typedef decltype(sizeof(void *)) size_t; 1130 1131 unsigned operator "" _s(const char*, size_t); 1132 1133 void test() { 1134 [["12"_s]]; 1135 } 1136 )cpp", 1137 {R"txt( 1138 StringUserDefinedLiteralExpression Expression 1139 `-'"12"_s' LiteralToken 1140 )txt"})); 1141 } 1142 1143 TEST_P(BuildSyntaxTreeTest, UserDefinedLiteral_Integer) { 1144 if (!GetParam().isCXX11OrLater()) { 1145 return; 1146 } 1147 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1148 R"cpp( 1149 unsigned operator "" _i(unsigned long long); 1150 unsigned operator "" _r(const char*); 1151 template <char...> 1152 unsigned operator "" _t(); 1153 1154 void test() { 1155 [[12_i]]; 1156 [[12_r]]; 1157 [[12_t]]; 1158 } 1159 )cpp", 1160 {R"txt( 1161 IntegerUserDefinedLiteralExpression Expression 1162 `-'12_i' LiteralToken 1163 )txt", 1164 R"txt( 1165 IntegerUserDefinedLiteralExpression Expression 1166 `-'12_r' LiteralToken 1167 )txt", 1168 R"txt( 1169 IntegerUserDefinedLiteralExpression Expression 1170 `-'12_t' LiteralToken 1171 )txt"})); 1172 } 1173 1174 TEST_P(BuildSyntaxTreeTest, UserDefinedLiteral_Float) { 1175 if (!GetParam().isCXX11OrLater()) { 1176 return; 1177 } 1178 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1179 R"cpp( 1180 unsigned operator "" _f(long double); 1181 unsigned operator "" _r(const char*); 1182 template <char...> 1183 unsigned operator "" _t(); 1184 1185 void test() { 1186 [[1.2_f]]; 1187 [[1.2_r]]; 1188 [[1.2_t]]; 1189 } 1190 )cpp", 1191 {R"txt( 1192 FloatUserDefinedLiteralExpression Expression 1193 `-'1.2_f' LiteralToken 1194 )txt", 1195 R"txt( 1196 FloatUserDefinedLiteralExpression Expression 1197 `-'1.2_r' LiteralToken 1198 )txt", 1199 R"txt( 1200 FloatUserDefinedLiteralExpression Expression 1201 `-'1.2_t' LiteralToken 1202 )txt"})); 1203 } 1204 1205 TEST_P(BuildSyntaxTreeTest, IntegerLiteral_LongLong) { 1206 if (!GetParam().isCXX11OrLater()) { 1207 return; 1208 } 1209 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1210 R"cpp( 1211 void test() { 1212 [[12ll]]; 1213 [[12ull]]; 1214 } 1215 )cpp", 1216 {R"txt( 1217 IntegerLiteralExpression Expression 1218 `-'12ll' LiteralToken 1219 )txt", 1220 R"txt( 1221 IntegerLiteralExpression Expression 1222 `-'12ull' LiteralToken 1223 )txt"})); 1224 } 1225 1226 TEST_P(BuildSyntaxTreeTest, IntegerLiteral_Binary) { 1227 if (!GetParam().isCXX14OrLater()) { 1228 return; 1229 } 1230 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1231 R"cpp( 1232 void test() { 1233 [[0b1100]]; 1234 } 1235 )cpp", 1236 {R"txt( 1237 IntegerLiteralExpression Expression 1238 `-'0b1100' LiteralToken 1239 )txt"})); 1240 } 1241 1242 TEST_P(BuildSyntaxTreeTest, IntegerLiteral_WithDigitSeparators) { 1243 if (!GetParam().isCXX14OrLater()) { 1244 return; 1245 } 1246 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1247 R"cpp( 1248 void test() { 1249 [[1'2'0ull]]; 1250 } 1251 )cpp", 1252 {R"txt( 1253 IntegerLiteralExpression Expression 1254 `-'1'2'0ull' LiteralToken 1255 )txt"})); 1256 } 1257 1258 TEST_P(BuildSyntaxTreeTest, CharacterLiteral) { 1259 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1260 R"cpp( 1261 void test() { 1262 [['a']]; 1263 [['\n']]; 1264 [['\x20']]; 1265 [['\0']]; 1266 [[L'a']]; 1267 [[L'α']]; 1268 } 1269 )cpp", 1270 {R"txt( 1271 CharacterLiteralExpression Expression 1272 `-''a'' LiteralToken 1273 )txt", 1274 R"txt( 1275 CharacterLiteralExpression Expression 1276 `-''\n'' LiteralToken 1277 )txt", 1278 R"txt( 1279 CharacterLiteralExpression Expression 1280 `-''\x20'' LiteralToken 1281 )txt", 1282 R"txt( 1283 CharacterLiteralExpression Expression 1284 `-''\0'' LiteralToken 1285 )txt", 1286 R"txt( 1287 CharacterLiteralExpression Expression 1288 `-'L'a'' LiteralToken 1289 )txt", 1290 R"txt( 1291 CharacterLiteralExpression Expression 1292 `-'L'α'' LiteralToken 1293 )txt"})); 1294 } 1295 1296 TEST_P(BuildSyntaxTreeTest, CharacterLiteral_Utf) { 1297 if (!GetParam().isCXX11OrLater()) { 1298 return; 1299 } 1300 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1301 R"cpp( 1302 void test() { 1303 [[u'a']]; 1304 [[u'構']]; 1305 [[U'a']]; 1306 [[U'��']]; 1307 } 1308 )cpp", 1309 {R"txt( 1310 CharacterLiteralExpression Expression 1311 `-'u'a'' LiteralToken 1312 )txt", 1313 R"txt( 1314 CharacterLiteralExpression Expression 1315 `-'u'構'' LiteralToken 1316 )txt", 1317 R"txt( 1318 CharacterLiteralExpression Expression 1319 `-'U'a'' LiteralToken 1320 )txt", 1321 R"txt( 1322 CharacterLiteralExpression Expression 1323 `-'U'��'' LiteralToken 1324 )txt"})); 1325 } 1326 1327 TEST_P(BuildSyntaxTreeTest, CharacterLiteral_Utf8) { 1328 if (!GetParam().isCXX17OrLater()) { 1329 return; 1330 } 1331 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1332 R"cpp( 1333 void test() { 1334 [[u8'a']]; 1335 [[u8'\x7f']]; 1336 } 1337 )cpp", 1338 {R"txt( 1339 CharacterLiteralExpression Expression 1340 `-'u8'a'' LiteralToken 1341 )txt", 1342 R"txt( 1343 CharacterLiteralExpression Expression 1344 `-'u8'\x7f'' LiteralToken 1345 )txt"})); 1346 } 1347 1348 TEST_P(BuildSyntaxTreeTest, FloatingLiteral) { 1349 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1350 R"cpp( 1351 void test() { 1352 [[1e-2]]; 1353 [[2.]]; 1354 [[.2]]; 1355 [[2.f]]; 1356 } 1357 )cpp", 1358 {R"txt( 1359 FloatingLiteralExpression Expression 1360 `-'1e-2' LiteralToken 1361 )txt", 1362 R"txt( 1363 FloatingLiteralExpression Expression 1364 `-'2.' LiteralToken 1365 )txt", 1366 R"txt( 1367 FloatingLiteralExpression Expression 1368 `-'.2' LiteralToken 1369 )txt", 1370 R"txt( 1371 FloatingLiteralExpression Expression 1372 `-'2.f' LiteralToken 1373 )txt"})); 1374 } 1375 1376 TEST_P(BuildSyntaxTreeTest, FloatingLiteral_Hexadecimal) { 1377 if (!GetParam().isCXX17OrLater()) { 1378 return; 1379 } 1380 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1381 R"cpp( 1382 void test() { 1383 [[0xfp1]]; 1384 [[0xf.p1]]; 1385 [[0x.fp1]]; 1386 [[0xf.fp1f]]; 1387 } 1388 )cpp", 1389 {R"txt( 1390 FloatingLiteralExpression Expression 1391 `-'0xfp1' LiteralToken 1392 )txt", 1393 R"txt( 1394 FloatingLiteralExpression Expression 1395 `-'0xf.p1' LiteralToken 1396 )txt", 1397 R"txt( 1398 FloatingLiteralExpression Expression 1399 `-'0x.fp1' LiteralToken 1400 )txt", 1401 R"txt( 1402 FloatingLiteralExpression Expression 1403 `-'0xf.fp1f' LiteralToken 1404 )txt"})); 1405 } 1406 1407 TEST_P(BuildSyntaxTreeTest, StringLiteral) { 1408 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1409 R"cpp( 1410 void test() { 1411 [["a\n\0\x20"]]; 1412 [[L"αβ"]]; 1413 } 1414 )cpp", 1415 {R"txt( 1416 StringLiteralExpression Expression 1417 `-'"a\n\0\x20"' LiteralToken 1418 )txt", 1419 R"txt( 1420 StringLiteralExpression Expression 1421 `-'L"αβ"' LiteralToken 1422 )txt"})); 1423 } 1424 1425 TEST_P(BuildSyntaxTreeTest, StringLiteral_Utf) { 1426 if (!GetParam().isCXX11OrLater()) { 1427 return; 1428 } 1429 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1430 R"cpp( 1431 void test() { 1432 [[u8"a\x1f\x05"]]; 1433 [[u"C++抽象構文木"]]; 1434 [[U"����\n"]]; 1435 } 1436 )cpp", 1437 {R"txt( 1438 StringLiteralExpression Expression 1439 `-'u8"a\x1f\x05"' LiteralToken 1440 )txt", 1441 R"txt( 1442 StringLiteralExpression Expression 1443 `-'u"C++抽象構文木"' LiteralToken 1444 )txt", 1445 R"txt( 1446 StringLiteralExpression Expression 1447 `-'U"����\n"' LiteralToken 1448 )txt"})); 1449 } 1450 1451 TEST_P(BuildSyntaxTreeTest, StringLiteral_Raw) { 1452 if (!GetParam().isCXX11OrLater()) { 1453 return; 1454 } 1455 // This test uses regular string literals instead of raw string literals to 1456 // hold source code and expected output because of a bug in MSVC up to MSVC 1457 // 2019 16.2: 1458 // https://developercommunity.visualstudio.com/content/problem/67300/stringifying-raw-string-literal.html 1459 EXPECT_TRUE(treeDumpEqual( // 1460 "void test() {\n" 1461 " R\"SyntaxTree(\n" 1462 " Hello \"Syntax\" \\\"\n" 1463 " )SyntaxTree\";\n" 1464 "}\n", 1465 "TranslationUnit Detached\n" 1466 "`-SimpleDeclaration\n" 1467 " |-'void'\n" 1468 " |-DeclaratorList Declarators\n" 1469 " | `-SimpleDeclarator ListElement\n" 1470 " | |-'test'\n" 1471 " | `-ParametersAndQualifiers\n" 1472 " | |-'(' OpenParen\n" 1473 " | `-')' CloseParen\n" 1474 " `-CompoundStatement\n" 1475 " |-'{' OpenParen\n" 1476 " |-ExpressionStatement Statement\n" 1477 " | |-StringLiteralExpression Expression\n" 1478 " | | `-'R\"SyntaxTree(\n" 1479 " Hello \"Syntax\" \\\"\n" 1480 " )SyntaxTree\"' LiteralToken\n" 1481 " | `-';'\n" 1482 " `-'}' CloseParen\n")); 1483 } 1484 1485 TEST_P(BuildSyntaxTreeTest, BoolLiteral) { 1486 if (GetParam().isC()) { 1487 return; 1488 } 1489 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1490 R"cpp( 1491 void test() { 1492 [[true]]; 1493 [[false]]; 1494 } 1495 )cpp", 1496 {R"txt( 1497 BoolLiteralExpression Expression 1498 `-'true' LiteralToken 1499 )txt", 1500 R"txt( 1501 BoolLiteralExpression Expression 1502 `-'false' LiteralToken 1503 )txt"})); 1504 } 1505 1506 TEST_P(BuildSyntaxTreeTest, CxxNullPtrLiteral) { 1507 if (!GetParam().isCXX11OrLater()) { 1508 return; 1509 } 1510 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1511 R"cpp( 1512 void test() { 1513 [[nullptr]]; 1514 } 1515 )cpp", 1516 {R"txt( 1517 CxxNullPtrExpression Expression 1518 `-'nullptr' LiteralToken 1519 )txt"})); 1520 } 1521 1522 TEST_P(BuildSyntaxTreeTest, PostfixUnaryOperator) { 1523 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1524 R"cpp( 1525 void test(int a) { 1526 [[a++]]; 1527 [[a--]]; 1528 } 1529 )cpp", 1530 {R"txt( 1531 PostfixUnaryOperatorExpression Expression 1532 |-IdExpression Operand 1533 | `-UnqualifiedId UnqualifiedId 1534 | `-'a' 1535 `-'++' OperatorToken 1536 )txt", 1537 R"txt( 1538 PostfixUnaryOperatorExpression Expression 1539 |-IdExpression Operand 1540 | `-UnqualifiedId UnqualifiedId 1541 | `-'a' 1542 `-'--' OperatorToken 1543 )txt"})); 1544 } 1545 1546 TEST_P(BuildSyntaxTreeTest, PrefixUnaryOperator) { 1547 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1548 R"cpp( 1549 void test(int a, int *ap) { 1550 [[--a]]; [[++a]]; 1551 [[~a]]; 1552 [[-a]]; 1553 [[+a]]; 1554 [[&a]]; 1555 [[*ap]]; 1556 [[!a]]; 1557 [[__real a]]; [[__imag a]]; 1558 } 1559 )cpp", 1560 {R"txt( 1561 PrefixUnaryOperatorExpression Expression 1562 |-'--' OperatorToken 1563 `-IdExpression Operand 1564 `-UnqualifiedId UnqualifiedId 1565 `-'a' 1566 )txt", 1567 R"txt( 1568 PrefixUnaryOperatorExpression Expression 1569 |-'++' OperatorToken 1570 `-IdExpression Operand 1571 `-UnqualifiedId UnqualifiedId 1572 `-'a' 1573 )txt", 1574 R"txt( 1575 PrefixUnaryOperatorExpression Expression 1576 |-'~' OperatorToken 1577 `-IdExpression Operand 1578 `-UnqualifiedId UnqualifiedId 1579 `-'a' 1580 )txt", 1581 R"txt( 1582 PrefixUnaryOperatorExpression Expression 1583 |-'-' OperatorToken 1584 `-IdExpression Operand 1585 `-UnqualifiedId UnqualifiedId 1586 `-'a' 1587 )txt", 1588 R"txt( 1589 PrefixUnaryOperatorExpression Expression 1590 |-'+' OperatorToken 1591 `-IdExpression Operand 1592 `-UnqualifiedId UnqualifiedId 1593 `-'a' 1594 )txt", 1595 R"txt( 1596 PrefixUnaryOperatorExpression Expression 1597 |-'&' OperatorToken 1598 `-IdExpression Operand 1599 `-UnqualifiedId UnqualifiedId 1600 `-'a' 1601 )txt", 1602 R"txt( 1603 PrefixUnaryOperatorExpression Expression 1604 |-'*' OperatorToken 1605 `-IdExpression Operand 1606 `-UnqualifiedId UnqualifiedId 1607 `-'ap' 1608 )txt", 1609 R"txt( 1610 PrefixUnaryOperatorExpression Expression 1611 |-'!' OperatorToken 1612 `-IdExpression Operand 1613 `-UnqualifiedId UnqualifiedId 1614 `-'a' 1615 )txt", 1616 R"txt( 1617 PrefixUnaryOperatorExpression Expression 1618 |-'__real' OperatorToken 1619 `-IdExpression Operand 1620 `-UnqualifiedId UnqualifiedId 1621 `-'a' 1622 )txt", 1623 R"txt( 1624 PrefixUnaryOperatorExpression Expression 1625 |-'__imag' OperatorToken 1626 `-IdExpression Operand 1627 `-UnqualifiedId UnqualifiedId 1628 `-'a' 1629 )txt"})); 1630 } 1631 1632 TEST_P(BuildSyntaxTreeTest, PrefixUnaryOperatorCxx) { 1633 if (!GetParam().isCXX()) { 1634 return; 1635 } 1636 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1637 R"cpp( 1638 void test(int a, bool b) { 1639 [[compl a]]; 1640 [[not b]]; 1641 } 1642 )cpp", 1643 {R"txt( 1644 PrefixUnaryOperatorExpression Expression 1645 |-'compl' OperatorToken 1646 `-IdExpression Operand 1647 `-UnqualifiedId UnqualifiedId 1648 `-'a' 1649 )txt", 1650 R"txt( 1651 PrefixUnaryOperatorExpression Expression 1652 |-'not' OperatorToken 1653 `-IdExpression Operand 1654 `-UnqualifiedId UnqualifiedId 1655 `-'b' 1656 )txt"})); 1657 } 1658 1659 TEST_P(BuildSyntaxTreeTest, BinaryOperator) { 1660 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1661 R"cpp( 1662 void test(int a) { 1663 [[1 - 2]]; 1664 [[1 == 2]]; 1665 [[a = 1]]; 1666 [[a <<= 1]]; 1667 [[1 || 0]]; 1668 [[1 & 2]]; 1669 [[a != 3]]; 1670 } 1671 )cpp", 1672 {R"txt( 1673 BinaryOperatorExpression Expression 1674 |-IntegerLiteralExpression LeftHandSide 1675 | `-'1' LiteralToken 1676 |-'-' OperatorToken 1677 `-IntegerLiteralExpression RightHandSide 1678 `-'2' LiteralToken 1679 )txt", 1680 R"txt( 1681 BinaryOperatorExpression Expression 1682 |-IntegerLiteralExpression LeftHandSide 1683 | `-'1' LiteralToken 1684 |-'==' OperatorToken 1685 `-IntegerLiteralExpression RightHandSide 1686 `-'2' LiteralToken 1687 )txt", 1688 R"txt( 1689 BinaryOperatorExpression Expression 1690 |-IdExpression LeftHandSide 1691 | `-UnqualifiedId UnqualifiedId 1692 | `-'a' 1693 |-'=' OperatorToken 1694 `-IntegerLiteralExpression RightHandSide 1695 `-'1' LiteralToken 1696 )txt", 1697 R"txt( 1698 BinaryOperatorExpression Expression 1699 |-IdExpression LeftHandSide 1700 | `-UnqualifiedId UnqualifiedId 1701 | `-'a' 1702 |-'<<=' OperatorToken 1703 `-IntegerLiteralExpression RightHandSide 1704 `-'1' LiteralToken 1705 )txt", 1706 R"txt( 1707 BinaryOperatorExpression Expression 1708 |-IntegerLiteralExpression LeftHandSide 1709 | `-'1' LiteralToken 1710 |-'||' OperatorToken 1711 `-IntegerLiteralExpression RightHandSide 1712 `-'0' LiteralToken 1713 )txt", 1714 R"txt( 1715 BinaryOperatorExpression Expression 1716 |-IntegerLiteralExpression LeftHandSide 1717 | `-'1' LiteralToken 1718 |-'&' OperatorToken 1719 `-IntegerLiteralExpression RightHandSide 1720 `-'2' LiteralToken 1721 )txt", 1722 R"txt( 1723 BinaryOperatorExpression Expression 1724 |-IdExpression LeftHandSide 1725 | `-UnqualifiedId UnqualifiedId 1726 | `-'a' 1727 |-'!=' OperatorToken 1728 `-IntegerLiteralExpression RightHandSide 1729 `-'3' LiteralToken 1730 )txt"})); 1731 } 1732 1733 TEST_P(BuildSyntaxTreeTest, BinaryOperatorCxx) { 1734 if (!GetParam().isCXX()) { 1735 return; 1736 } 1737 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1738 R"cpp( 1739 void test(int a) { 1740 [[true || false]]; 1741 [[true or false]]; 1742 [[1 bitand 2]]; 1743 [[a xor_eq 3]]; 1744 } 1745 )cpp", 1746 {R"txt( 1747 BinaryOperatorExpression Expression 1748 |-BoolLiteralExpression LeftHandSide 1749 | `-'true' LiteralToken 1750 |-'||' OperatorToken 1751 `-BoolLiteralExpression RightHandSide 1752 `-'false' LiteralToken 1753 )txt", 1754 R"txt( 1755 BinaryOperatorExpression Expression 1756 |-BoolLiteralExpression LeftHandSide 1757 | `-'true' LiteralToken 1758 |-'or' OperatorToken 1759 `-BoolLiteralExpression RightHandSide 1760 `-'false' LiteralToken 1761 )txt", 1762 R"txt( 1763 BinaryOperatorExpression Expression 1764 |-IntegerLiteralExpression LeftHandSide 1765 | `-'1' LiteralToken 1766 |-'bitand' OperatorToken 1767 `-IntegerLiteralExpression RightHandSide 1768 `-'2' LiteralToken 1769 )txt", 1770 R"txt( 1771 BinaryOperatorExpression Expression 1772 |-IdExpression LeftHandSide 1773 | `-UnqualifiedId UnqualifiedId 1774 | `-'a' 1775 |-'xor_eq' OperatorToken 1776 `-IntegerLiteralExpression RightHandSide 1777 `-'3' LiteralToken 1778 )txt"})); 1779 } 1780 1781 TEST_P(BuildSyntaxTreeTest, BinaryOperator_NestedWithParenthesis) { 1782 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1783 R"cpp( 1784 void test() { 1785 [[(1 + 2) * (4 / 2)]]; 1786 } 1787 )cpp", 1788 {R"txt( 1789 BinaryOperatorExpression Expression 1790 |-ParenExpression LeftHandSide 1791 | |-'(' OpenParen 1792 | |-BinaryOperatorExpression SubExpression 1793 | | |-IntegerLiteralExpression LeftHandSide 1794 | | | `-'1' LiteralToken 1795 | | |-'+' OperatorToken 1796 | | `-IntegerLiteralExpression RightHandSide 1797 | | `-'2' LiteralToken 1798 | `-')' CloseParen 1799 |-'*' OperatorToken 1800 `-ParenExpression RightHandSide 1801 |-'(' OpenParen 1802 |-BinaryOperatorExpression SubExpression 1803 | |-IntegerLiteralExpression LeftHandSide 1804 | | `-'4' LiteralToken 1805 | |-'/' OperatorToken 1806 | `-IntegerLiteralExpression RightHandSide 1807 | `-'2' LiteralToken 1808 `-')' CloseParen 1809 )txt"})); 1810 } 1811 1812 TEST_P(BuildSyntaxTreeTest, BinaryOperator_Associativity) { 1813 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1814 R"cpp( 1815 void test(int a, int b) { 1816 [[a + b + 42]]; 1817 [[a = b = 42]]; 1818 } 1819 )cpp", 1820 {R"txt( 1821 BinaryOperatorExpression Expression 1822 |-BinaryOperatorExpression LeftHandSide 1823 | |-IdExpression LeftHandSide 1824 | | `-UnqualifiedId UnqualifiedId 1825 | | `-'a' 1826 | |-'+' OperatorToken 1827 | `-IdExpression RightHandSide 1828 | `-UnqualifiedId UnqualifiedId 1829 | `-'b' 1830 |-'+' OperatorToken 1831 `-IntegerLiteralExpression RightHandSide 1832 `-'42' LiteralToken 1833 )txt", 1834 R"txt( 1835 BinaryOperatorExpression Expression 1836 |-IdExpression LeftHandSide 1837 | `-UnqualifiedId UnqualifiedId 1838 | `-'a' 1839 |-'=' OperatorToken 1840 `-BinaryOperatorExpression RightHandSide 1841 |-IdExpression LeftHandSide 1842 | `-UnqualifiedId UnqualifiedId 1843 | `-'b' 1844 |-'=' OperatorToken 1845 `-IntegerLiteralExpression RightHandSide 1846 `-'42' LiteralToken 1847 )txt"})); 1848 } 1849 1850 TEST_P(BuildSyntaxTreeTest, BinaryOperator_Precedence) { 1851 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1852 R"cpp( 1853 void test() { 1854 [[1 + 2 * 3 + 4]]; 1855 [[1 % 2 + 3 * 4]]; 1856 } 1857 )cpp", 1858 {R"txt( 1859 BinaryOperatorExpression Expression 1860 |-BinaryOperatorExpression LeftHandSide 1861 | |-IntegerLiteralExpression LeftHandSide 1862 | | `-'1' LiteralToken 1863 | |-'+' OperatorToken 1864 | `-BinaryOperatorExpression RightHandSide 1865 | |-IntegerLiteralExpression LeftHandSide 1866 | | `-'2' LiteralToken 1867 | |-'*' OperatorToken 1868 | `-IntegerLiteralExpression RightHandSide 1869 | `-'3' LiteralToken 1870 |-'+' OperatorToken 1871 `-IntegerLiteralExpression RightHandSide 1872 `-'4' LiteralToken 1873 )txt", 1874 R"txt( 1875 BinaryOperatorExpression Expression 1876 |-BinaryOperatorExpression LeftHandSide 1877 | |-IntegerLiteralExpression LeftHandSide 1878 | | `-'1' LiteralToken 1879 | |-'%' OperatorToken 1880 | `-IntegerLiteralExpression RightHandSide 1881 | `-'2' LiteralToken 1882 |-'+' OperatorToken 1883 `-BinaryOperatorExpression RightHandSide 1884 |-IntegerLiteralExpression LeftHandSide 1885 | `-'3' LiteralToken 1886 |-'*' OperatorToken 1887 `-IntegerLiteralExpression RightHandSide 1888 `-'4' LiteralToken 1889 )txt"})); 1890 } 1891 1892 TEST_P(BuildSyntaxTreeTest, OverloadedOperator_Assignment) { 1893 if (!GetParam().isCXX()) { 1894 return; 1895 } 1896 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1897 R"cpp( 1898 struct X { 1899 X& operator=(const X&); 1900 }; 1901 void test(X x, X y) { 1902 [[x = y]]; 1903 } 1904 )cpp", 1905 {R"txt( 1906 BinaryOperatorExpression Expression 1907 |-IdExpression LeftHandSide 1908 | `-UnqualifiedId UnqualifiedId 1909 | `-'x' 1910 |-'=' OperatorToken 1911 `-IdExpression RightHandSide 1912 `-UnqualifiedId UnqualifiedId 1913 `-'y' 1914 )txt"})); 1915 } 1916 1917 TEST_P(BuildSyntaxTreeTest, OverloadedOperator_Plus) { 1918 if (!GetParam().isCXX()) { 1919 return; 1920 } 1921 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1922 R"cpp( 1923 struct X { 1924 friend X operator+(X, const X&); 1925 }; 1926 void test(X x, X y) { 1927 [[x + y]]; 1928 } 1929 )cpp", 1930 {R"txt( 1931 BinaryOperatorExpression Expression 1932 |-IdExpression LeftHandSide 1933 | `-UnqualifiedId UnqualifiedId 1934 | `-'x' 1935 |-'+' OperatorToken 1936 `-IdExpression RightHandSide 1937 `-UnqualifiedId UnqualifiedId 1938 `-'y' 1939 )txt"})); 1940 } 1941 1942 TEST_P(BuildSyntaxTreeTest, OverloadedOperator_Less) { 1943 if (!GetParam().isCXX()) { 1944 return; 1945 } 1946 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1947 R"cpp( 1948 struct X { 1949 friend bool operator<(const X&, const X&); 1950 }; 1951 void test(X x, X y) { 1952 [[x < y]]; 1953 } 1954 )cpp", 1955 {R"txt( 1956 BinaryOperatorExpression Expression 1957 |-IdExpression LeftHandSide 1958 | `-UnqualifiedId UnqualifiedId 1959 | `-'x' 1960 |-'<' OperatorToken 1961 `-IdExpression RightHandSide 1962 `-UnqualifiedId UnqualifiedId 1963 `-'y' 1964 )txt"})); 1965 } 1966 1967 TEST_P(BuildSyntaxTreeTest, OverloadedOperator_LeftShift) { 1968 if (!GetParam().isCXX()) { 1969 return; 1970 } 1971 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1972 R"cpp( 1973 struct X { 1974 friend X operator<<(X&, const X&); 1975 }; 1976 void test(X x, X y) { 1977 [[x << y]]; 1978 } 1979 )cpp", 1980 {R"txt( 1981 BinaryOperatorExpression Expression 1982 |-IdExpression LeftHandSide 1983 | `-UnqualifiedId UnqualifiedId 1984 | `-'x' 1985 |-'<<' OperatorToken 1986 `-IdExpression RightHandSide 1987 `-UnqualifiedId UnqualifiedId 1988 `-'y' 1989 )txt"})); 1990 } 1991 1992 TEST_P(BuildSyntaxTreeTest, OverloadedOperator_Comma) { 1993 if (!GetParam().isCXX()) { 1994 return; 1995 } 1996 EXPECT_TRUE(treeDumpEqualOnAnnotations( 1997 R"cpp( 1998 struct X { 1999 X operator,(X&); 2000 }; 2001 void test(X x, X y) { 2002 [[x, y]]; 2003 } 2004 )cpp", 2005 {R"txt( 2006 BinaryOperatorExpression Expression 2007 |-IdExpression LeftHandSide 2008 | `-UnqualifiedId UnqualifiedId 2009 | `-'x' 2010 |-',' OperatorToken 2011 `-IdExpression RightHandSide 2012 `-UnqualifiedId UnqualifiedId 2013 `-'y' 2014 )txt"})); 2015 } 2016 2017 TEST_P(BuildSyntaxTreeTest, OverloadedOperator_PointerToMember) { 2018 if (!GetParam().isCXX()) { 2019 return; 2020 } 2021 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2022 R"cpp( 2023 struct X { 2024 X operator->*(int); 2025 }; 2026 void test(X* xp, int X::* pmi) { 2027 [[xp->*pmi]]; 2028 } 2029 )cpp", 2030 {R"txt( 2031 BinaryOperatorExpression Expression 2032 |-IdExpression LeftHandSide 2033 | `-UnqualifiedId UnqualifiedId 2034 | `-'xp' 2035 |-'->*' OperatorToken 2036 `-IdExpression RightHandSide 2037 `-UnqualifiedId UnqualifiedId 2038 `-'pmi' 2039 )txt"})); 2040 } 2041 2042 TEST_P(BuildSyntaxTreeTest, OverloadedOperator_Negation) { 2043 if (!GetParam().isCXX()) { 2044 return; 2045 } 2046 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2047 R"cpp( 2048 struct X { 2049 bool operator!(); 2050 }; 2051 void test(X x) { 2052 [[!x]]; 2053 } 2054 )cpp", 2055 {R"txt( 2056 PrefixUnaryOperatorExpression Expression 2057 |-'!' OperatorToken 2058 `-IdExpression Operand 2059 `-UnqualifiedId UnqualifiedId 2060 `-'x' 2061 )txt"})); 2062 } 2063 2064 TEST_P(BuildSyntaxTreeTest, OverloadedOperator_AddressOf) { 2065 if (!GetParam().isCXX()) { 2066 return; 2067 } 2068 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2069 R"cpp( 2070 struct X { 2071 X* operator&(); 2072 }; 2073 void test(X x) { 2074 [[&x]]; 2075 } 2076 )cpp", 2077 {R"txt( 2078 PrefixUnaryOperatorExpression Expression 2079 |-'&' OperatorToken 2080 `-IdExpression Operand 2081 `-UnqualifiedId UnqualifiedId 2082 `-'x' 2083 )txt"})); 2084 } 2085 2086 TEST_P(BuildSyntaxTreeTest, OverloadedOperator_PrefixIncrement) { 2087 if (!GetParam().isCXX()) { 2088 return; 2089 } 2090 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2091 R"cpp( 2092 struct X { 2093 X operator++(); 2094 }; 2095 void test(X x) { 2096 [[++x]]; 2097 } 2098 )cpp", 2099 {R"txt( 2100 PrefixUnaryOperatorExpression Expression 2101 |-'++' OperatorToken 2102 `-IdExpression Operand 2103 `-UnqualifiedId UnqualifiedId 2104 `-'x' 2105 )txt"})); 2106 } 2107 2108 TEST_P(BuildSyntaxTreeTest, OverloadedOperator_PostfixIncrement) { 2109 if (!GetParam().isCXX()) { 2110 return; 2111 } 2112 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2113 R"cpp( 2114 struct X { 2115 X operator++(int); 2116 }; 2117 void test(X x) { 2118 [[x++]]; 2119 } 2120 )cpp", 2121 {R"txt( 2122 PostfixUnaryOperatorExpression Expression 2123 |-IdExpression Operand 2124 | `-UnqualifiedId UnqualifiedId 2125 | `-'x' 2126 `-'++' OperatorToken 2127 )txt"})); 2128 } 2129 2130 TEST_P(BuildSyntaxTreeTest, MemberExpression_SimpleWithDot) { 2131 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2132 R"cpp( 2133 struct S { 2134 int a; 2135 }; 2136 void test(struct S s) { 2137 [[s.a]]; 2138 } 2139 )cpp", 2140 {R"txt( 2141 MemberExpression Expression 2142 |-IdExpression Object 2143 | `-UnqualifiedId UnqualifiedId 2144 | `-'s' 2145 |-'.' AccessToken 2146 `-IdExpression Member 2147 `-UnqualifiedId UnqualifiedId 2148 `-'a' 2149 )txt"})); 2150 } 2151 2152 TEST_P(BuildSyntaxTreeTest, MemberExpression_StaticDataMember) { 2153 if (!GetParam().isCXX()) { 2154 return; 2155 } 2156 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2157 R"cpp( 2158 struct S { 2159 static int a; 2160 }; 2161 void test(S s) { 2162 [[s.a]]; 2163 } 2164 )cpp", 2165 {R"txt( 2166 MemberExpression Expression 2167 |-IdExpression Object 2168 | `-UnqualifiedId UnqualifiedId 2169 | `-'s' 2170 |-'.' AccessToken 2171 `-IdExpression Member 2172 `-UnqualifiedId UnqualifiedId 2173 `-'a' 2174 )txt"})); 2175 } 2176 2177 TEST_P(BuildSyntaxTreeTest, MemberExpression_SimpleWithArrow) { 2178 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2179 R"cpp( 2180 struct S { 2181 int a; 2182 }; 2183 void test(struct S* sp) { 2184 [[sp->a]]; 2185 } 2186 )cpp", 2187 {R"txt( 2188 MemberExpression Expression 2189 |-IdExpression Object 2190 | `-UnqualifiedId UnqualifiedId 2191 | `-'sp' 2192 |-'->' AccessToken 2193 `-IdExpression Member 2194 `-UnqualifiedId UnqualifiedId 2195 `-'a' 2196 )txt"})); 2197 } 2198 2199 TEST_P(BuildSyntaxTreeTest, MemberExpression_Chaining) { 2200 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2201 R"cpp( 2202 struct S { 2203 struct S* next; 2204 }; 2205 void test(struct S s){ 2206 [[s.next->next]]; 2207 } 2208 )cpp", 2209 {R"txt( 2210 MemberExpression Expression 2211 |-MemberExpression Object 2212 | |-IdExpression Object 2213 | | `-UnqualifiedId UnqualifiedId 2214 | | `-'s' 2215 | |-'.' AccessToken 2216 | `-IdExpression Member 2217 | `-UnqualifiedId UnqualifiedId 2218 | `-'next' 2219 |-'->' AccessToken 2220 `-IdExpression Member 2221 `-UnqualifiedId UnqualifiedId 2222 `-'next' 2223 )txt"})); 2224 } 2225 2226 TEST_P(BuildSyntaxTreeTest, MemberExpression_OperatorFunction) { 2227 if (!GetParam().isCXX()) { 2228 return; 2229 } 2230 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2231 R"cpp( 2232 struct S { 2233 bool operator!(); 2234 }; 2235 void test(S s) { 2236 [[s.operator!()]]; 2237 } 2238 )cpp", 2239 {R"txt( 2240 CallExpression Expression 2241 |-MemberExpression Callee 2242 | |-IdExpression Object 2243 | | `-UnqualifiedId UnqualifiedId 2244 | | `-'s' 2245 | |-'.' AccessToken 2246 | `-IdExpression Member 2247 | `-UnqualifiedId UnqualifiedId 2248 | |-'operator' 2249 | `-'!' 2250 |-'(' OpenParen 2251 `-')' CloseParen 2252 )txt"})); 2253 } 2254 2255 TEST_P(BuildSyntaxTreeTest, MemberExpression_VariableTemplate) { 2256 if (!GetParam().isCXX14OrLater()) { 2257 return; 2258 } 2259 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2260 R"cpp( 2261 struct S { 2262 template<typename T> 2263 static constexpr T x = 42; 2264 }; 2265 // FIXME: `<int>` should be a child of `MemberExpression` and `;` of 2266 // `ExpressionStatement`. This is a bug in clang, in `getSourceRange` methods. 2267 void test(S s) [[{ 2268 s.x<int>; 2269 }]] 2270 )cpp", 2271 {R"txt( 2272 CompoundStatement 2273 |-'{' OpenParen 2274 |-ExpressionStatement Statement 2275 | `-MemberExpression Expression 2276 | |-IdExpression Object 2277 | | `-UnqualifiedId UnqualifiedId 2278 | | `-'s' 2279 | |-'.' AccessToken 2280 | `-IdExpression Member 2281 | `-UnqualifiedId UnqualifiedId 2282 | `-'x' 2283 |-'<' 2284 |-'int' 2285 |-'>' 2286 |-';' 2287 `-'}' CloseParen 2288 )txt"})); 2289 } 2290 2291 TEST_P(BuildSyntaxTreeTest, MemberExpression_FunctionTemplate) { 2292 if (!GetParam().isCXX()) { 2293 return; 2294 } 2295 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2296 R"cpp( 2297 struct S { 2298 template<typename T> 2299 T f(); 2300 }; 2301 void test(S* sp){ 2302 [[sp->f<int>()]]; 2303 } 2304 )cpp", 2305 {R"txt( 2306 CallExpression Expression 2307 |-MemberExpression Callee 2308 | |-IdExpression Object 2309 | | `-UnqualifiedId UnqualifiedId 2310 | | `-'sp' 2311 | |-'->' AccessToken 2312 | `-IdExpression Member 2313 | `-UnqualifiedId UnqualifiedId 2314 | |-'f' 2315 | |-'<' 2316 | |-'int' 2317 | `-'>' 2318 |-'(' OpenParen 2319 `-')' CloseParen 2320 )txt"})); 2321 } 2322 2323 TEST_P(BuildSyntaxTreeTest, 2324 MemberExpression_FunctionTemplateWithTemplateKeyword) { 2325 if (!GetParam().isCXX()) { 2326 return; 2327 } 2328 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2329 R"cpp( 2330 struct S { 2331 template<typename T> 2332 T f(); 2333 }; 2334 void test(S s){ 2335 [[s.template f<int>()]]; 2336 } 2337 )cpp", 2338 {R"txt( 2339 CallExpression Expression 2340 |-MemberExpression Callee 2341 | |-IdExpression Object 2342 | | `-UnqualifiedId UnqualifiedId 2343 | | `-'s' 2344 | |-'.' AccessToken 2345 | |-'template' 2346 | `-IdExpression Member 2347 | `-UnqualifiedId UnqualifiedId 2348 | |-'f' 2349 | |-'<' 2350 | |-'int' 2351 | `-'>' 2352 |-'(' OpenParen 2353 `-')' CloseParen 2354 )txt"})); 2355 } 2356 2357 TEST_P(BuildSyntaxTreeTest, MemberExpression_WithQualifier) { 2358 if (!GetParam().isCXX()) { 2359 return; 2360 } 2361 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2362 R"cpp( 2363 struct Base { 2364 void f(); 2365 }; 2366 struct S : public Base {}; 2367 void test(S s){ 2368 [[s.Base::f()]]; 2369 [[s.::S::~S()]]; 2370 } 2371 )cpp", 2372 {R"txt( 2373 CallExpression Expression 2374 |-MemberExpression Callee 2375 | |-IdExpression Object 2376 | | `-UnqualifiedId UnqualifiedId 2377 | | `-'s' 2378 | |-'.' AccessToken 2379 | `-IdExpression Member 2380 | |-NestedNameSpecifier Qualifier 2381 | | |-IdentifierNameSpecifier ListElement 2382 | | | `-'Base' 2383 | | `-'::' ListDelimiter 2384 | `-UnqualifiedId UnqualifiedId 2385 | `-'f' 2386 |-'(' OpenParen 2387 `-')' CloseParen 2388 )txt", 2389 R"txt( 2390 CallExpression Expression 2391 |-MemberExpression Callee 2392 | |-IdExpression Object 2393 | | `-UnqualifiedId UnqualifiedId 2394 | | `-'s' 2395 | |-'.' AccessToken 2396 | `-IdExpression Member 2397 | |-NestedNameSpecifier Qualifier 2398 | | |-'::' ListDelimiter 2399 | | |-IdentifierNameSpecifier ListElement 2400 | | | `-'S' 2401 | | `-'::' ListDelimiter 2402 | `-UnqualifiedId UnqualifiedId 2403 | |-'~' 2404 | `-'S' 2405 |-'(' OpenParen 2406 `-')' CloseParen 2407 )txt"})); 2408 } 2409 2410 TEST_P(BuildSyntaxTreeTest, MemberExpression_Complex) { 2411 if (!GetParam().isCXX()) { 2412 return; 2413 } 2414 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2415 R"cpp( 2416 template<typename T> 2417 struct U { 2418 template<typename U> 2419 U f(); 2420 }; 2421 struct S { 2422 U<int> getU(); 2423 }; 2424 void test(S* sp) { 2425 // FIXME: The first 'template' keyword is a child of `NestedNameSpecifier`, 2426 // but it should be a child of `MemberExpression` according to the grammar. 2427 // However one might argue that the 'template' keyword fits better inside 2428 // `NestedNameSpecifier` because if we change `U<int>` to `UI` we would like 2429 // equally to change the `NameSpecifier` `template U<int>` to just `UI`. 2430 [[sp->getU().template U<int>::template f<int>()]]; 2431 } 2432 )cpp", 2433 {R"txt( 2434 CallExpression Expression 2435 |-MemberExpression Callee 2436 | |-CallExpression Object 2437 | | |-MemberExpression Callee 2438 | | | |-IdExpression Object 2439 | | | | `-UnqualifiedId UnqualifiedId 2440 | | | | `-'sp' 2441 | | | |-'->' AccessToken 2442 | | | `-IdExpression Member 2443 | | | `-UnqualifiedId UnqualifiedId 2444 | | | `-'getU' 2445 | | |-'(' OpenParen 2446 | | `-')' CloseParen 2447 | |-'.' AccessToken 2448 | `-IdExpression Member 2449 | |-NestedNameSpecifier Qualifier 2450 | | |-SimpleTemplateNameSpecifier ListElement 2451 | | | |-'template' 2452 | | | |-'U' 2453 | | | |-'<' 2454 | | | |-'int' 2455 | | | `-'>' 2456 | | `-'::' ListDelimiter 2457 | |-'template' TemplateKeyword 2458 | `-UnqualifiedId UnqualifiedId 2459 | |-'f' 2460 | |-'<' 2461 | |-'int' 2462 | `-'>' 2463 |-'(' OpenParen 2464 `-')' CloseParen 2465 )txt"})); 2466 } 2467 2468 TEST_P(BuildSyntaxTreeTest, CallExpression_Callee_Member) { 2469 if (!GetParam().isCXX()) { 2470 return; 2471 } 2472 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2473 R"cpp( 2474 struct S{ 2475 void f(); 2476 }; 2477 void test(S s) { 2478 [[s.f()]]; 2479 } 2480 )cpp", 2481 {R"txt( 2482 CallExpression Expression 2483 |-MemberExpression Callee 2484 | |-IdExpression Object 2485 | | `-UnqualifiedId UnqualifiedId 2486 | | `-'s' 2487 | |-'.' AccessToken 2488 | `-IdExpression Member 2489 | `-UnqualifiedId UnqualifiedId 2490 | `-'f' 2491 |-'(' OpenParen 2492 `-')' CloseParen 2493 )txt"})); 2494 } 2495 2496 TEST_P(BuildSyntaxTreeTest, CallExpression_Callee_OperatorParens) { 2497 if (!GetParam().isCXX()) { 2498 return; 2499 } 2500 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2501 R"cpp( 2502 struct S { 2503 void operator()(); 2504 }; 2505 void test(S s) { 2506 [[s()]]; 2507 } 2508 )cpp", 2509 {R"txt( 2510 CallExpression Expression 2511 |-IdExpression Callee 2512 | `-UnqualifiedId UnqualifiedId 2513 | `-'s' 2514 |-'(' OpenParen 2515 `-')' CloseParen 2516 )txt"})); 2517 } 2518 2519 TEST_P(BuildSyntaxTreeTest, CallExpression_Callee_OperatorParensChaining) { 2520 if (!GetParam().isCXX()) { 2521 return; 2522 } 2523 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2524 R"cpp( 2525 struct S { 2526 S operator()(); 2527 }; 2528 void test(S s) { 2529 [[s()()]]; 2530 } 2531 )cpp", 2532 {R"txt( 2533 CallExpression Expression 2534 |-CallExpression Callee 2535 | |-IdExpression Callee 2536 | | `-UnqualifiedId UnqualifiedId 2537 | | `-'s' 2538 | |-'(' OpenParen 2539 | `-')' CloseParen 2540 |-'(' OpenParen 2541 `-')' CloseParen 2542 )txt"})); 2543 } 2544 2545 TEST_P(BuildSyntaxTreeTest, CallExpression_Callee_MemberWithThis) { 2546 if (!GetParam().isCXX()) { 2547 return; 2548 } 2549 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2550 R"cpp( 2551 struct Base { 2552 void f(); 2553 }; 2554 struct S: public Base { 2555 void f(); 2556 void test() { 2557 [[this->f()]]; 2558 [[f()]]; 2559 [[this->Base::f()]]; 2560 } 2561 }; 2562 )cpp", 2563 {R"txt( 2564 CallExpression Expression 2565 |-MemberExpression Callee 2566 | |-ThisExpression Object 2567 | | `-'this' IntroducerKeyword 2568 | |-'->' AccessToken 2569 | `-IdExpression Member 2570 | `-UnqualifiedId UnqualifiedId 2571 | `-'f' 2572 |-'(' OpenParen 2573 `-')' CloseParen 2574 )txt", 2575 R"txt( 2576 CallExpression Expression 2577 |-IdExpression Callee 2578 | `-UnqualifiedId UnqualifiedId 2579 | `-'f' 2580 |-'(' OpenParen 2581 `-')' CloseParen 2582 )txt", 2583 R"txt( 2584 CallExpression Expression 2585 |-MemberExpression Callee 2586 | |-ThisExpression Object 2587 | | `-'this' IntroducerKeyword 2588 | |-'->' AccessToken 2589 | `-IdExpression Member 2590 | |-NestedNameSpecifier Qualifier 2591 | | |-IdentifierNameSpecifier ListElement 2592 | | | `-'Base' 2593 | | `-'::' ListDelimiter 2594 | `-UnqualifiedId UnqualifiedId 2595 | `-'f' 2596 |-'(' OpenParen 2597 `-')' CloseParen 2598 )txt"})); 2599 } 2600 2601 TEST_P(BuildSyntaxTreeTest, CallExpression_Callee_FunctionPointer) { 2602 if (!GetParam().isCXX()) { 2603 return; 2604 } 2605 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2606 R"cpp( 2607 void (*pf)(); 2608 void test() { 2609 [[pf()]]; 2610 [[(*pf)()]]; 2611 } 2612 )cpp", 2613 {R"txt( 2614 CallExpression Expression 2615 |-IdExpression Callee 2616 | `-UnqualifiedId UnqualifiedId 2617 | `-'pf' 2618 |-'(' OpenParen 2619 `-')' CloseParen 2620 )txt", 2621 R"txt( 2622 CallExpression Expression 2623 |-ParenExpression Callee 2624 | |-'(' OpenParen 2625 | |-PrefixUnaryOperatorExpression SubExpression 2626 | | |-'*' OperatorToken 2627 | | `-IdExpression Operand 2628 | | `-UnqualifiedId UnqualifiedId 2629 | | `-'pf' 2630 | `-')' CloseParen 2631 |-'(' OpenParen 2632 `-')' CloseParen 2633 )txt"})); 2634 } 2635 2636 TEST_P(BuildSyntaxTreeTest, CallExpression_Callee_MemberFunctionPointer) { 2637 if (!GetParam().isCXX()) { 2638 return; 2639 } 2640 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2641 R"cpp( 2642 struct S { 2643 void f(); 2644 }; 2645 void test(S s) { 2646 void (S::*pmf)(); 2647 pmf = &S::f; 2648 [[(s.*pmf)()]]; 2649 } 2650 )cpp", 2651 {R"txt( 2652 CallExpression Expression 2653 |-ParenExpression Callee 2654 | |-'(' OpenParen 2655 | |-BinaryOperatorExpression SubExpression 2656 | | |-IdExpression LeftHandSide 2657 | | | `-UnqualifiedId UnqualifiedId 2658 | | | `-'s' 2659 | | |-'.*' OperatorToken 2660 | | `-IdExpression RightHandSide 2661 | | `-UnqualifiedId UnqualifiedId 2662 | | `-'pmf' 2663 | `-')' CloseParen 2664 |-'(' OpenParen 2665 `-')' CloseParen 2666 )txt"})); 2667 } 2668 2669 TEST_P(BuildSyntaxTreeTest, CallExpression_Arguments_Zero) { 2670 if (!GetParam().isCXX()) { 2671 return; 2672 } 2673 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2674 R"cpp( 2675 void f(); 2676 void test() { 2677 [[f();]] 2678 } 2679 )cpp", 2680 {R"txt( 2681 ExpressionStatement Statement 2682 |-CallExpression Expression 2683 | |-IdExpression Callee 2684 | | `-UnqualifiedId UnqualifiedId 2685 | | `-'f' 2686 | |-'(' OpenParen 2687 | `-')' CloseParen 2688 `-';' 2689 )txt"})); 2690 } 2691 2692 TEST_P(BuildSyntaxTreeTest, CallExpression_Arguments_One) { 2693 if (!GetParam().isCXX()) { 2694 return; 2695 } 2696 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2697 R"cpp( 2698 void f(int); 2699 void test() { 2700 [[f(1);]] 2701 } 2702 )cpp", 2703 {R"txt( 2704 ExpressionStatement Statement 2705 |-CallExpression Expression 2706 | |-IdExpression Callee 2707 | | `-UnqualifiedId UnqualifiedId 2708 | | `-'f' 2709 | |-'(' OpenParen 2710 | |-CallArguments Arguments 2711 | | `-IntegerLiteralExpression ListElement 2712 | | `-'1' LiteralToken 2713 | `-')' CloseParen 2714 `-';' 2715 )txt"})); 2716 } 2717 2718 TEST_P(BuildSyntaxTreeTest, CallExpression_Arguments_Multiple) { 2719 if (!GetParam().isCXX()) { 2720 return; 2721 } 2722 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2723 R"cpp( 2724 void f(int, char, float); 2725 void test() { 2726 [[f(1, '2', 3.);]] 2727 } 2728 )cpp", 2729 {R"txt( 2730 ExpressionStatement Statement 2731 |-CallExpression Expression 2732 | |-IdExpression Callee 2733 | | `-UnqualifiedId UnqualifiedId 2734 | | `-'f' 2735 | |-'(' OpenParen 2736 | |-CallArguments Arguments 2737 | | |-IntegerLiteralExpression ListElement 2738 | | | `-'1' LiteralToken 2739 | | |-',' ListDelimiter 2740 | | |-CharacterLiteralExpression ListElement 2741 | | | `-''2'' LiteralToken 2742 | | |-',' ListDelimiter 2743 | | `-FloatingLiteralExpression ListElement 2744 | | `-'3.' LiteralToken 2745 | `-')' CloseParen 2746 `-';' 2747 )txt"})); 2748 } 2749 2750 TEST_P(BuildSyntaxTreeTest, CallExpression_Arguments_Assignment) { 2751 if (!GetParam().isCXX()) { 2752 return; 2753 } 2754 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2755 R"cpp( 2756 void f(int); 2757 void test(int a) { 2758 [[f(a = 1);]] 2759 } 2760 )cpp", 2761 {R"txt( 2762 ExpressionStatement Statement 2763 |-CallExpression Expression 2764 | |-IdExpression Callee 2765 | | `-UnqualifiedId UnqualifiedId 2766 | | `-'f' 2767 | |-'(' OpenParen 2768 | |-CallArguments Arguments 2769 | | `-BinaryOperatorExpression ListElement 2770 | | |-IdExpression LeftHandSide 2771 | | | `-UnqualifiedId UnqualifiedId 2772 | | | `-'a' 2773 | | |-'=' OperatorToken 2774 | | `-IntegerLiteralExpression RightHandSide 2775 | | `-'1' LiteralToken 2776 | `-')' CloseParen 2777 `-';' 2778 )txt"})); 2779 } 2780 2781 TEST_P(BuildSyntaxTreeTest, CallExpression_Arguments_BracedInitList_Empty) { 2782 if (!GetParam().isCXX11OrLater()) { 2783 return; 2784 } 2785 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2786 R"cpp( 2787 void f(int[]); 2788 void test() { 2789 [[f({});]] 2790 } 2791 )cpp", 2792 {R"txt( 2793 ExpressionStatement Statement 2794 |-CallExpression Expression 2795 | |-IdExpression Callee 2796 | | `-UnqualifiedId UnqualifiedId 2797 | | `-'f' 2798 | |-'(' OpenParen 2799 | |-CallArguments Arguments 2800 | | `-UnknownExpression ListElement 2801 | | `-UnknownExpression 2802 | | |-'{' 2803 | | `-'}' 2804 | `-')' CloseParen 2805 `-';' 2806 )txt"})); 2807 } 2808 2809 TEST_P(BuildSyntaxTreeTest, CallExpression_Arguments_BracedInitList_Simple) { 2810 if (!GetParam().isCXX11OrLater()) { 2811 return; 2812 } 2813 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2814 R"cpp( 2815 struct TT {}; 2816 struct T{ 2817 int a; 2818 TT b; 2819 }; 2820 void f(T); 2821 void test() { 2822 [[f({1, {}});]] 2823 } 2824 )cpp", 2825 {R"txt( 2826 ExpressionStatement Statement 2827 |-CallExpression Expression 2828 | |-IdExpression Callee 2829 | | `-UnqualifiedId UnqualifiedId 2830 | | `-'f' 2831 | |-'(' OpenParen 2832 | |-CallArguments Arguments 2833 | | `-UnknownExpression ListElement 2834 | | `-UnknownExpression 2835 | | |-'{' 2836 | | |-IntegerLiteralExpression 2837 | | | `-'1' LiteralToken 2838 | | |-',' 2839 | | |-UnknownExpression 2840 | | | `-UnknownExpression 2841 | | | |-'{' 2842 | | | `-'}' 2843 | | `-'}' 2844 | `-')' CloseParen 2845 `-';' 2846 )txt"})); 2847 } 2848 2849 TEST_P(BuildSyntaxTreeTest, 2850 CallExpression_Arguments_BracedInitList_Designated) { 2851 if (!GetParam().isCXX11OrLater()) { 2852 return; 2853 } 2854 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2855 R"cpp( 2856 struct TT {}; 2857 struct T{ 2858 int a; 2859 TT b; 2860 }; 2861 void f(T); 2862 void test() { 2863 [[f({.a = 1, .b {}});]] 2864 } 2865 )cpp", 2866 {R"txt( 2867 ExpressionStatement Statement 2868 |-CallExpression Expression 2869 | |-IdExpression Callee 2870 | | `-UnqualifiedId UnqualifiedId 2871 | | `-'f' 2872 | |-'(' OpenParen 2873 | |-CallArguments Arguments 2874 | | `-UnknownExpression ListElement 2875 | | `-UnknownExpression 2876 | | |-'{' 2877 | | |-UnknownExpression 2878 | | | |-'.' 2879 | | | |-'a' 2880 | | | |-'=' 2881 | | | `-IntegerLiteralExpression 2882 | | | `-'1' LiteralToken 2883 | | |-',' 2884 | | |-UnknownExpression 2885 | | | |-'.' 2886 | | | |-'b' 2887 | | | `-UnknownExpression 2888 | | | `-UnknownExpression 2889 | | | |-'{' 2890 | | | `-'}' 2891 | | `-'}' 2892 | `-')' CloseParen 2893 `-';' 2894 )txt"})); 2895 } 2896 2897 TEST_P(BuildSyntaxTreeTest, CallExpression_Arguments_ParameterPack) { 2898 if (!GetParam().isCXX11OrLater() || GetParam().hasDelayedTemplateParsing()) { 2899 return; 2900 } 2901 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2902 R"cpp( 2903 template<typename T, typename... Args> 2904 void test(T t, Args... args) { 2905 [[test(args...)]]; 2906 } 2907 )cpp", 2908 {R"txt( 2909 CallExpression Expression 2910 |-UnknownExpression Callee 2911 | `-'test' 2912 |-'(' OpenParen 2913 |-CallArguments Arguments 2914 | `-UnknownExpression ListElement 2915 | |-IdExpression 2916 | | `-UnqualifiedId UnqualifiedId 2917 | | `-'args' 2918 | `-'...' 2919 `-')' CloseParen 2920 )txt"})); 2921 } 2922 2923 TEST_P(BuildSyntaxTreeTest, CallExpression_DefaultArguments) { 2924 if (!GetParam().isCXX11OrLater()) { 2925 return; 2926 } 2927 EXPECT_TRUE(treeDumpEqualOnAnnotations( 2928 R"cpp( 2929 void f(int i = 1, char c = '2'); 2930 void test() { 2931 [[f()]]; 2932 [[f(1)]]; 2933 [[f(1, '2')]]; 2934 } 2935 )cpp", 2936 {R"txt( 2937 CallExpression Expression 2938 |-IdExpression Callee 2939 | `-UnqualifiedId UnqualifiedId 2940 | `-'f' 2941 |-'(' OpenParen 2942 `-')' CloseParen 2943 )txt", 2944 R"txt( 2945 CallExpression Expression 2946 |-IdExpression Callee 2947 | `-UnqualifiedId UnqualifiedId 2948 | `-'f' 2949 |-'(' OpenParen 2950 |-CallArguments Arguments 2951 | `-IntegerLiteralExpression ListElement 2952 | `-'1' LiteralToken 2953 `-')' CloseParen 2954 )txt", 2955 R"txt( 2956 CallExpression Expression 2957 |-IdExpression Callee 2958 | `-UnqualifiedId UnqualifiedId 2959 | `-'f' 2960 |-'(' OpenParen 2961 |-CallArguments Arguments 2962 | |-IntegerLiteralExpression ListElement 2963 | | `-'1' LiteralToken 2964 | |-',' ListDelimiter 2965 | `-CharacterLiteralExpression ListElement 2966 | `-''2'' LiteralToken 2967 `-')' CloseParen 2968 )txt"})); 2969 } 2970 2971 TEST_P(BuildSyntaxTreeTest, MultipleDeclaratorsGrouping) { 2972 EXPECT_TRUE(treeDumpEqual( 2973 R"cpp( 2974 int *a, b; 2975 int *c, d; 2976 )cpp", 2977 R"txt( 2978 TranslationUnit Detached 2979 |-SimpleDeclaration 2980 | |-'int' 2981 | |-DeclaratorList Declarators 2982 | | |-SimpleDeclarator ListElement 2983 | | | |-'*' 2984 | | | `-'a' 2985 | | |-',' ListDelimiter 2986 | | `-SimpleDeclarator ListElement 2987 | | `-'b' 2988 | `-';' 2989 `-SimpleDeclaration 2990 |-'int' 2991 |-DeclaratorList Declarators 2992 | |-SimpleDeclarator ListElement 2993 | | |-'*' 2994 | | `-'c' 2995 | |-',' ListDelimiter 2996 | `-SimpleDeclarator ListElement 2997 | `-'d' 2998 `-';' 2999 )txt")); 3000 } 3001 3002 TEST_P(BuildSyntaxTreeTest, MultipleDeclaratorsGroupingTypedef) { 3003 EXPECT_TRUE(treeDumpEqual( 3004 R"cpp( 3005 typedef int *a, b; 3006 )cpp", 3007 R"txt( 3008 TranslationUnit Detached 3009 `-SimpleDeclaration 3010 |-'typedef' 3011 |-'int' 3012 |-DeclaratorList Declarators 3013 | |-SimpleDeclarator ListElement 3014 | | |-'*' 3015 | | `-'a' 3016 | |-',' ListDelimiter 3017 | `-SimpleDeclarator ListElement 3018 | `-'b' 3019 `-';' 3020 )txt")); 3021 } 3022 3023 TEST_P(BuildSyntaxTreeTest, MultipleDeclaratorsInsideStatement) { 3024 EXPECT_TRUE(treeDumpEqual( 3025 R"cpp( 3026 void foo() { 3027 int *a, b; 3028 typedef int *ta, tb; 3029 } 3030 )cpp", 3031 R"txt( 3032 TranslationUnit Detached 3033 `-SimpleDeclaration 3034 |-'void' 3035 |-DeclaratorList Declarators 3036 | `-SimpleDeclarator ListElement 3037 | |-'foo' 3038 | `-ParametersAndQualifiers 3039 | |-'(' OpenParen 3040 | `-')' CloseParen 3041 `-CompoundStatement 3042 |-'{' OpenParen 3043 |-DeclarationStatement Statement 3044 | |-SimpleDeclaration 3045 | | |-'int' 3046 | | `-DeclaratorList Declarators 3047 | | |-SimpleDeclarator ListElement 3048 | | | |-'*' 3049 | | | `-'a' 3050 | | |-',' ListDelimiter 3051 | | `-SimpleDeclarator ListElement 3052 | | `-'b' 3053 | `-';' 3054 |-DeclarationStatement Statement 3055 | |-SimpleDeclaration 3056 | | |-'typedef' 3057 | | |-'int' 3058 | | `-DeclaratorList Declarators 3059 | | |-SimpleDeclarator ListElement 3060 | | | |-'*' 3061 | | | `-'ta' 3062 | | |-',' ListDelimiter 3063 | | `-SimpleDeclarator ListElement 3064 | | `-'tb' 3065 | `-';' 3066 `-'}' CloseParen 3067 )txt")); 3068 } 3069 3070 TEST_P(BuildSyntaxTreeTest, SizeTTypedef) { 3071 if (!GetParam().isCXX11OrLater()) { 3072 return; 3073 } 3074 EXPECT_TRUE(treeDumpEqual( 3075 R"cpp( 3076 typedef decltype(sizeof(void *)) size_t; 3077 )cpp", 3078 R"txt( 3079 TranslationUnit Detached 3080 `-SimpleDeclaration 3081 |-'typedef' 3082 |-'decltype' 3083 |-'(' 3084 |-UnknownExpression 3085 | |-'sizeof' 3086 | |-'(' 3087 | |-'void' 3088 | |-'*' 3089 | `-')' 3090 |-')' 3091 |-DeclaratorList Declarators 3092 | `-SimpleDeclarator ListElement 3093 | `-'size_t' 3094 `-';' 3095 )txt")); 3096 } 3097 3098 TEST_P(BuildSyntaxTreeTest, Namespace_Nested) { 3099 if (!GetParam().isCXX()) { 3100 return; 3101 } 3102 EXPECT_TRUE(treeDumpEqual( 3103 R"cpp( 3104 namespace a { namespace b {} } 3105 )cpp", 3106 R"txt( 3107 TranslationUnit Detached 3108 `-NamespaceDefinition 3109 |-'namespace' 3110 |-'a' 3111 |-'{' 3112 |-NamespaceDefinition 3113 | |-'namespace' 3114 | |-'b' 3115 | |-'{' 3116 | `-'}' 3117 `-'}' 3118 )txt")); 3119 } 3120 3121 TEST_P(BuildSyntaxTreeTest, Namespace_NestedDefinition) { 3122 if (!GetParam().isCXX17OrLater()) { 3123 return; 3124 } 3125 EXPECT_TRUE(treeDumpEqual( 3126 R"cpp( 3127 namespace a::b {} 3128 )cpp", 3129 R"txt( 3130 TranslationUnit Detached 3131 `-NamespaceDefinition 3132 |-'namespace' 3133 |-'a' 3134 |-'::' 3135 |-'b' 3136 |-'{' 3137 `-'}' 3138 )txt")); 3139 } 3140 3141 TEST_P(BuildSyntaxTreeTest, Namespace_Unnamed) { 3142 if (!GetParam().isCXX()) { 3143 return; 3144 } 3145 EXPECT_TRUE(treeDumpEqual( 3146 R"cpp( 3147 namespace {} 3148 )cpp", 3149 R"txt( 3150 TranslationUnit Detached 3151 `-NamespaceDefinition 3152 |-'namespace' 3153 |-'{' 3154 `-'}' 3155 )txt")); 3156 } 3157 3158 TEST_P(BuildSyntaxTreeTest, Namespace_Alias) { 3159 if (!GetParam().isCXX()) { 3160 return; 3161 } 3162 EXPECT_TRUE(treeDumpEqualOnAnnotations( 3163 R"cpp( 3164 namespace a {} 3165 [[namespace foo = a;]] 3166 )cpp", 3167 {R"txt( 3168 NamespaceAliasDefinition 3169 |-'namespace' 3170 |-'foo' 3171 |-'=' 3172 |-'a' 3173 `-';' 3174 )txt"})); 3175 } 3176 3177 TEST_P(BuildSyntaxTreeTest, UsingDirective) { 3178 if (!GetParam().isCXX()) { 3179 return; 3180 } 3181 EXPECT_TRUE(treeDumpEqualOnAnnotations( 3182 R"cpp( 3183 namespace ns {} 3184 [[using namespace ::ns;]] 3185 )cpp", 3186 {R"txt( 3187 UsingNamespaceDirective 3188 |-'using' 3189 |-'namespace' 3190 |-NestedNameSpecifier 3191 | `-'::' ListDelimiter 3192 |-'ns' 3193 `-';' 3194 )txt"})); 3195 } 3196 3197 TEST_P(BuildSyntaxTreeTest, UsingDeclaration_Namespace) { 3198 if (!GetParam().isCXX()) { 3199 return; 3200 } 3201 EXPECT_TRUE(treeDumpEqualOnAnnotations( 3202 R"cpp( 3203 namespace ns { int a; } 3204 [[using ns::a;]] 3205 )cpp", 3206 {R"txt( 3207 UsingDeclaration 3208 |-'using' 3209 |-NestedNameSpecifier 3210 | |-IdentifierNameSpecifier ListElement 3211 | | `-'ns' 3212 | `-'::' ListDelimiter 3213 |-'a' 3214 `-';' 3215 )txt"})); 3216 } 3217 3218 TEST_P(BuildSyntaxTreeTest, UsingDeclaration_ClassMember) { 3219 if (!GetParam().isCXX()) { 3220 return; 3221 } 3222 EXPECT_TRUE(treeDumpEqualOnAnnotations( 3223 R"cpp( 3224 template <class T> struct X { 3225 [[using T::foo;]] 3226 [[using typename T::bar;]] 3227 }; 3228 )cpp", 3229 {R"txt( 3230 UsingDeclaration 3231 |-'using' 3232 |-NestedNameSpecifier 3233 | |-IdentifierNameSpecifier ListElement 3234 | | `-'T' 3235 | `-'::' ListDelimiter 3236 |-'foo' 3237 `-';' 3238 )txt", 3239 R"txt( 3240 UsingDeclaration 3241 |-'using' 3242 |-'typename' 3243 |-NestedNameSpecifier 3244 | |-IdentifierNameSpecifier ListElement 3245 | | `-'T' 3246 | `-'::' ListDelimiter 3247 |-'bar' 3248 `-';' 3249 )txt"})); 3250 } 3251 3252 TEST_P(BuildSyntaxTreeTest, UsingTypeAlias) { 3253 if (!GetParam().isCXX11OrLater()) { 3254 return; 3255 } 3256 EXPECT_TRUE(treeDumpEqual( 3257 R"cpp( 3258 using type = int; 3259 )cpp", 3260 R"txt( 3261 TranslationUnit Detached 3262 `-TypeAliasDeclaration 3263 |-'using' 3264 |-'type' 3265 |-'=' 3266 |-'int' 3267 `-';' 3268 )txt")); 3269 } 3270 3271 TEST_P(BuildSyntaxTreeTest, FreeStandingClass_ForwardDeclaration) { 3272 EXPECT_TRUE(treeDumpEqualOnAnnotations( 3273 R"cpp( 3274 [[struct X;]] 3275 [[struct Y *y1;]] 3276 )cpp", 3277 {R"txt( 3278 SimpleDeclaration 3279 |-'struct' 3280 |-'X' 3281 `-';' 3282 )txt", 3283 R"txt( 3284 SimpleDeclaration 3285 |-'struct' 3286 |-'Y' 3287 |-DeclaratorList Declarators 3288 | `-SimpleDeclarator ListElement 3289 | |-'*' 3290 | `-'y1' 3291 `-';' 3292 )txt"})); 3293 } 3294 3295 TEST_P(BuildSyntaxTreeTest, FreeStandingClasses_Definition) { 3296 EXPECT_TRUE(treeDumpEqualOnAnnotations( 3297 R"cpp( 3298 [[struct X {};]] 3299 [[struct Y {} *y2;]] 3300 [[struct {} *a1;]] 3301 )cpp", 3302 {R"txt( 3303 SimpleDeclaration 3304 |-'struct' 3305 |-'X' 3306 |-'{' 3307 |-'}' 3308 `-';' 3309 )txt", 3310 R"txt( 3311 SimpleDeclaration 3312 |-'struct' 3313 |-'Y' 3314 |-'{' 3315 |-'}' 3316 |-DeclaratorList Declarators 3317 | `-SimpleDeclarator ListElement 3318 | |-'*' 3319 | `-'y2' 3320 `-';' 3321 )txt", 3322 R"txt( 3323 SimpleDeclaration 3324 |-'struct' 3325 |-'{' 3326 |-'}' 3327 |-DeclaratorList Declarators 3328 | `-SimpleDeclarator ListElement 3329 | |-'*' 3330 | `-'a1' 3331 `-';' 3332 )txt"})); 3333 } 3334 3335 TEST_P(BuildSyntaxTreeTest, StaticMemberFunction) { 3336 if (!GetParam().isCXX11OrLater()) { 3337 return; 3338 } 3339 EXPECT_TRUE(treeDumpEqualOnAnnotations( 3340 R"cpp( 3341 struct S { 3342 [[static void f(){}]] 3343 }; 3344 )cpp", 3345 {R"txt( 3346 SimpleDeclaration 3347 |-'static' 3348 |-'void' 3349 |-DeclaratorList Declarators 3350 | `-SimpleDeclarator ListElement 3351 | |-'f' 3352 | `-ParametersAndQualifiers 3353 | |-'(' OpenParen 3354 | `-')' CloseParen 3355 `-CompoundStatement 3356 |-'{' OpenParen 3357 `-'}' CloseParen 3358 )txt"})); 3359 } 3360 3361 TEST_P(BuildSyntaxTreeTest, OutOfLineMemberFunctionDefinition) { 3362 if (!GetParam().isCXX11OrLater()) { 3363 return; 3364 } 3365 EXPECT_TRUE(treeDumpEqualOnAnnotations( 3366 R"cpp( 3367 struct S { 3368 void f(); 3369 }; 3370 [[void S::f(){}]] 3371 )cpp", 3372 {R"txt( 3373 SimpleDeclaration 3374 |-'void' 3375 |-DeclaratorList Declarators 3376 | `-SimpleDeclarator ListElement 3377 | |-NestedNameSpecifier 3378 | | |-IdentifierNameSpecifier ListElement 3379 | | | `-'S' 3380 | | `-'::' ListDelimiter 3381 | |-'f' 3382 | `-ParametersAndQualifiers 3383 | |-'(' OpenParen 3384 | `-')' CloseParen 3385 `-CompoundStatement 3386 |-'{' OpenParen 3387 `-'}' CloseParen 3388 )txt"})); 3389 } 3390 3391 TEST_P(BuildSyntaxTreeTest, ConversionMemberFunction) { 3392 if (!GetParam().isCXX()) { 3393 return; 3394 } 3395 EXPECT_TRUE(treeDumpEqualOnAnnotations( 3396 R"cpp( 3397 struct X { 3398 [[operator int();]] 3399 }; 3400 )cpp", 3401 {R"txt( 3402 SimpleDeclaration 3403 |-DeclaratorList Declarators 3404 | `-SimpleDeclarator ListElement 3405 | |-'operator' 3406 | |-'int' 3407 | `-ParametersAndQualifiers 3408 | |-'(' OpenParen 3409 | `-')' CloseParen 3410 `-';' 3411 )txt"})); 3412 } 3413 3414 TEST_P(BuildSyntaxTreeTest, LiteralOperatorDeclaration) { 3415 if (!GetParam().isCXX11OrLater()) { 3416 return; 3417 } 3418 EXPECT_TRUE(treeDumpEqual( 3419 R"cpp( 3420 unsigned operator "" _c(char); 3421 )cpp", 3422 R"txt( 3423 TranslationUnit Detached 3424 `-SimpleDeclaration 3425 |-'unsigned' 3426 |-DeclaratorList Declarators 3427 | `-SimpleDeclarator ListElement 3428 | |-'operator' 3429 | |-'""' 3430 | |-'_c' 3431 | `-ParametersAndQualifiers 3432 | |-'(' OpenParen 3433 | |-ParameterDeclarationList Parameters 3434 | | `-SimpleDeclaration ListElement 3435 | | `-'char' 3436 | `-')' CloseParen 3437 `-';' 3438 )txt")); 3439 } 3440 3441 TEST_P(BuildSyntaxTreeTest, NumericLiteralOperatorTemplateDeclaration) { 3442 if (!GetParam().isCXX11OrLater()) { 3443 return; 3444 } 3445 EXPECT_TRUE(treeDumpEqual( 3446 R"cpp( 3447 template <char...> 3448 unsigned operator "" _t(); 3449 )cpp", 3450 R"txt( 3451 TranslationUnit Detached 3452 `-TemplateDeclaration Declaration 3453 |-'template' IntroducerKeyword 3454 |-'<' 3455 |-SimpleDeclaration 3456 | `-'char' 3457 |-'...' 3458 |-'>' 3459 `-SimpleDeclaration 3460 |-'unsigned' 3461 |-DeclaratorList Declarators 3462 | `-SimpleDeclarator ListElement 3463 | |-'operator' 3464 | |-'""' 3465 | |-'_t' 3466 | `-ParametersAndQualifiers 3467 | |-'(' OpenParen 3468 | `-')' CloseParen 3469 `-';' 3470 )txt")); 3471 } 3472 3473 TEST_P(BuildSyntaxTreeTest, OverloadedOperatorDeclaration) { 3474 if (!GetParam().isCXX()) { 3475 return; 3476 } 3477 EXPECT_TRUE(treeDumpEqualOnAnnotations( 3478 R"cpp( 3479 struct X { 3480 [[X& operator=(const X&);]] 3481 }; 3482 )cpp", 3483 {R"txt( 3484 SimpleDeclaration 3485 |-'X' 3486 |-DeclaratorList Declarators 3487 | `-SimpleDeclarator ListElement 3488 | |-'&' 3489 | |-'operator' 3490 | |-'=' 3491 | `-ParametersAndQualifiers 3492 | |-'(' OpenParen 3493 | |-ParameterDeclarationList Parameters 3494 | | `-SimpleDeclaration ListElement 3495 | | |-'const' 3496 | | |-'X' 3497 | | `-DeclaratorList Declarators 3498 | | `-SimpleDeclarator ListElement 3499 | | `-'&' 3500 | `-')' CloseParen 3501 `-';' 3502 )txt"})); 3503 } 3504 3505 TEST_P(BuildSyntaxTreeTest, OverloadedOperatorFriendDeclaration) { 3506 if (!GetParam().isCXX()) { 3507 return; 3508 } 3509 EXPECT_TRUE(treeDumpEqualOnAnnotations( 3510 R"cpp( 3511 struct X { 3512 [[friend X operator+(X, const X&);]] 3513 }; 3514 )cpp", 3515 {R"txt( 3516 UnknownDeclaration 3517 `-SimpleDeclaration 3518 |-'friend' 3519 |-'X' 3520 |-DeclaratorList Declarators 3521 | `-SimpleDeclarator ListElement 3522 | |-'operator' 3523 | |-'+' 3524 | `-ParametersAndQualifiers 3525 | |-'(' OpenParen 3526 | |-ParameterDeclarationList Parameters 3527 | | |-SimpleDeclaration ListElement 3528 | | | `-'X' 3529 | | |-',' ListDelimiter 3530 | | `-SimpleDeclaration ListElement 3531 | | |-'const' 3532 | | |-'X' 3533 | | `-DeclaratorList Declarators 3534 | | `-SimpleDeclarator ListElement 3535 | | `-'&' 3536 | `-')' CloseParen 3537 `-';' 3538 )txt"})); 3539 } 3540 3541 TEST_P(BuildSyntaxTreeTest, ClassTemplateDeclaration) { 3542 if (!GetParam().isCXX()) { 3543 return; 3544 } 3545 EXPECT_TRUE(treeDumpEqual( 3546 R"cpp( 3547 template<typename T> 3548 struct ST {}; 3549 )cpp", 3550 R"txt( 3551 TranslationUnit Detached 3552 `-TemplateDeclaration Declaration 3553 |-'template' IntroducerKeyword 3554 |-'<' 3555 |-UnknownDeclaration 3556 | |-'typename' 3557 | `-'T' 3558 |-'>' 3559 `-SimpleDeclaration 3560 |-'struct' 3561 |-'ST' 3562 |-'{' 3563 |-'}' 3564 `-';' 3565 )txt")); 3566 } 3567 3568 TEST_P(BuildSyntaxTreeTest, FunctionTemplateDeclaration) { 3569 if (!GetParam().isCXX()) { 3570 return; 3571 } 3572 EXPECT_TRUE(treeDumpEqual( 3573 R"cpp( 3574 template<typename T> 3575 T f(); 3576 )cpp", 3577 R"txt( 3578 TranslationUnit Detached 3579 `-TemplateDeclaration Declaration 3580 |-'template' IntroducerKeyword 3581 |-'<' 3582 |-UnknownDeclaration 3583 | |-'typename' 3584 | `-'T' 3585 |-'>' 3586 `-SimpleDeclaration 3587 |-'T' 3588 |-DeclaratorList Declarators 3589 | `-SimpleDeclarator ListElement 3590 | |-'f' 3591 | `-ParametersAndQualifiers 3592 | |-'(' OpenParen 3593 | `-')' CloseParen 3594 `-';' 3595 )txt")); 3596 } 3597 3598 TEST_P(BuildSyntaxTreeTest, VariableTemplateDeclaration) { 3599 if (!GetParam().isCXX14OrLater()) { 3600 return; 3601 } 3602 EXPECT_TRUE(treeDumpEqual( 3603 R"cpp( 3604 template <class T> T var = 10; 3605 )cpp", 3606 R"txt( 3607 TranslationUnit Detached 3608 `-TemplateDeclaration Declaration 3609 |-'template' IntroducerKeyword 3610 |-'<' 3611 |-UnknownDeclaration 3612 | |-'class' 3613 | `-'T' 3614 |-'>' 3615 `-SimpleDeclaration 3616 |-'T' 3617 |-DeclaratorList Declarators 3618 | `-SimpleDeclarator ListElement 3619 | |-'var' 3620 | |-'=' 3621 | `-IntegerLiteralExpression 3622 | `-'10' LiteralToken 3623 `-';' 3624 )txt")); 3625 } 3626 3627 TEST_P(BuildSyntaxTreeTest, StaticMemberFunctionTemplate) { 3628 if (!GetParam().isCXX()) { 3629 return; 3630 } 3631 EXPECT_TRUE(treeDumpEqualOnAnnotations( 3632 R"cpp( 3633 struct S { 3634 [[template<typename U> 3635 static U f();]] 3636 }; 3637 )cpp", 3638 {R"txt( 3639 TemplateDeclaration Declaration 3640 |-'template' IntroducerKeyword 3641 |-'<' 3642 |-UnknownDeclaration 3643 | |-'typename' 3644 | `-'U' 3645 |-'>' 3646 `-SimpleDeclaration 3647 |-'static' 3648 |-'U' 3649 |-DeclaratorList Declarators 3650 | `-SimpleDeclarator ListElement 3651 | |-'f' 3652 | `-ParametersAndQualifiers 3653 | |-'(' OpenParen 3654 | `-')' CloseParen 3655 `-';' 3656 )txt"})); 3657 } 3658 3659 TEST_P(BuildSyntaxTreeTest, NestedTemplates) { 3660 if (!GetParam().isCXX()) { 3661 return; 3662 } 3663 EXPECT_TRUE(treeDumpEqual( 3664 R"cpp( 3665 template <class T> 3666 struct X { 3667 template <class U> 3668 U foo(); 3669 }; 3670 )cpp", 3671 R"txt( 3672 TranslationUnit Detached 3673 `-TemplateDeclaration Declaration 3674 |-'template' IntroducerKeyword 3675 |-'<' 3676 |-UnknownDeclaration 3677 | |-'class' 3678 | `-'T' 3679 |-'>' 3680 `-SimpleDeclaration 3681 |-'struct' 3682 |-'X' 3683 |-'{' 3684 |-TemplateDeclaration Declaration 3685 | |-'template' IntroducerKeyword 3686 | |-'<' 3687 | |-UnknownDeclaration 3688 | | |-'class' 3689 | | `-'U' 3690 | |-'>' 3691 | `-SimpleDeclaration 3692 | |-'U' 3693 | |-DeclaratorList Declarators 3694 | | `-SimpleDeclarator ListElement 3695 | | |-'foo' 3696 | | `-ParametersAndQualifiers 3697 | | |-'(' OpenParen 3698 | | `-')' CloseParen 3699 | `-';' 3700 |-'}' 3701 `-';' 3702 )txt")); 3703 } 3704 3705 TEST_P(BuildSyntaxTreeTest, NestedTemplatesInNamespace) { 3706 if (!GetParam().isCXX()) { 3707 return; 3708 } 3709 EXPECT_TRUE(treeDumpEqual( 3710 R"cpp( 3711 namespace n { 3712 template<typename T> 3713 struct ST { 3714 template<typename U> 3715 static U f(); 3716 }; 3717 } 3718 )cpp", 3719 R"txt( 3720 TranslationUnit Detached 3721 `-NamespaceDefinition 3722 |-'namespace' 3723 |-'n' 3724 |-'{' 3725 |-TemplateDeclaration Declaration 3726 | |-'template' IntroducerKeyword 3727 | |-'<' 3728 | |-UnknownDeclaration 3729 | | |-'typename' 3730 | | `-'T' 3731 | |-'>' 3732 | `-SimpleDeclaration 3733 | |-'struct' 3734 | |-'ST' 3735 | |-'{' 3736 | |-TemplateDeclaration Declaration 3737 | | |-'template' IntroducerKeyword 3738 | | |-'<' 3739 | | |-UnknownDeclaration 3740 | | | |-'typename' 3741 | | | `-'U' 3742 | | |-'>' 3743 | | `-SimpleDeclaration 3744 | | |-'static' 3745 | | |-'U' 3746 | | |-DeclaratorList Declarators 3747 | | | `-SimpleDeclarator ListElement 3748 | | | |-'f' 3749 | | | `-ParametersAndQualifiers 3750 | | | |-'(' OpenParen 3751 | | | `-')' CloseParen 3752 | | `-';' 3753 | |-'}' 3754 | `-';' 3755 `-'}' 3756 )txt")); 3757 } 3758 3759 TEST_P(BuildSyntaxTreeTest, ClassTemplate_MemberClassDefinition) { 3760 if (!GetParam().isCXX()) { 3761 return; 3762 } 3763 EXPECT_TRUE(treeDumpEqualOnAnnotations( 3764 R"cpp( 3765 template <class T> struct X { struct Y; }; 3766 [[template <class T> struct X<T>::Y {};]] 3767 )cpp", 3768 {R"txt( 3769 TemplateDeclaration Declaration 3770 |-'template' IntroducerKeyword 3771 |-'<' 3772 |-UnknownDeclaration 3773 | |-'class' 3774 | `-'T' 3775 |-'>' 3776 `-SimpleDeclaration 3777 |-'struct' 3778 |-NestedNameSpecifier 3779 | |-SimpleTemplateNameSpecifier ListElement 3780 | | |-'X' 3781 | | |-'<' 3782 | | |-'T' 3783 | | `-'>' 3784 | `-'::' ListDelimiter 3785 |-'Y' 3786 |-'{' 3787 |-'}' 3788 `-';' 3789 )txt"})); 3790 } 3791 3792 TEST_P(BuildSyntaxTreeTest, ExplicitClassTemplateInstantiation_Definition) { 3793 if (!GetParam().isCXX()) { 3794 return; 3795 } 3796 EXPECT_TRUE(treeDumpEqualOnAnnotations( 3797 R"cpp( 3798 template <class T> struct X {}; 3799 [[template struct X<double>;]] 3800 )cpp", 3801 {R"txt( 3802 ExplicitTemplateInstantiation 3803 |-'template' IntroducerKeyword 3804 `-SimpleDeclaration Declaration 3805 |-'struct' 3806 |-'X' 3807 |-'<' 3808 |-'double' 3809 |-'>' 3810 `-';' 3811 )txt"})); 3812 } 3813 3814 TEST_P(BuildSyntaxTreeTest, ExplicitClassTemplateInstantiation_Declaration) { 3815 if (!GetParam().isCXX()) { 3816 return; 3817 } 3818 EXPECT_TRUE(treeDumpEqualOnAnnotations( 3819 R"cpp( 3820 template <class T> struct X {}; 3821 [[extern template struct X<float>;]] 3822 )cpp", 3823 {R"txt( 3824 ExplicitTemplateInstantiation 3825 |-'extern' ExternKeyword 3826 |-'template' IntroducerKeyword 3827 `-SimpleDeclaration Declaration 3828 |-'struct' 3829 |-'X' 3830 |-'<' 3831 |-'float' 3832 |-'>' 3833 `-';' 3834 )txt"})); 3835 } 3836 3837 TEST_P(BuildSyntaxTreeTest, ClassTemplateSpecialization_Partial) { 3838 if (!GetParam().isCXX()) { 3839 return; 3840 } 3841 EXPECT_TRUE(treeDumpEqualOnAnnotations( 3842 R"cpp( 3843 template <class T> struct X {}; 3844 [[template <class T> struct X<T*> {};]] 3845 )cpp", 3846 {R"txt( 3847 TemplateDeclaration Declaration 3848 |-'template' IntroducerKeyword 3849 |-'<' 3850 |-UnknownDeclaration 3851 | |-'class' 3852 | `-'T' 3853 |-'>' 3854 `-SimpleDeclaration 3855 |-'struct' 3856 |-'X' 3857 |-'<' 3858 |-'T' 3859 |-'*' 3860 |-'>' 3861 |-'{' 3862 |-'}' 3863 `-';' 3864 )txt"})); 3865 } 3866 3867 TEST_P(BuildSyntaxTreeTest, ClassTemplateSpecialization_Full) { 3868 if (!GetParam().isCXX()) { 3869 return; 3870 } 3871 EXPECT_TRUE(treeDumpEqualOnAnnotations( 3872 R"cpp( 3873 template <class T> struct X {}; 3874 [[template <> struct X<int> {};]] 3875 )cpp", 3876 {R"txt( 3877 TemplateDeclaration Declaration 3878 |-'template' IntroducerKeyword 3879 |-'<' 3880 |-'>' 3881 `-SimpleDeclaration 3882 |-'struct' 3883 |-'X' 3884 |-'<' 3885 |-'int' 3886 |-'>' 3887 |-'{' 3888 |-'}' 3889 `-';' 3890 )txt"})); 3891 } 3892 3893 TEST_P(BuildSyntaxTreeTest, EmptyDeclaration) { 3894 EXPECT_TRUE(treeDumpEqual( 3895 R"cpp( 3896 ; 3897 )cpp", 3898 R"txt( 3899 TranslationUnit Detached 3900 `-EmptyDeclaration 3901 `-';' 3902 )txt")); 3903 } 3904 3905 TEST_P(BuildSyntaxTreeTest, StaticAssert) { 3906 if (!GetParam().isCXX11OrLater()) { 3907 return; 3908 } 3909 EXPECT_TRUE(treeDumpEqual( 3910 R"cpp( 3911 static_assert(true, "message"); 3912 )cpp", 3913 R"txt( 3914 TranslationUnit Detached 3915 `-StaticAssertDeclaration 3916 |-'static_assert' 3917 |-'(' 3918 |-BoolLiteralExpression Condition 3919 | `-'true' LiteralToken 3920 |-',' 3921 |-StringLiteralExpression Message 3922 | `-'"message"' LiteralToken 3923 |-')' 3924 `-';' 3925 )txt")); 3926 } 3927 3928 TEST_P(BuildSyntaxTreeTest, StaticAssert_WithoutMessage) { 3929 if (!GetParam().isCXX17OrLater()) { 3930 return; 3931 } 3932 EXPECT_TRUE(treeDumpEqual( 3933 R"cpp( 3934 static_assert(true); 3935 )cpp", 3936 R"txt( 3937 TranslationUnit Detached 3938 `-StaticAssertDeclaration 3939 |-'static_assert' 3940 |-'(' 3941 |-BoolLiteralExpression Condition 3942 | `-'true' LiteralToken 3943 |-')' 3944 `-';' 3945 )txt")); 3946 } 3947 3948 TEST_P(BuildSyntaxTreeTest, ExternC) { 3949 if (!GetParam().isCXX()) { 3950 return; 3951 } 3952 EXPECT_TRUE(treeDumpEqual( 3953 R"cpp( 3954 extern "C" int a; 3955 extern "C" { int b; int c; } 3956 )cpp", 3957 R"txt( 3958 TranslationUnit Detached 3959 |-LinkageSpecificationDeclaration 3960 | |-'extern' 3961 | |-'"C"' 3962 | `-SimpleDeclaration 3963 | |-'int' 3964 | |-DeclaratorList Declarators 3965 | | `-SimpleDeclarator ListElement 3966 | | `-'a' 3967 | `-';' 3968 `-LinkageSpecificationDeclaration 3969 |-'extern' 3970 |-'"C"' 3971 |-'{' 3972 |-SimpleDeclaration 3973 | |-'int' 3974 | |-DeclaratorList Declarators 3975 | | `-SimpleDeclarator ListElement 3976 | | `-'b' 3977 | `-';' 3978 |-SimpleDeclaration 3979 | |-'int' 3980 | |-DeclaratorList Declarators 3981 | | `-SimpleDeclarator ListElement 3982 | | `-'c' 3983 | `-';' 3984 `-'}' 3985 )txt")); 3986 } 3987 3988 TEST_P(BuildSyntaxTreeTest, Macro_ObjectLike_Leaf) { 3989 // All nodes can be mutated. 3990 EXPECT_TRUE(treeDumpEqual( 3991 R"cpp( 3992 #define OPEN { 3993 #define CLOSE } 3994 3995 void test() { 3996 OPEN 3997 1; 3998 CLOSE 3999 4000 OPEN 4001 2; 4002 } 4003 } 4004 )cpp", 4005 R"txt( 4006 TranslationUnit Detached 4007 `-SimpleDeclaration 4008 |-'void' 4009 |-DeclaratorList Declarators 4010 | `-SimpleDeclarator ListElement 4011 | |-'test' 4012 | `-ParametersAndQualifiers 4013 | |-'(' OpenParen 4014 | `-')' CloseParen 4015 `-CompoundStatement 4016 |-'{' OpenParen 4017 |-CompoundStatement Statement 4018 | |-'{' OpenParen 4019 | |-ExpressionStatement Statement 4020 | | |-IntegerLiteralExpression Expression 4021 | | | `-'1' LiteralToken 4022 | | `-';' 4023 | `-'}' CloseParen 4024 |-CompoundStatement Statement 4025 | |-'{' OpenParen 4026 | |-ExpressionStatement Statement 4027 | | |-IntegerLiteralExpression Expression 4028 | | | `-'2' LiteralToken 4029 | | `-';' 4030 | `-'}' CloseParen 4031 `-'}' CloseParen 4032 )txt")); 4033 } 4034 4035 TEST_P(BuildSyntaxTreeTest, Macro_ObjectLike_MatchTree) { 4036 // Some nodes are unmodifiable, they are marked with 'unmodifiable'. 4037 EXPECT_TRUE(treeDumpEqual( 4038 R"cpp( 4039 #define BRACES {} 4040 4041 void test() BRACES 4042 )cpp", 4043 R"txt( 4044 TranslationUnit Detached 4045 `-SimpleDeclaration 4046 |-'void' 4047 |-DeclaratorList Declarators 4048 | `-SimpleDeclarator ListElement 4049 | |-'test' 4050 | `-ParametersAndQualifiers 4051 | |-'(' OpenParen 4052 | `-')' CloseParen 4053 `-CompoundStatement 4054 |-'{' OpenParen unmodifiable 4055 `-'}' CloseParen unmodifiable 4056 )txt")); 4057 } 4058 4059 TEST_P(BuildSyntaxTreeTest, Macro_ObjectLike_MismatchTree) { 4060 EXPECT_TRUE(treeDumpEqual( 4061 R"cpp( 4062 #define HALF_IF if (1+ 4063 #define HALF_IF_2 1) {} 4064 void test() { 4065 HALF_IF HALF_IF_2 else {} 4066 })cpp", 4067 R"txt( 4068 TranslationUnit Detached 4069 `-SimpleDeclaration 4070 |-'void' 4071 |-DeclaratorList Declarators 4072 | `-SimpleDeclarator ListElement 4073 | |-'test' 4074 | `-ParametersAndQualifiers 4075 | |-'(' OpenParen 4076 | `-')' CloseParen 4077 `-CompoundStatement 4078 |-'{' OpenParen 4079 |-IfStatement Statement 4080 | |-'if' IntroducerKeyword unmodifiable 4081 | |-'(' unmodifiable 4082 | |-ExpressionStatement Condition unmodifiable 4083 | | `-BinaryOperatorExpression Expression unmodifiable 4084 | | |-IntegerLiteralExpression LeftHandSide unmodifiable 4085 | | | `-'1' LiteralToken unmodifiable 4086 | | |-'+' OperatorToken unmodifiable 4087 | | `-IntegerLiteralExpression RightHandSide unmodifiable 4088 | | `-'1' LiteralToken unmodifiable 4089 | |-')' unmodifiable 4090 | |-CompoundStatement ThenStatement unmodifiable 4091 | | |-'{' OpenParen unmodifiable 4092 | | `-'}' CloseParen unmodifiable 4093 | |-'else' ElseKeyword 4094 | `-CompoundStatement ElseStatement 4095 | |-'{' OpenParen 4096 | `-'}' CloseParen 4097 `-'}' CloseParen 4098 )txt")); 4099 } 4100 4101 TEST_P(BuildSyntaxTreeTest, Macro_FunctionLike_ModifiableArguments) { 4102 // FIXME: Note that the substitutions for `X` and `Y` are marked modifiable. 4103 // However we cannot change `X` freely. Indeed if we change its substitution 4104 // in the condition we should also change it the then-branch. 4105 EXPECT_TRUE(treeDumpEqual( 4106 R"cpp( 4107 #define MIN(X,Y) X < Y ? X : Y 4108 4109 void test() { 4110 MIN(1,2); 4111 } 4112 )cpp", 4113 R"txt( 4114 TranslationUnit Detached 4115 `-SimpleDeclaration 4116 |-'void' 4117 |-DeclaratorList Declarators 4118 | `-SimpleDeclarator ListElement 4119 | |-'test' 4120 | `-ParametersAndQualifiers 4121 | |-'(' OpenParen 4122 | `-')' CloseParen 4123 `-CompoundStatement 4124 |-'{' OpenParen 4125 |-ExpressionStatement Statement 4126 | |-UnknownExpression Expression 4127 | | |-BinaryOperatorExpression unmodifiable 4128 | | | |-IntegerLiteralExpression LeftHandSide 4129 | | | | `-'1' LiteralToken 4130 | | | |-'<' OperatorToken unmodifiable 4131 | | | `-IntegerLiteralExpression RightHandSide 4132 | | | `-'2' LiteralToken 4133 | | |-'?' unmodifiable 4134 | | |-IntegerLiteralExpression 4135 | | | `-'1' LiteralToken 4136 | | |-':' unmodifiable 4137 | | `-IntegerLiteralExpression 4138 | | `-'2' LiteralToken 4139 | `-';' 4140 `-'}' CloseParen 4141 )txt")); 4142 } 4143 4144 TEST_P(BuildSyntaxTreeTest, Macro_FunctionLike_MismatchTree) { 4145 EXPECT_TRUE(treeDumpEqual( 4146 R"cpp( 4147 #define HALF_IF(X) if (X && 4148 #define HALF_IF_2(Y) Y) {} 4149 void test() { 4150 HALF_IF(1) HALF_IF_2(0) else {} 4151 })cpp", 4152 R"txt( 4153 TranslationUnit Detached 4154 `-SimpleDeclaration 4155 |-'void' 4156 |-DeclaratorList Declarators 4157 | `-SimpleDeclarator ListElement 4158 | |-'test' 4159 | `-ParametersAndQualifiers 4160 | |-'(' OpenParen 4161 | `-')' CloseParen 4162 `-CompoundStatement 4163 |-'{' OpenParen 4164 |-IfStatement Statement 4165 | |-'if' IntroducerKeyword unmodifiable 4166 | |-'(' unmodifiable 4167 | |-ExpressionStatement Condition unmodifiable 4168 | | `-BinaryOperatorExpression Expression unmodifiable 4169 | | |-IntegerLiteralExpression LeftHandSide 4170 | | | `-'1' LiteralToken 4171 | | |-'&&' OperatorToken unmodifiable 4172 | | `-IntegerLiteralExpression RightHandSide 4173 | | `-'0' LiteralToken 4174 | |-')' unmodifiable 4175 | |-CompoundStatement ThenStatement unmodifiable 4176 | | |-'{' OpenParen unmodifiable 4177 | | `-'}' CloseParen unmodifiable 4178 | |-'else' ElseKeyword 4179 | `-CompoundStatement ElseStatement 4180 | |-'{' OpenParen 4181 | `-'}' CloseParen 4182 `-'}' CloseParen 4183 )txt")); 4184 } 4185 4186 TEST_P(BuildSyntaxTreeTest, Macro_FunctionLike_Variadic) { 4187 EXPECT_TRUE(treeDumpEqualOnAnnotations( 4188 R"cpp( 4189 #define CALL(F_NAME, ...) F_NAME(__VA_ARGS__) 4190 4191 void f(int); 4192 void g(int, int); 4193 void test() [[{ 4194 CALL(f, 0); 4195 CALL(g, 0, 1); 4196 }]] 4197 )cpp", 4198 {R"txt( 4199 CompoundStatement 4200 |-'{' OpenParen 4201 |-ExpressionStatement Statement 4202 | |-CallExpression Expression 4203 | | |-IdExpression Callee 4204 | | | `-UnqualifiedId UnqualifiedId 4205 | | | `-'f' 4206 | | |-'(' OpenParen unmodifiable 4207 | | |-CallArguments Arguments 4208 | | | `-IntegerLiteralExpression ListElement 4209 | | | `-'0' LiteralToken 4210 | | `-')' CloseParen unmodifiable 4211 | `-';' 4212 |-ExpressionStatement Statement 4213 | |-CallExpression Expression 4214 | | |-IdExpression Callee 4215 | | | `-UnqualifiedId UnqualifiedId 4216 | | | `-'g' 4217 | | |-'(' OpenParen unmodifiable 4218 | | |-CallArguments Arguments 4219 | | | |-IntegerLiteralExpression ListElement 4220 | | | | `-'0' LiteralToken 4221 | | | |-',' ListDelimiter 4222 | | | `-IntegerLiteralExpression ListElement 4223 | | | `-'1' LiteralToken 4224 | | `-')' CloseParen unmodifiable 4225 | `-';' 4226 `-'}' CloseParen 4227 )txt"})); 4228 } 4229 4230 TEST_P(BuildSyntaxTreeTest, InitDeclarator_Equal) { 4231 if (!GetParam().isCXX()) { 4232 return; 4233 } 4234 EXPECT_TRUE(treeDumpEqualOnAnnotations( 4235 R"cpp( 4236 struct S { S(int);}; 4237 void test() { 4238 [[S s = 1]]; 4239 } 4240 )cpp", 4241 {R"txt( 4242 SimpleDeclaration 4243 |-'S' 4244 `-DeclaratorList Declarators 4245 `-SimpleDeclarator ListElement 4246 |-'s' 4247 |-'=' 4248 `-IntegerLiteralExpression 4249 `-'1' LiteralToken 4250 )txt"})); 4251 } 4252 4253 TEST_P(BuildSyntaxTreeTest, InitDeclarator_Brace) { 4254 if (!GetParam().isCXX11OrLater()) { 4255 return; 4256 } 4257 EXPECT_TRUE(treeDumpEqualOnAnnotations( 4258 R"cpp( 4259 struct S { 4260 S(); 4261 S(int); 4262 S(int, float); 4263 }; 4264 void test(){ 4265 // FIXME: 's...' is a declarator and '{...}' is initializer 4266 [[S s0{}]]; 4267 [[S s1{1}]]; 4268 [[S s2{1, 2.}]]; 4269 } 4270 )cpp", 4271 {R"txt( 4272 SimpleDeclaration 4273 |-'S' 4274 `-DeclaratorList Declarators 4275 `-SimpleDeclarator ListElement 4276 `-UnknownExpression 4277 |-'s0' 4278 |-'{' 4279 `-'}' 4280 )txt", 4281 R"txt( 4282 SimpleDeclaration 4283 |-'S' 4284 `-DeclaratorList Declarators 4285 `-SimpleDeclarator ListElement 4286 `-UnknownExpression 4287 |-'s1' 4288 |-'{' 4289 |-IntegerLiteralExpression 4290 | `-'1' LiteralToken 4291 `-'}' 4292 )txt", 4293 R"txt( 4294 SimpleDeclaration 4295 |-'S' 4296 `-DeclaratorList Declarators 4297 `-SimpleDeclarator ListElement 4298 `-UnknownExpression 4299 |-'s2' 4300 |-'{' 4301 |-IntegerLiteralExpression 4302 | `-'1' LiteralToken 4303 |-',' 4304 |-FloatingLiteralExpression 4305 | `-'2.' LiteralToken 4306 `-'}' 4307 )txt"})); 4308 } 4309 4310 TEST_P(BuildSyntaxTreeTest, InitDeclarator_EqualBrace) { 4311 if (!GetParam().isCXX11OrLater()) { 4312 return; 4313 } 4314 EXPECT_TRUE(treeDumpEqualOnAnnotations( 4315 R"cpp( 4316 struct S { 4317 S(); 4318 S(int); 4319 S(int, float); 4320 }; 4321 void test() { 4322 // FIXME: '= {...}' is initializer 4323 [[S s0 = {}]]; 4324 [[S s1 = {1}]]; 4325 [[S s2 = {1, 2.}]]; 4326 } 4327 )cpp", 4328 {R"txt( 4329 SimpleDeclaration 4330 |-'S' 4331 `-DeclaratorList Declarators 4332 `-SimpleDeclarator ListElement 4333 |-'s0' 4334 |-'=' 4335 `-UnknownExpression 4336 |-'{' 4337 `-'}' 4338 )txt", 4339 R"txt( 4340 SimpleDeclaration 4341 |-'S' 4342 `-DeclaratorList Declarators 4343 `-SimpleDeclarator ListElement 4344 |-'s1' 4345 |-'=' 4346 `-UnknownExpression 4347 |-'{' 4348 |-IntegerLiteralExpression 4349 | `-'1' LiteralToken 4350 `-'}' 4351 )txt", 4352 R"txt( 4353 SimpleDeclaration 4354 |-'S' 4355 `-DeclaratorList Declarators 4356 `-SimpleDeclarator ListElement 4357 |-'s2' 4358 |-'=' 4359 `-UnknownExpression 4360 |-'{' 4361 |-IntegerLiteralExpression 4362 | `-'1' LiteralToken 4363 |-',' 4364 |-FloatingLiteralExpression 4365 | `-'2.' LiteralToken 4366 `-'}' 4367 )txt"})); 4368 } 4369 4370 TEST_P(BuildSyntaxTreeTest, InitDeclarator_Paren) { 4371 if (!GetParam().isCXX()) { 4372 return; 4373 } 4374 EXPECT_TRUE(treeDumpEqualOnAnnotations( 4375 R"cpp( 4376 struct S { 4377 S(int); 4378 S(int, float); 4379 }; 4380 // FIXME: 's...' is a declarator and '(...)' is initializer 4381 [[S s1(1);]] 4382 [[S s2(1, 2.);]] 4383 )cpp", 4384 {R"txt( 4385 SimpleDeclaration 4386 |-'S' 4387 |-DeclaratorList Declarators 4388 | `-SimpleDeclarator ListElement 4389 | `-UnknownExpression 4390 | |-'s1' 4391 | |-'(' 4392 | |-IntegerLiteralExpression 4393 | | `-'1' LiteralToken 4394 | `-')' 4395 `-';' 4396 )txt", 4397 R"txt( 4398 SimpleDeclaration 4399 |-'S' 4400 |-DeclaratorList Declarators 4401 | `-SimpleDeclarator ListElement 4402 | `-UnknownExpression 4403 | |-'s2' 4404 | |-'(' 4405 | |-IntegerLiteralExpression 4406 | | `-'1' LiteralToken 4407 | |-',' 4408 | |-FloatingLiteralExpression 4409 | | `-'2.' LiteralToken 4410 | `-')' 4411 `-';' 4412 )txt"})); 4413 } 4414 4415 TEST_P(BuildSyntaxTreeTest, InitDeclarator_Paren_DefaultArguments) { 4416 if (!GetParam().isCXX()) { 4417 return; 4418 } 4419 EXPECT_TRUE(treeDumpEqualOnAnnotations( 4420 R"cpp( 4421 struct S { 4422 S(int i = 1, float = 2.); 4423 }; 4424 [[S s0;]] 4425 // FIXME: 's...' is a declarator and '(...)' is initializer 4426 [[S s1(1);]] 4427 [[S s2(1, 2.);]] 4428 )cpp", 4429 {R"txt( 4430 SimpleDeclaration 4431 |-'S' 4432 |-DeclaratorList Declarators 4433 | `-SimpleDeclarator ListElement 4434 | `-'s0' 4435 `-';' 4436 )txt", 4437 R"txt( 4438 SimpleDeclaration 4439 |-'S' 4440 |-DeclaratorList Declarators 4441 | `-SimpleDeclarator ListElement 4442 | `-UnknownExpression 4443 | |-'s1' 4444 | |-'(' 4445 | |-IntegerLiteralExpression 4446 | | `-'1' LiteralToken 4447 | `-')' 4448 `-';' 4449 )txt", 4450 R"txt( 4451 SimpleDeclaration 4452 |-'S' 4453 |-DeclaratorList Declarators 4454 | `-SimpleDeclarator ListElement 4455 | `-UnknownExpression 4456 | |-'s2' 4457 | |-'(' 4458 | |-IntegerLiteralExpression 4459 | | `-'1' LiteralToken 4460 | |-',' 4461 | |-FloatingLiteralExpression 4462 | | `-'2.' LiteralToken 4463 | `-')' 4464 `-';' 4465 )txt"})); 4466 } 4467 4468 TEST_P(BuildSyntaxTreeTest, ImplicitConversion_Argument) { 4469 if (!GetParam().isCXX()) { 4470 return; 4471 } 4472 EXPECT_TRUE(treeDumpEqualOnAnnotations( 4473 R"cpp( 4474 struct X { 4475 X(int); 4476 }; 4477 void TakeX(const X&); 4478 void test() { 4479 [[TakeX(1)]]; 4480 } 4481 )cpp", 4482 {R"txt( 4483 CallExpression Expression 4484 |-IdExpression Callee 4485 | `-UnqualifiedId UnqualifiedId 4486 | `-'TakeX' 4487 |-'(' OpenParen 4488 |-CallArguments Arguments 4489 | `-IntegerLiteralExpression ListElement 4490 | `-'1' LiteralToken 4491 `-')' CloseParen 4492 )txt"})); 4493 } 4494 4495 TEST_P(BuildSyntaxTreeTest, ImplicitConversion_Return) { 4496 if (!GetParam().isCXX()) { 4497 return; 4498 } 4499 EXPECT_TRUE(treeDumpEqualOnAnnotations( 4500 R"cpp( 4501 struct X { 4502 X(int); 4503 }; 4504 X CreateX(){ 4505 [[return 1;]] 4506 } 4507 )cpp", 4508 {R"txt( 4509 ReturnStatement Statement 4510 |-'return' IntroducerKeyword 4511 |-IntegerLiteralExpression ReturnValue 4512 | `-'1' LiteralToken 4513 `-';' 4514 )txt"})); 4515 } 4516 4517 TEST_P(BuildSyntaxTreeTest, ConstructorCall_ZeroArguments) { 4518 if (!GetParam().isCXX()) { 4519 return; 4520 } 4521 EXPECT_TRUE(treeDumpEqualOnAnnotations( 4522 R"cpp( 4523 struct X { 4524 X(); 4525 }; 4526 X test() { 4527 [[return X();]] 4528 } 4529 )cpp", 4530 {R"txt( 4531 ReturnStatement Statement 4532 |-'return' IntroducerKeyword 4533 |-UnknownExpression ReturnValue 4534 | |-'X' 4535 | |-'(' 4536 | `-')' 4537 `-';' 4538 )txt"})); 4539 } 4540 4541 TEST_P(BuildSyntaxTreeTest, ConstructorCall_OneArgument) { 4542 if (!GetParam().isCXX()) { 4543 return; 4544 } 4545 EXPECT_TRUE(treeDumpEqualOnAnnotations( 4546 R"cpp( 4547 struct X { 4548 X(int); 4549 }; 4550 X test() { 4551 [[return X(1);]] 4552 } 4553 )cpp", 4554 {R"txt( 4555 ReturnStatement Statement 4556 |-'return' IntroducerKeyword 4557 |-UnknownExpression ReturnValue 4558 | |-'X' 4559 | |-'(' 4560 | |-IntegerLiteralExpression 4561 | | `-'1' LiteralToken 4562 | `-')' 4563 `-';' 4564 )txt"})); 4565 } 4566 4567 TEST_P(BuildSyntaxTreeTest, ConstructorCall_MultipleArguments) { 4568 if (!GetParam().isCXX()) { 4569 return; 4570 } 4571 EXPECT_TRUE(treeDumpEqualOnAnnotations( 4572 R"cpp( 4573 struct X { 4574 X(int, char); 4575 }; 4576 X test() { 4577 [[return X(1, '2');]] 4578 } 4579 )cpp", 4580 {R"txt( 4581 ReturnStatement Statement 4582 |-'return' IntroducerKeyword 4583 |-UnknownExpression ReturnValue 4584 | |-'X' 4585 | |-'(' 4586 | |-IntegerLiteralExpression 4587 | | `-'1' LiteralToken 4588 | |-',' 4589 | |-CharacterLiteralExpression 4590 | | `-''2'' LiteralToken 4591 | `-')' 4592 `-';' 4593 )txt"})); 4594 } 4595 4596 TEST_P(BuildSyntaxTreeTest, ConstructorCall_DefaultArguments) { 4597 if (!GetParam().isCXX()) { 4598 return; 4599 } 4600 EXPECT_TRUE(treeDumpEqualOnAnnotations( 4601 R"cpp( 4602 struct X { 4603 X(int i = 1, char c = '2'); 4604 }; 4605 X test() { 4606 auto x0 = [[X()]]; 4607 auto x1 = [[X(1)]]; 4608 auto x2 = [[X(1, '2')]]; 4609 } 4610 )cpp", 4611 {R"txt( 4612 UnknownExpression 4613 |-'X' 4614 |-'(' 4615 `-')' 4616 )txt", 4617 R"txt( 4618 UnknownExpression 4619 |-'X' 4620 |-'(' 4621 |-IntegerLiteralExpression 4622 | `-'1' LiteralToken 4623 `-')' 4624 )txt", 4625 R"txt( 4626 UnknownExpression 4627 |-'X' 4628 |-'(' 4629 |-IntegerLiteralExpression 4630 | `-'1' LiteralToken 4631 |-',' 4632 |-CharacterLiteralExpression 4633 | `-''2'' LiteralToken 4634 `-')' 4635 )txt"})); 4636 } 4637 4638 TEST_P(BuildSyntaxTreeTest, TypeConversion_FunctionalNotation) { 4639 if (!GetParam().isCXX()) { 4640 return; 4641 } 4642 EXPECT_TRUE(treeDumpEqualOnAnnotations( 4643 R"cpp( 4644 float test() { 4645 [[return float(1);]] 4646 } 4647 )cpp", 4648 {R"txt( 4649 ReturnStatement Statement 4650 |-'return' IntroducerKeyword 4651 |-UnknownExpression ReturnValue 4652 | |-'float' 4653 | |-'(' 4654 | |-IntegerLiteralExpression 4655 | | `-'1' LiteralToken 4656 | `-')' 4657 `-';' 4658 )txt"})); 4659 } 4660 4661 TEST_P(BuildSyntaxTreeTest, ArrayDeclarator_Simple) { 4662 EXPECT_TRUE(treeDumpEqual( 4663 R"cpp( 4664 int a[10]; 4665 )cpp", 4666 R"txt( 4667 TranslationUnit Detached 4668 `-SimpleDeclaration 4669 |-'int' 4670 |-DeclaratorList Declarators 4671 | `-SimpleDeclarator ListElement 4672 | |-'a' 4673 | `-ArraySubscript 4674 | |-'[' OpenParen 4675 | |-IntegerLiteralExpression Size 4676 | | `-'10' LiteralToken 4677 | `-']' CloseParen 4678 `-';' 4679 )txt")); 4680 } 4681 4682 TEST_P(BuildSyntaxTreeTest, ArrayDeclarator_Multidimensional) { 4683 EXPECT_TRUE(treeDumpEqual( 4684 R"cpp( 4685 int b[1][2][3]; 4686 )cpp", 4687 R"txt( 4688 TranslationUnit Detached 4689 `-SimpleDeclaration 4690 |-'int' 4691 |-DeclaratorList Declarators 4692 | `-SimpleDeclarator ListElement 4693 | |-'b' 4694 | |-ArraySubscript 4695 | | |-'[' OpenParen 4696 | | |-IntegerLiteralExpression Size 4697 | | | `-'1' LiteralToken 4698 | | `-']' CloseParen 4699 | |-ArraySubscript 4700 | | |-'[' OpenParen 4701 | | |-IntegerLiteralExpression Size 4702 | | | `-'2' LiteralToken 4703 | | `-']' CloseParen 4704 | `-ArraySubscript 4705 | |-'[' OpenParen 4706 | |-IntegerLiteralExpression Size 4707 | | `-'3' LiteralToken 4708 | `-']' CloseParen 4709 `-';' 4710 )txt")); 4711 } 4712 4713 TEST_P(BuildSyntaxTreeTest, ArrayDeclarator_UnknownBound) { 4714 EXPECT_TRUE(treeDumpEqual( 4715 R"cpp( 4716 int c[] = {1,2,3}; 4717 )cpp", 4718 R"txt( 4719 TranslationUnit Detached 4720 `-SimpleDeclaration 4721 |-'int' 4722 |-DeclaratorList Declarators 4723 | `-SimpleDeclarator ListElement 4724 | |-'c' 4725 | |-ArraySubscript 4726 | | |-'[' OpenParen 4727 | | `-']' CloseParen 4728 | |-'=' 4729 | `-UnknownExpression 4730 | `-UnknownExpression 4731 | |-'{' 4732 | |-IntegerLiteralExpression 4733 | | `-'1' LiteralToken 4734 | |-',' 4735 | |-IntegerLiteralExpression 4736 | | `-'2' LiteralToken 4737 | |-',' 4738 | |-IntegerLiteralExpression 4739 | | `-'3' LiteralToken 4740 | `-'}' 4741 `-';' 4742 )txt")); 4743 } 4744 4745 TEST_P(BuildSyntaxTreeTest, ArrayDeclarator_Static) { 4746 if (!GetParam().isC99OrLater()) { 4747 return; 4748 } 4749 EXPECT_TRUE(treeDumpEqual( 4750 R"cpp( 4751 void f(int xs[static 10]); 4752 )cpp", 4753 R"txt( 4754 TranslationUnit Detached 4755 `-SimpleDeclaration 4756 |-'void' 4757 |-DeclaratorList Declarators 4758 | `-SimpleDeclarator ListElement 4759 | |-'f' 4760 | `-ParametersAndQualifiers 4761 | |-'(' OpenParen 4762 | |-ParameterDeclarationList Parameters 4763 | | `-SimpleDeclaration ListElement 4764 | | |-'int' 4765 | | `-DeclaratorList Declarators 4766 | | `-SimpleDeclarator ListElement 4767 | | |-'xs' 4768 | | `-ArraySubscript 4769 | | |-'[' OpenParen 4770 | | |-'static' 4771 | | |-IntegerLiteralExpression Size 4772 | | | `-'10' LiteralToken 4773 | | `-']' CloseParen 4774 | `-')' CloseParen 4775 `-';' 4776 )txt")); 4777 } 4778 4779 TEST_P(BuildSyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Empty) { 4780 EXPECT_TRUE(treeDumpEqual( 4781 R"cpp( 4782 int func(); 4783 )cpp", 4784 R"txt( 4785 TranslationUnit Detached 4786 `-SimpleDeclaration 4787 |-'int' 4788 |-DeclaratorList Declarators 4789 | `-SimpleDeclarator ListElement 4790 | |-'func' 4791 | `-ParametersAndQualifiers 4792 | |-'(' OpenParen 4793 | `-')' CloseParen 4794 `-';' 4795 )txt")); 4796 } 4797 4798 TEST_P(BuildSyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Named) { 4799 EXPECT_TRUE(treeDumpEqualOnAnnotations( 4800 R"cpp( 4801 int func1([[int a]]); 4802 int func2([[int *ap]]); 4803 int func3([[int a, float b]]); 4804 int func4([[undef a]]); // error-ok: no crash on invalid type 4805 )cpp", 4806 {R"txt( 4807 ParameterDeclarationList Parameters 4808 `-SimpleDeclaration ListElement 4809 |-'int' 4810 `-DeclaratorList Declarators 4811 `-SimpleDeclarator ListElement 4812 `-'a' 4813 )txt", 4814 R"txt( 4815 ParameterDeclarationList Parameters 4816 `-SimpleDeclaration ListElement 4817 |-'int' 4818 `-DeclaratorList Declarators 4819 `-SimpleDeclarator ListElement 4820 |-'*' 4821 `-'ap' 4822 )txt", 4823 R"txt( 4824 ParameterDeclarationList Parameters 4825 |-SimpleDeclaration ListElement 4826 | |-'int' 4827 | `-DeclaratorList Declarators 4828 | `-SimpleDeclarator ListElement 4829 | `-'a' 4830 |-',' ListDelimiter 4831 `-SimpleDeclaration ListElement 4832 |-'float' 4833 `-DeclaratorList Declarators 4834 `-SimpleDeclarator ListElement 4835 `-'b' 4836 )txt", 4837 R"txt( 4838 ParameterDeclarationList Parameters 4839 `-SimpleDeclaration ListElement 4840 |-'undef' 4841 `-DeclaratorList Declarators 4842 `-SimpleDeclarator ListElement 4843 `-'a' 4844 )txt"})); 4845 } 4846 4847 TEST_P(BuildSyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Unnamed) { 4848 EXPECT_TRUE(treeDumpEqual( 4849 R"cpp( 4850 int func1(int); 4851 int func2(int *); 4852 int func3(int, float); 4853 )cpp", 4854 R"txt( 4855 TranslationUnit Detached 4856 |-SimpleDeclaration 4857 | |-'int' 4858 | |-DeclaratorList Declarators 4859 | | `-SimpleDeclarator ListElement 4860 | | |-'func1' 4861 | | `-ParametersAndQualifiers 4862 | | |-'(' OpenParen 4863 | | |-ParameterDeclarationList Parameters 4864 | | | `-SimpleDeclaration ListElement 4865 | | | `-'int' 4866 | | `-')' CloseParen 4867 | `-';' 4868 |-SimpleDeclaration 4869 | |-'int' 4870 | |-DeclaratorList Declarators 4871 | | `-SimpleDeclarator ListElement 4872 | | |-'func2' 4873 | | `-ParametersAndQualifiers 4874 | | |-'(' OpenParen 4875 | | |-ParameterDeclarationList Parameters 4876 | | | `-SimpleDeclaration ListElement 4877 | | | |-'int' 4878 | | | `-DeclaratorList Declarators 4879 | | | `-SimpleDeclarator ListElement 4880 | | | `-'*' 4881 | | `-')' CloseParen 4882 | `-';' 4883 `-SimpleDeclaration 4884 |-'int' 4885 |-DeclaratorList Declarators 4886 | `-SimpleDeclarator ListElement 4887 | |-'func3' 4888 | `-ParametersAndQualifiers 4889 | |-'(' OpenParen 4890 | |-ParameterDeclarationList Parameters 4891 | | |-SimpleDeclaration ListElement 4892 | | | `-'int' 4893 | | |-',' ListDelimiter 4894 | | `-SimpleDeclaration ListElement 4895 | | `-'float' 4896 | `-')' CloseParen 4897 `-';' 4898 )txt")); 4899 } 4900 4901 TEST_P(BuildSyntaxTreeTest, 4902 ParametersAndQualifiers_InFreeFunctions_Default_One) { 4903 if (!GetParam().isCXX()) { 4904 return; 4905 } 4906 EXPECT_TRUE(treeDumpEqualOnAnnotations( 4907 R"cpp( 4908 int func1([[int a = 1]]); 4909 )cpp", 4910 {R"txt( 4911 ParameterDeclarationList Parameters 4912 `-SimpleDeclaration ListElement 4913 |-'int' 4914 `-DeclaratorList Declarators 4915 `-SimpleDeclarator ListElement 4916 |-'a' 4917 |-'=' 4918 `-IntegerLiteralExpression 4919 `-'1' LiteralToken 4920 )txt"})); 4921 } 4922 4923 TEST_P(BuildSyntaxTreeTest, 4924 ParametersAndQualifiers_InFreeFunctions_Default_Multiple) { 4925 if (!GetParam().isCXX()) { 4926 return; 4927 } 4928 EXPECT_TRUE(treeDumpEqualOnAnnotations( 4929 R"cpp( 4930 int func2([[int *ap, int a = 1, char c = '2']]); 4931 )cpp", 4932 {R"txt( 4933 ParameterDeclarationList Parameters 4934 |-SimpleDeclaration ListElement 4935 | |-'int' 4936 | `-DeclaratorList Declarators 4937 | `-SimpleDeclarator ListElement 4938 | |-'*' 4939 | `-'ap' 4940 |-',' ListDelimiter 4941 |-SimpleDeclaration ListElement 4942 | |-'int' 4943 | `-DeclaratorList Declarators 4944 | `-SimpleDeclarator ListElement 4945 | |-'a' 4946 | |-'=' 4947 | `-IntegerLiteralExpression 4948 | `-'1' LiteralToken 4949 |-',' ListDelimiter 4950 `-SimpleDeclaration ListElement 4951 |-'char' 4952 `-DeclaratorList Declarators 4953 `-SimpleDeclarator ListElement 4954 |-'c' 4955 |-'=' 4956 `-CharacterLiteralExpression 4957 `-''2'' LiteralToken 4958 )txt"})); 4959 } 4960 4961 TEST_P(BuildSyntaxTreeTest, 4962 ParametersAndQualifiers_InVariadicFunctionTemplate_ParameterPack) { 4963 if (!GetParam().isCXX11OrLater() || GetParam().hasDelayedTemplateParsing()) { 4964 return; 4965 } 4966 EXPECT_TRUE(treeDumpEqualOnAnnotations( 4967 R"cpp( 4968 template<typename T, typename... Args> 4969 [[void test(T , Args... );]] 4970 )cpp", 4971 {R"txt( 4972 SimpleDeclaration 4973 |-'void' 4974 |-DeclaratorList Declarators 4975 | `-SimpleDeclarator ListElement 4976 | |-'test' 4977 | `-ParametersAndQualifiers 4978 | |-'(' OpenParen 4979 | |-ParameterDeclarationList Parameters 4980 | | |-SimpleDeclaration ListElement 4981 | | | `-'T' 4982 | | |-',' ListDelimiter 4983 | | `-SimpleDeclaration ListElement 4984 | | |-'Args' 4985 | | `-'...' 4986 | `-')' CloseParen 4987 `-';' 4988 )txt"})); 4989 } 4990 4991 TEST_P(BuildSyntaxTreeTest, 4992 ParametersAndQualifiers_InVariadicFunctionTemplate_NamedParameterPack) { 4993 if (!GetParam().isCXX11OrLater() || GetParam().hasDelayedTemplateParsing()) { 4994 return; 4995 } 4996 EXPECT_TRUE(treeDumpEqualOnAnnotations( 4997 R"cpp( 4998 template<typename T, typename... Args> 4999 [[void test(T t, Args... args);]] 5000 )cpp", 5001 {R"txt( 5002 SimpleDeclaration 5003 |-'void' 5004 |-DeclaratorList Declarators 5005 | `-SimpleDeclarator ListElement 5006 | |-'test' 5007 | `-ParametersAndQualifiers 5008 | |-'(' OpenParen 5009 | |-ParameterDeclarationList Parameters 5010 | | |-SimpleDeclaration ListElement 5011 | | | |-'T' 5012 | | | `-DeclaratorList Declarators 5013 | | | `-SimpleDeclarator ListElement 5014 | | | `-'t' 5015 | | |-',' ListDelimiter 5016 | | `-SimpleDeclaration ListElement 5017 | | |-'Args' 5018 | | |-'...' 5019 | | `-DeclaratorList Declarators 5020 | | `-SimpleDeclarator ListElement 5021 | | `-'args' 5022 | `-')' CloseParen 5023 `-';' 5024 )txt"})); 5025 } 5026 5027 TEST_P(BuildSyntaxTreeTest, 5028 ParametersAndQualifiers_InFreeFunctions_VariadicArguments) { 5029 if (!GetParam().isCXX11OrLater()) { 5030 return; 5031 } 5032 EXPECT_TRUE(treeDumpEqual( 5033 R"cpp( 5034 void test(int , char ...); 5035 )cpp", 5036 R"txt( 5037 TranslationUnit Detached 5038 `-SimpleDeclaration 5039 |-'void' 5040 |-DeclaratorList Declarators 5041 | `-SimpleDeclarator ListElement 5042 | |-'test' 5043 | `-ParametersAndQualifiers 5044 | |-'(' OpenParen 5045 | |-ParameterDeclarationList Parameters 5046 | | |-SimpleDeclaration ListElement 5047 | | | `-'int' 5048 | | |-',' ListDelimiter 5049 | | `-SimpleDeclaration ListElement 5050 | | `-'char' 5051 | |-'...' 5052 | `-')' CloseParen 5053 `-';' 5054 )txt")); 5055 } 5056 5057 TEST_P(BuildSyntaxTreeTest, 5058 ParametersAndQualifiers_InFreeFunctions_Cxx_CvQualifiers) { 5059 if (!GetParam().isCXX()) { 5060 return; 5061 } 5062 EXPECT_TRUE(treeDumpEqual( 5063 R"cpp( 5064 int func(const int a, volatile int b, const volatile int c); 5065 )cpp", 5066 R"txt( 5067 TranslationUnit Detached 5068 `-SimpleDeclaration 5069 |-'int' 5070 |-DeclaratorList Declarators 5071 | `-SimpleDeclarator ListElement 5072 | |-'func' 5073 | `-ParametersAndQualifiers 5074 | |-'(' OpenParen 5075 | |-ParameterDeclarationList Parameters 5076 | | |-SimpleDeclaration ListElement 5077 | | | |-'const' 5078 | | | |-'int' 5079 | | | `-DeclaratorList Declarators 5080 | | | `-SimpleDeclarator ListElement 5081 | | | `-'a' 5082 | | |-',' ListDelimiter 5083 | | |-SimpleDeclaration ListElement 5084 | | | |-'volatile' 5085 | | | |-'int' 5086 | | | `-DeclaratorList Declarators 5087 | | | `-SimpleDeclarator ListElement 5088 | | | `-'b' 5089 | | |-',' ListDelimiter 5090 | | `-SimpleDeclaration ListElement 5091 | | |-'const' 5092 | | |-'volatile' 5093 | | |-'int' 5094 | | `-DeclaratorList Declarators 5095 | | `-SimpleDeclarator ListElement 5096 | | `-'c' 5097 | `-')' CloseParen 5098 `-';' 5099 )txt")); 5100 } 5101 5102 TEST_P(BuildSyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Cxx_Ref) { 5103 if (!GetParam().isCXX()) { 5104 return; 5105 } 5106 EXPECT_TRUE(treeDumpEqual( 5107 R"cpp( 5108 int func(int& a); 5109 )cpp", 5110 R"txt( 5111 TranslationUnit Detached 5112 `-SimpleDeclaration 5113 |-'int' 5114 |-DeclaratorList Declarators 5115 | `-SimpleDeclarator ListElement 5116 | |-'func' 5117 | `-ParametersAndQualifiers 5118 | |-'(' OpenParen 5119 | |-ParameterDeclarationList Parameters 5120 | | `-SimpleDeclaration ListElement 5121 | | |-'int' 5122 | | `-DeclaratorList Declarators 5123 | | `-SimpleDeclarator ListElement 5124 | | |-'&' 5125 | | `-'a' 5126 | `-')' CloseParen 5127 `-';' 5128 )txt")); 5129 } 5130 5131 TEST_P(BuildSyntaxTreeTest, 5132 ParametersAndQualifiers_InFreeFunctions_Cxx11_RefRef) { 5133 if (!GetParam().isCXX11OrLater()) { 5134 return; 5135 } 5136 EXPECT_TRUE(treeDumpEqual( 5137 R"cpp( 5138 int func(int&& a); 5139 )cpp", 5140 R"txt( 5141 TranslationUnit Detached 5142 `-SimpleDeclaration 5143 |-'int' 5144 |-DeclaratorList Declarators 5145 | `-SimpleDeclarator ListElement 5146 | |-'func' 5147 | `-ParametersAndQualifiers 5148 | |-'(' OpenParen 5149 | |-ParameterDeclarationList Parameters 5150 | | `-SimpleDeclaration ListElement 5151 | | |-'int' 5152 | | `-DeclaratorList Declarators 5153 | | `-SimpleDeclarator ListElement 5154 | | |-'&&' 5155 | | `-'a' 5156 | `-')' CloseParen 5157 `-';' 5158 )txt")); 5159 } 5160 5161 TEST_P(BuildSyntaxTreeTest, ParametersAndQualifiers_InMemberFunctions_Simple) { 5162 if (!GetParam().isCXX()) { 5163 return; 5164 } 5165 EXPECT_TRUE(treeDumpEqual( 5166 R"cpp( 5167 struct Test { 5168 int a(); 5169 }; 5170 )cpp", 5171 R"txt( 5172 TranslationUnit Detached 5173 `-SimpleDeclaration 5174 |-'struct' 5175 |-'Test' 5176 |-'{' 5177 |-SimpleDeclaration 5178 | |-'int' 5179 | |-DeclaratorList Declarators 5180 | | `-SimpleDeclarator ListElement 5181 | | |-'a' 5182 | | `-ParametersAndQualifiers 5183 | | |-'(' OpenParen 5184 | | `-')' CloseParen 5185 | `-';' 5186 |-'}' 5187 `-';' 5188 )txt")); 5189 } 5190 5191 TEST_P(BuildSyntaxTreeTest, 5192 ParametersAndQualifiers_InMemberFunctions_CvQualifiers) { 5193 if (!GetParam().isCXX()) { 5194 return; 5195 } 5196 EXPECT_TRUE(treeDumpEqualOnAnnotations( 5197 R"cpp( 5198 struct Test { 5199 [[int b() const;]] 5200 [[int c() volatile;]] 5201 [[int d() const volatile;]] 5202 }; 5203 )cpp", 5204 {R"txt( 5205 SimpleDeclaration 5206 |-'int' 5207 |-DeclaratorList Declarators 5208 | `-SimpleDeclarator ListElement 5209 | |-'b' 5210 | `-ParametersAndQualifiers 5211 | |-'(' OpenParen 5212 | |-')' CloseParen 5213 | `-'const' 5214 `-';' 5215 )txt", 5216 R"txt( 5217 SimpleDeclaration 5218 |-'int' 5219 |-DeclaratorList Declarators 5220 | `-SimpleDeclarator ListElement 5221 | |-'c' 5222 | `-ParametersAndQualifiers 5223 | |-'(' OpenParen 5224 | |-')' CloseParen 5225 | `-'volatile' 5226 `-';' 5227 )txt", 5228 R"txt( 5229 SimpleDeclaration 5230 |-'int' 5231 |-DeclaratorList Declarators 5232 | `-SimpleDeclarator ListElement 5233 | |-'d' 5234 | `-ParametersAndQualifiers 5235 | |-'(' OpenParen 5236 | |-')' CloseParen 5237 | |-'const' 5238 | `-'volatile' 5239 `-';' 5240 )txt"})); 5241 } 5242 5243 TEST_P(BuildSyntaxTreeTest, ParametersAndQualifiers_InMemberFunctions_Ref) { 5244 if (!GetParam().isCXX11OrLater()) { 5245 return; 5246 } 5247 EXPECT_TRUE(treeDumpEqualOnAnnotations( 5248 R"cpp( 5249 struct Test { 5250 [[int e() &;]] 5251 }; 5252 )cpp", 5253 {R"txt( 5254 SimpleDeclaration 5255 |-'int' 5256 |-DeclaratorList Declarators 5257 | `-SimpleDeclarator ListElement 5258 | |-'e' 5259 | `-ParametersAndQualifiers 5260 | |-'(' OpenParen 5261 | |-')' CloseParen 5262 | `-'&' 5263 `-';' 5264 )txt"})); 5265 } 5266 5267 TEST_P(BuildSyntaxTreeTest, ParametersAndQualifiers_InMemberFunctions_RefRef) { 5268 if (!GetParam().isCXX11OrLater()) { 5269 return; 5270 } 5271 EXPECT_TRUE(treeDumpEqualOnAnnotations( 5272 R"cpp( 5273 struct Test { 5274 [[int f() &&;]] 5275 }; 5276 )cpp", 5277 {R"txt( 5278 SimpleDeclaration 5279 |-'int' 5280 |-DeclaratorList Declarators 5281 | `-SimpleDeclarator ListElement 5282 | |-'f' 5283 | `-ParametersAndQualifiers 5284 | |-'(' OpenParen 5285 | |-')' CloseParen 5286 | `-'&&' 5287 `-';' 5288 )txt"})); 5289 } 5290 5291 TEST_P(BuildSyntaxTreeTest, TrailingReturn) { 5292 if (!GetParam().isCXX11OrLater()) { 5293 return; 5294 } 5295 EXPECT_TRUE(treeDumpEqual( 5296 R"cpp( 5297 auto foo() -> int; 5298 )cpp", 5299 R"txt( 5300 TranslationUnit Detached 5301 `-SimpleDeclaration 5302 |-'auto' 5303 |-DeclaratorList Declarators 5304 | `-SimpleDeclarator ListElement 5305 | |-'foo' 5306 | `-ParametersAndQualifiers 5307 | |-'(' OpenParen 5308 | |-')' CloseParen 5309 | `-TrailingReturnType TrailingReturn 5310 | |-'->' ArrowToken 5311 | `-'int' 5312 `-';' 5313 )txt")); 5314 } 5315 5316 TEST_P(BuildSyntaxTreeTest, DynamicExceptionSpecification) { 5317 if (!GetParam().supportsCXXDynamicExceptionSpecification()) { 5318 return; 5319 } 5320 EXPECT_TRUE(treeDumpEqualOnAnnotations( 5321 R"cpp( 5322 struct MyException1 {}; 5323 struct MyException2 {}; 5324 [[int a() throw();]] 5325 [[int b() throw(...);]] 5326 [[int c() throw(MyException1);]] 5327 [[int d() throw(MyException1, MyException2);]] 5328 )cpp", 5329 {R"txt( 5330 SimpleDeclaration 5331 |-'int' 5332 |-DeclaratorList Declarators 5333 | `-SimpleDeclarator ListElement 5334 | |-'a' 5335 | `-ParametersAndQualifiers 5336 | |-'(' OpenParen 5337 | |-')' CloseParen 5338 | |-'throw' 5339 | |-'(' 5340 | `-')' 5341 `-';' 5342 )txt", 5343 R"txt( 5344 SimpleDeclaration 5345 |-'int' 5346 |-DeclaratorList Declarators 5347 | `-SimpleDeclarator ListElement 5348 | |-'b' 5349 | `-ParametersAndQualifiers 5350 | |-'(' OpenParen 5351 | |-')' CloseParen 5352 | |-'throw' 5353 | |-'(' 5354 | |-'...' 5355 | `-')' 5356 `-';' 5357 )txt", 5358 R"txt( 5359 SimpleDeclaration 5360 |-'int' 5361 |-DeclaratorList Declarators 5362 | `-SimpleDeclarator ListElement 5363 | |-'c' 5364 | `-ParametersAndQualifiers 5365 | |-'(' OpenParen 5366 | |-')' CloseParen 5367 | |-'throw' 5368 | |-'(' 5369 | |-'MyException1' 5370 | `-')' 5371 `-';' 5372 )txt", 5373 R"txt( 5374 SimpleDeclaration 5375 |-'int' 5376 |-DeclaratorList Declarators 5377 | `-SimpleDeclarator ListElement 5378 | |-'d' 5379 | `-ParametersAndQualifiers 5380 | |-'(' OpenParen 5381 | |-')' CloseParen 5382 | |-'throw' 5383 | |-'(' 5384 | |-'MyException1' 5385 | |-',' 5386 | |-'MyException2' 5387 | `-')' 5388 `-';' 5389 )txt"})); 5390 } 5391 5392 TEST_P(BuildSyntaxTreeTest, NoexceptExceptionSpecification) { 5393 if (!GetParam().isCXX11OrLater()) { 5394 return; 5395 } 5396 EXPECT_TRUE(treeDumpEqual( 5397 R"cpp( 5398 int a() noexcept; 5399 int b() noexcept(true); 5400 )cpp", 5401 R"txt( 5402 TranslationUnit Detached 5403 |-SimpleDeclaration 5404 | |-'int' 5405 | |-DeclaratorList Declarators 5406 | | `-SimpleDeclarator ListElement 5407 | | |-'a' 5408 | | `-ParametersAndQualifiers 5409 | | |-'(' OpenParen 5410 | | |-')' CloseParen 5411 | | `-'noexcept' 5412 | `-';' 5413 `-SimpleDeclaration 5414 |-'int' 5415 |-DeclaratorList Declarators 5416 | `-SimpleDeclarator ListElement 5417 | |-'b' 5418 | `-ParametersAndQualifiers 5419 | |-'(' OpenParen 5420 | |-')' CloseParen 5421 | |-'noexcept' 5422 | |-'(' 5423 | |-BoolLiteralExpression 5424 | | `-'true' LiteralToken 5425 | `-')' 5426 `-';' 5427 )txt")); 5428 } 5429 5430 TEST_P(BuildSyntaxTreeTest, DeclaratorsInParentheses) { 5431 EXPECT_TRUE(treeDumpEqual( 5432 R"cpp( 5433 int (a); 5434 int *(b); 5435 int (*c)(int); 5436 int *(d)(int); 5437 )cpp", 5438 R"txt( 5439 TranslationUnit Detached 5440 |-SimpleDeclaration 5441 | |-'int' 5442 | |-DeclaratorList Declarators 5443 | | `-SimpleDeclarator ListElement 5444 | | `-ParenDeclarator 5445 | | |-'(' OpenParen 5446 | | |-'a' 5447 | | `-')' CloseParen 5448 | `-';' 5449 |-SimpleDeclaration 5450 | |-'int' 5451 | |-DeclaratorList Declarators 5452 | | `-SimpleDeclarator ListElement 5453 | | |-'*' 5454 | | `-ParenDeclarator 5455 | | |-'(' OpenParen 5456 | | |-'b' 5457 | | `-')' CloseParen 5458 | `-';' 5459 |-SimpleDeclaration 5460 | |-'int' 5461 | |-DeclaratorList Declarators 5462 | | `-SimpleDeclarator ListElement 5463 | | |-ParenDeclarator 5464 | | | |-'(' OpenParen 5465 | | | |-'*' 5466 | | | |-'c' 5467 | | | `-')' CloseParen 5468 | | `-ParametersAndQualifiers 5469 | | |-'(' OpenParen 5470 | | |-ParameterDeclarationList Parameters 5471 | | | `-SimpleDeclaration ListElement 5472 | | | `-'int' 5473 | | `-')' CloseParen 5474 | `-';' 5475 `-SimpleDeclaration 5476 |-'int' 5477 |-DeclaratorList Declarators 5478 | `-SimpleDeclarator ListElement 5479 | |-'*' 5480 | |-ParenDeclarator 5481 | | |-'(' OpenParen 5482 | | |-'d' 5483 | | `-')' CloseParen 5484 | `-ParametersAndQualifiers 5485 | |-'(' OpenParen 5486 | |-ParameterDeclarationList Parameters 5487 | | `-SimpleDeclaration ListElement 5488 | | `-'int' 5489 | `-')' CloseParen 5490 `-';' 5491 )txt")); 5492 } 5493 5494 TEST_P(BuildSyntaxTreeTest, Declaration_ConstVolatileQualifiers_SimpleConst) { 5495 EXPECT_TRUE(treeDumpEqual( 5496 R"cpp( 5497 const int west = -1; 5498 int const east = 1; 5499 )cpp", 5500 R"txt( 5501 TranslationUnit Detached 5502 |-SimpleDeclaration 5503 | |-'const' 5504 | |-'int' 5505 | |-DeclaratorList Declarators 5506 | | `-SimpleDeclarator ListElement 5507 | | |-'west' 5508 | | |-'=' 5509 | | `-PrefixUnaryOperatorExpression 5510 | | |-'-' OperatorToken 5511 | | `-IntegerLiteralExpression Operand 5512 | | `-'1' LiteralToken 5513 | `-';' 5514 `-SimpleDeclaration 5515 |-'int' 5516 |-'const' 5517 |-DeclaratorList Declarators 5518 | `-SimpleDeclarator ListElement 5519 | |-'east' 5520 | |-'=' 5521 | `-IntegerLiteralExpression 5522 | `-'1' LiteralToken 5523 `-';' 5524 )txt")); 5525 } 5526 5527 TEST_P(BuildSyntaxTreeTest, Declaration_ConstVolatileQualifiers_MultipleConst) { 5528 EXPECT_TRUE(treeDumpEqual( 5529 R"cpp( 5530 const int const universal = 0; 5531 )cpp", 5532 R"txt( 5533 TranslationUnit Detached 5534 `-SimpleDeclaration 5535 |-'const' 5536 |-'int' 5537 |-'const' 5538 |-DeclaratorList Declarators 5539 | `-SimpleDeclarator ListElement 5540 | |-'universal' 5541 | |-'=' 5542 | `-IntegerLiteralExpression 5543 | `-'0' LiteralToken 5544 `-';' 5545 )txt")); 5546 } 5547 5548 TEST_P(BuildSyntaxTreeTest, 5549 Declaration_ConstVolatileQualifiers_ConstAndVolatile) { 5550 EXPECT_TRUE(treeDumpEqual( 5551 R"cpp( 5552 const int const *const *volatile b; 5553 )cpp", 5554 R"txt( 5555 TranslationUnit Detached 5556 `-SimpleDeclaration 5557 |-'const' 5558 |-'int' 5559 |-'const' 5560 |-DeclaratorList Declarators 5561 | `-SimpleDeclarator ListElement 5562 | |-'*' 5563 | |-'const' 5564 | |-'*' 5565 | |-'volatile' 5566 | `-'b' 5567 `-';' 5568 )txt")); 5569 } 5570 5571 TEST_P(BuildSyntaxTreeTest, RangesOfDeclaratorsWithTrailingReturnTypes) { 5572 if (!GetParam().isCXX11OrLater()) { 5573 return; 5574 } 5575 EXPECT_TRUE(treeDumpEqual( 5576 R"cpp( 5577 auto foo() -> auto(*)(int) -> double*; 5578 )cpp", 5579 R"txt( 5580 TranslationUnit Detached 5581 `-SimpleDeclaration 5582 |-'auto' 5583 |-DeclaratorList Declarators 5584 | `-SimpleDeclarator ListElement 5585 | |-'foo' 5586 | `-ParametersAndQualifiers 5587 | |-'(' OpenParen 5588 | |-')' CloseParen 5589 | `-TrailingReturnType TrailingReturn 5590 | |-'->' ArrowToken 5591 | |-'auto' 5592 | `-SimpleDeclarator Declarator 5593 | |-ParenDeclarator 5594 | | |-'(' OpenParen 5595 | | |-'*' 5596 | | `-')' CloseParen 5597 | `-ParametersAndQualifiers 5598 | |-'(' OpenParen 5599 | |-ParameterDeclarationList Parameters 5600 | | `-SimpleDeclaration ListElement 5601 | | `-'int' 5602 | |-')' CloseParen 5603 | `-TrailingReturnType TrailingReturn 5604 | |-'->' ArrowToken 5605 | |-'double' 5606 | `-SimpleDeclarator Declarator 5607 | `-'*' 5608 `-';' 5609 )txt")); 5610 } 5611 5612 TEST_P(BuildSyntaxTreeTest, MemberPointers) { 5613 if (!GetParam().isCXX()) { 5614 return; 5615 } 5616 EXPECT_TRUE(treeDumpEqualOnAnnotations( 5617 R"cpp( 5618 struct X {}; 5619 [[int X::* a;]] 5620 [[const int X::* b;]] 5621 )cpp", 5622 {R"txt( 5623 SimpleDeclaration 5624 |-'int' 5625 |-DeclaratorList Declarators 5626 | `-SimpleDeclarator ListElement 5627 | |-MemberPointer 5628 | | |-'X' 5629 | | |-'::' 5630 | | `-'*' 5631 | `-'a' 5632 `-';' 5633 )txt", 5634 R"txt( 5635 SimpleDeclaration 5636 |-'const' 5637 |-'int' 5638 |-DeclaratorList Declarators 5639 | `-SimpleDeclarator ListElement 5640 | |-MemberPointer 5641 | | |-'X' 5642 | | |-'::' 5643 | | `-'*' 5644 | `-'b' 5645 `-';' 5646 )txt"})); 5647 } 5648 5649 TEST_P(BuildSyntaxTreeTest, MemberFunctionPointer) { 5650 if (!GetParam().isCXX()) { 5651 return; 5652 } 5653 EXPECT_TRUE(treeDumpEqualOnAnnotations( 5654 R"cpp( 5655 struct X { 5656 struct Y {}; 5657 }; 5658 [[void (X::*xp)();]] 5659 [[void (X::**xpp)(const int*);]] 5660 // FIXME: Generate the right syntax tree for this type, 5661 // i.e. create a syntax node for the outer member pointer 5662 [[void (X::Y::*xyp)(const int*, char);]] 5663 )cpp", 5664 {R"txt( 5665 SimpleDeclaration 5666 |-'void' 5667 |-DeclaratorList Declarators 5668 | `-SimpleDeclarator ListElement 5669 | |-ParenDeclarator 5670 | | |-'(' OpenParen 5671 | | |-MemberPointer 5672 | | | |-'X' 5673 | | | |-'::' 5674 | | | `-'*' 5675 | | |-'xp' 5676 | | `-')' CloseParen 5677 | `-ParametersAndQualifiers 5678 | |-'(' OpenParen 5679 | `-')' CloseParen 5680 `-';' 5681 )txt", 5682 R"txt( 5683 SimpleDeclaration 5684 |-'void' 5685 |-DeclaratorList Declarators 5686 | `-SimpleDeclarator ListElement 5687 | |-ParenDeclarator 5688 | | |-'(' OpenParen 5689 | | |-MemberPointer 5690 | | | |-'X' 5691 | | | |-'::' 5692 | | | `-'*' 5693 | | |-'*' 5694 | | |-'xpp' 5695 | | `-')' CloseParen 5696 | `-ParametersAndQualifiers 5697 | |-'(' OpenParen 5698 | |-ParameterDeclarationList Parameters 5699 | | `-SimpleDeclaration ListElement 5700 | | |-'const' 5701 | | |-'int' 5702 | | `-DeclaratorList Declarators 5703 | | `-SimpleDeclarator ListElement 5704 | | `-'*' 5705 | `-')' CloseParen 5706 `-';' 5707 )txt", 5708 R"txt( 5709 SimpleDeclaration 5710 |-'void' 5711 |-DeclaratorList Declarators 5712 | `-SimpleDeclarator ListElement 5713 | |-ParenDeclarator 5714 | | |-'(' OpenParen 5715 | | |-'X' 5716 | | |-'::' 5717 | | |-MemberPointer 5718 | | | |-'Y' 5719 | | | |-'::' 5720 | | | `-'*' 5721 | | |-'xyp' 5722 | | `-')' CloseParen 5723 | `-ParametersAndQualifiers 5724 | |-'(' OpenParen 5725 | |-ParameterDeclarationList Parameters 5726 | | |-SimpleDeclaration ListElement 5727 | | | |-'const' 5728 | | | |-'int' 5729 | | | `-DeclaratorList Declarators 5730 | | | `-SimpleDeclarator ListElement 5731 | | | `-'*' 5732 | | |-',' ListDelimiter 5733 | | `-SimpleDeclaration ListElement 5734 | | `-'char' 5735 | `-')' CloseParen 5736 `-';' 5737 )txt"})); 5738 } 5739 5740 TEST_P(BuildSyntaxTreeTest, ComplexDeclarator) { 5741 EXPECT_TRUE(treeDumpEqual( 5742 R"cpp( 5743 void x(char a, short (*b)(int)); 5744 )cpp", 5745 R"txt( 5746 TranslationUnit Detached 5747 `-SimpleDeclaration 5748 |-'void' 5749 |-DeclaratorList Declarators 5750 | `-SimpleDeclarator ListElement 5751 | |-'x' 5752 | `-ParametersAndQualifiers 5753 | |-'(' OpenParen 5754 | |-ParameterDeclarationList Parameters 5755 | | |-SimpleDeclaration ListElement 5756 | | | |-'char' 5757 | | | `-DeclaratorList Declarators 5758 | | | `-SimpleDeclarator ListElement 5759 | | | `-'a' 5760 | | |-',' ListDelimiter 5761 | | `-SimpleDeclaration ListElement 5762 | | |-'short' 5763 | | `-DeclaratorList Declarators 5764 | | `-SimpleDeclarator ListElement 5765 | | |-ParenDeclarator 5766 | | | |-'(' OpenParen 5767 | | | |-'*' 5768 | | | |-'b' 5769 | | | `-')' CloseParen 5770 | | `-ParametersAndQualifiers 5771 | | |-'(' OpenParen 5772 | | |-ParameterDeclarationList Parameters 5773 | | | `-SimpleDeclaration ListElement 5774 | | | `-'int' 5775 | | `-')' CloseParen 5776 | `-')' CloseParen 5777 `-';' 5778 )txt")); 5779 } 5780 5781 TEST_P(BuildSyntaxTreeTest, ComplexDeclarator2) { 5782 EXPECT_TRUE(treeDumpEqual( 5783 R"cpp( 5784 void x(char a, short (*b)(int), long (**c)(long long)); 5785 )cpp", 5786 R"txt( 5787 TranslationUnit Detached 5788 `-SimpleDeclaration 5789 |-'void' 5790 |-DeclaratorList Declarators 5791 | `-SimpleDeclarator ListElement 5792 | |-'x' 5793 | `-ParametersAndQualifiers 5794 | |-'(' OpenParen 5795 | |-ParameterDeclarationList Parameters 5796 | | |-SimpleDeclaration ListElement 5797 | | | |-'char' 5798 | | | `-DeclaratorList Declarators 5799 | | | `-SimpleDeclarator ListElement 5800 | | | `-'a' 5801 | | |-',' ListDelimiter 5802 | | |-SimpleDeclaration ListElement 5803 | | | |-'short' 5804 | | | `-DeclaratorList Declarators 5805 | | | `-SimpleDeclarator ListElement 5806 | | | |-ParenDeclarator 5807 | | | | |-'(' OpenParen 5808 | | | | |-'*' 5809 | | | | |-'b' 5810 | | | | `-')' CloseParen 5811 | | | `-ParametersAndQualifiers 5812 | | | |-'(' OpenParen 5813 | | | |-ParameterDeclarationList Parameters 5814 | | | | `-SimpleDeclaration ListElement 5815 | | | | `-'int' 5816 | | | `-')' CloseParen 5817 | | |-',' ListDelimiter 5818 | | `-SimpleDeclaration ListElement 5819 | | |-'long' 5820 | | `-DeclaratorList Declarators 5821 | | `-SimpleDeclarator ListElement 5822 | | |-ParenDeclarator 5823 | | | |-'(' OpenParen 5824 | | | |-'*' 5825 | | | |-'*' 5826 | | | |-'c' 5827 | | | `-')' CloseParen 5828 | | `-ParametersAndQualifiers 5829 | | |-'(' OpenParen 5830 | | |-ParameterDeclarationList Parameters 5831 | | | `-SimpleDeclaration ListElement 5832 | | | |-'long' 5833 | | | `-'long' 5834 | | `-')' CloseParen 5835 | `-')' CloseParen 5836 `-';' 5837 )txt")); 5838 } 5839 5840 } // namespace 5841