[SyntaxTree] Migrate `ParamatersAndQualifiers` to use the new List API

[eduucaldas]

nits

[gribozavr2]

I think we also need to update List::getTerminationKind() and other similar List methods to handle this list kind.

[gribozavr2]

Could you add some tests with variadic parameter lists & variadic function templates? If we don't handle them correctly, please leave a FIXME in the test.

[eduucaldas]

answer code-review comments

[gribozavr2]

clang/unittests/Tooling/Syntax/BuildTreeTest.cpp

4041

Could you also add one with a name? Args... args

[eduucaldas]

Add test

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

enum class NodeKind : uint16_t {
   SimpleDeclarator,
   ParenDeclarator,
 
   ArraySubscript,
   TrailingReturnType,
   ParametersAndQualifiers,
   MemberPointer,
   UnqualifiedId,
+  ParameterDeclarationList,
   // Nested Name Specifiers.
   NestedNameSpecifier,
   GlobalNameSpecifier,
   DecltypeNameSpecifier,
   IdentifierNameSpecifier,
   SimpleTemplateNameSpecifier,
   CallArguments
 };
enum class NodeRole : uint8_t {
   CompoundStatement_statement,
   StaticAssertDeclaration_condition,
   StaticAssertDeclaration_message,
   SimpleDeclaration_declarator,
   TemplateDeclaration_declaration,
   ExplicitTemplateInstantiation_declaration,
   ArraySubscript_sizeExpression,
   TrailingReturnType_declarator,
-  ParametersAndQualifiers_parameter,
+  ParametersAndQualifiers_parameters,
   ParametersAndQualifiers_trailingReturn,
   IdExpression_id,
   IdExpression_qualifier,
   ParenExpression_subExpression,
   MemberExpression_object,
   MemberExpression_accessToken,
   MemberExpression_member,
   CallExpression_callee,
public:
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::TrailingReturnType;
   }
   // TODO: add accessors for specifiers.
   Leaf *arrowToken();
   SimpleDeclarator *declarator();
 };
 
+/// Models a `parameter-declaration-list` which appears within
+/// `parameters-and-qualifiers`. See C++ [dcl.fct]
+class ParameterDeclarationList final : public List {
+public:
+  ParameterDeclarationList() : List(NodeKind::ParameterDeclarationList) {}
+  static bool classof(const Node *N) {
+    return N->kind() == NodeKind::ParameterDeclarationList;
+  }
+  std::vector<SimpleDeclaration *> parameterDeclarations();
+  std::vector<List::ElementAndDelimiter<syntax::SimpleDeclaration>>
+  parametersAndCommas();
+};
+
 /// Parameter list for a function type and a trailing return type, if the
 /// function has one.
 /// E.g.:
 ///  `(int a) volatile ` in `int foo(int a) volatile;`
 ///  `(int a) &&` in `int foo(int a) &&;`
 ///  `() -> int` in `auto foo() -> int;`
 ///  `() const` in `int foo() const;`
 ///  `() noexcept` in `int foo() noexcept;`
 ///  `() throw()` in `int foo() throw();`
 ///
 /// (!) override doesn't belong here.
 class ParametersAndQualifiers final : public Tree {
 public:
   ParametersAndQualifiers() : Tree(NodeKind::ParametersAndQualifiers) {}
   static bool classof(const Node *N) {
     return N->kind() == NodeKind::ParametersAndQualifiers;
   }
   Leaf *lparen();
-  /// FIXME: use custom iterator instead of 'vector'.
-  std::vector<SimpleDeclaration *> parameters();
+  ParameterDeclarationList *parameters();
   Leaf *rparen();
   TrailingReturnType *trailingReturn();
 };
 
 /// Member pointer inside a declarator
 /// E.g. `X::*` in `int X::* a = 0;`
 class MemberPointer final : public Tree {
 public:

clang/lib/Tooling/Syntax/BuildTree.cpp

bool WalkUpFromArrayTypeLoc(ArrayTypeLoc L) {
     Builder.markExprChild(L.getSizeExpr(),
                           syntax::NodeRole::ArraySubscript_sizeExpression);
     Builder.markChildToken(L.getRBracketLoc(), syntax::NodeRole::CloseParen);
     Builder.foldNode(Builder.getRange(L.getLBracketLoc(), L.getRBracketLoc()),
                      new (allocator()) syntax::ArraySubscript, L);
     return true;
   }
 
+  syntax::ParameterDeclarationList *
+  buildParameterDeclarationList(ArrayRef<ParmVarDecl *> Params) {
+    for (auto *P : Params) {
+      Builder.markChild(P, syntax::NodeRole::List_element);
+      const auto *DelimiterToken = std::next(Builder.findToken(P->getEndLoc()));
+      if (DelimiterToken->kind() == clang::tok::TokenKind::comma)
+        Builder.markChildToken(DelimiterToken,
+                               syntax::NodeRole::List_delimiter);
+    }
+    auto *Parameters = new (allocator()) syntax::ParameterDeclarationList;
+    if (!Params.empty())
+      Builder.foldNode(Builder.getRange(Params.front()->getBeginLoc(),
+                                        Params.back()->getEndLoc()),
+                       Parameters, nullptr);
+    return Parameters;
+  }
+
   bool WalkUpFromFunctionTypeLoc(FunctionTypeLoc L) {
     Builder.markChildToken(L.getLParenLoc(), syntax::NodeRole::OpenParen);
-    for (auto *P : L.getParams()) {
-      Builder.markChild(P, syntax::NodeRole::ParametersAndQualifiers_parameter);
-    }
+
+    Builder.markChild(buildParameterDeclarationList(L.getParams()),
+                      syntax::NodeRole::ParametersAndQualifiers_parameters);
+
     Builder.markChildToken(L.getRParenLoc(), syntax::NodeRole::CloseParen);
     Builder.foldNode(Builder.getRange(L.getLParenLoc(), L.getEndLoc()),
                      new (allocator()) syntax::ParametersAndQualifiers, L);
     return true;
   }
 
   bool WalkUpFromFunctionProtoTypeLoc(FunctionProtoTypeLoc L) {
     if (!L.getTypePtr()->hasTrailingReturn())

clang/lib/Tooling/Syntax/Nodes.cpp

raw_ostream &syntax::operator<<(raw_ostream &OS, NodeKind K) {
   case NodeKind::SimpleTemplateNameSpecifier:
     return OS << "SimpleTemplateNameSpecifier";
   case NodeKind::NestedNameSpecifier:
     return OS << "NestedNameSpecifier";
   case NodeKind::MemberExpression:
     return OS << "MemberExpression";
   case NodeKind::CallArguments:
     return OS << "CallArguments";
+  case NodeKind::ParameterDeclarationList:
+    return OS << "ParameterDeclarationList";
   }
   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::TemplateDeclaration_declaration:
     return OS << "TemplateDeclaration_declaration";
   case syntax::NodeRole::ExplicitTemplateInstantiation_declaration:
     return OS << "ExplicitTemplateInstantiation_declaration";
   case syntax::NodeRole::ArraySubscript_sizeExpression:
     return OS << "ArraySubscript_sizeExpression";
   case syntax::NodeRole::TrailingReturnType_declarator:
     return OS << "TrailingReturnType_declarator";
-  case syntax::NodeRole::ParametersAndQualifiers_parameter:
-    return OS << "ParametersAndQualifiers_parameter";
+  case syntax::NodeRole::ParametersAndQualifiers_parameters:
+    return OS << "ParametersAndQualifiers_parameters";
   case syntax::NodeRole::ParametersAndQualifiers_trailingReturn:
     return OS << "ParametersAndQualifiers_trailingReturn";
   case syntax::NodeRole::IdExpression_id:
     return OS << "IdExpression_id";
   case syntax::NodeRole::IdExpression_qualifier:
     return OS << "IdExpression_qualifier";
   case syntax::NodeRole::ParenExpression_subExpression:
     return OS << "ParenExpression_subExpression";
syntax::CallArguments::argumentsAndCommas() {
   for (const auto &ArgumentAsNodeAndComma : ArgumentsAsNodesAndCommas) {
     Children.push_back(
         {llvm::cast<syntax::Expression>(ArgumentAsNodeAndComma.element),
          ArgumentAsNodeAndComma.delimiter});
   }
   return Children;
 }
 
+std::vector<syntax::SimpleDeclaration *>
+syntax::ParameterDeclarationList::parameterDeclarations() {
+  auto ParametersAsNodes = getElementsAsNodes();
+  std::vector<syntax::SimpleDeclaration *> Children;
+  for (const auto &ParameterAsNode : ParametersAsNodes) {
+    Children.push_back(llvm::cast<syntax::SimpleDeclaration>(ParameterAsNode));
+  }
+  return Children;
+}
+
+std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclaration>>
+syntax::ParameterDeclarationList::parametersAndCommas() {
+  auto ParametersAsNodesAndCommas = getElementsAsNodesAndDelimiters();
+  std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclaration>>
+      Children;
+  for (const auto &ParameterAsNodeAndComma : ParametersAsNodesAndCommas) {
+    Children.push_back(
+        {llvm::cast<syntax::SimpleDeclaration>(ParameterAsNodeAndComma.element),
+         ParameterAsNodeAndComma.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));
syntax::SimpleDeclarator *syntax::TrailingReturnType::declarator() {
   return cast_or_null<syntax::SimpleDeclarator>(
       findChild(syntax::NodeRole::TrailingReturnType_declarator));
 }
 
 syntax::Leaf *syntax::ParametersAndQualifiers::lparen() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
 }
 
-std::vector<syntax::SimpleDeclaration *>
+syntax::ParameterDeclarationList *
 syntax::ParametersAndQualifiers::parameters() {
-  std::vector<syntax::SimpleDeclaration *> Children;
-  for (auto *C = firstChild(); C; C = C->nextSibling()) {
-    if (C->role() == syntax::NodeRole::ParametersAndQualifiers_parameter)
-      Children.push_back(cast<syntax::SimpleDeclaration>(C));
-  }
-  return Children;
+  return cast_or_null<syntax::ParameterDeclarationList>(
+      findChild(syntax::NodeRole::ParametersAndQualifiers_parameters));
 }
 
 syntax::Leaf *syntax::ParametersAndQualifiers::rparen() {
   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
 }
 
 syntax::TrailingReturnType *syntax::ParametersAndQualifiers::trailingReturn() {
   return cast_or_null<syntax::TrailingReturnType>(
       findChild(syntax::NodeRole::ParametersAndQualifiers_trailingReturn));
 }

clang/lib/Tooling/Syntax/Tree.cpp

std::vector<syntax::Node *> syntax::List::getElementsAsNodes() {
 
   return children;
 }
 
 clang::tok::TokenKind syntax::List::getDelimiterTokenKind() {
   switch (this->kind()) {
   case NodeKind::NestedNameSpecifier:
     return clang::tok::coloncolon;
+  case NodeKind::CallArguments:
+  case NodeKind::ParametersAndQualifiers:
+    return clang::tok::comma;
   default:
     llvm_unreachable("This is not a subclass of List, thus "
                      "getDelimiterTokenKind() cannot be called");
   }
 }
 
 syntax::List::TerminationKind syntax::List::getTerminationKind() {
   switch (this->kind()) {
   case NodeKind::NestedNameSpecifier:
     return TerminationKind::Terminated;
+  case NodeKind::CallArguments:
+  case NodeKind::ParametersAndQualifiers:
+    return TerminationKind::Separated;
   default:
     llvm_unreachable("This is not a subclass of List, thus "
                      "getTerminationKind() cannot be called");
   }
 }
 
 bool syntax::List::canBeEmpty() {
   switch (this->kind()) {
   case NodeKind::NestedNameSpecifier:
     return false;
+  case NodeKind::CallArguments:
+    return true;
+  case NodeKind::ParametersAndQualifiers:
+    return true;
   default:
     llvm_unreachable("This is not a subclass of List, thus canBeEmpty() "
                      "cannot be called");
   }
 }

clang/unittests/Tooling/Syntax/BuildTreeTest.cpp

)cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'void'
   |-SimpleDeclarator SimpleDeclaration_declarator
   | |-'foo'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   | |-'int'
-  |   | `-SimpleDeclarator SimpleDeclaration_declarator
-  |   |   `-'a'
-  |   |-','
-  |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   | |-'int'
-  |   | `-SimpleDeclarator SimpleDeclaration_declarator
-  |   |   `-'b'
+  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+  |   | |-SimpleDeclaration List_element
+  |   | | |-'int'
+  |   | | `-SimpleDeclarator SimpleDeclaration_declarator
+  |   | |   `-'a'
+  |   | |-',' List_delimiter
+  |   | `-SimpleDeclaration List_element
+  |   |   |-'int'
+  |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+  |   |     `-'b'
   |   `-')' CloseParen
   `-CompoundStatement
     |-'{' OpenParen
     `-'}' CloseParen
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, If) {

 `-SimpleDeclaration
   |-'unsigned'
   |-SimpleDeclarator SimpleDeclaration_declarator
   | |-'operator'
   | |-'""'
   | |-'_c'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   | `-'char'
+  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+  |   | `-SimpleDeclaration List_element
+  |   |   `-'char'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, NumericLiteralOperatorTemplateDeclaration) {
   if (!GetParam().isCXX11OrLater()) {
     return;

 SimpleDeclaration
 |-'X'
 |-SimpleDeclarator SimpleDeclaration_declarator
 | |-'&'
 | |-'operator'
 | |-'='
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
-|   |-SimpleDeclaration ParametersAndQualifiers_parameter
-|   | |-'const'
-|   | |-'X'
-|   | `-SimpleDeclarator SimpleDeclaration_declarator
-|   |   `-'&'
+|   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+|   | `-SimpleDeclaration List_element
+|   |   |-'const'
+|   |   |-'X'
+|   |   `-SimpleDeclarator SimpleDeclaration_declarator
+|   |     `-'&'
 |   `-')' CloseParen
 `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, OverloadedOperatorFriendDeclaration) {
   if (!GetParam().isCXX()) {
     return;

 `-SimpleDeclaration
   |-'friend'
   |-'X'
   |-SimpleDeclarator SimpleDeclaration_declarator
   | |-'operator'
   | |-'+'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   | `-'X'
-  |   |-','
-  |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   | |-'const'
-  |   | |-'X'
-  |   | `-SimpleDeclarator SimpleDeclaration_declarator
-  |   |   `-'&'
+  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+  |   | |-SimpleDeclaration List_element
+  |   | | `-'X'
+  |   | |-',' List_delimiter
+  |   | `-SimpleDeclaration List_element
+  |   |   |-'const'
+  |   |   |-'X'
+  |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+  |   |     `-'&'
   |   `-')' CloseParen
   `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, ClassTemplateDeclaration) {
   if (!GetParam().isCXX()) {
     return;
)cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'void'
   |-SimpleDeclarator SimpleDeclaration_declarator
   | |-'f'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   | |-'int'
-  |   | `-SimpleDeclarator SimpleDeclaration_declarator
-  |   |   |-'xs'
-  |   |   `-ArraySubscript
-  |   |     |-'[' OpenParen
-  |   |     |-'static'
-  |   |     |-IntegerLiteralExpression ArraySubscript_sizeExpression
-  |   |     | `-'10' LiteralToken
-  |   |     `-']' CloseParen
+  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+  |   | `-SimpleDeclaration List_element
+  |   |   |-'int'
+  |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+  |   |     |-'xs'
+  |   |     `-ArraySubscript
+  |   |       |-'[' OpenParen
+  |   |       |-'static'
+  |   |       |-IntegerLiteralExpression ArraySubscript_sizeExpression
+  |   |       | `-'10' LiteralToken
+  |   |       `-']' CloseParen
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Empty) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
)cpp",
       R"txt(
 TranslationUnit Detached
 |-SimpleDeclaration
 | |-'int'
 | |-SimpleDeclarator SimpleDeclaration_declarator
 | | |-'func1'
 | | `-ParametersAndQualifiers
 | |   |-'(' OpenParen
-| |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-| |   | |-'int'
-| |   | `-SimpleDeclarator SimpleDeclaration_declarator
-| |   |   `-'a'
+| |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+| |   | `-SimpleDeclaration List_element
+| |   |   |-'int'
+| |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+| |   |     `-'a'
 | |   `-')' CloseParen
 | `-';'
 |-SimpleDeclaration
 | |-'int'
 | |-SimpleDeclarator SimpleDeclaration_declarator
 | | |-'func2'
 | | `-ParametersAndQualifiers
 | |   |-'(' OpenParen
-| |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-| |   | |-'int'
-| |   | `-SimpleDeclarator SimpleDeclaration_declarator
-| |   |   |-'*'
-| |   |   `-'ap'
+| |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+| |   | `-SimpleDeclaration List_element
+| |   |   |-'int'
+| |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+| |   |     |-'*'
+| |   |     `-'ap'
 | |   `-')' CloseParen
 | `-';'
 `-SimpleDeclaration
   |-'int'
   |-SimpleDeclarator SimpleDeclaration_declarator
   | |-'func3'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   | |-'int'
-  |   | `-SimpleDeclarator SimpleDeclaration_declarator
-  |   |   `-'a'
-  |   |-','
-  |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   | |-'float'
-  |   | `-SimpleDeclarator SimpleDeclaration_declarator
-  |   |   `-'b'
+  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+  |   | |-SimpleDeclaration List_element
+  |   | | |-'int'
+  |   | | `-SimpleDeclarator SimpleDeclaration_declarator
+  |   | |   `-'a'
+  |   | |-',' List_delimiter
+  |   | `-SimpleDeclaration List_element
+  |   |   |-'float'
+  |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+  |   |     `-'b'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Unnamed) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int func1(int);
 int func2(int *);
 int func3(int, float);
 )cpp",
       R"txt(
 TranslationUnit Detached
 |-SimpleDeclaration
 | |-'int'
 | |-SimpleDeclarator SimpleDeclaration_declarator
 | | |-'func1'
 | | `-ParametersAndQualifiers
 | |   |-'(' OpenParen
-| |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-| |   | `-'int'
+| |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+| |   | `-SimpleDeclaration List_element
+| |   |   `-'int'
 | |   `-')' CloseParen
 | `-';'
 |-SimpleDeclaration
 | |-'int'
 | |-SimpleDeclarator SimpleDeclaration_declarator
 | | |-'func2'
 | | `-ParametersAndQualifiers
 | |   |-'(' OpenParen
-| |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-| |   | |-'int'
-| |   | `-SimpleDeclarator SimpleDeclaration_declarator
-| |   |   `-'*'
+| |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+| |   | `-SimpleDeclaration List_element
+| |   |   |-'int'
+| |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+| |   |     `-'*'
 | |   `-')' CloseParen
 | `-';'
 `-SimpleDeclaration
   |-'int'
   |-SimpleDeclarator SimpleDeclaration_declarator
   | |-'func3'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   | `-'int'
-  |   |-','
-  |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   | `-'float'
+  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+  |   | |-SimpleDeclaration List_element
+  |   | | `-'int'
+  |   | |-',' List_delimiter
+  |   | `-SimpleDeclaration List_element
+  |   |   `-'float'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest,
+       ParametersAndQualifiers_InVariadicFunctionTemplate_ParameterPack) {
+  if (!GetParam().isCXX11OrLater() || GetParam().hasDelayedTemplateParsing()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+template<typename T, typename... Args>
+[[void test(T , Args... );]]
+)cpp",
+      {R"txt(
+SimpleDeclaration
+|-'void'
+|-SimpleDeclarator SimpleDeclaration_declarator
+| |-'test'
+| `-ParametersAndQualifiers
+|   |-'(' OpenParen
+|   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+|   | |-SimpleDeclaration List_element
+|   | | `-'T'
+|   | |-',' List_delimiter
+|   | `-SimpleDeclaration List_element
+|   |   |-'Args'
+|   |   `-'...'
+|   `-')' CloseParen
+`-';'
+)txt"}));
+}
+
+TEST_P(SyntaxTreeTest,
+       ParametersAndQualifiers_InVariadicFunctionTemplate_NamedParameterPack) {
+  if (!GetParam().isCXX11OrLater() || GetParam().hasDelayedTemplateParsing()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqualOnAnnotations(
+      R"cpp(
+template<typename T, typename... Args>
+[[void test(T t, Args... args);]]
+)cpp",
+      {R"txt(
+SimpleDeclaration
+|-'void'
+|-SimpleDeclarator SimpleDeclaration_declarator
+| |-'test'
+| `-ParametersAndQualifiers
+|   |-'(' OpenParen
+|   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+|   | |-SimpleDeclaration List_element
+|   | | |-'T'
+|   | | `-SimpleDeclarator SimpleDeclaration_declarator
+|   | |   `-'t'
+|   | |-',' List_delimiter
+|   | `-SimpleDeclaration List_element
+|   |   |-'Args'
+|   |   |-'...'
+|   |   `-SimpleDeclarator SimpleDeclaration_declarator
+|   |     `-'args'
+|   `-')' CloseParen
+`-';'
+)txt"}));
+}
+
+TEST_P(SyntaxTreeTest,
+       ParametersAndQualifiers_InFreeFunctions_VariadicArguments) {
+  if (!GetParam().isCXX11OrLater()) {
+    return;
+  }
+  EXPECT_TRUE(treeDumpEqual(
+      R"cpp(
+void test(int , char ...);
+)cpp",
+      R"txt(
+TranslationUnit Detached
+`-SimpleDeclaration
+  |-'void'
+  |-SimpleDeclarator SimpleDeclaration_declarator
+  | |-'test'
+  | `-ParametersAndQualifiers
+  |   |-'(' OpenParen
+  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+  |   | |-SimpleDeclaration List_element
+  |   | | `-'int'
+  |   | |-',' List_delimiter
+  |   | `-SimpleDeclaration List_element
+  |   |   `-'char'
+  |   |-'...'
+  |   `-')' CloseParen
+  `-';'
+)txt"));
+}
+
+TEST_P(SyntaxTreeTest,
        ParametersAndQualifiers_InFreeFunctions_Cxx_CvQualifiers) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int func(const int a, volatile int b, const volatile int c);
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'int'
   |-SimpleDeclarator SimpleDeclaration_declarator
   | |-'func'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   | |-'const'
-  |   | |-'int'
-  |   | `-SimpleDeclarator SimpleDeclaration_declarator
-  |   |   `-'a'
-  |   |-','
-  |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   | |-'volatile'
-  |   | |-'int'
-  |   | `-SimpleDeclarator SimpleDeclaration_declarator
-  |   |   `-'b'
-  |   |-','
-  |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   | |-'const'
-  |   | |-'volatile'
-  |   | |-'int'
-  |   | `-SimpleDeclarator SimpleDeclaration_declarator
-  |   |   `-'c'
+  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+  |   | |-SimpleDeclaration List_element
+  |   | | |-'const'
+  |   | | |-'int'
+  |   | | `-SimpleDeclarator SimpleDeclaration_declarator
+  |   | |   `-'a'
+  |   | |-',' List_delimiter
+  |   | |-SimpleDeclaration List_element
+  |   | | |-'volatile'
+  |   | | |-'int'
+  |   | | `-SimpleDeclarator SimpleDeclaration_declarator
+  |   | |   `-'b'
+  |   | |-',' List_delimiter
+  |   | `-SimpleDeclaration List_element
+  |   |   |-'const'
+  |   |   |-'volatile'
+  |   |   |-'int'
+  |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+  |   |     `-'c'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Cxx_Ref) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int func(int& a);
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'int'
   |-SimpleDeclarator SimpleDeclaration_declarator
   | |-'func'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   | |-'int'
-  |   | `-SimpleDeclarator SimpleDeclaration_declarator
-  |   |   |-'&'
-  |   |   `-'a'
+  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+  |   | `-SimpleDeclaration List_element
+  |   |   |-'int'
+  |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+  |   |     |-'&'
+  |   |     `-'a'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Cxx11_RefRef) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int func(int&& a);
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'int'
   |-SimpleDeclarator SimpleDeclaration_declarator
   | |-'func'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   | |-'int'
-  |   | `-SimpleDeclarator SimpleDeclaration_declarator
-  |   |   |-'&&'
-  |   |   `-'a'
+  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+  |   | `-SimpleDeclaration List_element
+  |   |   |-'int'
+  |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+  |   |     |-'&&'
+  |   |     `-'a'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, ParametersAndQualifiers_InMemberFunctions_Simple) {
   if (!GetParam().isCXX()) {
     return;

 | |-SimpleDeclarator SimpleDeclaration_declarator
 | | |-ParenDeclarator
 | | | |-'(' OpenParen
 | | | |-'*'
 | | | |-'c'
 | | | `-')' CloseParen
 | | `-ParametersAndQualifiers
 | |   |-'(' OpenParen
-| |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-| |   | `-'int'
+| |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+| |   | `-SimpleDeclaration List_element
+| |   |   `-'int'
 | |   `-')' CloseParen
 | `-';'
 `-SimpleDeclaration
   |-'int'
   |-SimpleDeclarator SimpleDeclaration_declarator
   | |-'*'
   | |-ParenDeclarator
   | | |-'(' OpenParen
   | | |-'d'
   | | `-')' CloseParen
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   | `-'int'
+  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+  |   | `-SimpleDeclaration List_element
+  |   |   `-'int'
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, Declaration_ConstVolatileQualifiers_SimpleConst) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
`-SimpleDeclaration
   |     |-'auto'
   |     `-SimpleDeclarator TrailingReturnType_declarator
   |       |-ParenDeclarator
   |       | |-'(' OpenParen
   |       | |-'*'
   |       | `-')' CloseParen
   |       `-ParametersAndQualifiers
   |         |-'(' OpenParen
-  |         |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |         | `-'int'
+  |         |-ParameterDeclarationList ParametersAndQualifiers_parameters
+  |         | `-SimpleDeclaration List_element
+  |         |   `-'int'
   |         |-')' CloseParen
   |         `-TrailingReturnType ParametersAndQualifiers_trailingReturn
   |           |-'->' ArrowToken
   |           |-'double'
   |           `-SimpleDeclarator TrailingReturnType_declarator
   |             `-'*'
   `-';'
 )txt"));

 | | | |-'X'
 | | | |-'::'
 | | | `-'*'
 | | |-'*'
 | | |-'xpp'
 | | `-')' CloseParen
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
-|   |-SimpleDeclaration ParametersAndQualifiers_parameter
-|   | |-'const'
-|   | |-'int'
-|   | `-SimpleDeclarator SimpleDeclaration_declarator
-|   |   `-'*'
+|   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+|   | `-SimpleDeclaration List_element
+|   |   |-'const'
+|   |   |-'int'
+|   |   `-SimpleDeclarator SimpleDeclaration_declarator
+|   |     `-'*'
 |   `-')' CloseParen
 `-';'
 )txt",
        R"txt(
 SimpleDeclaration
 |-'void'
 |-SimpleDeclarator SimpleDeclaration_declarator
 | |-ParenDeclarator
 | | |-'(' OpenParen
 | | |-'X'
 | | |-'::'
 | | |-MemberPointer
 | | | |-'Y'
 | | | |-'::'
 | | | `-'*'
 | | |-'xyp'
 | | `-')' CloseParen
 | `-ParametersAndQualifiers
 |   |-'(' OpenParen
-|   |-SimpleDeclaration ParametersAndQualifiers_parameter
-|   | |-'const'
-|   | |-'int'
-|   | `-SimpleDeclarator SimpleDeclaration_declarator
-|   |   `-'*'
-|   |-','
-|   |-SimpleDeclaration ParametersAndQualifiers_parameter
-|   | `-'char'
+|   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+|   | |-SimpleDeclaration List_element
+|   | | |-'const'
+|   | | |-'int'
+|   | | `-SimpleDeclarator SimpleDeclaration_declarator
+|   | |   `-'*'
+|   | |-',' List_delimiter
+|   | `-SimpleDeclaration List_element
+|   |   `-'char'
 |   `-')' CloseParen
 `-';'
 )txt"}));
 }
 
 TEST_P(SyntaxTreeTest, ComplexDeclarator) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void x(char a, short (*b)(int));
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'void'
   |-SimpleDeclarator SimpleDeclaration_declarator
   | |-'x'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   | |-'char'
-  |   | `-SimpleDeclarator SimpleDeclaration_declarator
-  |   |   `-'a'
-  |   |-','
-  |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   | |-'short'
-  |   | `-SimpleDeclarator SimpleDeclaration_declarator
-  |   |   |-ParenDeclarator
-  |   |   | |-'(' OpenParen
-  |   |   | |-'*'
-  |   |   | |-'b'
-  |   |   | `-')' CloseParen
-  |   |   `-ParametersAndQualifiers
-  |   |     |-'(' OpenParen
-  |   |     |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   |     | `-'int'
-  |   |     `-')' CloseParen
+  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+  |   | |-SimpleDeclaration List_element
+  |   | | |-'char'
+  |   | | `-SimpleDeclarator SimpleDeclaration_declarator
+  |   | |   `-'a'
+  |   | |-',' List_delimiter
+  |   | `-SimpleDeclaration List_element
+  |   |   |-'short'
+  |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+  |   |     |-ParenDeclarator
+  |   |     | |-'(' OpenParen
+  |   |     | |-'*'
+  |   |     | |-'b'
+  |   |     | `-')' CloseParen
+  |   |     `-ParametersAndQualifiers
+  |   |       |-'(' OpenParen
+  |   |       |-ParameterDeclarationList ParametersAndQualifiers_parameters
+  |   |       | `-SimpleDeclaration List_element
+  |   |       |   `-'int'
+  |   |       `-')' CloseParen
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
 TEST_P(SyntaxTreeTest, ComplexDeclarator2) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void x(char a, short (*b)(int), long (**c)(long long));
 )cpp",
       R"txt(
 TranslationUnit Detached
 `-SimpleDeclaration
   |-'void'
   |-SimpleDeclarator SimpleDeclaration_declarator
   | |-'x'
   | `-ParametersAndQualifiers
   |   |-'(' OpenParen
-  |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   | |-'char'
-  |   | `-SimpleDeclarator SimpleDeclaration_declarator
-  |   |   `-'a'
-  |   |-','
-  |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   | |-'short'
-  |   | `-SimpleDeclarator SimpleDeclaration_declarator
-  |   |   |-ParenDeclarator
-  |   |   | |-'(' OpenParen
-  |   |   | |-'*'
-  |   |   | |-'b'
-  |   |   | `-')' CloseParen
-  |   |   `-ParametersAndQualifiers
-  |   |     |-'(' OpenParen
-  |   |     |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   |     | `-'int'
-  |   |     `-')' CloseParen
-  |   |-','
-  |   |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   | |-'long'
-  |   | `-SimpleDeclarator SimpleDeclaration_declarator
-  |   |   |-ParenDeclarator
-  |   |   | |-'(' OpenParen
-  |   |   | |-'*'
-  |   |   | |-'*'
-  |   |   | |-'c'
-  |   |   | `-')' CloseParen
-  |   |   `-ParametersAndQualifiers
-  |   |     |-'(' OpenParen
-  |   |     |-SimpleDeclaration ParametersAndQualifiers_parameter
-  |   |     | |-'long'
-  |   |     | `-'long'
-  |   |     `-')' CloseParen
+  |   |-ParameterDeclarationList ParametersAndQualifiers_parameters
+  |   | |-SimpleDeclaration List_element
+  |   | | |-'char'
+  |   | | `-SimpleDeclarator SimpleDeclaration_declarator
+  |   | |   `-'a'
+  |   | |-',' List_delimiter
+  |   | |-SimpleDeclaration List_element
+  |   | | |-'short'
+  |   | | `-SimpleDeclarator SimpleDeclaration_declarator
+  |   | |   |-ParenDeclarator
+  |   | |   | |-'(' OpenParen
+  |   | |   | |-'*'
+  |   | |   | |-'b'
+  |   | |   | `-')' CloseParen
+  |   | |   `-ParametersAndQualifiers
+  |   | |     |-'(' OpenParen
+  |   | |     |-ParameterDeclarationList ParametersAndQualifiers_parameters
+  |   | |     | `-SimpleDeclaration List_element
+  |   | |     |   `-'int'
+  |   | |     `-')' CloseParen
+  |   | |-',' List_delimiter
+  |   | `-SimpleDeclaration List_element
+  |   |   |-'long'
+  |   |   `-SimpleDeclarator SimpleDeclaration_declarator
+  |   |     |-ParenDeclarator
+  |   |     | |-'(' OpenParen
+  |   |     | |-'*'
+  |   |     | |-'*'
+  |   |     | |-'c'
+  |   |     | `-')' CloseParen
+  |   |     `-ParametersAndQualifiers
+  |   |       |-'(' OpenParen
+  |   |       |-ParameterDeclarationList ParametersAndQualifiers_parameters
+  |   |       | `-SimpleDeclaration List_element
+  |   |       |   |-'long'
+  |   |       |   `-'long'
+  |   |       `-')' CloseParen
   |   `-')' CloseParen
   `-';'
 )txt"));
 }
 
 } // namespace