[TableGen] Move generated *Attr class methods out of line

[rnk]

Summary

After this change, clang spends ~200ms parsing Attrs.inc instead of
~560ms. A large part of the cost was from the StringSwitch
instantiations, but this is a good way to avoid similar problems in the
future.

[rjmccall]

Are there any classes of methods which are worth continuing to generate inline? Surely some of the accessors are trivial.

[rnk]

The main things going out of line are:

• Create* factory methods
• Constructors
• Enum/string converters (use StringSwitch -> slow to instantiate)

Here's two examples from before & after:
https://reviews.llvm.org/P8203
https://reviews.llvm.org/P8204

The constructors and factory methods *could* be trivial, but some of them are quite complex.

clang/utils/TableGen/ClangAttrEmitter.cpp

269

Most trivial accessors are still defined inline, like here. I think there's only one override of writeAccesorDefinitions.

[rjmccall]

Okay, thanks. LGTM.

[aaron.ballman]

LGTM as well, though please run clang-format over the patch (some of the formatting looks to have gone weird in places).

[rnk]

In D76040#1919170, @aaron.ballman wrote:

LGTM as well, though please run clang-format over the patch (some of the formatting looks to have gone weird in places).

Thanks, done. I undid some of its more questionable reformattings in writeCtorBody where the original formatting more clearly shows the generated code.

clang/utils/TableGen/ClangAttrEmitter.cpp

class SimpleArgument : public Argument {
     std::string type;
 
   public:
     SimpleArgument(const Record &Arg, StringRef Attr, std::string T)
         : Argument(Arg, Attr), type(std::move(T)) {}
 
     std::string getType() const { return type; }
 
     void writeAccessors(raw_ostream &OS) const override {
       OS << "  " << type << " get" << getUpperName() << "() const {\n";
       OS << "    return " << getLowerName() << ";\n";
       OS << "  }";
     }
 
     void writeCloneArgs(raw_ostream &OS) const override {
       OS << getLowerName();
     }
void writeCloneArgs(raw_ostream &OS) const override {
       OS << "get" << getUpperName() << "()";
     }
 
     void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
       OS << "A->get" << getUpperName() << "()";
     }
 
     void writeCtorBody(raw_ostream &OS) const override {
-      OS << "      if (!" << getUpperName() << ".empty())\n";
-      OS << "        std::memcpy(" << getLowerName() << ", " << getUpperName()
+      OS << "    if (!" << getUpperName() << ".empty())\n";
+      OS << "      std::memcpy(" << getLowerName() << ", " << getUpperName()
          << ".data(), " << getLowerName() << "Length);\n";
     }
 
     void writeCtorInitializers(raw_ostream &OS) const override {
       OS << getLowerName() << "Length(" << getUpperName() << ".size()),"
          << getLowerName() << "(new (Ctx, 1) char[" << getLowerName()
          << "Length])";
     }
void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
          << "A->" << getLowerName() << "_size()";
     }
 
     void writeASTVisitorTraversal(raw_ostream &OS) const override {
       // FIXME: Traverse the elements.
     }
 
     void writeCtorBody(raw_ostream &OS) const override {
-      OS << "    std::copy(" << getUpperName() << ", " << getUpperName()
-         << " + " << ArgSizeName << ", " << ArgName << ");\n";
+      OS << "  std::copy(" << getUpperName() << ", " << getUpperName() << " + "
+         << ArgSizeName << ", " << ArgName << ");\n";
     }
 
     void writeCtorInitializers(raw_ostream &OS) const override {
       OS << ArgSizeName << "(" << getUpperName() << "Size), "
          << ArgName << "(new (Ctx, 16) " << getType() << "["
          << ArgSizeName << "])";
     }
 
void writeDump(raw_ostream &OS) const override {
       for (const auto &I : uniques) {
         OS << "    case " << getAttrName() << "Attr::" << I << ":\n";
         OS << "      OS << \" " << I << "\";\n";
         OS << "      break;\n";
       }
       OS << "    }\n";
     }
 
-    void writeConversion(raw_ostream &OS) const {
-      OS << "  static bool ConvertStrTo" << type << "(StringRef Val, ";
-      OS << type << " &Out) {\n";
-      OS << "    Optional<" << type << "> R = llvm::StringSwitch<Optional<";
+    void writeConversion(raw_ostream &OS, bool Header) const {
+      if (Header) {
+        OS << "  static bool ConvertStrTo" << type << "(StringRef Val, " << type
+           << " &Out);\n";
+        OS << "  static const char *Convert" << type << "ToStr(" << type
+           << " Val);\n";
+        return;
+      }
+
+      OS << "bool " << getAttrName() << "Attr::ConvertStrTo" << type
+         << "(StringRef Val, " << type << " &Out) {\n";
+      OS << "  Optional<" << type << "> R = llvm::StringSwitch<Optional<";
       OS << type << ">>(Val)\n";
       for (size_t I = 0; I < enums.size(); ++I) {
-        OS << "      .Case(\"" << values[I] << "\", ";
+        OS << "    .Case(\"" << values[I] << "\", ";
         OS << getAttrName() << "Attr::" << enums[I] << ")\n";
       }
-      OS << "      .Default(Optional<" << type << ">());\n";
-      OS << "    if (R) {\n";
-      OS << "      Out = *R;\n      return true;\n    }\n";
-      OS << "    return false;\n";
-      OS << "  }\n\n";
+      OS << "    .Default(Optional<" << type << ">());\n";
+      OS << "  if (R) {\n";
+      OS << "    Out = *R;\n      return true;\n    }\n";
+      OS << "  return false;\n";
+      OS << "}\n\n";
 
       // Mapping from enumeration values back to enumeration strings isn't
       // trivial because some enumeration values have multiple named
       // enumerators, such as type_visibility(internal) and
       // type_visibility(hidden) both mapping to TypeVisibilityAttr::Hidden.
-      OS << "  static const char *Convert" << type << "ToStr("
-         << type << " Val) {\n"
-         << "    switch(Val) {\n";
+      OS << "const char *" << getAttrName() << "Attr::Convert" << type
+         << "ToStr(" << type << " Val) {\n"
+         << "  switch(Val) {\n";
       SmallDenseSet<StringRef, 8> Uniques;
       for (size_t I = 0; I < enums.size(); ++I) {
         if (Uniques.insert(enums[I]).second)
-          OS << "    case " << getAttrName() << "Attr::" << enums[I]
+          OS << "  case " << getAttrName() << "Attr::" << enums[I]
              << ": return \"" << values[I] << "\";\n";
       }
-      OS << "    }\n"
-         << "    llvm_unreachable(\"No enumerator with that value\");\n"
-         << "  }\n";
+      OS << "  }\n"
+         << "  llvm_unreachable(\"No enumerator with that value\");\n"
+         << "}\n";
     }
   };
 
   class VariadicEnumArgument: public VariadicArgument {
     std::string type, QualifiedTypeName;
     std::vector<StringRef> values, enums, uniques;
 
   protected:
public:
     void writePCHWrite(raw_ostream &OS) const override {
       OS << "    Record.push_back(SA->" << getLowerName() << "_size());\n";
       OS << "    for (" << getAttrName() << "Attr::" << getLowerName()
          << "_iterator i = SA->" << getLowerName() << "_begin(), e = SA->"
          << getLowerName() << "_end(); i != e; ++i)\n";
       OS << "      " << WritePCHRecord(QualifiedTypeName, "(*i)");
     }
 
-    void writeConversion(raw_ostream &OS) const {
-      OS << "  static bool ConvertStrTo" << type << "(StringRef Val, ";
+    void writeConversion(raw_ostream &OS, bool Header) const {
+      if (Header) {
+        OS << "  static bool ConvertStrTo" << type << "(StringRef Val, " << type
+           << " &Out);\n";
+        OS << "  static const char *Convert" << type << "ToStr(" << type
+           << " Val);\n";
+        return;
+      }
+
+      OS << "bool " << getAttrName() << "Attr::ConvertStrTo" << type
+         << "(StringRef Val, ";
       OS << type << " &Out) {\n";
-      OS << "    Optional<" << type << "> R = llvm::StringSwitch<Optional<";
+      OS << "  Optional<" << type << "> R = llvm::StringSwitch<Optional<";
       OS << type << ">>(Val)\n";
       for (size_t I = 0; I < enums.size(); ++I) {
-        OS << "      .Case(\"" << values[I] << "\", ";
+        OS << "    .Case(\"" << values[I] << "\", ";
         OS << getAttrName() << "Attr::" << enums[I] << ")\n";
       }
-      OS << "      .Default(Optional<" << type << ">());\n";
-      OS << "    if (R) {\n";
-      OS << "      Out = *R;\n      return true;\n    }\n";
-      OS << "    return false;\n";
-      OS << "  }\n\n";
+      OS << "    .Default(Optional<" << type << ">());\n";
+      OS << "  if (R) {\n";
+      OS << "    Out = *R;\n      return true;\n    }\n";
+      OS << "  return false;\n";
+      OS << "}\n\n";
 
-      OS << "  static const char *Convert" << type << "ToStr("
-        << type << " Val) {\n"
-        << "    switch(Val) {\n";
+      OS << "const char *" << getAttrName() << "Attr::Convert" << type
+         << "ToStr(" << type << " Val) {\n"
+         << "  switch(Val) {\n";
       SmallDenseSet<StringRef, 8> Uniques;
       for (size_t I = 0; I < enums.size(); ++I) {
         if (Uniques.insert(enums[I]).second)
-          OS << "    case " << getAttrName() << "Attr::" << enums[I]
+          OS << "  case " << getAttrName() << "Attr::" << enums[I]
              << ": return \"" << values[I] << "\";\n";
       }
-      OS << "    }\n"
-        << "    llvm_unreachable(\"No enumerator with that value\");\n"
-        << "  }\n";
+      OS << "  }\n"
+         << "  llvm_unreachable(\"No enumerator with that value\");\n"
+         << "}\n";
     }
   };
 
   class VersionArgument : public Argument {
   public:
     VersionArgument(const Record &Arg, StringRef Attr)
       : Argument(Arg, Attr)
     {}

 
   class VariadicStringArgument : public VariadicArgument {
   public:
     VariadicStringArgument(const Record &Arg, StringRef Attr)
       : VariadicArgument(Arg, Attr, "StringRef")
     {}
 
     void writeCtorBody(raw_ostream &OS) const override {
-      OS << "    for (size_t I = 0, E = " << getArgSizeName() << "; I != E;\n"
-            "         ++I) {\n"
-            "      StringRef Ref = " << getUpperName() << "[I];\n"
-            "      if (!Ref.empty()) {\n"
-            "        char *Mem = new (Ctx, 1) char[Ref.size()];\n"
-            "        std::memcpy(Mem, Ref.data(), Ref.size());\n"
-            "        " << getArgName() << "[I] = StringRef(Mem, Ref.size());\n"
-            "      }\n"
-            "    }\n";
+      OS << "  for (size_t I = 0, E = " << getArgSizeName() << "; I != E;\n"
+            "       ++I) {\n"
+            "    StringRef Ref = " << getUpperName() << "[I];\n"
+            "    if (!Ref.empty()) {\n"
+            "      char *Mem = new (Ctx, 1) char[Ref.size()];\n"
+            "      std::memcpy(Mem, Ref.data(), Ref.size());\n"
+            "      " << getArgName() << "[I] = StringRef(Mem, Ref.size());\n"
+            "    }\n"
+            "  }\n";
     }
 
     void writeValueImpl(raw_ostream &OS) const override {
       OS << "    OS << \"\\\"\" << Val << \"\\\"\";\n";
     }
   };
 
   class TypeArgument : public SimpleArgument {
static void writeDeprecatedAttrValue(raw_ostream &OS, std::string &Variety) {
   OS << "\\\"\" << getMessage() << \"\\\"\";\n";
   // Only GNU deprecated has an optional fixit argument at the second position.
   if (Variety == "GNU")
      OS << "    if (!getReplacement().empty()) OS << \", \\\"\""
            " << getReplacement() << \"\\\"\";\n";
   OS << "    OS << \"";
 }
 
-static void writeGetSpellingFunction(Record &R, raw_ostream &OS) {
+static void writeGetSpellingFunction(const Record &R, raw_ostream &OS) {
   std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
 
   OS << "const char *" << R.getName() << "Attr::getSpelling() const {\n";
   if (Spellings.empty()) {
     OS << "  return \"(No spelling)\";\n}\n\n";
     return;
   }
 
   OS << "  switch (getAttributeSpellingListIndex()) {\n"
         "  default:\n"
         "    llvm_unreachable(\"Unknown attribute spelling!\");\n"
         "    return \"(No spelling)\";\n";
 
   for (unsigned I = 0; I < Spellings.size(); ++I)
     OS << "  case " << I << ":\n"
           "    return \"" << Spellings[I].name() << "\";\n";
   // End of the switch statement.
   OS << "  }\n";
   // End of the getSpelling function.
   OS << "}\n\n";
 }
 
 static void
-writePrettyPrintFunction(Record &R,
+writePrettyPrintFunction(const Record &R,
                          const std::vector<std::unique_ptr<Argument>> &Args,
                          raw_ostream &OS) {
   std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
 
   OS << "void " << R.getName() << "Attr::printPretty("
     << "raw_ostream &OS, const PrintingPolicy &Policy) const {\n";
 
   if (Spellings.empty()) {
forEachUniqueSpelling(*A, [&](const FlattenedSpelling &S) {
       OS << ".Case(\"" << S.name() << "\", "
          << "true"
          << ")\n";
     });
   }
   OS << "#endif // CLANG_ATTR_THIS_ISA_IDENTIFIER_ARG_LIST\n\n";
 }
 
-// Emits the class definitions for attributes.
-void clang::EmitClangAttrClass(RecordKeeper &Records, raw_ostream &OS) {
-  emitSourceFileHeader("Attribute classes' definitions", OS);
-
-  OS << "#ifndef LLVM_CLANG_ATTR_CLASSES_INC\n";
-  OS << "#define LLVM_CLANG_ATTR_CLASSES_INC\n\n";
-
+static void emitAttributes(RecordKeeper &Records, raw_ostream &OS,
+                           bool Header) {
   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
   ParsedAttrMap AttrMap = getParsedAttrList(Records);
 
   for (const auto *Attr : Attrs) {
     const Record &R = *Attr;
 
     // FIXME: Currently, documentation is generated as-needed due to the fact
     // that there is no way to allow a generated project "reach into" the docs
for (const auto &Super : llvm::reverse(Supers)) {
       const Record *R = Super.first;
       if (R->getName() != "TargetSpecificAttr" &&
           R->getName() != "DeclOrTypeAttr" && SuperName.empty())
         SuperName = std::string(R->getName());
       if (R->getName() == "InheritableAttr")
         Inheritable = true;
     }
 
+    if (Header)
       OS << "class " << R.getName() << "Attr : public " << SuperName << " {\n";
+    else
+      OS << "\n// " << R.getName() << "Attr implementation\n\n";
 
     std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
     std::vector<std::unique_ptr<Argument>> Args;
     Args.reserve(ArgRecords.size());
 
     bool HasOptArg = false;
     bool HasFakeArg = false;
     for (const auto *ArgRecord : ArgRecords) {
       Args.emplace_back(createArgument(*ArgRecord, R.getName()));
+      if (Header) {
         Args.back()->writeDeclarations(OS);
         OS << "\n\n";
+      }
 
       // For these purposes, fake takes priority over optional.
       if (Args.back()->isFake()) {
         HasFakeArg = true;
       } else if (Args.back()->isOptional()) {
         HasOptArg = true;
       }
     }
 
+    if (Header)
       OS << "public:\n";
 
     std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
 
     // If there are zero or one spellings, all spelling-related functionality
     // can be elided. If all of the spellings share the same name, the spelling
     // functionality can also be elided.
     bool ElideSpelling = (Spellings.size() <= 1) ||
                          SpellingNamesAreCommon(Spellings);
 
     // This maps spelling index values to semantic Spelling enumerants.
     SemanticSpellingMap SemanticToSyntacticMap;
 
+    std::string SpellingEnum;
     if (!ElideSpelling)
-      OS << CreateSemanticSpellings(Spellings, SemanticToSyntacticMap);
+      SpellingEnum = CreateSemanticSpellings(Spellings, SemanticToSyntacticMap);
+    if (Header)
+      OS << SpellingEnum;
 
     const auto &ParsedAttrSpellingItr = llvm::find_if(
         AttrMap, [R](const std::pair<std::string, const Record *> &P) {
           return &R == P.second;
         });
 
     // Emit CreateImplicit factory methods.
     auto emitCreate = [&](bool Implicit, bool emitFake) {
-      OS << "  static " << R.getName() << "Attr *Create";
-        if (Implicit)
-          OS << "Implicit";
+      if (Header)
+        OS << "  static ";
+      OS << R.getName() << "Attr *";
+      if (!Header)
+        OS << R.getName() << "Attr::";
+      OS << "Create";
       OS << "(";
       OS << "ASTContext &Ctx";
       for (auto const &ai : Args) {
         if (ai->isFake() && !emitFake) continue;
         OS << ", ";
         ai->writeCtorParameters(OS);
       }
-      OS << ", const AttributeCommonInfo &CommonInfo = {SourceRange{}}) {\n";
-      OS << "    auto *A = new (Ctx) " << R.getName();
+      OS << ", const AttributeCommonInfo &CommonInfo";
+      if (Header)
+        OS << " = {SourceRange{}}";
+      OS << ")";
+      if (Header) {
+        OS << ";\n";
+        return;
+      }
+
+      OS << " {\n";
+      OS << "  auto *A = new (Ctx) " << R.getName();
       OS << "Attr(Ctx, CommonInfo";
       for (auto const &ai : Args) {
         if (ai->isFake() && !emitFake) continue;
         OS << ", ";
         ai->writeImplicitCtorArgs(OS);
       }
       OS << ");\n";
       if (Implicit) {
-        OS << "    A->setImplicit(true);\n";
+        OS << "  A->setImplicit(true);\n";
       }
       if (Implicit || ElideSpelling) {
-        OS << "    if (!A->isAttributeSpellingListCalculated() && "
+        OS << "  if (!A->isAttributeSpellingListCalculated() && "
               "!A->getAttrName())\n";
-        OS << "      A->setAttributeSpellingListIndex(0);\n";
+        OS << "    A->setAttributeSpellingListIndex(0);\n";
       }
-      OS << "    return A;\n  }\n\n";
+      OS << "  return A;\n}\n\n";
     };
 
     auto emitCreateNoCI = [&](bool Implicit, bool emitFake) {
-      OS <<"  static " << R.getName() << "Attr *Create";
+      if (Header)
+        OS << "  static ";
+      OS << R.getName() << "Attr *";
+      if (!Header)
+        OS << R.getName() << "Attr::";
+      OS << "Create";
       if (Implicit)
         OS << "Implicit";
       OS << "(";
       OS << "ASTContext &Ctx";
       for (auto const &ai : Args) {
         if (ai->isFake() && !emitFake) continue;
         OS << ", ";
         ai->writeCtorParameters(OS);
       }
       OS << ", SourceRange Range, AttributeCommonInfo::Syntax Syntax";
-      if (!ElideSpelling)
-        OS << ", " << R.getName()
-           << "Attr::Spelling S = "
-              "static_cast<Spelling>(SpellingNotCalculated)";
-      OS << ") {\n";
-      OS << "    AttributeCommonInfo I(Range, ";
+      if (!ElideSpelling) {
+        OS << ", " << R.getName() << "Attr::Spelling S";
+        if (Header)
+          OS << " = static_cast<Spelling>(SpellingNotCalculated)";
+      }
+      OS << ")";
+      if (Header) {
+        OS << ";\n";
+        return;
+      }
+
+      OS << " {\n";
+      OS << "  AttributeCommonInfo I(Range, ";
 
       if (ParsedAttrSpellingItr != std::end(AttrMap))
         OS << "AT_" << ParsedAttrSpellingItr->first;
       else
         OS << "NoSemaHandlerAttribute";
 
       OS << ", Syntax";
       if (!ElideSpelling)
         OS << ", S";
       OS << ");\n";
-      OS << "    return Create";
+      OS << "  return Create";
       if (Implicit)
         OS << "Implicit";
       OS << "(Ctx";
       for (auto const &ai : Args) {
         if (ai->isFake() && !emitFake) continue;
         OS << ", ";
         ai->writeImplicitCtorArgs(OS);
       }
       OS << ", I);\n";
-      OS << "  }\n";
+      OS << "}\n\n";
     };
 
     auto emitCreates = [&](bool emitFake) {
       emitCreate(true, emitFake);
       emitCreate(false, emitFake);
       emitCreateNoCI(true, emitFake);
       emitCreateNoCI(false, emitFake);
     };
 
+    if (Header)
+      OS << "  // Factory methods\n";
+
     // Emit a CreateImplicit that takes all the arguments.
     emitCreates(true);
 
     // Emit a CreateImplicit that takes all the non-fake arguments.
     if (HasFakeArg)
       emitCreates(false);
 
     // Emit constructors.
     auto emitCtor = [&](bool emitOpt, bool emitFake) {
       auto shouldEmitArg = [=](const std::unique_ptr<Argument> &arg) {
         if (arg->isFake()) return emitFake;
         if (arg->isOptional()) return emitOpt;
         return true;
       };
-      OS << "  " << R.getName()
+      if (Header)
+        OS << "  ";
+      else
+        OS << R.getName() << "Attr::";
+      OS << R.getName()
          << "Attr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo";
       OS << '\n';
       for (auto const &ai : Args) {
         if (!shouldEmitArg(ai)) continue;
         OS << "              , ";
         ai->writeCtorParameters(OS);
         OS << "\n";
       }
 
-      OS << "             )\n";
-      OS << "    : " << SuperName << "(Ctx, CommonInfo, ";
+      OS << "             )";
+      if (Header) {
+        OS << ";\n";
+        return;
+      }
+      OS << "\n  : " << SuperName << "(Ctx, CommonInfo, ";
       OS << "attr::" << R.getName() << ", "
          << (R.getValueAsBit("LateParsed") ? "true" : "false");
       if (Inheritable) {
         OS << ", "
            << (R.getValueAsBit("InheritEvenIfAlreadyPresent") ? "true"
                                                               : "false");
       }
       OS << ")\n";
auto emitCtor = [&](bool emitOpt, bool emitFake) {
       }
 
       OS << "  {\n";
 
       for (auto const &ai : Args) {
         if (!shouldEmitArg(ai)) continue;
         ai->writeCtorBody(OS);
       }
-      OS << "  }\n\n";
+      OS << "}\n\n";
     };
 
+    if (Header)
+      OS << "\n  // Constructors\n";
+
     // Emit a constructor that includes all the arguments.
     // This is necessary for cloning.
     emitCtor(true, true);
 
     // Emit a constructor that takes all the non-fake arguments.
     if (HasFakeArg)
       emitCtor(true, false);
 
     // Emit a constructor that takes all the non-fake, non-optional arguments.
     if (HasOptArg)
       emitCtor(false, false);
 
+    if (Header) {
+      OS << '\n';
       OS << "  " << R.getName() << "Attr *clone(ASTContext &C) const;\n";
       OS << "  void printPretty(raw_ostream &OS,\n"
          << "                   const PrintingPolicy &Policy) const;\n";
       OS << "  const char *getSpelling() const;\n";
+    }
 
     if (!ElideSpelling) {
       assert(!SemanticToSyntacticMap.empty() && "Empty semantic mapping list");
-      OS << "  Spelling getSemanticSpelling() const {\n";
+      if (Header)
+        OS << "  Spelling getSemanticSpelling() const;\n";
+      else {
+        OS << R.getName() << "Attr::Spelling " << R.getName()
+           << "Attr::getSemanticSpelling() const {\n";
         WriteSemanticSpellingSwitch("getAttributeSpellingListIndex()",
                                     SemanticToSyntacticMap, OS);
-      OS << "  }\n";
+        OS << "}\n";
       }
+    }
 
+    if (Header)
       writeAttrAccessorDefinition(R, OS);
 
     for (auto const &ai : Args) {
+      if (Header) {
         ai->writeAccessors(OS);
+      } else {
+        ai->writeAccessorDefinitions(OS);
+      }
       OS << "\n\n";
 
       // Don't write conversion routines for fake arguments.
       if (ai->isFake()) continue;
 
       if (ai->isEnumArg())
-        static_cast<const EnumArgument *>(ai.get())->writeConversion(OS);
+        static_cast<const EnumArgument *>(ai.get())->writeConversion(OS,
+                                                                     Header);
       else if (ai->isVariadicEnumArg())
-        static_cast<const VariadicEnumArgument *>(ai.get())
-            ->writeConversion(OS);
+        static_cast<const VariadicEnumArgument *>(ai.get())->writeConversion(
+            OS, Header);
     }
 
+    if (Header) {
       OS << R.getValueAsString("AdditionalMembers");
       OS << "\n\n";
 
       OS << "  static bool classof(const Attr *A) { return A->getKind() == "
          << "attr::" << R.getName() << "; }\n";
 
       OS << "};\n\n";
-  }
-
-  OS << "#endif // LLVM_CLANG_ATTR_CLASSES_INC\n";
-}
-
-// Emits the class method definitions for attributes.
-void clang::EmitClangAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
-  emitSourceFileHeader("Attribute classes' member function definitions", OS);
-
-  std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
-
-  for (auto *Attr : Attrs) {
-    Record &R = *Attr;
-
-    if (!R.getValueAsBit("ASTNode"))
-      continue;
-
-    std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
-    std::vector<std::unique_ptr<Argument>> Args;
-    for (const auto *Arg : ArgRecords)
-      Args.emplace_back(createArgument(*Arg, R.getName()));
-
-    for (auto const &ai : Args)
-      ai->writeAccessorDefinitions(OS);
-
+    } else {
       OS << R.getName() << "Attr *" << R.getName()
          << "Attr::clone(ASTContext &C) const {\n";
       OS << "  auto *A = new (C) " << R.getName() << "Attr(C, *this";
       for (auto const &ai : Args) {
         OS << ", ";
         ai->writeCloneArgs(OS);
       }
       OS << ");\n";
       OS << "  A->Inherited = Inherited;\n";
       OS << "  A->IsPackExpansion = IsPackExpansion;\n";
       OS << "  A->setImplicit(Implicit);\n";
       OS << "  return A;\n}\n\n";
 
       writePrettyPrintFunction(R, Args, OS);
       writeGetSpellingFunction(R, OS);
     }
+  }
+}
+// Emits the class definitions for attributes.
+void clang::EmitClangAttrClass(RecordKeeper &Records, raw_ostream &OS) {
+  emitSourceFileHeader("Attribute classes' definitions", OS);
+
+  OS << "#ifndef LLVM_CLANG_ATTR_CLASSES_INC\n";
+  OS << "#define LLVM_CLANG_ATTR_CLASSES_INC\n\n";
+
+  emitAttributes(Records, OS, true);
+
+  OS << "#endif // LLVM_CLANG_ATTR_CLASSES_INC\n";
+}
+
+// Emits the class method definitions for attributes.
+void clang::EmitClangAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
+  emitSourceFileHeader("Attribute classes' member function definitions", OS);
+
+  emitAttributes(Records, OS, false);
+
+  std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
 
   // Instead of relying on virtual dispatch we just create a huge dispatch
   // switch. This is both smaller and faster than virtual functions.
   auto EmitFunc = [&](const char *Method) {
     OS << "  switch (getKind()) {\n";
     for (const auto *Attr : Attrs) {
       const Record &R = *Attr;
       if (!R.getValueAsBit("ASTNode"))