[Support][CommandLine] Add cl::Option::setDefault()

[emankov]

Summary

Add abstract virtual method setDefault() to class Option() and implement it in its inheritors in order to be able to set all the options to its default values in user's code without actually knowing all these options. For instance:

for (auto SC : llvm::cl::getRegisteredSubcommands()) {
  for (auto &OM : SC->OptionsMap) {
    llvm::cl::Option *O = OM.second;
    // added functionality:
    O->setDefault();
  }
}

[rampitec]

I think you need a test here.

[Eugene.Zelenko]

include/llvm/Support/CommandLine.h

1514 ↗

(On Diff #111683)

Please run Clang-format over diff. Isn't this should be?

void setDefault() override {}

[emankov]

formatting

[emankov]

This comment was removed by emankov.

[emankov]

Test is added.

[rampitec]

LGTM, but someone else should approve too.

[kasaurov]

The test looks fine to me.

[dberris]

LGTM

llvm/trunk/include/llvm/Support/CommandLine.h

public:
 
   // printOptionInfo - Print out information about this option.  The
   // to-be-maintained width is specified.
   //
   virtual void printOptionInfo(size_t GlobalWidth) const = 0;
 
   virtual void printOptionValue(size_t GlobalWidth, bool Force) const = 0;
 
+  virtual void setDefault() = 0;
+
   static void printHelpStr(StringRef HelpStr, size_t Indent,
                            size_t FirstLineIndentedBy);
 
   virtual void getExtraOptionNames(SmallVectorImpl<StringRef> &) {}
 
   // addOccurrence - Wrapper around handleOccurrence that enforces Flags.
   //
   virtual bool addOccurrence(unsigned pos, StringRef ArgName, StringRef Value,
class opt : public Option,
 
   void printOptionValue(size_t GlobalWidth, bool Force) const override {
     if (Force || this->getDefault().compare(this->getValue())) {
       cl::printOptionDiff<ParserClass>(*this, Parser, this->getValue(),
                                        this->getDefault(), GlobalWidth);
     }
   }
 
+  template <class T, class = typename std::enable_if<
+            std::is_assignable<T&, T>::value>::type>
+  void setDefaultImpl() {
+    const OptionValue<DataType> &V = this->getDefault();
+    if (V.hasValue())
+      this->setValue(V.getValue());
+  }
+
+  template <class T, class = typename std::enable_if<
+            !std::is_assignable<T&, T>::value>::type>
+  void setDefaultImpl(...) {}
+
+  void setDefault() override { setDefaultImpl<DataType>(); }
+
   void done() {
     addArgument();
     Parser.initialize();
   }
 
 public:
   // Command line options should not be copyable
   opt(const opt &) = delete;
class list : public Option, public list_storage<DataType, StorageClass> {
   void printOptionInfo(size_t GlobalWidth) const override {
     Parser.printOptionInfo(*this, GlobalWidth);
   }
 
   // Unimplemented: list options don't currently store their default value.
   void printOptionValue(size_t /*GlobalWidth*/, bool /*Force*/) const override {
   }
 
+  void setDefault() override {}
+
   void done() {
     addArgument();
     Parser.initialize();
   }
 
 public:
   // Command line options should not be copyable
   list(const list &) = delete;
class bits : public Option, public bits_storage<DataType, Storage> {
   void printOptionInfo(size_t GlobalWidth) const override {
     Parser.printOptionInfo(*this, GlobalWidth);
   }
 
   // Unimplemented: bits options don't currently store their default values.
   void printOptionValue(size_t /*GlobalWidth*/, bool /*Force*/) const override {
   }
 
+  void setDefault() override {}
+
   void done() {
     addArgument();
     Parser.initialize();
   }
 
 public:
   // Command line options should not be copyable
   bits(const bits &) = delete;
class alias : public Option {
   // Handle printing stuff...
   size_t getOptionWidth() const override;
   void printOptionInfo(size_t GlobalWidth) const override;
 
   // Aliases do not need to print their values.
   void printOptionValue(size_t /*GlobalWidth*/, bool /*Force*/) const override {
   }
 
+  void setDefault() override { AliasFor->setDefault(); }
+
   ValueExpected getValueExpectedFlagDefault() const override {
     return AliasFor->getValueExpectedFlag();
   }
 
   void done() {
     if (!hasArgStr())
       error("cl::alias must have argument name specified!");
     if (!AliasFor)

llvm/trunk/unittests/Support/CommandLineTest.cpp

TEST(CommandLineTest, ResponseFiles) {
   EXPECT_STREQ(Argv[8], "-flag_2");
 
   llvm::sys::fs::remove(IncludedFileName2);
   llvm::sys::fs::remove(IncDir);
   llvm::sys::fs::remove(IncludedFileName);
   llvm::sys::fs::remove(TestDir);
 }
 
+TEST(CommandLineTest, SetDefautValue) {
+  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"};
+
+  EXPECT_TRUE(
+    cl::ParseCommandLineOptions(2, args, StringRef(), &llvm::nulls()));
+
+  EXPECT_TRUE(Opt1 == "false");
+  EXPECT_TRUE(Opt2);
+  EXPECT_TRUE(Opt3 == 3);
+
+  Opt2 = false;
+  Opt3 = 1;
+
+  cl::ResetAllOptionOccurrences();
+
+  for (auto &OM : cl::getRegisteredOptions(*cl::TopLevelSubCommand)) {
+    cl::Option *O = OM.second;
+    if (O->ArgStr == "opt2") {
+      continue;
+    }
+    O->setDefault();
+  }
+
+  EXPECT_TRUE(Opt1 == "true");
+  EXPECT_TRUE(Opt2);
+  EXPECT_TRUE(Opt3 == 3);
+}
+
 }  // anonymous namespace