clang/unittests/Tooling/Syntax/BuildTreeTest.cpp

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