More refactorings

Author: Prabhuk

llvm/include/llvm/Option/ArgList.h

@@ -283,7 +283,7 @@ class ArgList {
 
   /// getSubcommand - Find subcommand from the arguments if the usage is valid.
   ///
-  /// \param Commands - A list of all valid subcommands.
+  /// \param AllSubCommands - A list of all valid subcommands.
   /// \param HandleMultipleSubcommands - A callback for the case where multiple
   /// subcommands are present in the arguments. It gets a list of all found
   /// subcommands.

llvm/include/llvm/Option/OptTable.h

@@ -87,7 +87,7 @@ class LLVM_ABI OptTable {
     unsigned short AliasID;
     const char *AliasArgs;
     const char *Values;
-    unsigned CommandIDsOffset;
+    unsigned SubCommandIDsOffset;
 
     bool hasNoPrefix() const { return PrefixesOffset == 0; }
 
@@ -103,17 +103,17 @@ class LLVM_ABI OptTable {
                                                  getNumPrefixes(PrefixesTable));
     }
 
-    bool hasCommands() const { return CommandIDsOffset != 0; }
+    bool hasCommands() const { return SubCommandIDsOffset != 0; }
 
     unsigned getNumCommandIDs(ArrayRef<unsigned> SubCommandIDsTable) const {
-      // We embed the number of command IDs in the value of the first offset.
-      return SubCommandIDsTable[CommandIDsOffset];
+      // We embed the number of subcommand IDs in the value of the first offset.
+      return SubCommandIDsTable[SubCommandIDsOffset];
     }
 
     ArrayRef<unsigned>
     getCommandIDs(ArrayRef<unsigned> SubCommandIDsTable) const {
       return hasCommands() ? SubCommandIDsTable.slice(
-                                 CommandIDsOffset + 1,
+                                 SubCommandIDsOffset + 1,
                                  getNumCommandIDs(SubCommandIDsTable))
                            : ArrayRef<unsigned>();
     }
@@ -159,10 +159,10 @@ class LLVM_ABI OptTable {
 
   bool IgnoreCase;
 
-  /// The command information table.
+  /// The subcommand information table.
   ArrayRef<SubCommand> SubCommands;
 
-  /// The command IDs table.
+  /// The subcommand IDs table.
   ArrayRef<unsigned> SubCommandIDsTable;
 
   bool GroupedShortOptions = false;
@@ -466,7 +466,7 @@ class GenericOptTable : public OptTable {
   LLVM_ABI GenericOptTable(const StringTable &StrTable,
                            ArrayRef<StringTable::Offset> PrefixesTable,
                            ArrayRef<Info> OptionInfos, bool IgnoreCase = false,
-                           ArrayRef<SubCommand> Commands = {},
+                           ArrayRef<SubCommand> SubCommands = {},
                            ArrayRef<unsigned> SubCommandIDsTable = {});
 };
 

llvm/lib/Option/OptTable.cpp

@@ -776,12 +776,11 @@ void OptTable::internalPrintHelp(
   }
 
   auto DoesOptionBelongToSubcommand = [&](const Info &CandidateInfo) {
-    // llvm::outs() << CandidateInfo.
-    ArrayRef<unsigned> CommandIDs =
+    ArrayRef<unsigned> SubCommandIDs =
         CandidateInfo.getCommandIDs(SubCommandIDsTable);
 
-    // Options with no commands are global.
-    if (CommandIDs.empty()) {
+    // Options with no subcommands are global.
+    if (SubCommandIDs.empty()) {
       // if Subcommand is not empty then don't print global options.
       return Subcommand.empty();
     }
@@ -790,12 +789,12 @@ void OptTable::internalPrintHelp(
     if (Subcommand.empty())
       return false;
 
-    // The command ID is its index in the Commands table.
-    unsigned ActiveCommandID = ActiveSubCommand - &SubCommands[0];
+    // The subcommand ID is its index in the SubCommands table.
+    unsigned ActiveSubCommandID = ActiveSubCommand - &SubCommands[0];
 
     // Check if the option belongs to the active subcommand.
-    for (unsigned ID : CommandIDs) {
-      if (ID == ActiveCommandID) {
+    for (unsigned ID : SubCommandIDs) {
+      if (ID == ActiveSubCommandID) {
         return true;
       }
     }
@@ -846,9 +845,9 @@ void OptTable::internalPrintHelp(
 GenericOptTable::GenericOptTable(const StringTable &StrTable,
                                  ArrayRef<StringTable::Offset> PrefixesTable,
                                  ArrayRef<Info> OptionInfos, bool IgnoreCase,
-                                 ArrayRef<SubCommand> Commands,
+                                 ArrayRef<SubCommand> SubCommands,
                                  ArrayRef<unsigned> SubCommandIDsTable)
-    : OptTable(StrTable, PrefixesTable, OptionInfos, IgnoreCase, Commands,
+    : OptTable(StrTable, PrefixesTable, OptionInfos, IgnoreCase, SubCommands,
                SubCommandIDsTable) {
 
   std::set<StringRef> TmpPrefixesUnion;

llvm/utils/TableGen/OptionParserEmitter.cpp

@@ -285,10 +285,10 @@ static void emitOptionParser(const RecordKeeper &Records, raw_ostream &OS) {
     if (R.getValue("SubCommands") != nullptr) {
       std::vector<const Record *> SubCommands =
           R.getValueAsListOfDefs("SubCommands");
-      SubCommandKeyT CommandKey;
+      SubCommandKeyT SubCommandKey;
       for (const auto &SubCommand : SubCommands)
-        CommandKey.push_back(SubCommand->getName());
-      OS << SubCommandIDs[CommandKey];
+        SubCommandKey.push_back(SubCommand->getName());
+      OS << SubCommandIDs[SubCommandKey];
     } else {
       // The option SubCommandIDsOffset (for default top level toolname is 0).
       OS << " 0";
@@ -299,10 +299,10 @@ static void emitOptionParser(const RecordKeeper &Records, raw_ostream &OS) {
   for (const Record &R : llvm::make_pointee_range(Opts)) {
     std::vector<const Record *> RSubCommands =
         R.getValueAsListOfDefs("SubCommands");
-    SubCommandKeyT CommandKey;
+    SubCommandKeyT SubCommandKey;
     for (const auto &SubCommand : RSubCommands)
-      CommandKey.push_back(SubCommand->getName());
-    SubCommandIDs.try_emplace(CommandKey, 0);
+      SubCommandKey.push_back(SubCommand->getName());
+    SubCommandIDs.try_emplace(SubCommandKey, 0);
   }
 
   DenseSet<StringRef> PrefixesUnionSet;
@@ -357,34 +357,35 @@ static void emitOptionParser(const RecordKeeper &Records, raw_ostream &OS) {
   OS << "\n};\n";
   OS << "#endif // OPTTABLE_PREFIXES_TABLE_CODE\n\n";
 
-  // Dump command IDs.
+  // Dump subcommand IDs.
   OS << "/////////";
-  OS << "// Command IDs\n\n";
+  OS << "// SubCommand IDs\n\n";
   OS << "#ifdef OPTTABLE_SUBCOMMAND_IDS_TABLE_CODE\n";
   OS << "static constexpr unsigned OptionSubCommandIDsTable[] = {\n";
   {
-    // Ensure the first command set is always empty.
+    // Ensure the first subcommand set is always empty.
     assert(!SubCommandIDs.empty() &&
-           "We should always emit an empty set of commands");
+           "We should always emit an empty set of subcommands");
     assert(SubCommandIDs.begin()->first.empty() &&
-           "First command set should always be empty");
+           "First subcommand set should always be empty");
     llvm::ListSeparator Sep(",\n");
     unsigned CurIndex = 0;
-    for (auto &[Command, CommandIndex] : SubCommandIDs) {
-      // First emit the number of command strings in this list of commands.
-      OS << Sep << "  " << Command.size() << " /* commands */";
-      CommandIndex = CurIndex;
-      assert((CurIndex == 0 || !Command.empty()) &&
-             "Only first command set should be empty!");
-      for (const auto &CommandKey : Command) {
+    for (auto &[SubCommand, SubCommandIndex] : SubCommandIDs) {
+      // First emit the number of subcommand strings in this list of
+      // subcommands.
+      OS << Sep << "  " << SubCommand.size() << " /* subcommands */";
+      SubCommandIndex = CurIndex;
+      assert((CurIndex == 0 || !SubCommand.empty()) &&
+             "Only first subcommand set should be empty!");
+      for (const auto &SubCommandKey : SubCommand) {
         auto It = std::find_if(
             SubCommands.begin(), SubCommands.end(),
-            [&](const Record *R) { return R->getName() == CommandKey; });
-        assert(It != SubCommands.end() && "Command not found");
+            [&](const Record *R) { return R->getName() == SubCommandKey; });
+        assert(It != SubCommands.end() && "SubCommand not found");
         OS << ", " << std::distance(SubCommands.begin(), It) << " /* '"
-           << CommandKey << "' */";
+           << SubCommandKey << "' */";
       }
-      CurIndex += Command.size() + 1;
+      CurIndex += SubCommand.size() + 1;
     }
   }
   OS << "\n};\n";