[openmp][openacc][NFC] Simplify access and validation of DirectiveBase information

[clementval]

Summary

This patch adds some helper in the DirectiveLanguage wrapper to initialize it from
the RecordKeeper and validate the records. This simplify arguments in lots of function
since only the DirectiveLanguge is passed.

[kiranchandramohan]

LGTM.

llvm/include/llvm/TableGen/DirectiveEmitter.h

 #ifndef LLVM_TABLEGEN_DIRECTIVEEMITTER_H
 #define LLVM_TABLEGEN_DIRECTIVEEMITTER_H
 
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/TableGen/Record.h"
 
 namespace llvm {
 
 // Wrapper class that contains DirectiveLanguage's information defined in
 // DirectiveBase.td and provides helper methods for accessing it.
 class DirectiveLanguage {
 public:
-  explicit DirectiveLanguage(const llvm::Record *Def) : Def(Def) {}
+  explicit DirectiveLanguage(const llvm::RecordKeeper &Records)
+      : Records(Records) {
+    const auto &DirectiveLanguages = getDirectiveLanguages();
+    Def = DirectiveLanguages[0];
+  }
 
   StringRef getName() const { return Def->getValueAsString("name"); }
 
   StringRef getCppNamespace() const {
     return Def->getValueAsString("cppNamespace");
   }
 
   StringRef getDirectivePrefix() const {
public:
   bool hasMakeEnumAvailableInNamespace() const {
     return Def->getValueAsBit("makeEnumAvailableInNamespace");
   }
 
   bool hasEnableBitmaskEnumInNamespace() const {
     return Def->getValueAsBit("enableBitmaskEnumInNamespace");
   }
 
+  const std::vector<Record *> getDirectives() const {
+    return Records.getAllDerivedDefinitions("Directive");
+  }
+
+  const std::vector<Record *> getClauses() const {
+    return Records.getAllDerivedDefinitions("Clause");
+  }
+
+  bool CheckRecordsValidity() const;
+
 private:
   const llvm::Record *Def;
+  const llvm::RecordKeeper &Records;
+
+  const std::vector<Record *> getDirectiveLanguages() const {
+    return Records.getAllDerivedDefinitions("DirectiveLanguage");
+  }
 };
 
 // Base record class used for Directive and Clause class defined in
 // DirectiveBase.td.
 class BaseRecord {
 public:
   explicit BaseRecord(const llvm::Record *Def) : Def(Def) {}
 

llvm/utils/TableGen/DirectiveEmitter.cpp

 };
 } // end anonymous namespace
 
 namespace llvm {
 
 // Generate enum class
 void GenerateEnumClass(const std::vector<Record *> &Records, raw_ostream &OS,
                        StringRef Enum, StringRef Prefix,
-                       DirectiveLanguage &DirLang) {
+                       const DirectiveLanguage &DirLang) {
   OS << "\n";
   OS << "enum class " << Enum << " {\n";
   for (const auto &R : Records) {
     BaseRecord Rec{R};
     OS << "  " << Prefix << Rec.getFormattedName() << ",\n";
   }
   OS << "};\n";
   OS << "\n";
for (const auto &R : Records) {
          << "::" << Prefix << Rec.getFormattedName() << ";\n";
     }
   }
 }
 
 // Generate enums for values that clauses can take.
 // Also generate function declarations for get<Enum>Name(StringRef Str).
 void GenerateEnumClauseVal(const std::vector<Record *> &Records,
-                           raw_ostream &OS, DirectiveLanguage &DirLang,
+                           raw_ostream &OS, const DirectiveLanguage &DirLang,
                            std::string &EnumHelperFuncs) {
   for (const auto &R : Records) {
     Clause C{R};
     const auto &ClauseVals = C.getClauseVals();
     if (ClauseVals.size() <= 0)
       continue;
 
     const auto &EnumName = C.getEnumName();
if (HasDuplicateClauses(Dir.getAllowedClauses(), Dir, Clauses) ||
       return true;
     }
   }
   return false;
 }
 
 // Check consitency of records. Return true if an error has been detected.
 // Return false if the records are valid.
-bool CheckRecordsValidity(RecordKeeper &Records) {
-  const auto &DirectiveLanguages =
-      Records.getAllDerivedDefinitions("DirectiveLanguage");
-
-  if (DirectiveLanguages.size() != 1) {
+bool DirectiveLanguage::CheckRecordsValidity() const {
+  if (getDirectiveLanguages().size() != 1) {
     PrintError("A single definition of DirectiveLanguage is needed.");
     return true;
   }
 
-  const auto &Directives = Records.getAllDerivedDefinitions("Directive");
-  return HasDuplicateClausesInDirectives(Directives);
+  return HasDuplicateClausesInDirectives(getDirectives());
 }
 
 // Generate the declaration section for the enumeration in the directive
 // language
 void EmitDirectivesDecl(RecordKeeper &Records, raw_ostream &OS) {
-
-  if (CheckRecordsValidity(Records))
+  const auto DirLang = DirectiveLanguage{Records};
+  if (DirLang.CheckRecordsValidity())
     return;
 
-  const auto &DirectiveLanguages =
-      Records.getAllDerivedDefinitions("DirectiveLanguage");
-
-  DirectiveLanguage DirLang{DirectiveLanguages[0]};
-  const auto &Directives = Records.getAllDerivedDefinitions("Directive");
-
   OS << "#ifndef LLVM_" << DirLang.getName() << "_INC\n";
   OS << "#define LLVM_" << DirLang.getName() << "_INC\n";
 
   if (DirLang.hasEnableBitmaskEnumInNamespace())
     OS << "\n#include \"llvm/ADT/BitmaskEnum.h\"\n";
 
   OS << "\n";
   OS << "namespace llvm {\n";
   OS << "class StringRef;\n";
 
   // Open namespaces defined in the directive language
   llvm::SmallVector<StringRef, 2> Namespaces;
   llvm::SplitString(DirLang.getCppNamespace(), Namespaces, "::");
   for (auto Ns : Namespaces)
     OS << "namespace " << Ns << " {\n";
 
   if (DirLang.hasEnableBitmaskEnumInNamespace())
     OS << "\nLLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();\n";
 
   // Emit Directive enumeration
-  GenerateEnumClass(Directives, OS, "Directive", DirLang.getDirectivePrefix(),
-                    DirLang);
+  GenerateEnumClass(DirLang.getDirectives(), OS, "Directive",
+                    DirLang.getDirectivePrefix(), DirLang);
 
   // Emit Clause enumeration
-  const auto &Clauses = Records.getAllDerivedDefinitions("Clause");
-  GenerateEnumClass(Clauses, OS, "Clause", DirLang.getClausePrefix(), DirLang);
+  GenerateEnumClass(DirLang.getClauses(), OS, "Clause",
+                    DirLang.getClausePrefix(), DirLang);
 
   // Emit ClauseVal enumeration
   std::string EnumHelperFuncs;
-  GenerateEnumClauseVal(Clauses, OS, DirLang, EnumHelperFuncs);
+  GenerateEnumClauseVal(DirLang.getClauses(), OS, DirLang, EnumHelperFuncs);
 
   // Generic function signatures
   OS << "\n";
   OS << "// Enumeration helper functions\n";
   OS << "Directive get" << DirLang.getName()
      << "DirectiveKind(llvm::StringRef Str);\n";
   OS << "\n";
   OS << "llvm::StringRef get" << DirLang.getName()
void EmitDirectivesDecl(RecordKeeper &Records, raw_ostream &OS) {
 
   OS << "} // namespace llvm\n";
 
   OS << "#endif // LLVM_" << DirLang.getName() << "_INC\n";
 }
 
 // Generate function implementation for get<Enum>Name(StringRef Str)
 void GenerateGetName(const std::vector<Record *> &Records, raw_ostream &OS,
-                     StringRef Enum, DirectiveLanguage &DirLang,
+                     StringRef Enum, const DirectiveLanguage &DirLang,
                      StringRef Prefix) {
   OS << "\n";
   OS << "llvm::StringRef llvm::" << DirLang.getCppNamespace() << "::get"
      << DirLang.getName() << Enum << "Name(" << Enum << " Kind) {\n";
   OS << "  switch (Kind) {\n";
   for (const auto &R : Records) {
     BaseRecord Rec{R};
     OS << "    case " << Prefix << Rec.getFormattedName() << ":\n";
     OS << "      return \"";
     if (Rec.getAlternativeName().empty())
       OS << Rec.getName();
     else
       OS << Rec.getAlternativeName();
     OS << "\";\n";
   }
   OS << "  }\n"; // switch
   OS << "  llvm_unreachable(\"Invalid " << DirLang.getName() << " " << Enum
      << " kind\");\n";
   OS << "}\n";
 }
 
 // Generate function implementation for get<Enum>Kind(StringRef Str)
 void GenerateGetKind(const std::vector<Record *> &Records, raw_ostream &OS,
-                     StringRef Enum, DirectiveLanguage &DirLang,
+                     StringRef Enum, const DirectiveLanguage &DirLang,
                      StringRef Prefix, bool ImplicitAsUnknown) {
 
   auto DefaultIt = std::find_if(Records.begin(), Records.end(), [](Record *R) {
     return R->getValueAsBit("isDefault") == true;
   });
 
   if (DefaultIt == Records.end()) {
     PrintError("At least one " + Enum + " must be defined as default.");
if (ImplicitAsUnknown && R->getValueAsBit("isImplicit")) {
          << Rec.getFormattedName() << ")\n";
     }
   }
   OS << "    .Default(" << Prefix << DefaultRec.getFormattedName() << ");\n";
   OS << "}\n";
 }
 
 // Generate function implementation for get<ClauseVal>Kind(StringRef Str)
-void GenerateGetKindClauseVal(const std::vector<Record *> &Records,
-                              raw_ostream &OS, StringRef Namespace) {
-
-  for (const auto &R : Records) {
+void GenerateGetKindClauseVal(const DirectiveLanguage &DirLang,
+                              raw_ostream &OS) {
+  for (const auto &R : DirLang.getClauses()) {
     Clause C{R};
     const auto &ClauseVals = C.getClauseVals();
     if (ClauseVals.size() <= 0)
       continue;
 
     auto DefaultIt =
         std::find_if(ClauseVals.begin(), ClauseVals.end(), [](Record *CV) {
           return CV->getValueAsBit("isDefault") == true;
for (const auto &R : DirLang.getClauses()) {
     const auto &EnumName = C.getEnumName();
     if (EnumName.size() == 0) {
       PrintError("enumClauseValue field not set in Clause" +
                  C.getFormattedName() + ".");
       return;
     }
 
     OS << "\n";
-    OS << EnumName << " llvm::" << Namespace << "::get" << EnumName
-       << "(llvm::StringRef Str) {\n";
+    OS << EnumName << " llvm::" << DirLang.getCppNamespace() << "::get"
+       << EnumName << "(llvm::StringRef Str) {\n";
     OS << "  return llvm::StringSwitch<" << EnumName << ">(Str)\n";
     for (const auto &CV : ClauseVals) {
       ClauseVal CVal{CV};
       OS << "    .Case(\"" << CVal.getFormattedName() << "\"," << CV->getName()
          << ")\n";
     }
     OS << "    .Default(" << DefaultName << ");\n";
     OS << "}\n";
   }
 }
 
 void GenerateCaseForVersionedClauses(const std::vector<Record *> &Clauses,
                                      raw_ostream &OS, StringRef DirectiveName,
-                                     DirectiveLanguage &DirLang,
+                                     const DirectiveLanguage &DirLang,
                                      llvm::StringSet<> &Cases) {
   for (const auto &C : Clauses) {
     VersionedClause VerClause{C};
 
     const auto ClauseFormattedName = VerClause.getClause().getFormattedName();
 
     if (Cases.find(ClauseFormattedName) == Cases.end()) {
       Cases.insert(ClauseFormattedName);
       OS << "        case " << DirLang.getClausePrefix() << ClauseFormattedName
          << ":\n";
       OS << "          return " << VerClause.getMinVersion()
          << " <= Version && " << VerClause.getMaxVersion() << " >= Version;\n";
     }
   }
 }
 
 // Generate the isAllowedClauseForDirective function implementation.
-void GenerateIsAllowedClause(const std::vector<Record *> &Directives,
-                             raw_ostream &OS, DirectiveLanguage &DirLang) {
+void GenerateIsAllowedClause(const DirectiveLanguage &DirLang,
+                             raw_ostream &OS) {
   OS << "\n";
   OS << "bool llvm::" << DirLang.getCppNamespace()
      << "::isAllowedClauseForDirective("
      << "Directive D, Clause C, unsigned Version) {\n";
   OS << "  assert(unsigned(D) <= llvm::" << DirLang.getCppNamespace()
      << "::Directive_enumSize);\n";
   OS << "  assert(unsigned(C) <= llvm::" << DirLang.getCppNamespace()
      << "::Clause_enumSize);\n";
 
   OS << "  switch (D) {\n";
 
-  for (const auto &D : Directives) {
+  for (const auto &D : DirLang.getDirectives()) {
     Directive Dir{D};
 
     OS << "    case " << DirLang.getDirectivePrefix() << Dir.getFormattedName()
        << ":\n";
     if (Dir.getAllowedClauses().size() == 0 &&
         Dir.getAllowedOnceClauses().size() == 0 &&
         Dir.getAllowedExclusiveClauses().size() == 0 &&
         Dir.getRequiredClauses().size() == 0) {
void GenerateIsAllowedClause(const DirectiveLanguage &DirLang,
   OS << "  llvm_unreachable(\"Invalid " << DirLang.getName()
      << " Directive kind\");\n";
   OS << "}\n"; // End of function isAllowedClauseForDirective
 }
 
 // Generate a simple enum set with the give clauses.
 void GenerateClauseSet(const std::vector<Record *> &Clauses, raw_ostream &OS,
                        StringRef ClauseSetPrefix, Directive &Dir,
-                       DirectiveLanguage &DirLang) {
+                       const DirectiveLanguage &DirLang) {
 
   OS << "\n";
   OS << "  static " << DirLang.getClauseEnumSetClass() << " " << ClauseSetPrefix
      << DirLang.getDirectivePrefix() << Dir.getFormattedName() << " {\n";
 
   for (const auto &C : Clauses) {
     VersionedClause VerClause{C};
     OS << "    llvm::" << DirLang.getCppNamespace()
        << "::Clause::" << DirLang.getClausePrefix()
        << VerClause.getClause().getFormattedName() << ",\n";
   }
   OS << "  };\n";
 }
 
 // Generate an enum set for the 4 kinds of clauses linked to a directive.
-void GenerateDirectiveClauseSets(const std::vector<Record *> &Directives,
-                                 raw_ostream &OS, DirectiveLanguage &DirLang) {
+void GenerateDirectiveClauseSets(const DirectiveLanguage &DirLang,
+                                 raw_ostream &OS) {
 
   IfDefScope Scope("GEN_FLANG_DIRECTIVE_CLAUSE_SETS", OS);
 
   OS << "\n";
   OS << "namespace llvm {\n";
 
   // Open namespaces defined in the directive language.
   llvm::SmallVector<StringRef, 2> Namespaces;
   llvm::SplitString(DirLang.getCppNamespace(), Namespaces, "::");
   for (auto Ns : Namespaces)
     OS << "namespace " << Ns << " {\n";
 
-  for (const auto &D : Directives) {
+  for (const auto &D : DirLang.getDirectives()) {
     Directive Dir{D};
 
     OS << "\n";
     OS << "  // Sets for " << Dir.getName() << "\n";
 
     GenerateClauseSet(Dir.getAllowedClauses(), OS, "allowedClauses_", Dir,
                       DirLang);
     GenerateClauseSet(Dir.getAllowedOnceClauses(), OS, "allowedOnceClauses_",
for (auto Ns : llvm::reverse(Namespaces))
     OS << "} // namespace " << Ns << "\n";
 
   OS << "} // namespace llvm\n";
 }
 
 // Generate a map of directive (key) with DirectiveClauses struct as values.
 // The struct holds the 4 sets of enumeration for the 4 kinds of clauses
 // allowances (allowed, allowed once, allowed exclusive and required).
-void GenerateDirectiveClauseMap(const std::vector<Record *> &Directives,
-                                raw_ostream &OS, DirectiveLanguage &DirLang) {
+void GenerateDirectiveClauseMap(const DirectiveLanguage &DirLang,
+                                raw_ostream &OS) {
 
   IfDefScope Scope("GEN_FLANG_DIRECTIVE_CLAUSE_MAP", OS);
 
   OS << "\n";
   OS << "{\n";
 
-  for (const auto &D : Directives) {
+  for (const auto &D : DirLang.getDirectives()) {
     Directive Dir{D};
     OS << "  {llvm::" << DirLang.getCppNamespace()
        << "::Directive::" << DirLang.getDirectivePrefix()
        << Dir.getFormattedName() << ",\n";
     OS << "    {\n";
     OS << "      llvm::" << DirLang.getCppNamespace() << "::allowedClauses_"
        << DirLang.getDirectivePrefix() << Dir.getFormattedName() << ",\n";
     OS << "      llvm::" << DirLang.getCppNamespace() << "::allowedOnceClauses_"
void GenerateDirectiveClauseMap(const DirectiveLanguage &DirLang,
   OS << "}\n";
 }
 
 // Generate classes entry for Flang clauses in the Flang parse-tree
 // If the clause as a non-generic class, no entry is generated.
 // If the clause does not hold a value, an EMPTY_CLASS is used.
 // If the clause class is generic then a WRAPPER_CLASS is used. When the value
 // is optional, the value class is wrapped into a std::optional.
-void GenerateFlangClauseParserClass(const std::vector<Record *> &Clauses,
+void GenerateFlangClauseParserClass(const DirectiveLanguage &DirLang,
                                     raw_ostream &OS) {
 
   IfDefScope Scope("GEN_FLANG_CLAUSE_PARSER_CLASSES", OS);
 
   OS << "\n";
 
-  for (const auto &C : Clauses) {
+  for (const auto &C : DirLang.getClauses()) {
     Clause Clause{C};
     // Clause has a non generic class.
     if (!Clause.getFlangClass().empty())
       continue;
     if (!Clause.getFlangClassValue().empty()) {
       OS << "WRAPPER_CLASS(" << Clause.getFormattedParserClassName() << ", ";
       if (Clause.isValueOptional() && Clause.isValueList()) {
         OS << "std::optional<std::list<" << Clause.getFlangClassValue()
            << ">>";
       } else if (Clause.isValueOptional()) {
         OS << "std::optional<" << Clause.getFlangClassValue() << ">";
       } else if (Clause.isValueList()) {
         OS << "std::list<" << Clause.getFlangClassValue() << ">";
       } else {
         OS << Clause.getFlangClassValue();
       }
     } else {
       OS << "EMPTY_CLASS(" << Clause.getFormattedParserClassName();
     }
     OS << ");\n";
   }
 }
 
 // Generate a list of the different clause classes for Flang.
-void GenerateFlangClauseParserClassList(const std::vector<Record *> &Clauses,
+void GenerateFlangClauseParserClassList(const DirectiveLanguage &DirLang,
                                         raw_ostream &OS) {
 
   IfDefScope Scope("GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST", OS);
 
   OS << "\n";
-  llvm::interleaveComma(Clauses, OS, [&](Record *C) {
+  llvm::interleaveComma(DirLang.getClauses(), OS, [&](Record *C) {
     Clause Clause{C};
     if (Clause.getFlangClass().empty())
       OS << Clause.getFormattedParserClassName() << "\n";
     else
       OS << Clause.getFlangClass() << "\n";
   });
 }
 
 // Generate dump node list for the clauses holding a generic class name.
-void GenerateFlangClauseDump(const std::vector<Record *> &Clauses,
-                             const DirectiveLanguage &DirLang,
+void GenerateFlangClauseDump(const DirectiveLanguage &DirLang,
                              raw_ostream &OS) {
 
   IfDefScope Scope("GEN_FLANG_DUMP_PARSE_TREE_CLAUSES", OS);
 
   OS << "\n";
-  for (const auto &C : Clauses) {
+  for (const auto &C : DirLang.getClauses()) {
     Clause Clause{C};
     // Clause has a non generic class.
     if (!Clause.getFlangClass().empty())
       continue;
 
     OS << "NODE(" << DirLang.getFlangClauseBaseClass() << ", "
        << Clause.getFormattedParserClassName() << ")\n";
   }
 }
 
 // Generate Unparse functions for clauses classes in the Flang parse-tree
 // If the clause is a non-generic class, no entry is generated.
-void GenerateFlangClauseUnparse(const std::vector<Record *> &Clauses,
-                                const DirectiveLanguage &DirLang,
+void GenerateFlangClauseUnparse(const DirectiveLanguage &DirLang,
                                 raw_ostream &OS) {
 
   IfDefScope Scope("GEN_FLANG_CLAUSE_UNPARSE", OS);
 
   OS << "\n";
 
-  for (const auto &C : Clauses) {
+  for (const auto &C : DirLang.getClauses()) {
     Clause Clause{C};
     // Clause has a non generic class.
     if (!Clause.getFlangClass().empty())
       continue;
     if (!Clause.getFlangClassValue().empty()) {
       if (Clause.isValueOptional() && Clause.getDefaultValue().empty()) {
         OS << "void Unparse(const " << DirLang.getFlangClauseBaseClass()
            << "::" << Clause.getFormattedParserClassName() << " &x) {\n";
if (!Clause.getFlangClassValue().empty()) {
          << "::" << Clause.getFormattedParserClassName() << " &) { Word(\""
          << Clause.getName().upper() << "\"); }\n";
     }
   }
 }
 
 // Generate the implemenation section for the enumeration in the directive
 // language
-void EmitDirectivesFlangImpl(const std::vector<Record *> &Directives,
-                             const std::vector<Record *> &Clauses,
-                             raw_ostream &OS,
-                             DirectiveLanguage &DirectiveLanguage) {
+void EmitDirectivesFlangImpl(const DirectiveLanguage &DirLang,
+                             raw_ostream &OS) {
 
-  GenerateDirectiveClauseSets(Directives, OS, DirectiveLanguage);
+  GenerateDirectiveClauseSets(DirLang, OS);
 
-  GenerateDirectiveClauseMap(Directives, OS, DirectiveLanguage);
+  GenerateDirectiveClauseMap(DirLang, OS);
 
-  GenerateFlangClauseParserClass(Clauses, OS);
+  GenerateFlangClauseParserClass(DirLang, OS);
 
-  GenerateFlangClauseParserClassList(Clauses, OS);
+  GenerateFlangClauseParserClassList(DirLang, OS);
 
-  GenerateFlangClauseDump(Clauses, DirectiveLanguage, OS);
+  GenerateFlangClauseDump(DirLang, OS);
 
-  GenerateFlangClauseUnparse(Clauses, DirectiveLanguage, OS);
+  GenerateFlangClauseUnparse(DirLang, OS);
 }
 
 // Generate the implemenation section for the enumeration in the directive
 // language.
 void EmitDirectivesGen(RecordKeeper &Records, raw_ostream &OS) {
-  if (CheckRecordsValidity(Records))
+  const auto DirLang = DirectiveLanguage{Records};
+  if (DirLang.CheckRecordsValidity())
     return;
 
-  const auto &DirectiveLanguages =
-      Records.getAllDerivedDefinitions("DirectiveLanguage");
-  const auto &Directives = Records.getAllDerivedDefinitions("Directive");
-  const auto &Clauses = Records.getAllDerivedDefinitions("Clause");
-  DirectiveLanguage DirectiveLanguage{DirectiveLanguages[0]};
-  EmitDirectivesFlangImpl(Directives, Clauses, OS, DirectiveLanguage);
+  EmitDirectivesFlangImpl(DirLang, OS);
 }
 
 // Generate the implemenation for the enumeration in the directive
 // language. This code can be included in library.
 void EmitDirectivesImpl(RecordKeeper &Records, raw_ostream &OS) {
-  if (CheckRecordsValidity(Records))
+  const auto DirLang = DirectiveLanguage{Records};
+  if (DirLang.CheckRecordsValidity())
     return;
 
-  const auto &DirectiveLanguages =
-      Records.getAllDerivedDefinitions("DirectiveLanguage");
-  const auto &Directives = Records.getAllDerivedDefinitions("Directive");
-  DirectiveLanguage DirLang = DirectiveLanguage{DirectiveLanguages[0]};
-
-  const auto &Clauses = Records.getAllDerivedDefinitions("Clause");
-
   if (!DirLang.getIncludeHeader().empty())
     OS << "#include \"" << DirLang.getIncludeHeader() << "\"\n\n";
 
   OS << "#include \"llvm/ADT/StringRef.h\"\n";
   OS << "#include \"llvm/ADT/StringSwitch.h\"\n";
   OS << "#include \"llvm/Support/ErrorHandling.h\"\n";
   OS << "\n";
   OS << "using namespace llvm;\n";
   llvm::SmallVector<StringRef, 2> Namespaces;
   llvm::SplitString(DirLang.getCppNamespace(), Namespaces, "::");
   for (auto Ns : Namespaces)
     OS << "using namespace " << Ns << ";\n";
 
   // getDirectiveKind(StringRef Str)
-  GenerateGetKind(Directives, OS, "Directive", DirLang,
+  GenerateGetKind(DirLang.getDirectives(), OS, "Directive", DirLang,
                   DirLang.getDirectivePrefix(), /*ImplicitAsUnknown=*/false);
 
   // getDirectiveName(Directive Kind)
-  GenerateGetName(Directives, OS, "Directive", DirLang,
+  GenerateGetName(DirLang.getDirectives(), OS, "Directive", DirLang,
                   DirLang.getDirectivePrefix());
 
   // getClauseKind(StringRef Str)
-  GenerateGetKind(Clauses, OS, "Clause", DirLang, DirLang.getClausePrefix(),
+  GenerateGetKind(DirLang.getClauses(), OS, "Clause", DirLang,
+                  DirLang.getClausePrefix(),
                   /*ImplicitAsUnknown=*/true);
 
   // getClauseName(Clause Kind)
-  GenerateGetName(Clauses, OS, "Clause", DirLang, DirLang.getClausePrefix());
+  GenerateGetName(DirLang.getClauses(), OS, "Clause", DirLang,
+                  DirLang.getClausePrefix());
 
   // get<ClauseVal>Kind(StringRef Str)
-  GenerateGetKindClauseVal(Clauses, OS, DirLang.getCppNamespace());
+  GenerateGetKindClauseVal(DirLang, OS);
 
   // isAllowedClauseForDirective(Directive D, Clause C, unsigned Version)
-  GenerateIsAllowedClause(Directives, OS, DirLang);
+  GenerateIsAllowedClause(DirLang, OS);
 }
 
 } // namespace llvm