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