[Support][CommandLine] Add cl::getRegisteredSubcommands()

[dberris]

Summary

This should allow users of the library to get a range to iterate through
all the subcommands that are registered to the global parser. This
allows users to define subcommands in libraries that self-register to
have dispatch done at a different stage (like main). It allows for
writing code like the following:

for (auto *S : cl::getRegisteredSubcommands()) {
  if (*S) {
    // Dispatch on S->getName().
  }
}

This change also contains tests that show this usage pattern.

[dberris]

• Style fixes

[dberris]

This was reverted in rL281292. Trying will try again.

[dberris]

• Add options to subcommands

[dberris]

• Explicitly initialise the option

[dberris]

Ping?

include/llvm/Support/CommandLine.h

 /// the control of the client. The options should be modified before calling
 /// llvm::cl::ParseCommandLineOptions().
 ///
 /// Hopefully this API can be depricated soon. Any situation where options need
 /// to be modified by tools or libraries should be handled by sane APIs rather
 /// than just handing around a global list.
 StringMap<Option *> &getRegisteredOptions(SubCommand &Sub = *TopLevelSubCommand);
 
+/// \brief Use this to get all registered SubCommands from the provided parser.
+///
+/// \return A range of all SubCommand pointers registered with the parser.
+///
+/// Typical usage:
+/// \code
+/// main(int argc, char* argv[]) {
+///   llvm::cl::ParseCommandLineOptions(argc, argv);
+///   for (auto* S : llvm::cl::getRegisteredSubcommands()) {
+///     if (*S) {
+///       std::cout << "Executing subcommand: " << S->getName() << std::endl;
+///       // Execute some function based on the name...
+///     }
+///   }
+/// }
+/// \endcode
+///
+/// This interface is useful for defining subcommands in libraries and
+/// the dispatch from a single point (like in the main function).
+iterator_range<typename SmallPtrSet<SubCommand *, 4>::iterator>
+getRegisteredSubcommands();
+
 //===----------------------------------------------------------------------===//
 // Standalone command line processing utilities.
 //
 
 /// \brief Tokenizes a command line that can contain escapes and quotes.
 //
 /// The quoting rules match those used by GCC and other tools that use
 /// libiberty's buildargv() or expandargv() utilities, and do not match bash.

lib/Support/CommandLine.cpp

if (sub != &*AllSubCommands) {
       }
     }
   }
 
   void unregisterSubCommand(SubCommand *sub) {
     RegisteredSubCommands.erase(sub);
   }
 
+  iterator_range<typename SmallPtrSet<SubCommand *, 4>::iterator>
+  getRegisteredSubcommands() {
+    return make_range(RegisteredSubCommands.begin(),
+                      RegisteredSubCommands.end());
+  }
+
   void reset() {
     ActiveSubCommand = nullptr;
     ProgramName.clear();
     ProgramOverview = nullptr;
 
     MoreHelp.clear();
     RegisteredOptionCategories.clear();
 

 
 StringMap<Option *> &cl::getRegisteredOptions(SubCommand &Sub) {
   auto &Subs = GlobalParser->RegisteredSubCommands;
   (void)Subs;
   assert(is_contained(Subs, &Sub));
   return Sub.OptionsMap;
 }
 
+iterator_range<typename SmallPtrSet<SubCommand *, 4>::iterator>
+cl::getRegisteredSubcommands() {
+  return GlobalParser->getRegisteredSubcommands();
+}
+
 void cl::HideUnrelatedOptions(cl::OptionCategory &Category, SubCommand &Sub) {
   for (auto &I : Sub.OptionsMap) {
     if (I.second->Category != &Category &&
         I.second->Category != &GenericCategory)
       I.second->setHiddenFlag(cl::ReallyHidden);
   }
 }
 

unittests/Support/CommandLineTest.cpp

TEST(CommandLineTest, RemoveFromAllSubCommands) {
   cl::ResetAllOptionOccurrences();
   EXPECT_FALSE(cl::ParseCommandLineOptions(2, args0, nullptr, true));
   cl::ResetAllOptionOccurrences();
   EXPECT_FALSE(cl::ParseCommandLineOptions(3, args1, nullptr, true));
   cl::ResetAllOptionOccurrences();
   EXPECT_FALSE(cl::ParseCommandLineOptions(3, args2, nullptr, true));
 }
 
+TEST(CommandLineTest, GetRegisteredSubcommands) {
+  cl::ResetCommandLineParser();
+
+  StackSubCommand SC1("sc1", "First Subcommand");
+  StackSubCommand SC2("sc2", "Second subcommand");
+
+  const char *args0[] = {"prog", "sc1"};
+  const char *args1[] = {"prog", "sc2"};
+
+  EXPECT_TRUE(cl::ParseCommandLineOptions(2, args0, nullptr, true));
+  for (auto *S : cl::getRegisteredSubcommands()) {
+    if (*S)
+      EXPECT_STREQ("sc1", S->getName());
+  }
+
+  cl::ResetAllOptionOccurrences();
+  EXPECT_TRUE(cl::ParseCommandLineOptions(2, args1, nullptr, true));
+  for (auto *S : cl::getRegisteredSubcommands()) {
+    if (*S)
+      EXPECT_STREQ("sc2", S->getName());
+  }
+}
+
 }  // anonymous namespace