[Debug] Convert DebugOnly from cl::opt with a custom type to cl::list [NFC]

[hintonda]

Summary

Convert DebugOnly from cl::opt with a custom type to cl::list
with a cl::callback. The callback is needed in order to set DebugFlag
whenever DebugOnly is passed.

Also, add list_storage specialization for ManagedStatic<vector<T>> to
support cl::location for managed statics.

[hintonda]

• Remove unneeded cl::ValueRequired, since it is the default

[hintonda]

post holiday ping...

[beanz]

Looks totally reasonable to me, and like a good simplification of the logic.

llvm/include/llvm/Support/CommandLine.h

public:
 
   template <class T> void addValue(const T &V) {
     assert(Location != 0 && "cl::location(...) not specified for a command "
                             "line option with external storage!");
     Location->push_back(V);
   }
 };
 
+// Specialization for ManagedStatic<std::vector<T>>.
+template <class DataType>
+class list_storage<DataType, ManagedStatic<std::vector<DataType>>> {
+  using StorageClass = ManagedStatic<std::vector<DataType>>;
+  StorageClass *Location = nullptr; // Where to store the object...
+
+public:
+  list_storage() = default;
+
+  void clear() {
+    getStorageClass()->clear();
+  }
+
+  bool setLocation(Option &O, StorageClass &L) {
+    if (Location)
+      return O.error("cl::location(x) specified more than once!");
+    Location = &L;
+    return false;
+  }
+
+  template <class T> void addValue(const T &V) {
+    getStorageClass()->push_back(V);
+  }
+private:
+  StorageClass &getStorageClass() {
+    assert(Location != 0 && "cl::location(...) not specified for a command "
+                            "line option with external storage!");
+    return *Location;
+  }
+};
+
 // Define how to hold a class type object, such as a string.
 // Originally this code inherited from std::vector. In transitioning to a new
 // API for command line options we should change this. The new implementation
 // of this list_storage specialization implements the minimum subset of the
 // std::vector API required for all the current clients.
 //
 // FIXME: Reduce this API to a more narrow subset of std::vector
 //

llvm/lib/Support/Debug.cpp

 static cl::opt<unsigned>
 DebugBufferSize("debug-buffer-size",
                 cl::desc("Buffer the last N characters of debug output "
                          "until program termination. "
                          "[default 0 -- immediate print-out]"),
                 cl::Hidden,
                 cl::init(0));
 
-namespace {
-
-struct DebugOnlyOpt {
-  void operator=(const std::string &Val) const {
-    if (Val.empty())
-      return;
-    DebugFlag = true;
-    SmallVector<StringRef,8> dbgTypes;
-    StringRef(Val).split(dbgTypes, ',', -1, false);
-    for (auto dbgType : dbgTypes)
-      CurrentDebugType->push_back(dbgType);
-  }
-};
-
-}
-
-static DebugOnlyOpt DebugOnlyOptLoc;
-
-static cl::opt<DebugOnlyOpt, true, cl::parser<std::string> >
-DebugOnly("debug-only", cl::desc("Enable a specific type of debug output (comma separated list of types)"),
+static cl::list<std::string, ManagedStatic<std::vector<std::string>>>
+    DebugOnly("debug-only",
+              cl::desc("Enable a specific type of debug output (comma "
+                       "separated list of types)"),
               cl::Hidden, cl::ZeroOrMore, cl::value_desc("debug string"),
-          cl::location(DebugOnlyOptLoc), cl::ValueRequired);
+              cl::location(CurrentDebugType), cl::CommaSeparated,
+              cl::callback([](const std::string &) { DebugFlag = true; }));
+
 // Signal handlers - dump debug output on termination.
 static void debug_user_sig_handler(void *Cookie) {
   // This is a bit sneaky.  Since this is under #ifndef NDEBUG, we
   // know that debug mode is enabled and dbgs() really is a
   // circular_raw_ostream.  If NDEBUG is defined, then dbgs() ==
   // errs() but this will never be invoked.
   llvm::circular_raw_ostream &dbgout =
       static_cast<circular_raw_ostream &>(llvm::dbgs());

llvm/unittests/Support/CommandLineTest.cpp

TEST(CommandLineTest, Callback) {
   EXPECT_TRUE(cl::ParseCommandLineOptions(2, args5));
   EXPECT_FALSE(OptA);
   EXPECT_FALSE(OptB);
   EXPECT_FALSE(OptC);
   EXPECT_TRUE(List.size() == 1);
 
   cl::ResetAllOptionOccurrences();
 }
+
+TEST(CommandLineTest, ManagedStaticLocation) {
+  cl::ResetCommandLineParser();
+
+  ManagedStatic<std::vector<std::string>> ManagedStringVec;
+
+  StackOption<bool> OptA("a", cl::desc("option a"));
+  StackOption<std::string,
+              cl::list<std::string, ManagedStatic<std::vector<std::string>>>>
+      ManagedList(
+          "managedlist",
+          cl::desc("option managedlist -- This option turns on options a when "
+                   "'foo' is included in list"),
+          cl::location(ManagedStringVec), cl::CommaSeparated,
+          cl::callback([&](const std::string &Str) {
+            if (Str == "foo")
+              OptA = true;
+          }));
+
+  const char *args[] = {"prog", "--managedlist=foo"};
+  EXPECT_TRUE(cl::ParseCommandLineOptions(2, args));
+  EXPECT_TRUE(OptA);
+  EXPECT_TRUE(ManagedStringVec->size() == 1);
+
+  cl::ResetAllOptionOccurrences();
+}
 } // anonymous namespace