[SyntaxTree] Add support for call expressions

[eduucaldas]

Summary

Add support for all C++ call expressions, including those coming from operator().
A call expression's arguments are inside their own node - CallArguments - based on the List base API.

[eduucaldas]

• Nits

[eduucaldas]

clang/unittests/Tooling/Syntax/BuildTreeTest.cpp

506

This is wrong but it's just because decltype is all wrong

2734

Here there is a divergence between the grammar and the ClangAST.
According to the grammar ... would an optional element of CallArguments, but here ... is part of an expression.

Perhaps I have used the wrong kind of ...

[gribozavr2]

clang/include/clang/Tooling/Syntax/Nodes.h

333

clang/lib/Tooling/Syntax/BuildTree.cpp

1070

Could you add an assertion that it is indeed an open paren?

Or, rather, due to the decltype test, it has to be a check, and a FIXME that says that the check should become an assertion.

1166

I don't understand this change to the unknown case, could you explain?

clang/unittests/Tooling/Syntax/BuildTreeTest.cpp

2320

2343

2431–2436

2437

Please also add a test for pf() -- that's allowed, but I believe the AST is slightly different from f().

2734

... would an optional element of CallArguments

I don't think so. Note that every element of initializer-list can have a ... in it.

[eduucaldas]

Answer code review, squash commits

clang/lib/Tooling/Syntax/BuildTree.cpp

1070

Thanks! It is indeed what I should've done :)

1166

CXXOperatorCallExpr <- CallExpr <- Expr

In this change we added an overload for WalkUpFromCallExpr, so we started intercepting the WalkUp at CallExpr instead of Expr, this works around that.

clang/unittests/Tooling/Syntax/BuildTreeTest.cpp

2734

True! I hadn't seen it correctly!

clang/include/clang/Tooling/Syntax/Nodes.h

enum class NodeKind : uint16_t {
   CxxNullPtrExpression,
   IntegerUserDefinedLiteralExpression,
   FloatUserDefinedLiteralExpression,
   CharUserDefinedLiteralExpression,
   StringUserDefinedLiteralExpression,
   IdExpression,
   MemberExpression,
   ThisExpression,
+  CallExpression,
 
   // Statements.
   UnknownStatement,
   DeclarationStatement,
   EmptyStatement,
   SwitchStatement,
   CaseStatement,
   DefaultStatement,
enum class NodeKind : uint16_t {
   ParametersAndQualifiers,
   MemberPointer,
   UnqualifiedId,
   // Nested Name Specifiers.
   NestedNameSpecifier,
   GlobalNameSpecifier,
   DecltypeNameSpecifier,
   IdentifierNameSpecifier,
-  SimpleTemplateNameSpecifier
+  SimpleTemplateNameSpecifier,
+  CallArguments
 };
 /// For debugging purposes.
 raw_ostream &operator<<(raw_ostream &OS, NodeKind K);
 
 /// A relation between a parent and child node, e.g. 'left-hand-side of
 /// a binary expression'. Used for implementing accessors.
 ///
 /// Some roles describe parent/child relations that occur multiple times in
enum class NodeRole : uint8_t {
   ParametersAndQualifiers_parameter,
   ParametersAndQualifiers_trailingReturn,
   IdExpression_id,
   IdExpression_qualifier,
   ParenExpression_subExpression,
   MemberExpression_object,
   MemberExpression_accessToken,
   MemberExpression_member,
+  CallExpression_callee,
+  CallExpression_arguments,
 };
 /// For debugging purposes.
 raw_ostream &operator<<(raw_ostream &OS, NodeRole R);
 
 class SimpleDeclarator;
 
 /// A root node for a translation unit. Parent is always null.
 class TranslationUnit final : public Tree {

 public:
   ThisExpression() : Expression(NodeKind::ThisExpression) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::ThisExpression;
   }
   Leaf *thisKeyword();
 };
 
+/// Models arguments of a function call.
+///   call-arguments:
+///     delimited_list(expression, ',')
+/// Note: This construct is a simplification of the grammar rule for
+/// `expression-list`, that is used in the definition of `call-expression`
+class CallArguments final : public List {
+public:
+  CallArguments() : List(NodeKind::CallArguments) {}
+  static bool classof(const Node *N) {
+    return N->kind() <= NodeKind::CallArguments;
+  }
+  std::vector<Expression *> arguments();
+  std::vector<List::ElementAndDelimiter<Expression>> argumentsAndCommas();
+};
+
+/// A function call. C++ [expr.call]
+/// call-expression:
+///   expression '(' call-arguments ')'
+/// e.g `f(1, '2')` or `this->Base::f()`
+class CallExpression final : public Expression {
+public:
+  CallExpression() : Expression(NodeKind::CallExpression) {}
+  static bool classof(const Node *N) {
+    return N->kind() == NodeKind::CallExpression;
+  }
+  Expression *callee();
+  Leaf *openParen();
+  CallArguments *arguments();
+  Leaf *closeParen();
+};
+
 /// Models a parenthesized expression `(E)`. C++ [expr.prim.paren]
 /// e.g. `(3 + 2)` in `a = 1 + (3 + 2);`
 class ParenExpression final : public Expression {
 public:
   ParenExpression() : Expression(NodeKind::ParenExpression) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::ParenExpression;
   }

clang/lib/Tooling/Syntax/BuildTree.cpp

case OO_Amp:
     }
     return syntax::NodeKind::BinaryOperatorExpression;
   // Not yet supported by SyntaxTree
   case OO_New:
   case OO_Delete:
   case OO_Array_New:
   case OO_Array_Delete:
   case OO_Coawait:
-  case OO_Call:
   case OO_Subscript:
   case OO_Arrow:
     return syntax::NodeKind::UnknownExpression;
+  case OO_Call:
+    return syntax::NodeKind::CallExpression;
   case OO_Conditional: // not overloadable
   case NUM_OVERLOADED_OPERATORS:
   case OO_None:
     llvm_unreachable("Not an overloadable operator");
   }
   llvm_unreachable("Unknown OverloadedOperatorKind enum");
 }
 
Builder.markChildToken(S->getOperatorLoc(),
                            syntax::NodeRole::OperatorExpression_operatorToken);
     Builder.markExprChild(
         S->getRHS(), syntax::NodeRole::BinaryOperatorExpression_rightHandSide);
     Builder.foldNode(Builder.getExprRange(S),
                      new (allocator()) syntax::BinaryOperatorExpression, S);
     return true;
   }
 
+  syntax::CallArguments *buildCallArguments(CallExpr::arg_range Args) {
+    for (const auto &Arg : Args) {
+      Builder.markExprChild(Arg, syntax::NodeRole::List_element);
+      const auto *DelimiterToken =
+          std::next(Builder.findToken(Arg->getEndLoc()));
+      if (DelimiterToken->kind() == clang::tok::TokenKind::comma)
+        Builder.markChildToken(DelimiterToken,
+                               syntax::NodeRole::List_delimiter);
+    }
+
+    auto *Arguments = new (allocator()) syntax::CallArguments;
+    if (!Args.empty())
+      Builder.foldNode(Builder.getRange((*Args.begin())->getBeginLoc(),
+                                        (*(Args.end() - 1))->getEndLoc()),
+                       Arguments, nullptr);
+
+    return Arguments;
+  }
+
+  bool WalkUpFromCallExpr(CallExpr *S) {
+    Builder.markExprChild(S->getCallee(),
+                          syntax::NodeRole::CallExpression_callee);
+
+    const auto *LParenToken =
+        std::next(Builder.findToken(S->getCallee()->getEndLoc()));
+    // FIXME: Assert that `LParenToken` is indeed a `l_paren` once we have fixed
+    // the test on decltype desctructors.
+    if (LParenToken->kind() == clang::tok::l_paren)
+      Builder.markChildToken(LParenToken, syntax::NodeRole::OpenParen);
+
+    Builder.markChild(buildCallArguments(S->arguments()),
+                      syntax::NodeRole::CallExpression_arguments);
+
+    Builder.markChildToken(S->getRParenLoc(), syntax::NodeRole::CloseParen);
+
+    Builder.foldNode(Builder.getRange(S->getSourceRange()),
+                     new (allocator()) syntax::CallExpression, S);
+    return true;
+  }
+
   bool TraverseCXXOperatorCallExpr(CXXOperatorCallExpr *S) {
     // To construct a syntax tree of the same shape for calls to built-in and
     // user-defined operators, ignore the `DeclRefExpr` that refers to the
     // operator and treat it as a simple token. Do that by traversing
     // arguments instead of children.
     for (auto *child : S->arguments()) {
       // A postfix unary operator is declared as taking two operands. The
       // second operand is used to distinguish from its prefix counterpart. In
case syntax::NodeKind::PostfixUnaryOperatorExpression:
           S->getOperatorLoc(),
           syntax::NodeRole::OperatorExpression_operatorToken);
       Builder.markExprChild(S->getArg(0),
                             syntax::NodeRole::UnaryOperatorExpression_operand);
       Builder.foldNode(Builder.getExprRange(S),
                        new (allocator()) syntax::PostfixUnaryOperatorExpression,
                        S);
       return true;
+    case syntax::NodeKind::CallExpression: {
+      Builder.markExprChild(S->getArg(0),
+                            syntax::NodeRole::CallExpression_callee);
+
+      const auto *LParenToken =
+          std::next(Builder.findToken(S->getArg(0)->getEndLoc()));
+      // FIXME: Assert that `LParenToken` is indeed a `l_paren` once we have
+      // fixed the test on decltype desctructors.
+      if (LParenToken->kind() == clang::tok::l_paren)
+        Builder.markChildToken(LParenToken, syntax::NodeRole::OpenParen);
+
+      Builder.markChild(buildCallArguments(CallExpr::arg_range(
+                            S->arg_begin() + 1, S->arg_end())),
+                        syntax::NodeRole::CallExpression_arguments);
+
+      Builder.markChildToken(S->getRParenLoc(), syntax::NodeRole::CloseParen);
+
+      Builder.foldNode(Builder.getRange(S->getSourceRange()),
+                       new (allocator()) syntax::CallExpression, S);
+      return true;
+    }
     case syntax::NodeKind::UnknownExpression:
-      return RecursiveASTVisitor::WalkUpFromCXXOperatorCallExpr(S);
+      return WalkUpFromExpr(S);
     default:
       llvm_unreachable("getOperatorNodeKind() does not return this value");
     }
   }
 
   bool WalkUpFromNamespaceDecl(NamespaceDecl *S) {
     auto Tokens = Builder.getDeclarationRange(S);
     if (Tokens.front().kind() == tok::coloncolon) {

clang/lib/Tooling/Syntax/Nodes.cpp

raw_ostream &syntax::operator<<(raw_ostream &OS, NodeKind K) {
   case NodeKind::PostfixUnaryOperatorExpression:
     return OS << "PostfixUnaryOperatorExpression";
   case NodeKind::BinaryOperatorExpression:
     return OS << "BinaryOperatorExpression";
   case NodeKind::UnqualifiedId:
     return OS << "UnqualifiedId";
   case NodeKind::IdExpression:
     return OS << "IdExpression";
+  case NodeKind::CallExpression:
+    return OS << "CallExpression";
   case NodeKind::UnknownStatement:
     return OS << "UnknownStatement";
   case NodeKind::DeclarationStatement:
     return OS << "DeclarationStatement";
   case NodeKind::EmptyStatement:
     return OS << "EmptyStatement";
   case NodeKind::SwitchStatement:
     return OS << "SwitchStatement";
raw_ostream &syntax::operator<<(raw_ostream &OS, NodeKind K) {
   case NodeKind::IdentifierNameSpecifier:
     return OS << "IdentifierNameSpecifier";
   case NodeKind::SimpleTemplateNameSpecifier:
     return OS << "SimpleTemplateNameSpecifier";
   case NodeKind::NestedNameSpecifier:
     return OS << "NestedNameSpecifier";
   case NodeKind::MemberExpression:
     return OS << "MemberExpression";
+  case NodeKind::CallArguments:
+    return OS << "CallArguments";
   }
   llvm_unreachable("unknown node kind");
 }
 
 raw_ostream &syntax::operator<<(raw_ostream &OS, NodeRole R) {
   switch (R) {
   case syntax::NodeRole::Detached:
     return OS << "Detached";
raw_ostream &syntax::operator<<(raw_ostream &OS, NodeRole R) {
   case syntax::NodeRole::ParenExpression_subExpression:
     return OS << "ParenExpression_subExpression";
   case syntax::NodeRole::MemberExpression_object:
     return OS << "MemberExpression_object";
   case syntax::NodeRole::MemberExpression_accessToken:
     return OS << "MemberExpression_accessToken";
   case syntax::NodeRole::MemberExpression_member:
     return OS << "MemberExpression_member";
+  case syntax::NodeRole::CallExpression_callee:
+    return OS << "CallExpression_callee";
+  case syntax::NodeRole::CallExpression_arguments:
+    return OS << "CallExpression_arguments";
   }
   llvm_unreachable("invalid role");
 }
 
 // We could have an interator in list to not pay memory costs of temporary
 // vector
 std::vector<syntax::NameSpecifier *> syntax::NestedNameSpecifier::specifiers() {
   auto specifiersAsNodes = getElementsAsNodes();
syntax::NestedNameSpecifier::specifiersAndDoubleColons() {
   for (const auto &specifierAndDoubleColon : specifiersAsNodesAndDoubleColons) {
     Children.push_back(
         {llvm::cast<syntax::NameSpecifier>(specifierAndDoubleColon.element),
          specifierAndDoubleColon.delimiter});
   }
   return Children;
 }
 
+std::vector<syntax::Expression *> syntax::CallArguments::arguments() {
+  auto ArgumentsAsNodes = getElementsAsNodes();
+  std::vector<syntax::Expression *> Children;
+  for (const auto &ArgumentAsNode : ArgumentsAsNodes) {
+    Children.push_back(llvm::cast<syntax::Expression>(ArgumentAsNode));
+  }
+  return Children;
+}
+
+std::vector<syntax::List::ElementAndDelimiter<syntax::Expression>>
+syntax::CallArguments::argumentsAndCommas() {
+  auto ArgumentsAsNodesAndCommas = getElementsAsNodesAndDelimiters();
+  std::vector<syntax::List::ElementAndDelimiter<syntax::Expression>> Children;
+  for (const auto &ArgumentAsNodeAndComma : ArgumentsAsNodesAndCommas) {
+    Children.push_back(
+        {llvm::cast<syntax::Expression>(ArgumentAsNodeAndComma.element),
+         ArgumentAsNodeAndComma.delimiter});
+  }
+  return Children;
+}
+
 syntax::Expression *syntax::MemberExpression::object() {
   return cast_or_null<syntax::Expression>(
       findChild(syntax::NodeRole::MemberExpression_object));
 }
 
 syntax::Leaf *syntax::MemberExpression::templateKeyword() {
   return llvm::cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::TemplateKeyword));
return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::OperatorExpression_operatorToken));
 }
 
 syntax::Expression *syntax::BinaryOperatorExpression::rhs() {
   return cast_or_null<syntax::Expression>(
       findChild(syntax::NodeRole::BinaryOperatorExpression_rightHandSide));
 }
 
+syntax::Expression *syntax::CallExpression::callee() {
+  return cast_or_null<syntax::Expression>(
+      findChild(syntax::NodeRole::CallExpression_callee));
+}
+
+syntax::Leaf *syntax::CallExpression::openParen() {
+  return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
+}
+
+syntax::CallArguments *syntax::CallExpression::arguments() {
+  return cast_or_null<syntax::CallArguments>(
+      findChild(syntax::NodeRole::CallExpression_arguments));
+}
+
+syntax::Leaf *syntax::CallExpression::closeParen() {
+  return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
+}
+
 syntax::Leaf *syntax::SwitchStatement::switchKeyword() {
   return cast_or_null<syntax::Leaf>(
       findChild(syntax::NodeRole::IntroducerKeyword));
 }
 
 syntax::Statement *syntax::SwitchStatement::body() {
   return cast_or_null<syntax::Statement>(
       findChild(syntax::NodeRole::BodyStatement));

clang/unittests/Tooling/Syntax/BuildTreeTest.cpp

`-SimpleDeclaration
   |-SimpleDeclarator SimpleDeclaration_declarator
   | |-'test'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
   |   `-')' CloseParen
   `-CompoundStatement
     |-'{' OpenParen
     |-ExpressionStatement CompoundStatement_statement
-    | |-UnknownExpression ExpressionStatement_expression
-    | | |-IdExpression
+    | |-CallExpression ExpressionStatement_expression
+    | | |-IdExpression CallExpression_callee
     | | | `-UnqualifiedId IdExpression_id
     | | |   `-'test'
-    | | |-'('
-    | | `-')'
+    | | |-'(' OpenParen
+    | | `-')' CloseParen
     | `-';'
     |-IfStatement CompoundStatement_statement
     | |-'if' IntroducerKeyword
     | |-'('
     | |-IntegerLiteralExpression
     | | `-'1' LiteralToken
     | |-')'
     | |-ExpressionStatement IfStatement_thenStatement
-    | | |-UnknownExpression ExpressionStatement_expression
-    | | | |-IdExpression
+    | | |-CallExpression ExpressionStatement_expression
+    | | | |-IdExpression CallExpression_callee
     | | | | `-UnqualifiedId IdExpression_id
     | | | |   `-'test'
-    | | | |-'('
-    | | | `-')'
+    | | | |-'(' OpenParen
+    | | | `-')' CloseParen
     | | `-';'
     | |-'else' IfStatement_elseKeyword
     | `-ExpressionStatement IfStatement_elseStatement
-    |   |-UnknownExpression ExpressionStatement_expression
-    |   | |-IdExpression
+    |   |-CallExpression ExpressionStatement_expression
+    |   | |-IdExpression CallExpression_callee
     |   | | `-UnqualifiedId IdExpression_id
     |   | |   `-'test'
-    |   | |-'('
-    |   | `-')'
+    |   | |-'(' OpenParen
+    |   | `-')' CloseParen
     |   `-';'
     `-'}' CloseParen
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, UnqualifiedId_Identifier) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(

 struct X {
   friend X operator+(const X&, const X&);
 };
 void test(X x) {
   [[operator+(x, x)]];
 }
 )cpp",
       {R"txt(
-UnknownExpression ExpressionStatement_expression
-|-IdExpression
+CallExpression ExpressionStatement_expression
+|-IdExpression CallExpression_callee
 | `-UnqualifiedId IdExpression_id
 |   |-'operator'
 |   `-'+'
-|-'('
-|-IdExpression
-| `-UnqualifiedId IdExpression_id
-|   `-'x'
-|-','
-|-IdExpression
-| `-UnqualifiedId IdExpression_id
-|   `-'x'
-`-')'
+|-'(' OpenParen
+|-CallArguments CallExpression_arguments
+| |-IdExpression List_element
+| | `-UnqualifiedId IdExpression_id
+| |   `-'x'
+| |-',' List_delimiter
+| `-IdExpression List_element
+|   `-UnqualifiedId IdExpression_id
+|     `-'x'
+`-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, UnqualifiedId_ConversionFunctionId) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X {
   operator int();
 };
 void test(X x) {
   [[x.operator int()]];
 }
 )cpp",
       {R"txt(
-UnknownExpression ExpressionStatement_expression
-|-MemberExpression
+CallExpression ExpressionStatement_expression
+|-MemberExpression CallExpression_callee
 | |-IdExpression MemberExpression_object
 | | `-UnqualifiedId IdExpression_id
 | |   `-'x'
 | |-'.' MemberExpression_accessToken
 | `-IdExpression MemberExpression_member
 |   `-UnqualifiedId IdExpression_id
 |     |-'operator'
 |     `-'int'
-|-'('
-`-')'
+|-'(' OpenParen
+`-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, UnqualifiedId_LiteralOperatorId) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 unsigned operator "" _w(char);
 void test() {
   [[operator "" _w('1')]];
 }
 )cpp",
       {R"txt(
-UnknownExpression ExpressionStatement_expression
-|-IdExpression
+CallExpression ExpressionStatement_expression
+|-IdExpression CallExpression_callee
 | `-UnqualifiedId IdExpression_id
 |   |-'operator'
 |   |-'""'
 |   `-'_w'
-|-'('
-|-CharacterLiteralExpression
-| `-''1'' LiteralToken
-`-')'
+|-'(' OpenParen
+|-CallArguments CallExpression_arguments
+| `-CharacterLiteralExpression List_element
+|   `-''1'' LiteralToken
+`-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, UnqualifiedId_Destructor) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X { };
 void test(X x) {
   [[x.~X()]];
 }
 )cpp",
       {R"txt(
-UnknownExpression ExpressionStatement_expression
-|-MemberExpression
+CallExpression ExpressionStatement_expression
+|-MemberExpression CallExpression_callee
 | |-IdExpression MemberExpression_object
 | | `-UnqualifiedId IdExpression_id
 | |   `-'x'
 | |-'.' MemberExpression_accessToken
 | `-IdExpression MemberExpression_member
 |   `-UnqualifiedId IdExpression_id
 |     |-'~'
 |     `-'X'
-|-'('
-`-')'
+|-'(' OpenParen
+`-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, UnqualifiedId_DecltypeDestructor) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct X { };
 void test(X x) {
   // FIXME: Make `decltype(x)` a child of `MemberExpression`. It is currently
   // not because `Expr::getSourceRange()` returns the range of `x.~` for the
   // `MemberExpr` instead of the expected `x.~decltype(x)`, this is a bug in
   // clang.
   [[x.~decltype(x)()]];
 }
 )cpp",
       {R"txt(
-UnknownExpression ExpressionStatement_expression
-|-MemberExpression
+CallExpression ExpressionStatement_expression
+|-MemberExpression CallExpression_callee
 | |-IdExpression MemberExpression_object
 | | `-UnqualifiedId IdExpression_id
 | |   `-'x'
 | |-'.' MemberExpression_accessToken
 | `-IdExpression MemberExpression_member
 |   `-UnqualifiedId IdExpression_id
 |     `-'~'
 |-'decltype'
 |-'('
 |-'x'
 |-')'
 |-'('
-`-')'
+`-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, UnqualifiedId_TemplateId) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 template<typename T>
 T f();
 void test() {
   [[f<int>()]];
 }
 )cpp",
       {R"txt(
-UnknownExpression ExpressionStatement_expression
-|-IdExpression
+CallExpression ExpressionStatement_expression
+|-IdExpression CallExpression_callee
 | `-UnqualifiedId IdExpression_id
 |   |-'f'
 |   |-'<'
 |   |-'int'
 |   `-'>'
-|-'('
-`-')'
+|-'(' OpenParen
+`-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, QualifiedId_NamespaceSpecifier) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(

 struct S {
   static void f(){}
 };
 void test(S s) {
   [[decltype(s)::f()]];
 }
 )cpp",
       {R"txt(
-UnknownExpression ExpressionStatement_expression
-|-IdExpression
+CallExpression ExpressionStatement_expression
+|-IdExpression CallExpression_callee
 | |-NestedNameSpecifier IdExpression_qualifier
 | | |-DecltypeNameSpecifier List_element
 | | | |-'decltype'
 | | | |-'('
 | | | |-IdExpression
 | | | | `-UnqualifiedId IdExpression_id
 | | | |   `-'s'
 | | | `-')'
 | | `-'::' List_delimiter
 | `-UnqualifiedId IdExpression_id
 |   `-'f'
-|-'('
-`-')'
+|-'(' OpenParen
+`-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, QualifiedId_OptionalTemplateKw) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   template<typename U>
   static U f();
 };
 void test() {
   [[S::f<int>()]];
   [[S::template f<int>()]];
 }
 )cpp",
       {R"txt(
-UnknownExpression ExpressionStatement_expression
-|-IdExpression
+CallExpression ExpressionStatement_expression
+|-IdExpression CallExpression_callee
 | |-NestedNameSpecifier IdExpression_qualifier
 | | |-IdentifierNameSpecifier List_element
 | | | `-'S'
 | | `-'::' List_delimiter
 | `-UnqualifiedId IdExpression_id
 |   |-'f'
 |   |-'<'
 |   |-'int'
 |   `-'>'
-|-'('
-`-')'
+|-'(' OpenParen
+`-')' CloseParen
 )txt",
        R"txt(
-UnknownExpression ExpressionStatement_expression
-|-IdExpression
+CallExpression ExpressionStatement_expression
+|-IdExpression CallExpression_callee
 | |-NestedNameSpecifier IdExpression_qualifier
 | | |-IdentifierNameSpecifier List_element
 | | | `-'S'
 | | `-'::' List_delimiter
 | |-'template' TemplateKeyword
 | `-UnqualifiedId IdExpression_id
 |   |-'f'
 |   |-'<'
 |   |-'int'
 |   `-'>'
-|-'('
-`-')'
+|-'(' OpenParen
+`-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, QualifiedId_Complex) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 namespace n {
   template<typename T>
   struct ST {
     template<typename U>
     static U f();
   };
 }
 void test() {
   [[::n::template ST<int>::template f<int>()]];
 }
 )cpp",
       {R"txt(
-UnknownExpression ExpressionStatement_expression
-|-IdExpression
+CallExpression ExpressionStatement_expression
+|-IdExpression CallExpression_callee
 | |-NestedNameSpecifier IdExpression_qualifier
 | | |-'::' List_delimiter
 | | |-IdentifierNameSpecifier List_element
 | | | `-'n'
 | | |-'::' List_delimiter
 | | |-SimpleTemplateNameSpecifier List_element
 | | | |-'template'
 | | | |-'ST'
 | | | |-'<'
 | | | |-'int'
 | | | `-'>'
 | | `-'::' List_delimiter
 | |-'template' TemplateKeyword
 | `-UnqualifiedId IdExpression_id
 |   |-'f'
 |   |-'<'
 |   |-'int'
 |   `-'>'
-|-'('
-`-')'
+|-'(' OpenParen
+`-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, QualifiedId_DependentType) {
   if (!GetParam().isCXX()) {
     return;
   }
   if (GetParam().hasDelayedTemplateParsing()) {
     // FIXME: Make this test work on Windows by generating the expected syntax
     // tree when `-fdelayed-template-parsing` is active.
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 template <typename T>
 void test() {
   [[T::template U<int>::f()]];
   [[T::U::f()]];
   [[T::template f<0>()]];
 }
 )cpp",
       {R"txt(
-UnknownExpression ExpressionStatement_expression
-|-IdExpression
+CallExpression ExpressionStatement_expression
+|-IdExpression CallExpression_callee
 | |-NestedNameSpecifier IdExpression_qualifier
 | | |-IdentifierNameSpecifier List_element
 | | | `-'T'
 | | |-'::' List_delimiter
 | | |-SimpleTemplateNameSpecifier List_element
 | | | |-'template'
 | | | |-'U'
 | | | |-'<'
 | | | |-'int'
 | | | `-'>'
 | | `-'::' List_delimiter
 | `-UnqualifiedId IdExpression_id
 |   `-'f'
-|-'('
-`-')'
+|-'(' OpenParen
+`-')' CloseParen
 )txt",
        R"txt(
-UnknownExpression ExpressionStatement_expression
-|-IdExpression
+CallExpression ExpressionStatement_expression
+|-IdExpression CallExpression_callee
 | |-NestedNameSpecifier IdExpression_qualifier
 | | |-IdentifierNameSpecifier List_element
 | | | `-'T'
 | | |-'::' List_delimiter
 | | |-IdentifierNameSpecifier List_element
 | | | `-'U'
 | | `-'::' List_delimiter
 | `-UnqualifiedId IdExpression_id
 |   `-'f'
-|-'('
-`-')'
+|-'(' OpenParen
+`-')' CloseParen
 )txt",
        R"txt(
-UnknownExpression ExpressionStatement_expression
-|-IdExpression
+CallExpression ExpressionStatement_expression
+|-IdExpression CallExpression_callee
 | |-NestedNameSpecifier IdExpression_qualifier
 | | |-IdentifierNameSpecifier List_element
 | | | `-'T'
 | | `-'::' List_delimiter
 | |-'template' TemplateKeyword
 | `-UnqualifiedId IdExpression_id
 |   |-'f'
 |   |-'<'
 |   |-IntegerLiteralExpression
 |   | `-'0' LiteralToken
 |   `-'>'
-|-'('
-`-')'
+|-'(' OpenParen
+`-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, This_Simple) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(

 struct S {
   bool operator!();
 };
 void test(S s) {
   [[s.operator!()]];
 }
 )cpp",
       {R"txt(
-UnknownExpression ExpressionStatement_expression
-|-MemberExpression
+CallExpression ExpressionStatement_expression
+|-MemberExpression CallExpression_callee
 | |-IdExpression MemberExpression_object
 | | `-UnqualifiedId IdExpression_id
 | |   `-'s'
 | |-'.' MemberExpression_accessToken
 | `-IdExpression MemberExpression_member
 |   `-UnqualifiedId IdExpression_id
 |     |-'operator'
 |     `-'!'
-|-'('
-`-')'
+|-'(' OpenParen
+`-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, MemberExpression_VariableTemplate) {
   if (!GetParam().isCXX14OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
struct S {
   template<typename T>
   T f();
 };
 void test(S* sp){
   [[sp->f<int>()]];
 }
 )cpp",
       {R"txt(
-UnknownExpression ExpressionStatement_expression
-|-MemberExpression
+CallExpression ExpressionStatement_expression
+|-MemberExpression CallExpression_callee
 | |-IdExpression MemberExpression_object
 | | `-UnqualifiedId IdExpression_id
 | |   `-'sp'
 | |-'->' MemberExpression_accessToken
 | `-IdExpression MemberExpression_member
 |   `-UnqualifiedId IdExpression_id
 |     |-'f'
 |     |-'<'
 |     |-'int'
 |     `-'>'
-|-'('
-`-')'
+|-'(' OpenParen
+`-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, MemberExpression_FunctionTemplateWithTemplateKeyword) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct S {
   template<typename T>
   T f();
 };
 void test(S s){
   [[s.template f<int>()]];
 }
 )cpp",
       {R"txt(
-UnknownExpression ExpressionStatement_expression
-|-MemberExpression
+CallExpression ExpressionStatement_expression
+|-MemberExpression CallExpression_callee
 | |-IdExpression MemberExpression_object
 | | `-UnqualifiedId IdExpression_id
 | |   `-'s'
 | |-'.' MemberExpression_accessToken
 | |-'template'
 | `-IdExpression MemberExpression_member
 |   `-UnqualifiedId IdExpression_id
 |     |-'f'
 |     |-'<'
 |     |-'int'
 |     `-'>'
-|-'('
-`-')'
+|-'(' OpenParen
+`-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, MemberExpression_WithQualifier) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
 struct Base {
   void f();
 };
 struct S : public Base {};
 void test(S s){
   [[s.Base::f()]];
   [[s.::S::~S()]];
 }
 )cpp",
       {R"txt(
-UnknownExpression ExpressionStatement_expression
-|-MemberExpression
+CallExpression ExpressionStatement_expression
+|-MemberExpression CallExpression_callee
 | |-IdExpression MemberExpression_object
 | | `-UnqualifiedId IdExpression_id
 | |   `-'s'
 | |-'.' MemberExpression_accessToken
 | `-IdExpression MemberExpression_member
 |   |-NestedNameSpecifier IdExpression_qualifier
 |   | |-IdentifierNameSpecifier List_element
 |   | | `-'Base'
 |   | `-'::' List_delimiter
 |   `-UnqualifiedId IdExpression_id
 |     `-'f'
-|-'('
-`-')'
+|-'(' OpenParen
+`-')' CloseParen
       )txt",
        R"txt(
-UnknownExpression ExpressionStatement_expression
-|-MemberExpression
+CallExpression ExpressionStatement_expression
+|-MemberExpression CallExpression_callee
 | |-IdExpression MemberExpression_object
 | | `-UnqualifiedId IdExpression_id
 | |   `-'s'
 | |-'.' MemberExpression_accessToken
 | `-IdExpression MemberExpression_member
 |   |-NestedNameSpecifier IdExpression_qualifier
 |   | |-'::' List_delimiter
 |   | |-IdentifierNameSpecifier List_element
 |   | | `-'S'
 |   | `-'::' List_delimiter
 |   `-UnqualifiedId IdExpression_id
 |     |-'~'
 |     `-'S'
-|-'('
-`-')'
+|-'(' OpenParen
+`-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, MemberExpression_Complex) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
void test(S* sp) {
   // but it should be a child of `MemberExpression` according to the grammar.
   // However one might argue that the 'template' keyword fits better inside
   // `NestedNameSpecifier` because if we change `U<int>` to `UI` we would like
   // equally to change the `NameSpecifier` `template U<int>` to just `UI`.
   [[sp->getU().template U<int>::template f<int>()]];
 }
 )cpp",
       {R"txt(
-UnknownExpression ExpressionStatement_expression
-|-MemberExpression
-| |-UnknownExpression MemberExpression_object
-| | |-MemberExpression
+CallExpression ExpressionStatement_expression
+|-MemberExpression CallExpression_callee
+| |-CallExpression MemberExpression_object
+| | |-MemberExpression CallExpression_callee
 | | | |-IdExpression MemberExpression_object
 | | | | `-UnqualifiedId IdExpression_id
 | | | |   `-'sp'
 | | | |-'->' MemberExpression_accessToken
 | | | `-IdExpression MemberExpression_member
 | | |   `-UnqualifiedId IdExpression_id
 | | |     `-'getU'
-| | |-'('
-| | `-')'
+| | |-'(' OpenParen
+| | `-')' CloseParen
 | |-'.' MemberExpression_accessToken
 | `-IdExpression MemberExpression_member
 |   |-NestedNameSpecifier IdExpression_qualifier
 |   | |-SimpleTemplateNameSpecifier List_element
 |   | | |-'template'
 |   | | |-'U'
 |   | | |-'<'
 |   | | |-'int'
 |   | | `-'>'
 |   | `-'::' List_delimiter
 |   |-'template' TemplateKeyword
 |   `-UnqualifiedId IdExpression_id
 |     |-'f'
 |     |-'<'
 |     |-'int'
 |     `-'>'
-|-'('
-`-')'
+|-'(' OpenParen
+`-')' CloseParen
+)txt"}));
+}
+
+TEST_P(SyntaxTreeTest, CallExpression_Callee_Member) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+struct S{
+  void f();
+};
+void test(S s) {
+  [[s.f()]];
+}
+)cpp",
+      {R"txt(
+CallExpression ExpressionStatement_expression
+|-MemberExpression CallExpression_callee
+| |-IdExpression MemberExpression_object
+| | `-UnqualifiedId IdExpression_id
+| |   `-'s'
+| |-'.' MemberExpression_accessToken
+| `-IdExpression MemberExpression_member
+|   `-UnqualifiedId IdExpression_id
+|     `-'f'
+|-'(' OpenParen
+`-')' CloseParen
+)txt"}));
+}
+
+TEST_P(SyntaxTreeTest, CallExpression_Callee_OperatorParens) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+struct S {
+  void operator()();
+};
+void test(S s) {
+  [[s()]];
+}
+)cpp",
+      {R"txt(
+CallExpression ExpressionStatement_expression
+|-IdExpression CallExpression_callee
+| `-UnqualifiedId IdExpression_id
+|   `-'s'
+|-'(' OpenParen
+`-')' CloseParen
+)txt"}));
+}
+
+TEST_P(SyntaxTreeTest, CallExpression_Callee_OperatorParensChaining) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+struct S {
+  S operator()();
+};
+void test(S s) {
+  [[s()()]];
+}
+)cpp",
+      {R"txt(
+CallExpression ExpressionStatement_expression
+|-CallExpression CallExpression_callee
+| |-IdExpression CallExpression_callee
+| | `-UnqualifiedId IdExpression_id
+| |   `-'s'
+| |-'(' OpenParen
+| `-')' CloseParen
+|-'(' OpenParen
+`-')' CloseParen
+)txt"}));
+}
+
+TEST_P(SyntaxTreeTest, CallExpression_Callee_MemberWithThis) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+struct Base {
+  void f();
+};
+struct S: public Base {
+  void f();
+  void test() {
+    [[this->f()]];
+    [[f()]];
+    [[this->Base::f()]];
+  }
+};
+)cpp",
+      {R"txt(
+CallExpression ExpressionStatement_expression
+|-MemberExpression CallExpression_callee
+| |-ThisExpression MemberExpression_object
+| | `-'this' IntroducerKeyword
+| |-'->' MemberExpression_accessToken
+| `-IdExpression MemberExpression_member
+|   `-UnqualifiedId IdExpression_id
+|     `-'f'
+|-'(' OpenParen
+`-')' CloseParen
+      )txt",
+       R"txt(
+CallExpression ExpressionStatement_expression
+|-IdExpression CallExpression_callee
+| `-UnqualifiedId IdExpression_id
+|   `-'f'
+|-'(' OpenParen
+`-')' CloseParen
+      )txt",
+       R"txt(
+CallExpression ExpressionStatement_expression
+|-MemberExpression CallExpression_callee
+| |-ThisExpression MemberExpression_object
+| | `-'this' IntroducerKeyword
+| |-'->' MemberExpression_accessToken
+| `-IdExpression MemberExpression_member
+|   |-NestedNameSpecifier IdExpression_qualifier
+|   | |-IdentifierNameSpecifier List_element
+|   | | `-'Base'
+|   | `-'::' List_delimiter
+|   `-UnqualifiedId IdExpression_id
+|     `-'f'
+|-'(' OpenParen
+`-')' CloseParen
+)txt"}));
+}
+
+TEST_P(SyntaxTreeTest, CallExpression_Callee_FunctionPointer) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+void (*pf)();
+void test() {
+  [[pf()]];
+  [[(*pf)()]];
+}
+)cpp",
+      {R"txt(
+CallExpression ExpressionStatement_expression
+|-IdExpression CallExpression_callee
+| `-UnqualifiedId IdExpression_id
+|   `-'pf'
+|-'(' OpenParen
+`-')' CloseParen
+)txt",
+       R"txt(
+CallExpression ExpressionStatement_expression
+|-ParenExpression CallExpression_callee
+| |-'(' OpenParen
+| |-PrefixUnaryOperatorExpression ParenExpression_subExpression
+| | |-'*' OperatorExpression_operatorToken
+| | `-IdExpression UnaryOperatorExpression_operand
+| |   `-UnqualifiedId IdExpression_id
+| |     `-'pf'
+| `-')' CloseParen
+|-'(' OpenParen
+`-')' CloseParen
+)txt"}));
+}
+
+TEST_P(SyntaxTreeTest, CallExpression_Callee_MemberFunctionPointer) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+struct S {
+  void f();
+};
+void test(S s) {
+  void (S::*pmf)();
+  pmf = &S::f;
+  [[(s.*pmf)()]];
+}
+)cpp",
+      {R"txt(
+CallExpression ExpressionStatement_expression
+|-ParenExpression CallExpression_callee
+| |-'(' OpenParen
+| |-BinaryOperatorExpression ParenExpression_subExpression
+| | |-IdExpression BinaryOperatorExpression_leftHandSide
+| | | `-UnqualifiedId IdExpression_id
+| | |   `-'s'
+| | |-'.*' OperatorExpression_operatorToken
+| | `-IdExpression BinaryOperatorExpression_rightHandSide
+| |   `-UnqualifiedId IdExpression_id
+| |     `-'pmf'
+| `-')' CloseParen
+|-'(' OpenParen
+`-')' CloseParen
+)txt"}));
+}
+
+TEST_P(SyntaxTreeTest, CallExpression_Arguments_Zero) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+void f();
+void test() {
+  [[f();]]
+}
+)cpp",
+      {R"txt(
+ExpressionStatement CompoundStatement_statement
+|-CallExpression ExpressionStatement_expression
+| |-IdExpression CallExpression_callee
+| | `-UnqualifiedId IdExpression_id
+| |   `-'f'
+| |-'(' OpenParen
+| `-')' CloseParen
+`-';'
+)txt"}));
+}
+
+TEST_P(SyntaxTreeTest, CallExpression_Arguments_One) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+void f(int);
+void test() {
+  [[f(1);]]
+}
+)cpp",
+      {R"txt(
+ExpressionStatement CompoundStatement_statement
+|-CallExpression ExpressionStatement_expression
+| |-IdExpression CallExpression_callee
+| | `-UnqualifiedId IdExpression_id
+| |   `-'f'
+| |-'(' OpenParen
+| |-CallArguments CallExpression_arguments
+| | `-IntegerLiteralExpression List_element
+| |   `-'1' LiteralToken
+| `-')' CloseParen
+`-';'
+)txt"}));
+}
+
+TEST_P(SyntaxTreeTest, CallExpression_Arguments_Multiple) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+void f(int, char, float);
+void test() {
+  [[f(1, '2', 3.);]]
+}
+)cpp",
+      {R"txt(
+ExpressionStatement CompoundStatement_statement
+|-CallExpression ExpressionStatement_expression
+| |-IdExpression CallExpression_callee
+| | `-UnqualifiedId IdExpression_id
+| |   `-'f'
+| |-'(' OpenParen
+| |-CallArguments CallExpression_arguments
+| | |-IntegerLiteralExpression List_element
+| | | `-'1' LiteralToken
+| | |-',' List_delimiter
+| | |-CharacterLiteralExpression List_element
+| | | `-''2'' LiteralToken
+| | |-',' List_delimiter
+| | `-FloatingLiteralExpression List_element
+| |   `-'3.' LiteralToken
+| `-')' CloseParen
+`-';'
+)txt"}));
+}
+
+TEST_P(SyntaxTreeTest, CallExpression_Arguments_Assignment) {
+  if (!GetParam().isCXX()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+void f(int);
+void test(int a) {
+  [[f(a = 1);]]
+}
+)cpp",
+      {R"txt(
+ExpressionStatement CompoundStatement_statement
+|-CallExpression ExpressionStatement_expression
+| |-IdExpression CallExpression_callee
+| | `-UnqualifiedId IdExpression_id
+| |   `-'f'
+| |-'(' OpenParen
+| |-CallArguments CallExpression_arguments
+| | `-BinaryOperatorExpression List_element
+| |   |-IdExpression BinaryOperatorExpression_leftHandSide
+| |   | `-UnqualifiedId IdExpression_id
+| |   |   `-'a'
+| |   |-'=' OperatorExpression_operatorToken
+| |   `-IntegerLiteralExpression BinaryOperatorExpression_rightHandSide
+| |     `-'1' LiteralToken
+| `-')' CloseParen
+`-';'
+)txt"}));
+}
+
+TEST_P(SyntaxTreeTest, CallExpression_Arguments_BracedInitList_Empty) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+void f(int[]);
+void test() {
+  [[f({});]]
+}
+)cpp",
+      {R"txt(
+ExpressionStatement CompoundStatement_statement
+|-CallExpression ExpressionStatement_expression
+| |-IdExpression CallExpression_callee
+| | `-UnqualifiedId IdExpression_id
+| |   `-'f'
+| |-'(' OpenParen
+| |-CallArguments CallExpression_arguments
+| | `-UnknownExpression List_element
+| |   `-UnknownExpression
+| |     |-'{'
+| |     `-'}'
+| `-')' CloseParen
+`-';'
+)txt"}));
+}
+
+TEST_P(SyntaxTreeTest, CallExpression_Arguments_BracedInitList_Simple) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+struct TT {};
+struct T{
+  int a;
+  TT b;
+};
+void f(T);
+void test() {
+  [[f({1, {}});]]
+}
+)cpp",
+      {R"txt(
+ExpressionStatement CompoundStatement_statement
+|-CallExpression ExpressionStatement_expression
+| |-IdExpression CallExpression_callee
+| | `-UnqualifiedId IdExpression_id
+| |   `-'f'
+| |-'(' OpenParen
+| |-CallArguments CallExpression_arguments
+| | `-UnknownExpression List_element
+| |   `-UnknownExpression
+| |     |-'{'
+| |     |-IntegerLiteralExpression
+| |     | `-'1' LiteralToken
+| |     |-','
+| |     |-UnknownExpression
+| |     | `-UnknownExpression
+| |     |   |-'{'
+| |     |   `-'}'
+| |     `-'}'
+| `-')' CloseParen
+`-';'
+)txt"}));
+}
+
+TEST_P(SyntaxTreeTest, CallExpression_Arguments_BracedInitList_Designated) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+struct TT {};
+struct T{
+  int a;
+  TT b;
+};
+void f(T);
+void test() {
+  [[f({.a = 1, .b {}});]]
+}
+)cpp",
+      {R"txt(
+ExpressionStatement CompoundStatement_statement
+|-CallExpression ExpressionStatement_expression
+| |-IdExpression CallExpression_callee
+| | `-UnqualifiedId IdExpression_id
+| |   `-'f'
+| |-'(' OpenParen
+| |-CallArguments CallExpression_arguments
+| | `-UnknownExpression List_element
+| |   `-UnknownExpression
+| |     |-'{'
+| |     |-UnknownExpression
+| |     | |-'.'
+| |     | |-'a'
+| |     | |-'='
+| |     | `-IntegerLiteralExpression
+| |     |   `-'1' LiteralToken
+| |     |-','
+| |     |-UnknownExpression
+| |     | |-'.'
+| |     | |-'b'
+| |     | `-UnknownExpression
+| |     |   `-UnknownExpression
+| |     |     |-'{'
+| |     |     `-'}'
+| |     `-'}'
+| `-')' CloseParen
+`-';'
+)txt"}));
+}
+
+TEST_P(SyntaxTreeTest, CallExpression_Arguments_ParameterPack) {
+  if (!GetParam().isCXX11OrLater() || GetParam().hasDelayedTemplateParsing()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+template<typename T, typename... Args>
+void test(T t, Args... args) {
+  [[test(args...)]];
+}
+)cpp",
+      {R"txt(
+CallExpression ExpressionStatement_expression
+|-UnknownExpression CallExpression_callee
+| `-'test'
+|-'(' OpenParen
+|-CallArguments CallExpression_arguments
+| `-UnknownExpression List_element
+|   |-IdExpression
+|   | `-UnqualifiedId IdExpression_id
+|   |   `-'args'
+|   `-'...'
+`-')' CloseParen
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, MultipleDeclaratorsGrouping) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int *a, b;
 int *c, d;