Move things from AttrParserStringSwitches into ParsedAttrInfo

[john.brawn]

Summary

This allows attributes defined by plugins to define those things.

[john.brawn]

Abandoning this old patch

include/clang/Parse/CMakeLists.txt

-clang_tablegen(AttrParserStringSwitches.inc -gen-clang-attr-parser-string-switches
-  -I ${CMAKE_CURRENT_SOURCE_DIR}/../../
-  SOURCE ../Basic/Attr.td
-  TARGET ClangAttrParserStringSwitches)

include/clang/Sema/AttributeList.h

struct ParsedAttrInfo {
   /// True if this attribute is only available for certain targets
   unsigned IsTargetSpecific : 1;
   /// True if this attribute applies to types
   unsigned IsType : 1;
   /// True if this attribute applies to statements
   unsigned IsStmt : 1;
   /// True if this attribute has any spellings that are known to gcc
   unsigned IsKnownToGCC : 1;
+  /// True if the arguments to this attribute should be parsed in an unevaluated
+  /// context
+  unsigned IsUnevaluatedArgContext : 1;
+  // 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) { }
+    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;
   }

lib/Parse/ParseDecl.cpp

if (Range)
     *Range = DeclaratorInfo.getSourceRange();
 
   if (DeclaratorInfo.isInvalidType())
     return true;
 
   return Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
 }
 
-/// isAttributeLateParsed - Return true if the attribute has arguments that
-/// require late parsing.
-static bool isAttributeLateParsed(const IdentifierInfo &II) {
-#define CLANG_ATTR_LATE_PARSED_LIST
-    return llvm::StringSwitch<bool>(II.getName())
-#include "clang/Parse/AttrParserStringSwitches.inc"
-        .Default(false);
-#undef CLANG_ATTR_LATE_PARSED_LIST
-}
-
 /// ParseGNUAttributes - Parse a non-empty attributes list.
 ///
 /// [GNU] attributes:
 ///         attribute
 ///         attributes attribute
 ///
 /// [GNU]  attribute:
 ///          '__attribute__' '(' '(' attribute-list ')' ')'
while (true) {
 
       if (Tok.isNot(tok::l_paren)) {
         attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
                      AttributeList::AS_GNU);
         continue;
       }
 
       // Handle "parameterized" attributes
-      if (!LateAttrs || !isAttributeLateParsed(*AttrName)) {
+      std::unique_ptr<ParsedAttrInfo> Info =
+        AttributeList::getInfo(AttrName, nullptr, AttributeList::AS_GNU);
+      if (!LateAttrs || !Info->IsLateParsed) {
         ParseGNUAttributeArgs(AttrName, AttrNameLoc, attrs, endLoc, nullptr,
                               SourceLocation(), AttributeList::AS_GNU, D);
         continue;
       }
 
       // Handle attributes with arguments that require late parsing.
       LateParsedAttribute *LA =
           new LateParsedAttribute(this, *AttrName, AttrNameLoc);

 
 /// \brief Normalizes an attribute name by dropping prefixed and suffixed __.
 static StringRef normalizeAttrName(StringRef Name) {
   if (Name.size() >= 4 && Name.startswith("__") && Name.endswith("__"))
     Name = Name.drop_front(2).drop_back(2);
   return Name;
 }
 
-/// \brief Determine whether the given attribute has an identifier argument.
-static bool attributeHasIdentifierArg(const IdentifierInfo &II) {
-#define CLANG_ATTR_IDENTIFIER_ARG_LIST
-  return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
-#include "clang/Parse/AttrParserStringSwitches.inc"
-           .Default(false);
-#undef CLANG_ATTR_IDENTIFIER_ARG_LIST
-}
-
-/// \brief Determine whether the given attribute parses a type argument.
-static bool attributeIsTypeArgAttr(const IdentifierInfo &II) {
-#define CLANG_ATTR_TYPE_ARG_LIST
-  return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
-#include "clang/Parse/AttrParserStringSwitches.inc"
-           .Default(false);
-#undef CLANG_ATTR_TYPE_ARG_LIST
-}
-
-/// \brief Determine whether the given attribute requires parsing its arguments
-/// in an unevaluated context or not.
-static bool attributeParsedArgsUnevaluated(const IdentifierInfo &II) {
-#define CLANG_ATTR_ARG_CONTEXT_LIST
-  return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
-#include "clang/Parse/AttrParserStringSwitches.inc"
-           .Default(false);
-#undef CLANG_ATTR_ARG_CONTEXT_LIST
-}
-
 IdentifierLoc *Parser::ParseIdentifierLoc() {
   assert(Tok.is(tok::identifier) && "expected an identifier");
   IdentifierLoc *IL = IdentifierLoc::create(Actions.Context,
                                             Tok.getLocation(),
                                             Tok.getIdentifierInfo());
   ConsumeToken();
   return IL;
 }
unsigned Parser::ParseAttributeArgsCommon(
   ConsumeParen();
 
   std::unique_ptr<ParsedAttrInfo> Info =
       AttributeList::getInfo(AttrName, ScopeName, Syntax);
 
   ArgsVector ArgExprs;
   if (Tok.is(tok::identifier)) {
     // If this attribute wants an 'identifier' argument, make it so.
-    bool IsIdentifierArg = attributeHasIdentifierArg(*AttrName);
+    bool IsIdentifierArg = Info->IsIdentifierArg;
     AttributeList::Kind AttrKind = AttributeList::Kind(Info->AttrKind);
 
     // If we don't know how to parse this attribute, but this is the only
     // token in this argument, assume it's meant to be an identifier.
     if (AttrKind == AttributeList::UnknownAttribute ||
         AttrKind == AttributeList::IgnoredAttribute) {
       const Token &Next = NextToken();
       IsIdentifierArg = Next.isOneOf(tok::r_paren, tok::comma);
     }
 
     if (IsIdentifierArg)
       ArgExprs.push_back(ParseIdentifierLoc());
   }
 
   if (!ArgExprs.empty() ? Tok.is(tok::comma) : Tok.isNot(tok::r_paren)) {
     // Eat the comma.
     if (!ArgExprs.empty())
       ConsumeToken();
 
     // Parse the non-empty comma-separated list of expressions.
     do {
-      bool Uneval = attributeParsedArgsUnevaluated(*AttrName);
+      bool Uneval = Info->IsUnevaluatedArgContext;
       EnterExpressionEvaluationContext Unevaluated(
           Actions, Uneval ? Sema::Unevaluated : Sema::ConstantEvaluated,
           /*LambdaContextDecl=*/nullptr,
           /*IsDecltype=*/false);
 
       ExprResult ArgExpr(
           Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression()));
       if (ArgExpr.isInvalid()) {
void Parser::ParseGNUAttributeArgs(IdentifierInfo *AttrName,
   } else if (AttrKind == AttributeList::AT_ObjCBridgeRelated) {
     ParseObjCBridgeRelatedAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
                                     ScopeName, ScopeLoc, Syntax);
     return;
   } else if (AttrKind == AttributeList::AT_TypeTagForDatatype) {
     ParseTypeTagForDatatypeAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
                                      ScopeName, ScopeLoc, Syntax);
     return;
-  } else if (attributeIsTypeArgAttr(*AttrName)) {
+  } else if (Info->IsTypeArg) {
     ParseAttributeWithTypeArg(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
                               ScopeLoc, Syntax);
     return;
   }
 
   // These may refer to the function arguments, but need to be parsed early to
   // participate in determining whether it's a redeclaration.
   llvm::Optional<ParseScope> PrototypeScope;

utils/TableGen/ClangAttrEmitter.cpp

void WriteSemanticSpellingSwitch(const std::string &VarName,
                                  raw_ostream &OS) {
   OS << "  switch (" << VarName << ") {\n    default: "
     << "llvm_unreachable(\"Unknown spelling list index\");\n";
   for (const auto &I : Map)
     OS << "    case " << I.first << ": return " << I.second << ";\n";
   OS << "  }\n";
 }
 
-// Emits the LateParsed property for attributes.
-static void emitClangAttrLateParsedList(RecordKeeper &Records, raw_ostream &OS) {
-  OS << "#if defined(CLANG_ATTR_LATE_PARSED_LIST)\n";
-  std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
-
-  for (const auto *Attr : Attrs) {
-    bool LateParsed = Attr->getValueAsBit("LateParsed");
-
-    if (LateParsed) {
-      std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Attr);
-
-      // FIXME: Handle non-GNU attributes
-      for (const auto &I : Spellings) {
-        if (I.variety() != "GNU")
-          continue;
-        OS << ".Case(\"" << I.name() << "\", " << LateParsed << ")\n";
-      }
-    }
-  }
-  OS << "#endif // CLANG_ATTR_LATE_PARSED_LIST\n\n";
-}
-
-template <typename Fn>
-static void forEachUniqueSpelling(const Record &Attr, Fn &&F) {
-  std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
-  SmallDenseSet<StringRef, 8> Seen;
-  for (const FlattenedSpelling &S : Spellings) {
-    if (Seen.insert(S.name()).second)
-      F(S);
-  }
-}
-
-/// \brief Emits the first-argument-is-type property for attributes.
-static void emitClangAttrTypeArgList(RecordKeeper &Records, raw_ostream &OS) {
-  OS << "#if defined(CLANG_ATTR_TYPE_ARG_LIST)\n";
-  std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
-
-  for (const auto *Attr : Attrs) {
-    // Determine whether the first argument is a type.
-    std::vector<Record *> Args = Attr->getValueAsListOfDefs("Args");
-    if (Args.empty())
-      continue;
-
-    if (Args[0]->getSuperClasses().back().first->getName() != "TypeArgument")
-      continue;
-
-    // All these spellings take a single type argument.
-    forEachUniqueSpelling(*Attr, [&](const FlattenedSpelling &S) {
-      OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n";
-    });
-  }
-  OS << "#endif // CLANG_ATTR_TYPE_ARG_LIST\n\n";
-}
-
-/// \brief Emits the parse-arguments-in-unevaluated-context property for
-/// attributes.
-static void emitClangAttrArgContextList(RecordKeeper &Records, raw_ostream &OS) {
-  OS << "#if defined(CLANG_ATTR_ARG_CONTEXT_LIST)\n";
-  ParsedAttrMap Attrs = getParsedAttrList(Records);
-  for (const auto &I : Attrs) {
-    const Record &Attr = *I.second;
-
-    if (!Attr.getValueAsBit("ParseArgumentsAsUnevaluated"))
-      continue;
-
-    // All these spellings take are parsed unevaluated.
-    forEachUniqueSpelling(Attr, [&](const FlattenedSpelling &S) {
-      OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n";
-    });
-  }
-  OS << "#endif // CLANG_ATTR_ARG_CONTEXT_LIST\n\n";
-}
-
-static bool isIdentifierArgument(Record *Arg) {
+// Is the first arg of Attr an identifier argument?
+static bool isIdentifierArgument(const Record &Attr) {
+  std::vector<Record*> ArgRecords = Attr.getValueAsListOfDefs("Args");
+  if (ArgRecords.empty())
+    return false;
+  const Record *Arg = ArgRecords[0];
   return !Arg->getSuperClasses().empty() &&
     llvm::StringSwitch<bool>(Arg->getSuperClasses().back().first->getName())
     .Case("IdentifierArgument", true)
     .Case("EnumArgument", true)
     .Case("VariadicEnumArgument", true)
     .Default(false);
 }
 
-// Emits the first-argument-is-identifier property for attributes.
-static void emitClangAttrIdentifierArgList(RecordKeeper &Records, raw_ostream &OS) {
-  OS << "#if defined(CLANG_ATTR_IDENTIFIER_ARG_LIST)\n";
-  std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
-
-  for (const auto *Attr : Attrs) {
-    // Determine whether the first argument is an identifier.
-    std::vector<Record *> Args = Attr->getValueAsListOfDefs("Args");
-    if (Args.empty() || !isIdentifierArgument(Args[0]))
-      continue;
-
-    // All these spellings take an identifier argument.
-    forEachUniqueSpelling(*Attr, [&](const FlattenedSpelling &S) {
-      OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n";
-    });
-  }
-  OS << "#endif // CLANG_ATTR_IDENTIFIER_ARG_LIST\n\n";
+// Is the first arg of Attr a type argument?
+static bool isTypeArgument(const Record &Attr) {
+  std::vector<Record*> ArgRecords = Attr.getValueAsListOfDefs("Args");
+  if (ArgRecords.empty())
+    return false;
+  const Record *Arg = ArgRecords[0];
+  return !Arg->getSuperClasses().empty() &&
+    ArgRecords[0]->getSuperClasses().back().first->getName() == "TypeArgument";
 }
 
 namespace clang {
 
 // Emits the class definitions for attributes.
 void EmitClangAttrClass(RecordKeeper &Records, raw_ostream &OS) {
   emitSourceFileHeader("Attribute classes' definitions", OS);
 
for (const auto &S : Spellings) {
       OS << "    IsTargetSpecific = ";
       OS << Attr.isSubClassOf("TargetSpecificAttr") << ";\n";
       OS << "    IsType = ";
       OS << Attr.isSubClassOf("TypeAttr") << ";\n";
       OS << "    IsStmt = ";
       OS << Attr.isSubClassOf("StmtAttr") << ";\n";
       OS << "    IsKnownToGCC = ";
       OS << IsKnownToGCC(Attr) << ";\n";
+      OS << "    IsUnevaluatedArgContext = ";
+      OS << Attr.getValueAsBit("ParseArgumentsAsUnevaluated") << ";\n";
+      OS << "    IsIdentifierArg = ";
+      OS << isIdentifierArgument(Attr) << ";\n";
+      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;
for (const auto *Attr : Attrs) {
     }
     OS <<
       "    break;\n"
       "  }\n";
   }
   OS << "  }\n";
 }
 
-void EmitClangAttrParserStringSwitches(RecordKeeper &Records,
-                                       raw_ostream &OS) {
-  emitSourceFileHeader("Parser-related llvm::StringSwitch cases", OS);
-  emitClangAttrArgContextList(Records, OS);
-  emitClangAttrIdentifierArgList(Records, OS);
-  emitClangAttrTypeArgList(Records, OS);
-  emitClangAttrLateParsedList(Records, OS);
-}
-
 class DocumentationData {
 public:
   const Record *Documentation;
   const Record *Attribute;
 
   DocumentationData(const Record &Documentation, const Record &Attribute)
       : Documentation(&Documentation), Attribute(&Attribute) {}
 };

utils/TableGen/TableGen.cpp

 #include "llvm/TableGen/Main.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace llvm;
 using namespace clang;
 
 enum ActionType {
   GenClangAttrClasses,
-  GenClangAttrParserStringSwitches,
   GenClangAttrImpl,
   GenClangAttrList,
   GenClangAttrPCHRead,
   GenClangAttrPCHWrite,
   GenClangAttrHasAttributeImpl,
   GenClangAttrSpellingListIndex,
   GenClangAttrASTVisitor,
   GenClangAttrTemplateInstantiate,

 };
 
 namespace {
 cl::opt<ActionType> Action(
     cl::desc("Action to perform:"),
     cl::values(
         clEnumValN(GenClangAttrClasses, "gen-clang-attr-classes",
                    "Generate clang attribute clases"),
-        clEnumValN(GenClangAttrParserStringSwitches,
-                   "gen-clang-attr-parser-string-switches",
-                   "Generate all parser-related attribute string switches"),
         clEnumValN(GenClangAttrImpl, "gen-clang-attr-impl",
                    "Generate clang attribute implementations"),
         clEnumValN(GenClangAttrList, "gen-clang-attr-list",
                    "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"),
ClangComponent("clang-component",
                cl::desc("Only use warnings from specified component"),
                cl::value_desc("component"), cl::Hidden);
 
 bool ClangTableGenMain(raw_ostream &OS, RecordKeeper &Records) {
   switch (Action) {
   case GenClangAttrClasses:
     EmitClangAttrClass(Records, OS);
     break;
-  case GenClangAttrParserStringSwitches:
-    EmitClangAttrParserStringSwitches(Records, OS);
-    break;
   case GenClangAttrImpl:
     EmitClangAttrImpl(Records, OS);
     break;
   case GenClangAttrList:
     EmitClangAttrList(Records, OS);
     break;
   case GenClangAttrPCHRead:
     EmitClangAttrPCHRead(Records, OS);

utils/TableGen/TableGenBackends.h

 using llvm::RecordKeeper;
 
 namespace clang {
 
 void EmitClangDeclContext(RecordKeeper &RK, raw_ostream &OS);
 void EmitClangASTNodes(RecordKeeper &RK, raw_ostream &OS,
                        const std::string &N, const std::string &S);
 
-void EmitClangAttrParserStringSwitches(RecordKeeper &Records, raw_ostream &OS);
 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);