Introduce API to check if a subcommand is registered with a given option.

Author: Prabhuk

llvm/examples/OptSubcommand/llvm-hello-sub.cpp

@@ -78,17 +78,30 @@ int main(int argc, char **argv) {
   InputArgList Args = T.ParseArgs(ArrayRef(argv + 1, argc - 1), MissingArgIndex,
                                   MissingArgCount);
 
-  StringRef Subcommand = Args.getSubcommand(
+  StringRef SubCommand = Args.getSubCommand(
       T.getSubCommands(), HandleMultipleSubcommands, HandleOtherPositionals);
   // Handle help. When help options is found, ignore all other options and exit
   // after printing help.
 
   if (Args.hasArg(OPT_help)) {
     T.printHelp(llvm::outs(), "llvm-hello-sub [subcommand] [options]",
-                "LLVM Hello Subcommand Example", false, false, Visibility(),
-                Subcommand);
+                "LLVM Hello SubCommand Example", false, false, Visibility(),
+                SubCommand);
     return 0;
   }
+
+  auto HandleSubCommandArg = [&](ID OptionType) {
+    if (!Args.hasArg(OptionType))
+      return false;
+    auto O = T.getOption(OptionType);
+    if (!O.isRegisteredSC(SubCommand)) {
+      llvm::errs() << "Option [" << O.getName()
+                   << "] is not valid for SubCommand [" << SubCommand << "]\n";
+      return false;
+    }
+    return true;
+  };
+
   bool HasUnknownOptions = false;
   for (const Arg *A : Args.filtered(OPT_UNKNOWN)) {
     HasUnknownOptions = true;
@@ -98,26 +111,26 @@ int main(int argc, char **argv) {
     llvm::errs() << "See `OptSubcommand --help`.\n";
     return 1;
   }
-  if (Subcommand.empty()) {
+  if (SubCommand.empty()) {
     if (Args.hasArg(OPT_version))
-      llvm::outs() << "LLVM Hello Subcommand Example 1.0\n";
-  } else if (Subcommand == "foo") {
-    if (Args.hasArg(OPT_uppercase))
+      llvm::outs() << "LLVM Hello SubCommand Example 1.0\n";
+  } else if (SubCommand == "foo") {
+    if (HandleSubCommandArg(OPT_uppercase))
       llvm::outs() << "FOO\n";
-    else if (Args.hasArg(OPT_lowercase))
+    else if (HandleSubCommandArg(OPT_lowercase))
       llvm::outs() << "foo\n";
 
-    if (Args.hasArg(OPT_version))
-      llvm::outs() << "LLVM Hello Subcommand foo Example 1.0\n";
+    if (HandleSubCommandArg(OPT_version))
+      llvm::outs() << "LLVM Hello SubCommand foo Example 1.0\n";
 
-  } else if (Subcommand == "bar") {
-    if (Args.hasArg(OPT_lowercase))
+  } else if (SubCommand == "bar") {
+    if (HandleSubCommandArg(OPT_lowercase))
       llvm::outs() << "bar\n";
-    else if (Args.hasArg(OPT_uppercase))
+    else if (HandleSubCommandArg(OPT_uppercase))
       llvm::outs() << "BAR\n";
 
-    if (Args.hasArg(OPT_version))
-      llvm::outs() << "LLVM Hello Subcommand bar Example 1.0\n";
+    if (HandleSubCommandArg(OPT_version))
+      llvm::outs() << "LLVM Hello SubCommand bar Example 1.0\n";
   }
 
   return 0;

llvm/include/llvm/Option/ArgList.h

@@ -281,7 +281,7 @@ class ArgList {
   /// list.
   virtual unsigned getNumInputArgStrings() const = 0;
 
-  /// getSubcommand - Find subcommand from the arguments if the usage is valid.
+  /// getSubCommand - Find subcommand from the arguments if the usage is valid.
   ///
   /// \param AllSubCommands - A list of all valid subcommands.
   /// \param HandleMultipleSubcommands - A callback for the case where multiple
@@ -292,7 +292,7 @@ class ArgList {
   /// \return The name of the subcommand found. If no subcommand is found,
   /// this returns an empty StringRef. If multiple subcommands are found, the
   /// first one is returned.
-  StringRef getSubcommand(
+  StringRef getSubCommand(
       ArrayRef<OptTable::SubCommand> AllSubCommands,
       std::function<void(ArrayRef<StringRef>)> HandleMultipleSubcommands,
       std::function<void(ArrayRef<StringRef>)> HandleOtherPositionals) const;

llvm/include/llvm/Option/OptTable.h

@@ -86,6 +86,7 @@ class LLVM_ABI OptTable {
     unsigned short AliasID;
     const char *AliasArgs;
     const char *Values;
+    // Offset into OptTable's SubCommandIDsTable.
     unsigned SubCommandIDsOffset;
 
     bool hasNoPrefix() const { return PrefixesOffset == 0; }
@@ -102,7 +103,7 @@ class LLVM_ABI OptTable {
                                                  getNumPrefixes(PrefixesTable));
     }
 
-    bool hasCommands() const { return SubCommandIDsOffset != 0; }
+    bool hasSubCommands() const { return SubCommandIDsOffset != 0; }
 
     unsigned getNumCommandIDs(ArrayRef<unsigned> SubCommandIDsTable) const {
       // We embed the number of subcommand IDs in the value of the first offset.
@@ -111,10 +112,10 @@ class LLVM_ABI OptTable {
 
     ArrayRef<unsigned>
     getCommandIDs(ArrayRef<unsigned> SubCommandIDsTable) const {
-      return hasCommands() ? SubCommandIDsTable.slice(
-                                 SubCommandIDsOffset + 1,
-                                 getNumCommandIDs(SubCommandIDsTable))
-                           : ArrayRef<unsigned>();
+      return hasSubCommands() ? SubCommandIDsTable.slice(
+                                    SubCommandIDsOffset + 1,
+                                    getNumCommandIDs(SubCommandIDsTable))
+                              : ArrayRef<unsigned>();
     }
 
     void appendPrefixes(const StringTable &StrTable,
@@ -142,6 +143,22 @@ class LLVM_ABI OptTable {
     }
   };
 
+public:
+  bool isValidForSubCommand(const Info *CandidateInfo,
+                            StringRef SubCommand) const {
+    assert(!SubCommand.empty() &&
+           "This helper is only for valid registered subcommands.");
+    typename ArrayRef<OptTable::SubCommand>::iterator SCIT =
+        std::find_if(SubCommands.begin(), SubCommands.end(),
+                     [&](const auto &C) { return SubCommand == C.Name; });
+    assert(SCIT != SubCommands.end() &&
+           "This helper is only for valid registered subcommands.");
+    auto SubCommandIDs = CandidateInfo->getCommandIDs(SubCommandIDsTable);
+    unsigned CurrentSubCommandID = SCIT - &SubCommands[0];
+    return std::find(SubCommandIDs.begin(), SubCommandIDs.end(),
+                     CurrentSubCommandID) != SubCommandIDs.end();
+  }
+
 private:
   // A unified string table for these options. Individual strings are stored as
   // null terminated C-strings at offsets within this table.

llvm/include/llvm/Option/Option.h

@@ -216,6 +216,12 @@ class Option {
   /// always be false.
   LLVM_ABI bool matches(OptSpecifier ID) const;
 
+  LLVM_ABI bool isRegisteredSC(StringRef SubCommand) const {
+    assert(Info && "Must have a valid info!");
+    assert(Owner && "Must have a valid owner!");
+    return Owner->isValidForSubCommand(Info, SubCommand);
+  }
+
   /// Potentially accept the current argument, returning a new Arg instance,
   /// or 0 if the option does not accept this argument (or the argument is
   /// missing values).

llvm/lib/Option/ArgList.cpp

@@ -204,7 +204,7 @@ void ArgList::print(raw_ostream &O) const {
 LLVM_DUMP_METHOD void ArgList::dump() const { print(dbgs()); }
 #endif
 
-StringRef ArgList::getSubcommand(
+StringRef ArgList::getSubCommand(
     ArrayRef<OptTable::SubCommand> AllSubCommands,
     std::function<void(ArrayRef<StringRef>)> HandleMultipleSubcommands,
     std::function<void(ArrayRef<StringRef>)> HandleOtherPositionals) const {

llvm/unittests/Option/OptionSubCommandsTest.cpp

@@ -95,7 +95,7 @@ TYPED_TEST(OptSubCommandTableTest, SubCommandParsing) {
     const char *Args[] = {"-version"};
     InputArgList AL = T.ParseArgs(Args, MAI, MAC);
     EXPECT_TRUE(AL.hasArg(OPT_version));
-    StringRef SC = AL.getSubcommand(
+    StringRef SC = AL.getSubCommand(
         T.getSubCommands(), HandleMultipleSubcommands, HandleOtherPositionals);
     EXPECT_TRUE(SC.empty());
     EXPECT_FALSE(AL.hasArg(OPT_uppercase));
@@ -106,7 +106,7 @@ TYPED_TEST(OptSubCommandTableTest, SubCommandParsing) {
     // Test case 2: Subcommand 'foo' with its valid options
     const char *Args[] = {"foo", "-uppercase"};
     InputArgList AL = T.ParseArgs(Args, MAI, MAC);
-    StringRef SC = AL.getSubcommand(
+    StringRef SC = AL.getSubCommand(
         T.getSubCommands(), HandleMultipleSubcommands, HandleOtherPositionals);
     EXPECT_EQ(SC, "foo");
     EXPECT_TRUE(AL.hasArg(OPT_uppercase));
@@ -123,7 +123,7 @@ TYPED_TEST(OptSubCommandTableTest, SubCommandParsing) {
     // subcommand option.
     const char *Args[] = {"-uppercase", "foo"};
     InputArgList AL = T.ParseArgs(Args, MAI, MAC);
-    StringRef SC = AL.getSubcommand(
+    StringRef SC = AL.getSubCommand(
         T.getSubCommands(), HandleMultipleSubcommands, HandleOtherPositionals);
     EXPECT_EQ(SC, "foo");
     EXPECT_TRUE(AL.hasArg(OPT_uppercase));
@@ -139,7 +139,7 @@ TYPED_TEST(OptSubCommandTableTest, SubCommandParsing) {
     // Test case 4: Check invalid use of passing multiple subcommands.
     const char *Args[] = {"-uppercase", "foo", "bar"};
     InputArgList AL = T.ParseArgs(Args, MAI, MAC);
-    StringRef SC = AL.getSubcommand(
+    StringRef SC = AL.getSubCommand(
         T.getSubCommands(), HandleMultipleSubcommands, HandleOtherPositionals);
     // No valid subcommand should be returned as this is an invalid invocation.
     EXPECT_TRUE(SC.empty());
@@ -155,7 +155,7 @@ TYPED_TEST(OptSubCommandTableTest, SubCommandParsing) {
     // Test case 5: Check invalid use of passing unregistered subcommands.
     const char *Args[] = {"foobar"};
     InputArgList AL = T.ParseArgs(Args, MAI, MAC);
-    StringRef SC = AL.getSubcommand(
+    StringRef SC = AL.getSubCommand(
         T.getSubCommands(), HandleMultipleSubcommands, HandleOtherPositionals);
     // No valid subcommand should be returned as this is an invalid invocation.
     EXPECT_TRUE(SC.empty());