[pseudo] Don't misparse ... as an abstract declarator in template argument.

[hokein]

Summary

The motivation is to eliminate a false ambiguous parse of
tempalte-arugment-list, see test file for details.

clang-tools-extra/pseudo/lib/cxx/CXX.cpp

case clang::tok::kw_volatile:
       break;
     default:
       return false;
     }
   }
   return true;
 }
 
+bool guardEllipsisInAbstractDeclarator(const GuardParams& P) {
+  const auto* TypeID = P.RHS[0];
+  assert(TypeID->symbol() == Symbol::type_id);
+  if (TypeID->kind() == ForestNode::Sequence &&
+      TypeID->rule() == rule::type_id::type_specifier_seq__abstract_declarator) {
+    const auto* AbstractDeclarator = TypeID->elements()[1];
+    for (auto &Child : AbstractDeclarator->descendants()) {
+      if (Child.kind() == ForestNode::Terminal)
+        if (symbolToToken(Child.symbol()) == clang::tok::ellipsis)
+          return false;
+    }
+    return true;
+  }
+  return true;
+}
+
 // Whether this e.g. decl-specifier contains an "exclusive" type such as a class
 // name, and thus can't combine with a second exclusive type.
 //
 // Returns false for
 //  - non-types
 //  - "unsigned" etc that may suffice as types but may modify others
 //  - cases of uncertainty (e.g. due to ambiguity)
 bool hasExclusiveType(const ForestNode *N) {
return {
       //   or cv-qualifiers, the program is ill-formed.
       {rule::simple_declaration::
            decl_specifier_seq__ref_qualifier__L_SQUARE__identifier_list__R_SQUARE__initializer__SEMI,
        specifiesStructuredBinding},
       {rule::simple_declaration::
            decl_specifier_seq__L_SQUARE__identifier_list__R_SQUARE__initializer__SEMI,
        specifiesStructuredBinding},
 
+      // Per C++ [dcl.fct#25] -- A declarator-id or abstract-declarator containing
+      // an ellipsis shall only be used in a parameter-declaration.
+      //
+      // We should not misparse the `int...` in `vector<int...> abc;` as a
+      // type-id template argument (... is an abstractor-declarator).
+      {
+        rule::template_argument::type_id,
+        guardEllipsisInAbstractDeclarator
+      },
+
       // The grammar distinguishes (only) user-defined vs plain string literals,
       // where the clang lexer distinguishes (only) encoding types.
       {rule::user_defined_string_literal_chunk::STRING_LITERAL,
        TOKEN_GUARD(string_literal, isStringUserDefined(Tok))},
       {rule::user_defined_string_literal_chunk::UTF8_STRING_LITERAL,
        TOKEN_GUARD(utf8_string_literal, isStringUserDefined(Tok))},
       {rule::user_defined_string_literal_chunk::UTF16_STRING_LITERAL,
        TOKEN_GUARD(utf16_string_literal, isStringUserDefined(Tok))},

clang-tools-extra/pseudo/lib/cxx/cxx.bnf

 type-constraint := nested-name-specifier_opt concept-name < template-argument-list_opt >
 simple-template-id := template-name < template-argument-list_opt >
 template-id := simple-template-id
 template-id := operator-function-id < template-argument-list_opt >
 template-id := literal-operator-id < template-argument-list_opt >
 template-argument-list := template-argument ..._opt
 template-argument-list := template-argument-list , template-argument ..._opt
 template-argument := constant-expression
-template-argument := type-id
+template-argument := type-id [guard]
 template-argument := id-expression
 constraint-expression := logical-or-expression
 deduction-guide := explicit-specifier_opt template-name ( parameter-declaration-list_opt ) -> simple-template-id ;
 concept-definition := CONCEPT concept-name = constraint-expression ;
 concept-name := IDENTIFIER
 typename-specifier := TYPENAME nested-name-specifier IDENTIFIER
 typename-specifier := TYPENAME nested-name-specifier TEMPLATE_opt simple-template-id
 explicit-instantiation := EXTERN_opt TEMPLATE declaration

clang-tools-extra/pseudo/test/cxx/ellipsis-in-abstractor-declarator.cpp

+// RUN: clang-pseudo -grammar=cxx -source=%s --print-forest | FileCheck %s
+
+// Verify that we don't misparse T... as a complete type-id template argument
+Foo<T...> abc;
+// CHECK-NOT:  template-argument-list := <ambiguous>
+// CHECK: template-argument-list := template-argument ...