[LLVM][Support] Support for `llvm::cl::list`'s default values

[tyb0807]

Summary

This patch introduces support for default values of list of CL options.
It fixes the issue in https://github.com/llvm/llvm-project/issues/52667

[zero9178]

llvm/include/llvm/Support/CommandLine.h

440

The naming here is a bit unfortunate since it sort of clashes with the common C++ vocabulary that is std::initializer_list but I don't have a lot of better ideas :(

441

All these const llvm::ArrayRef<Ty>& ought to be able to just be llvm::ArrayRef<Ty> (both in the struct here and the function parameters below). ArrayRef essentially already acts as a view/reference to some storage and is cheap and trivially copyable. I believe you can also drop the llvm:: namespace qualifier

[tyb0807]

Change initialization functions' names and correctly use ArrayRef

llvm/include/llvm/Support/CommandLine.h

440

Maybe I'll go with list_initializer and list_init to avoid name collision

[bkramer]

looks good now

llvm/include/llvm/Support/CommandLine.h

 // This is only valid on "opt" arguments, not on "list" arguments.
 template <class Ty> struct initializer {
   const Ty &Init;
   initializer(const Ty &Val) : Init(Val) {}
 
   template <class Opt> void apply(Opt &O) const { O.setInitialValue(Init); }
 };
 
+template <class Ty> struct list_initializer {
+  ArrayRef<Ty> Inits;
+  list_initializer(ArrayRef<Ty> Vals) : Inits(Vals) {}
+
+  template <class Opt> void apply(Opt &O) const { O.setInitialValues(Inits); }
+};
+
 template <class Ty> initializer<Ty> init(const Ty &Val) {
   return initializer<Ty>(Val);
 }
 
+template <class Ty>
+list_initializer<Ty> list_init(ArrayRef<Ty> Vals) {
+  return list_initializer<Ty>(Vals);
+}
+
 // Allow the user to specify which external variable they want to store the
 // results of the command line argument processing into, if they don't want to
 // store it in the option itself.
 template <class Ty> struct LocationClass {
   Ty &Loc;
 
   LocationClass(Ty &L) : Loc(L) {}
 

 
 //===----------------------------------------------------------------------===//
 // Default storage class definition: external storage.  This implementation
 // assumes the user will specify a variable to store the data into with the
 // cl::location(x) modifier.
 //
 template <class DataType, class StorageClass> class list_storage {
   StorageClass *Location = nullptr; // Where to store the object...
+  std::vector<OptionValue<DataType>> Default =
+      std::vector<OptionValue<DataType>>();
+  bool DefaultAssigned = false;
 
 public:
   list_storage() = default;
 
   void 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) {
+  template <class T> void addValue(const T &V, bool initial = false) {
     assert(Location != nullptr &&
            "cl::location(...) not specified for a command "
            "line option with external storage!");
     Location->push_back(V);
+    if (initial)
+      Default.push_back(V);
+  }
+
+  const std::vector<OptionValue<DataType>> &getDefault() const {
+    return Default;
   }
+
+  void assignDefault() { DefaultAssigned = true; }
+  void overwriteDefault() { DefaultAssigned = false; }
+  bool isDefaultAssigned() { return DefaultAssigned; }
 };
 
 // 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
 //
 template <class DataType> class list_storage<DataType, bool> {
   std::vector<DataType> Storage;
+  std::vector<OptionValue<DataType>> Default;
+  bool DefaultAssigned = false;
 
 public:
   using iterator = typename std::vector<DataType>::iterator;
 
   iterator begin() { return Storage.begin(); }
   iterator end() { return Storage.end(); }
 
   using const_iterator = typename std::vector<DataType>::const_iterator;
public:
   reference front() { return Storage.front(); }
   const_reference front() const { return Storage.front(); }
 
   operator std::vector<DataType> &() { return Storage; }
   operator ArrayRef<DataType>() const { return Storage; }
   std::vector<DataType> *operator&() { return &Storage; }
   const std::vector<DataType> *operator&() const { return &Storage; }
 
-  template <class T> void addValue(const T &V) { Storage.push_back(V); }
+  template <class T> void addValue(const T &V, bool initial = false) {
+    Storage.push_back(V);
+    if (initial)
+      Default.push_back(OptionValue<DataType>(V));
+  }
+
+  const std::vector<OptionValue<DataType>> &getDefault() const {
+    return Default;
+  }
+
+  void assignDefault() { DefaultAssigned = true; }
+  void overwriteDefault() { DefaultAssigned = false; }
+  bool isDefaultAssigned() { return DefaultAssigned; }
 };
 
 //===----------------------------------------------------------------------===//
 // A list of command line options.
 //
 template <class DataType, class StorageClass = bool,
           class ParserClass = parser<DataType>>
 class list : public Option, public list_storage<DataType, StorageClass> {
   std::vector<unsigned> Positions;
   ParserClass Parser;
 
   enum ValueExpected getValueExpectedFlagDefault() const override {
     return Parser.getValueExpectedFlagDefault();
   }
 
   void getExtraOptionNames(SmallVectorImpl<StringRef> &OptionNames) override {
     return Parser.getExtraOptionNames(OptionNames);
   }
 
   bool handleOccurrence(unsigned pos, StringRef ArgName,
                         StringRef Arg) override {
     typename ParserClass::parser_data_type Val =
         typename ParserClass::parser_data_type();
+    if (list_storage<DataType, StorageClass>::isDefaultAssigned()) {
+      clear();
+      list_storage<DataType, StorageClass>::overwriteDefault();
+    }
     if (Parser.parse(*this, ArgName, Arg, Val))
       return true; // Parse Error!
     list_storage<DataType, StorageClass>::addValue(Val);
     setPosition(pos);
     Positions.push_back(pos);
     Callback(Val);
     return false;
   }
class list : public Option, public list_storage<DataType, StorageClass> {
 
   // Unimplemented: list options don't currently store their default value.
   void printOptionValue(size_t /*GlobalWidth*/, bool /*Force*/) const override {
   }
 
   void setDefault() override {
     Positions.clear();
     list_storage<DataType, StorageClass>::clear();
+    for (auto &Val : list_storage<DataType, StorageClass>::getDefault())
+      list_storage<DataType, StorageClass>::addValue(Val.getValue());
   }
 
   void done() {
     addArgument();
     Parser.initialize();
   }
 
 public:
   // Command line options should not be copyable
   list(const list &) = delete;
   list &operator=(const list &) = delete;
 
   ParserClass &getParser() { return Parser; }
 
   unsigned getPosition(unsigned optnum) const {
     assert(optnum < this->size() && "Invalid option index");
     return Positions[optnum];
   }
 
+  void clear() {
+    Positions.clear();
+    list_storage<DataType, StorageClass>::clear();
+  }
+
+  // setInitialValues - Used by the cl::list_init modifier...
+  void setInitialValues(ArrayRef<DataType> Vs) {
+    assert(!(list_storage<DataType, StorageClass>::isDefaultAssigned()) &&
+           "Cannot have two default values");
+    list_storage<DataType, StorageClass>::assignDefault();
+    for (auto &Val : Vs)
+      list_storage<DataType, StorageClass>::addValue(Val, true);
+  }
+
   void setNumAdditionalVals(unsigned n) { Option::setNumAdditionalVals(n); }
 
   template <class... Mods>
   explicit list(const Mods &... Ms)
       : Option(ZeroOrMore, NotHidden), Parser(*this) {
     apply(this, Ms...);
     done();
   }

llvm/unittests/Support/CommandLineTest.cpp

for (size_t I = 0, E = std::size(Expected); I < E; ++I) {
     if (Expected[I] == nullptr) {
       ASSERT_EQ(Argv[I], nullptr);
     } else {
       ASSERT_STREQ(Expected[I], Argv[I]);
     }
   }
 }
 
-TEST(CommandLineTest, SetDefautValue) {
+TEST(CommandLineTest, SetDefaultValue) {
   cl::ResetCommandLineParser();
 
   StackOption<std::string> Opt1("opt1", cl::init("true"));
   StackOption<bool> Opt2("opt2", cl::init(true));
   cl::alias Alias("alias", llvm::cl::aliasopt(Opt2));
   StackOption<int> Opt3("opt3", cl::init(3));
 
-  const char *args[] = {"prog", "-opt1=false", "-opt2", "-opt3"};
+  llvm::SmallVector<int, 3> IntVals = {1, 2, 3};
+  llvm::SmallVector<std::string, 3> StrVals = {"foo", "bar", "baz"};
+
+  StackOption<int, cl::list<int>> List1(
+      "list1", cl::list_init<int>(llvm::ArrayRef<int>(IntVals)),
+      cl::CommaSeparated);
+  StackOption<std::string, cl::list<std::string>> List2(
+      "list2", cl::list_init<std::string>(llvm::ArrayRef<std::string>(StrVals)),
+      cl::CommaSeparated);
+  cl::alias ListAlias("list-alias", llvm::cl::aliasopt(List2));
+
+  const char *args[] = {"prog",   "-opt1=false", "-list1", "4",
+                        "-list1", "5,6",         "-opt2",  "-opt3"};
 
   EXPECT_TRUE(
-    cl::ParseCommandLineOptions(2, args, StringRef(), &llvm::nulls()));
+      cl::ParseCommandLineOptions(7, args, StringRef(), &llvm::nulls()));
 
   EXPECT_EQ(Opt1, "false");
   EXPECT_TRUE(Opt2);
   EXPECT_EQ(Opt3, 3);
 
+  for (size_t I = 0, E = IntVals.size(); I < E; ++I) {
+    EXPECT_EQ(IntVals[I] + 3, List1[I]);
+    EXPECT_EQ(StrVals[I], List2[I]);
+  }
+
   Opt2 = false;
   Opt3 = 1;
 
   cl::ResetAllOptionOccurrences();
 
   for (auto &OM : cl::getRegisteredOptions(cl::SubCommand::getTopLevel())) {
     cl::Option *O = OM.second;
     if (O->ArgStr == "opt2") {
       continue;
     }
     O->setDefault();
   }
 
   EXPECT_EQ(Opt1, "true");
   EXPECT_TRUE(Opt2);
   EXPECT_EQ(Opt3, 3);
+  for (size_t I = 0, E = IntVals.size(); I < E; ++I) {
+    EXPECT_EQ(IntVals[I], List1[I]);
+    EXPECT_EQ(StrVals[I], List2[I]);
+  }
+
   Alias.removeArgument();
+  ListAlias.removeArgument();
 }
 
 TEST(CommandLineTest, ReadConfigFile) {
   llvm::SmallVector<const char *, 1> Argv;
 
   TempDir TestDir("unittest", /*Unique*/ true);
   TempDir TestSubDir(TestDir.path("subdir"), /*Unique*/ false);
 

mlir/include/mlir/Pass/PassOptions.h

public:
     operator=(const ListOption<DataType, OptionParser> &other) {
       *this = ArrayRef<DataType>(other);
       this->optHasValue = other.optHasValue;
       return *this;
     }
 
     bool handleOccurrence(unsigned pos, StringRef argName,
                           StringRef arg) override {
+      if (this->isDefaultAssigned()) {
+        this->clear();
+        this->overwriteDefault();
+      }
       this->optHasValue = true;
       return failed(detail::pass_options::parseCommaSeparatedList(
           *this, argName, arg, elementParser,
           [&](const DataType &value) { this->addValue(value); }));
     }
 
     /// Allow assigning from an ArrayRef.
     ListOption<DataType, OptionParser> &operator=(ArrayRef<DataType> values) {

 //===----------------------------------------------------------------------===//
 // OpPassManager: OptionValue
 
 template <>
 struct OptionValue<mlir::OpPassManager> final : GenericOptionValue {
   using WrapperType = mlir::OpPassManager;
 
   OptionValue();
+  OptionValue(const OptionValue<mlir::OpPassManager> &rhs);
   OptionValue(const mlir::OpPassManager &value);
   OptionValue<mlir::OpPassManager> &operator=(const mlir::OpPassManager &rhs);
   ~OptionValue();
 
   /// Returns if the current option has a value.
   bool hasValue() const { return value.get(); }
 
   /// Returns the current value of the option.

mlir/lib/Pass/PassRegistry.cpp

 //===----------------------------------------------------------------------===//
 // OpPassManager: OptionValue
 
 llvm::cl::OptionValue<OpPassManager>::OptionValue() = default;
 llvm::cl::OptionValue<OpPassManager>::OptionValue(
     const mlir::OpPassManager &value) {
   setValue(value);
 }
+llvm::cl::OptionValue<OpPassManager>::OptionValue(
+    const llvm::cl::OptionValue<mlir::OpPassManager> &rhs) {
+  if (rhs.hasValue())
+    setValue(rhs.getValue());
+}
 llvm::cl::OptionValue<OpPassManager> &
 llvm::cl::OptionValue<OpPassManager>::operator=(
     const mlir::OpPassManager &rhs) {
   setValue(rhs);
   return *this;
 }
 
 llvm::cl::OptionValue<OpPassManager>::~OptionValue<OpPassManager>() = default;