Get rid of AttrSpellingListIndex.inc and instead put the index in ParsedAttrInfo

[john.brawn]

Summary

We already know the spelling index so this is overall simpler.

[john.brawn]

Abandoning this old patch.

include/clang/Sema/AttributeList.h

 };
 
 /// \brief A union of the various pointer types that can be passed to an
 /// AttributeList as an argument.
 typedef llvm::PointerUnion<Expr*, IdentifierLoc*> ArgsUnion;
 typedef llvm::SmallVector<ArgsUnion, 12U> ArgsVector;
 
 struct ParsedAttrInfo {
+  /// Which spelling of the attribute this ParsedAttrInfo corresponds to
+  unsigned SpellingListIndex;
   /// Corresponds to the AttributeList::Kind enum
   unsigned AttrKind : 16;
   /// Corresponds to the AttributeList::Syntax enum
   unsigned Syntax : 3;
   /// The number of required arguments of this attribute
   unsigned NumArgs : 4;
   /// The number of optional arguments of this attributes
   unsigned OptArgs : 4;
struct ParsedAttrInfo {
   // True if the first argument to the attribute is an identifier
   unsigned IsIdentifierArg : 1;
   // True if the first argument to the attribute is a type argument
   unsigned IsTypeArg : 1;
   /// True if this attribute has arguments that require late parsing
   unsigned IsLateParsed : 1;
 
   ParsedAttrInfo()
-  : AttrKind(0), Syntax(0), NumArgs(0), OptArgs(0), HasCustomParsing(0),
-    IsTargetSpecific(0), IsType(0), IsStmt(0), IsKnownToGCC(0),
-    IsUnevaluatedArgContext(0), IsIdentifierArg(0), IsTypeArg(0),
-    IsLateParsed(0) { }
+  : SpellingListIndex(0), AttrKind(0), Syntax(0), NumArgs(0), OptArgs(0),
+    HasCustomParsing(0), IsTargetSpecific(0), IsType(0), IsStmt(0),
+    IsKnownToGCC(0), IsUnevaluatedArgContext(0), IsIdentifierArg(0),
+    IsTypeArg(0), IsLateParsed(0) { }
 
   virtual ~ParsedAttrInfo() {}
 
   /// Check if this attribute appertains to D, and issue a diagnostic if not
   virtual bool diagAppertainsToDecl(Sema &S, const AttributeList &Attr,
                                     const Decl *D) const {
     return true;
   }

include/clang/Sema/CMakeLists.txt

 clang_tablegen(AttrTemplateInstantiate.inc -gen-clang-attr-template-instantiate
   -I ${CMAKE_CURRENT_SOURCE_DIR}/../../
   SOURCE ../Basic/Attr.td
   TARGET ClangAttrTemplateInstantiate)
   
 clang_tablegen(AttrParsedAttrList.inc -gen-clang-attr-parsed-attr-list
   -I ${CMAKE_CURRENT_SOURCE_DIR}/../../
   SOURCE ../Basic/Attr.td
   TARGET ClangAttrParsedAttrList)
 
-clang_tablegen(AttrSpellingListIndex.inc -gen-clang-attr-spelling-index
-  -I ${CMAKE_CURRENT_SOURCE_DIR}/../../
-  SOURCE ../Basic/Attr.td
-  TARGET ClangAttrSpellingListIndex)
-
 clang_tablegen(AttrParsedAttrImpl.inc -gen-clang-attr-parsed-attr-impl
   -I ${CMAKE_CURRENT_SOURCE_DIR}/../../
   SOURCE ../Basic/Attr.td
   TARGET ClangAttrParsedAttrImpl)

lib/Sema/AttributeList.cpp

AttributeList::getInfo(const IdentifierInfo *Name,
 
   // If we failed to find a match then the attribute is unknown
   std::unique_ptr<ParsedAttrInfo> ret = llvm::make_unique<ParsedAttrInfo>();
   ret->AttrKind = AttributeList::UnknownAttribute;
   return ret;
 }
 
 unsigned AttributeList::getAttributeSpellingListIndex() const {
-  // Both variables will be used in tablegen generated
-  // attribute spell list index matching code.
-  StringRef Scope = ScopeName ? ScopeName->getName() : "";
-  StringRef Name = normalizeAttrName(AttrName->getName(), Scope,
-                                     (AttributeList::Syntax)SyntaxUsed);
-  Kind AttrKind = Kind(getInfo()->AttrKind);
-
-#include "clang/Sema/AttrSpellingListIndex.inc"
-
+  return getInfo()->SpellingListIndex;
 }
 
 unsigned AttributeList::getMinArgs() const {
   return getInfo()->NumArgs;
 }
 
 unsigned AttributeList::getMaxArgs() const {
   return getMinArgs() + getInfo()->OptArgs;

utils/TableGen/ClangAttrEmitter.cpp

for (auto I = CXX.cbegin(), E = CXX.cend(); I != E; ++I) {
     OS << "  return llvm::StringSwitch<int>(Name)\n";
     GenerateHasAttrSpellingStringSwitch(I->second, OS, "CXX11", I->first);
     OS << "}";
   }
   OS << "\n}\n";
   OS << "}\n";
 }
 
-void EmitClangAttrSpellingListIndex(RecordKeeper &Records, raw_ostream &OS) {
-  emitSourceFileHeader("Code to translate different attribute spellings "
-                       "into internal identifiers", OS);
-
-  OS << "  switch (AttrKind) {\n";
-
-  ParsedAttrMap Attrs = getParsedAttrList(Records);
-  for (const auto &I : Attrs) {
-    const Record &R = *I.second;
-    std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
-    OS << "  case AT_" << I.first << ": {\n";
-    for (unsigned I = 0; I < Spellings.size(); ++ I) {
-      OS << "    if (Name == \"" << Spellings[I].name() << "\" && "
-         << "SyntaxUsed == "
-         << StringSwitch<unsigned>(Spellings[I].variety())
-                .Case("GNU", 0)
-                .Case("CXX11", 1)
-                .Case("Declspec", 2)
-                .Case("Microsoft", 3)
-                .Case("Keyword", 4)
-                .Case("Pragma", 5)
-                .Default(0)
-         << " && Scope == \"" << Spellings[I].nameSpace() << "\")\n"
-         << "        return " << I << ";\n";
-    }
-
-    OS << "    break;\n";
-    OS << "  }\n";
-  }
-
-  OS << "  }\n";
-  OS << "  return 0;\n";
-}
-
 // Emits code used by RecursiveASTVisitor to visit attributes
 void EmitClangAttrASTVisitor(RecordKeeper &Records, raw_ostream &OS) {
   emitSourceFileHeader("Used by RecursiveASTVisitor to visit attributes.", OS);
 
   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
 
   // Write method declarations for Traverse* methods.
   // We emit this here because we only generate methods for attributes that
for (const auto &S : Spellings) {
       if (S.variety() == "CXX11") {
         Spelling += S.nameSpace();
         Spelling += "::";
       }
       Spelling += (S.variety() == "GNU" ? NormalizeGNUAttrSpelling(S.name()) : StringRef(S.name()));
       std::string AttrInfoName = "AttrInfo" + std::to_string(SpellingIdx) + AttrName;
       OS << "struct " << AttrInfoName << " : public ParsedAttrInfo {\n";
       OS << "  " << AttrInfoName << "() {\n";
+      OS << "    SpellingListIndex = " << SpellingIdx << ";\n";
       if (Attr.getValueAsBit("Ignored")) {
         OS << "    AttrKind = AttributeList::IgnoredAttribute;\n";
       } else {
         OS << "    AttrKind = AttributeList::AT_" << AttrName << ";\n";
       }
       OS << "    Syntax = AttributeList::AS_" << S.variety() << ";\n";
       emitArgInfo(Attr, OS);
       OS << "    HasCustomParsing = ";

utils/TableGen/TableGen.cpp

 
 enum ActionType {
   GenClangAttrClasses,
   GenClangAttrImpl,
   GenClangAttrList,
   GenClangAttrPCHRead,
   GenClangAttrPCHWrite,
   GenClangAttrHasAttributeImpl,
-  GenClangAttrSpellingListIndex,
   GenClangAttrASTVisitor,
   GenClangAttrTemplateInstantiate,
   GenClangAttrParsedAttrList,
   GenClangAttrParsedAttrImpl,
   GenClangAttrDump,
   GenClangDiagsDefs,
   GenClangDiagGroups,
   GenClangDiagsIndexName,
cl::values(
                    "Generate a clang attribute list"),
         clEnumValN(GenClangAttrPCHRead, "gen-clang-attr-pch-read",
                    "Generate clang PCH attribute reader"),
         clEnumValN(GenClangAttrPCHWrite, "gen-clang-attr-pch-write",
                    "Generate clang PCH attribute writer"),
         clEnumValN(GenClangAttrHasAttributeImpl,
                    "gen-clang-attr-has-attribute-impl",
                    "Generate a clang attribute spelling list"),
-        clEnumValN(GenClangAttrSpellingListIndex,
-                   "gen-clang-attr-spelling-index",
-                   "Generate a clang attribute spelling index"),
         clEnumValN(GenClangAttrASTVisitor,
                    "gen-clang-attr-ast-visitor",
                    "Generate a recursive AST visitor for clang attributes"),
         clEnumValN(GenClangAttrTemplateInstantiate,
                    "gen-clang-attr-template-instantiate",
                    "Generate a clang template instantiate code"),
         clEnumValN(GenClangAttrParsedAttrList,
                    "gen-clang-attr-parsed-attr-list",
case GenClangAttrPCHRead:
     EmitClangAttrPCHRead(Records, OS);
     break;
   case GenClangAttrPCHWrite:
     EmitClangAttrPCHWrite(Records, OS);
     break;
   case GenClangAttrHasAttributeImpl:
     EmitClangAttrHasAttrImpl(Records, OS);
     break;
-  case GenClangAttrSpellingListIndex:
-    EmitClangAttrSpellingListIndex(Records, OS);
-    break;
   case GenClangAttrASTVisitor:
     EmitClangAttrASTVisitor(Records, OS);
     break;
   case GenClangAttrTemplateInstantiate:
     EmitClangAttrTemplateInstantiate(Records, OS);
     break;
   case GenClangAttrParsedAttrList:
     EmitClangAttrParsedAttrList(Records, OS);

utils/TableGen/TableGenBackends.h

void EmitClangASTNodes(RecordKeeper &RK, raw_ostream &OS,
                        const std::string &N, const std::string &S);
 
 void EmitClangAttrClass(RecordKeeper &Records, raw_ostream &OS);
 void EmitClangAttrImpl(RecordKeeper &Records, raw_ostream &OS);
 void EmitClangAttrList(RecordKeeper &Records, raw_ostream &OS);
 void EmitClangAttrPCHRead(RecordKeeper &Records, raw_ostream &OS);
 void EmitClangAttrPCHWrite(RecordKeeper &Records, raw_ostream &OS);
 void EmitClangAttrHasAttrImpl(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangAttrSpellingListIndex(RecordKeeper &Records, raw_ostream &OS);
 void EmitClangAttrASTVisitor(RecordKeeper &Records, raw_ostream &OS);
 void EmitClangAttrTemplateInstantiate(RecordKeeper &Records, raw_ostream &OS);
 void EmitClangAttrParsedAttrList(RecordKeeper &Records, raw_ostream &OS);
 void EmitClangAttrParsedAttrImpl(RecordKeeper &Records, raw_ostream &OS);
 void EmitClangAttrDump(RecordKeeper &Records, raw_ostream &OS);
 
 void EmitClangDiagsDefs(RecordKeeper &Records, raw_ostream &OS,
                         const std::string &Component);