Get rid of SpellingIndexToSemanticSpelling and instead use ParsedAttrInfo

[john.brawn]

Summary

There's no reason to do the lookup at runtime when we know what the result will be when generating the ParsedAttrInfo.

[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 Spelling enum of the corresponding Attr class
+  unsigned SemanticSpelling;
   /// 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()
-  : SpellingListIndex(0), AttrKind(0), Syntax(0), NumArgs(0), OptArgs(0),
-    HasCustomParsing(0), IsTargetSpecific(0), IsType(0), IsStmt(0),
-    IsKnownToGCC(0), IsUnevaluatedArgContext(0), IsIdentifierArg(0),
+  : SpellingListIndex(0), SemanticSpelling(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;
   }
   /// Check if this attribute is allowed by the language we are compiling, and
   /// issue a diagnostic if not
   virtual bool diagLangOpts(Sema &S, const AttributeList &Attr) const {
     return true;
   }
   /// Check if this attribute is allowed when compiling for the given target
   virtual bool existsInTarget(const TargetInfo &Target) const {
     return true;
   }
-  /// Convert the spelling index of Attr to a semantic spelling enum value
-  virtual unsigned
-  spellingIndexToSemanticSpelling(const AttributeList &Attr) const {
-    return UINT_MAX;
-  }
 };
 
 /// AttributeList - Represents a syntactic attribute.
 ///
 /// For a GNU attribute, there are four forms of this construct:
 ///
 /// 1: __attribute__(( const )). ParmName/Args/NumArgs will all be unused.
 /// 2: __attribute__(( mode(byte) )). ParmName used, Args/NumArgs unused.

lib/Sema/AttributeList.cpp

bool AttributeList::existsInTarget(const TargetInfo &Target) const {
   return getInfo()->existsInTarget(Target);
 }
 
 bool AttributeList::isKnownToGCC() const {
   return getInfo()->IsKnownToGCC;
 }
 
 unsigned AttributeList::getSemanticSpelling() const {
-  return getInfo()->spellingIndexToSemanticSpelling(*this);
+  return getInfo()->SemanticSpelling;
 }
 
 bool AttributeList::hasVariadicArg() const {
   // If the attribute has the maximum number of optional arguments, we will
   // claim that as being variadic. If we someday get an attribute that
   // legitimately bumps up against that maximum, we can use another bit to track
   // whether it's truly variadic or not.
   return getInfo()->OptArgs == 15;
 }

utils/TableGen/ClangAttrEmitter.cpp

static void GenerateTargetRequirements(const Record &Attr,
   GenerateTargetSpecificAttrChecks(R, Arches, Test, &FnName);
 
   OS << "  virtual bool existsInTarget(const TargetInfo &Target) const {\n";
   OS << "    const llvm::Triple &T = Target.getTriple();\n";
   OS << "    return " << Test << ";\n";
   OS << "  }\n\n";
 }
 
-static void GenerateSpellingIndexToSemanticSpelling(const Record &Attr,
-                                                    raw_ostream &OS) {
-  // If the attribute does not have a semantic form, we can bail out early.
-  if (!Attr.getValueAsBit("ASTNode"))
-    return;
-
-  std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
-
-  // If there are zero or one spellings, or all of the spellings share the same
-  // name, we can also bail out early.
-  if (Spellings.size() <= 1 || SpellingNamesAreCommon(Spellings))
-    return;
-
-  // Generate the enumeration we will use for the mapping.
-  SemanticSpellingMap SemanticToSyntacticMap;
-  std::string Enum = CreateSemanticSpellings(Spellings, SemanticToSyntacticMap);
-  std::string Name = Attr.getName().str() + "AttrSpellingMap";
-
-  OS << "  virtual unsigned spellingIndexToSemanticSpelling(";
-  OS << "const AttributeList &Attr) const {\n";
-  OS << Enum;
-  OS << "    unsigned Idx = Attr.getAttributeSpellingListIndex();\n";
-  WriteSemanticSpellingSwitch("Idx", SemanticToSyntacticMap, OS);
-  OS << "  }\n\n";
-}
-
 static bool IsKnownToGCC(const Record &Attr) {
   // Look at the spellings for this subject; if there are any spellings which
   // claim to be known to GCC, the attribute is known to GCC.
   return llvm::any_of(
       GetFlattenedSpellings(Attr),
       [](const FlattenedSpelling &S) { return S.knownToGCC(); });
 }
 
for (const auto &I : Attrs) {
     // TODO: If the attribute's kind appears in the list of duplicates, that is
     // because it is a target-specific attribute that appears multiple times.
     // It would be beneficial to test whether the duplicates are "similar
     // enough" to each other to not cause problems. For instance, check that
     // the spellings are identical, and custom parsing rules match, etc.
     const Record &Attr = *I.second;
     const std::string &AttrName = I.first;
     std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
+    SemanticSpellingMap SemanticToSyntacticMap;
+    CreateSemanticSpellings(Spellings, SemanticToSyntacticMap);
     unsigned SpellingIdx = 0;
     for (const auto &S : Spellings) {
       std::string Spelling;
       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 the attribute does not have a semantic form, has at most one
+      // spelling, or all spellings share the same name then it has no semantic
+      // spelling.
+      if (!Attr.getValueAsBit("ASTNode") || Spellings.size() <= 1 ||
+          SpellingNamesAreCommon(Spellings)) {
+        OS << "    SemanticSpelling = UINT_MAX;\n";
+      } else {
+        OS << "    SemanticSpelling = " << Attr.getName() << "Attr::"
+           << SemanticToSyntacticMap[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 = ";
for (const auto &S : Spellings) {
       OS << "    IsTypeArg = ";
       OS << isTypeArgument(Attr) << ";\n";
       OS << "    IsLateParsed = ";
       OS  << Attr.getValueAsBit("LateParsed") << ";\n";
       OS << "  }\n";
       GenerateAppertainsTo(Attr, OS);
       GenerateLangOptRequirements(Attr, OS);
       GenerateTargetRequirements(Attr, Dupes, OS);
-      GenerateSpellingIndexToSemanticSpelling(Attr, OS);
       OS << "};\n";
       OS << "static AttrInfoRegistry::Add<" << AttrInfoName << "> " << AttrInfoName << "Instance(\"" << Spelling << "\",\"\");\n";
       ++SpellingIdx;
     }
   }
 }
 
 // Emits the code to dump an attribute.