[pseudo] Reorganize CXX.h enums

- Place rules under rule::lhs::rhs__rhs__rhs
- Change mangling of keywords to ALL_CAPS (needed to turn keywords that appear
  alone on RHS into valid identifiers)
- Make enums implicitly convertible to underlying type (though still scoped,
  using alias tricks)

In principle this lets us exhaustively write a switch over all rules of a NT:
  switch ((rule::declarator)N->rule()) {
    case rule::declarator::noptr_declarator:
      ...
  }
In practice we don't do this anywhere yet as we're often switching over multiple
nonterminal kinds at once.

Differential Revision: https://reviews.llvm.org/D130414

Author: sam-mccall

clang-tools-extra/pseudo/gen/Main.cpp

@@ -58,6 +58,50 @@ std::string readOrDie(llvm::StringRef Path) {
 }
 } // namespace
 
+namespace clang {
+namespace pseudo {
+namespace {
+
+// Mangles a symbol name into a valid identifier.
+//
+// These follow names in the grammar fairly closely:
+//   nonterminal: `ptr-declartor` becomes `ptr_declarator`;
+//   punctuator: `,` becomes `COMMA`;
+//   keyword: `INT` becomes `INT`;
+//   terminal: `IDENTIFIER` becomes `IDENTIFIER`;
+std::string mangleSymbol(SymbolID SID, const Grammar &G) {
+  static std::string *TokNames = new std::string[]{
+#define TOK(X) llvm::StringRef(#X).upper(),
+#define KEYWORD(Keyword, Condition) llvm::StringRef(#Keyword).upper(),
+#include "clang/Basic/TokenKinds.def"
+      };
+  if (isToken(SID))
+    return TokNames[symbolToToken(SID)];
+  std::string Name = G.symbolName(SID).str();
+  // translation-unit -> translation_unit
+  std::replace(Name.begin(), Name.end(), '-', '_');
+  return Name;
+}
+
+// Mangles the RHS of a rule definition into a valid identifier.
+// 
+// These are unique only for a fixed LHS.
+// e.g. for the grammar rule `ptr-declarator := ptr-operator ptr-declarator`,
+// it is `ptr_operator__ptr_declarator`.
+std::string mangleRule(RuleID RID, const Grammar &G) {
+  const auto &R = G.lookupRule(RID);
+  std::string MangleName = mangleSymbol(R.seq().front(), G);
+  for (SymbolID S : R.seq().drop_front()) {
+    MangleName.append("__");
+    MangleName.append(mangleSymbol(S, G));
+  }
+  return MangleName;
+}
+
+} // namespace
+} // namespace pseudo
+} // namespace clang
+
 int main(int argc, char *argv[]) {
   llvm::cl::ParseCommandLineOptions(argc, argv, "");
 
@@ -81,21 +125,26 @@ int main(int argc, char *argv[]) {
   case EmitSymbolList:
     Out.os() << R"cpp(
 #ifndef NONTERMINAL
-#define NONTERMINAL(X, Y)
+#define NONTERMINAL(NAME, ID)
 #endif
 #ifndef RULE
-#define RULE(X, Y)
+#define RULE(LHS, RHS, ID)
 #endif
 #ifndef EXTENSION
-#define EXTENSION(X, Y)
+#define EXTENSION(NAME, ID)
 #endif
 )cpp";
     for (clang::pseudo::SymbolID ID = 0; ID < G.table().Nonterminals.size();
-         ++ID)
-      Out.os() << llvm::formatv("NONTERMINAL({0}, {1})\n", G.mangleSymbol(ID),
-                                ID);
-    for (clang::pseudo::RuleID RID = 0; RID < G.table().Rules.size(); ++RID)
-      Out.os() << llvm::formatv("RULE({0}, {1})\n", G.mangleRule(RID), RID);
+         ++ID) {
+      Out.os() << llvm::formatv("NONTERMINAL({0}, {1})\n",
+                                clang::pseudo::mangleSymbol(ID, G), ID);
+      for (const clang::pseudo::Rule &R : G.rulesFor(ID)) {
+        clang::pseudo::RuleID RID = &R - G.table().Rules.data();
+        Out.os() << llvm::formatv("RULE({0}, {1}, {2})\n",
+                                  clang::pseudo::mangleSymbol(R.Target, G),
+                                  clang::pseudo::mangleRule(RID, G), RID);
+      }
+    }
     for (clang::pseudo::ExtensionID EID = 1 /*skip the sentinel 0 value*/;
          EID < G.table().AttributeValues.size(); ++EID) {
       llvm::StringRef Name = G.table().AttributeValues[EID];

clang-tools-extra/pseudo/include/clang-pseudo/cxx/CXX.h

@@ -29,25 +29,56 @@
 namespace clang {
 namespace pseudo {
 namespace cxx {
-// Symbol represents nonterminal symbols in the C++ grammar.
-// It provides a simple uniform way to access a particular nonterminal.
-enum class Symbol : SymbolID {
+
+// We want enums to be scoped but implicitly convertible to RuleID etc.
+// So create regular (unscoped) enums inside subnamespaces of `detail`.
+// Then add aliases for them outside `detail`.
+namespace detail {
+namespace symbols {
+enum Symbol : SymbolID {
 #define NONTERMINAL(X, Y) X = Y,
 #include "CXXSymbols.inc"
 #undef NONTERMINAL
 };
+} // namespace symbols
 
-enum class Rule : RuleID {
-#define RULE(X, Y) X = Y,
+namespace extensions {
+enum Extension : ExtensionID {
+#define EXTENSION(X, Y) X = Y,
 #include "CXXSymbols.inc"
-#undef RULE
+#undef EXTENSION
 };
+} // namespace extensions
 
-enum class Extension : ExtensionID {
-#define EXTENSION(X, Y) X = Y,
+namespace rules {
+// For each symbol we close the last symbol's enum+namespace and open new ones.
+// We need a dummy namespace+enum so that this works for the first rule.
+namespace dummy {
+enum Dummy {
+//clang-format off
+#define NONTERMINAL(NAME, ID) \
+};                            \
+}                             \
+namespace NAME {              \
+enum Rule : RuleID {
+//clang-format on
+#define RULE(LHS, RHS, ID) RHS = ID,
 #include "CXXSymbols.inc"
-#undef EXTENSION
 };
+}
+} // namespace rules
+} // namespace detail
+
+// Symbol represents nonterminal symbols in the C++ grammar.
+// It provides a simple uniform way to access a particular nonterminal.
+using Symbol = detail::symbols::Symbol;
+
+using Extension = detail::extensions::Extension;
+
+namespace rule {
+#define NONTERMINAL(NAME, ID) using NAME = detail::rules::NAME::Rule;
+#include "CXXSymbols.inc"
+} // namespace rule
 
 // Returns the Language for the cxx.bnf grammar.
 const Language &getLanguage();

clang-tools-extra/pseudo/include/clang-pseudo/grammar/Grammar.h

@@ -162,21 +162,6 @@ class Grammar {
   // Terminals have names like "," (kw_comma) or "OPERATOR" (kw_operator).
   llvm::StringRef symbolName(SymbolID) const;
 
-  // Gets the mangled name for a terminal/nonterminal.
-  // Compared to names in the grammar,
-  //   nonterminals `ptr-declartor` becomes `ptr_declarator`;
-  //   terminal `,` becomes `comma`;
-  //   terminal `IDENTIFIER` becomes `identifier`;
-  //   terminal `INT` becomes `int`;
-  // NOTE: for nonterminals, the mangled name is the same as the cxx::Symbol
-  // enum class; for terminals, we deliberately stripped the `kw_` prefix in
-  // favor of the simplicity.
-  std::string mangleSymbol(SymbolID) const;
-  // Gets the mangled name for the rule.
-  // E.g. for the grammar rule `ptr-declarator := ptr-operator ptr-declarator`,
-  // it is `ptr_declarator_0ptr_operator_1ptr_declarator`.
-  std::string mangleRule(RuleID) const;
-
   // Lookup the SymbolID of the nonterminal symbol by Name.
   llvm::Optional<SymbolID> findNonterminal(llvm::StringRef Name) const;