[pseudo] Eliminate a false parse of the template parameter "class T".

[hokein]

Summary

Implements the temp.param#2 rule with the guard.

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

 //===--- CXX.cpp - Define public interfaces for C++ grammar ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang-pseudo/cxx/CXX.h"
 #include "clang-pseudo/Forest.h"
 #include "clang-pseudo/Language.h"
 #include "clang-pseudo/grammar/Grammar.h"
 #include "clang-pseudo/grammar/LRTable.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/TokenKinds.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/Debug.h"
 #include <utility>
 #define DEBUG_TYPE "CXX.cpp"
 
 namespace clang {
 namespace pseudo {
 namespace cxx {
case clang::tok::kw_volatile:
       break;
     default:
       return false;
     }
   }
   return true;
 }
 
+bool isNotClassIdentifierFormTemplateParameter(
+    const GuardParams &TemplateParameter) {
+  const ForestNode *ParameterDeclaration = TemplateParameter.RHS[0];
+  assert(ParameterDeclaration->symbol() == cxx::Symbol::parameter_declaration);
+  llvm::SmallVector<clang::tok::TokenKind, 2> Tokens;
+  // FIXME: This is an awkward way to get the end of the covered token range,
+  // pass it in the GuardParams?
+  Token::Index Start = ParameterDeclaration->startTokenIndex();
+  if (TemplateParameter.Tokens.tokens()[Start].Kind != clang::tok::kw_class)
+    return true;
+  Token::Index Last = Start;
+  for (auto &Child : ParameterDeclaration->descendants()) {
+    if (Child.kind() == ForestNode::Terminal)
+      Last = std::max(Last, Child.startTokenIndex());
+  }
+  return !(Last - Start == 1 && TemplateParameter.Tokens.tokens()[Last].Kind ==
+                                    clang::tok::identifier);
+}
+
 // 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},
 
+      // C++ [temp.param#2]:
+      //   ...A template-parameter of the form class identifier is a type-parameter.
+      //
+      //   template<class T, T i> void f(T t);
+      // Here, the template f has a type-parameter called T, rather than an
+      // unnamed non-type template-parameter of class T.
+      {
+        rule::template_parameter::parameter_declaration,
+        isNotClassIdentifierFormTemplateParameter,
+      },
+
       // 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

 template-parameter-list := template-parameter
 template-parameter-list := template-parameter-list , template-parameter
 requires-clause := REQUIRES constraint-logical-or-expression
 constraint-logical-or-expression := constraint-logical-and-expression
 constraint-logical-or-expression := constraint-logical-or-expression || constraint-logical-and-expression
 constraint-logical-and-expression := primary-expression
 constraint-logical-and-expression := constraint-logical-and-expression && primary-expression
 template-parameter := type-parameter
-template-parameter := parameter-declaration
+template-parameter := parameter-declaration [guard]
 type-parameter := type-parameter-key ..._opt IDENTIFIER_opt
 type-parameter := type-parameter-key IDENTIFIER_opt = type-id
 type-parameter := type-constraint ..._opt IDENTIFIER_opt
 type-parameter := type-constraint IDENTIFIER_opt = type-id
 type-parameter := template-head type-parameter-key ..._opt IDENTIFIER_opt
 type-parameter := template-head type-parameter-key IDENTIFIER_opt = id-expression
 type-parameter-key := CLASS
 type-parameter-key := TYPENAME

clang-tools-extra/pseudo/test/cxx/type-template-parameter.cpp

+// RUN: clang-pseudo -grammar=cxx -source=%s --print-forest | FileCheck %s
+
+// Verify that we don't misparse the "class abc" as an unnamed non-type template-parameter of class T.
+template<class abc>
+struct Foo {};
+
+// CHECK:      template-parameter-list~type-parameter := type-parameter-key IDENTIFIER
+// CHECK-NEXT: ├─type-parameter-key~CLASS :=
+// CHECK-NEXT: └─IDENTIFIER :=