clean up command line arguments code, NFC

[kevgs]

Summary

const char * > StringRef
for > for each
remove unneeded specifiers

include/llvm/IR/LegacyPassNameParser.h

   // ValLessThan - Provide a sorting comparator for Values elements...
   static int ValLessThan(const PassNameParser::OptionInfo *VT1,
                          const PassNameParser::OptionInfo *VT2) {
-    return std::strcmp(VT1->Name, VT2->Name);
+    return VT1->Name.compare(VT2->Name);
   }
 };
 

include/llvm/Support/CommandLine.h

 // ParseCommandLineOptions - Command line option processing entry point.
 //
 void ParseCommandLineOptions(int argc, const char *const *argv,
-                             const char *Overview = nullptr);
+                             StringRef Overview = StringRef());
 
 //===----------------------------------------------------------------------===//
 // ParseEnvironmentOptions - Environment variable option processing alternate
 //                           entry point.
 //
-void ParseEnvironmentOptions(const char *progName, const char *envvar,
-                             const char *Overview = nullptr);
+void ParseEnvironmentOptions(StringRef progName, StringRef envvar,
+                             StringRef Overview = StringRef());
 
 ///===---------------------------------------------------------------------===//
 /// SetVersionPrinter - Override the default (LLVM specific) version printer

 ///
 /// Literal options are used by some parsers to register special option values.
 /// This is how the PassNameParser registers pass names for opt.
-void AddLiteralOption(Option &O, const char *Name);
+void AddLiteralOption(Option &O, StringRef Name);
 
 //===----------------------------------------------------------------------===//
 // Flags permitted to be passed to command line arguments

 //
 class OptionCategory {
 private:
-  const char *const Name;
-  const char *const Description;
+  StringRef Name;
+  StringRef Description;
   void registerCategory();
 
 public:
-  OptionCategory(const char *const Name,
-                 const char *const Description = nullptr)
+  OptionCategory(StringRef Name, StringRef Description = StringRef())
       : Name(Name), Description(Description) {
     registerCategory();
   }
-  const char *getName() const { return Name; }
-  const char *getDescription() const { return Description; }
+  StringRef getName() const { return Name; }
+  StringRef getDescription() const { return Description; }
 };
 
 // The general Option Category (used as default category).

   virtual bool handleOccurrence(unsigned pos, StringRef ArgName,
                                 StringRef Arg) = 0;
 
-  virtual enum ValueExpected getValueExpectedFlagDefault() const {
+  virtual ValueExpected getValueExpectedFlagDefault() const {
     return ValueOptional;
   }
 

   unsigned Position;       // Position of last occurrence of the option
   unsigned AdditionalVals; // Greater than 0 for multi-valued option.
 
+  StringRef ArgStr;      // The argument string itself (ex: "help", "o")
+  StringRef Description; // The descriptive text message for -help
+  StringRef ValueStr;    // String describing what the value of this option is
+
 public:
-  const char *ArgStr;   // The argument string itself (ex: "help", "o")
-  const char *HelpStr;  // The descriptive text message for -help
-  const char *ValueStr; // String describing what the value of this option is
   OptionCategory *Category; // The Category this option belongs to
   bool FullyInitialized;    // Has addArguemnt been called?
 
-  inline enum NumOccurrencesFlag getNumOccurrencesFlag() const {
-    return (enum NumOccurrencesFlag)Occurrences;
-  }
-  inline enum ValueExpected getValueExpectedFlag() const {
-    return Value ? ((enum ValueExpected)Value) : getValueExpectedFlagDefault();
+  NumOccurrencesFlag getNumOccurrencesFlag() const {
+    return (NumOccurrencesFlag)Occurrences;
   }
-  inline enum OptionHidden getOptionHiddenFlag() const {
-    return (enum OptionHidden)HiddenFlag;
+  ValueExpected getValueExpectedFlag() const {
+    return Value ? ((ValueExpected)Value) : getValueExpectedFlagDefault();
   }
-  inline enum FormattingFlags getFormattingFlag() const {
-    return (enum FormattingFlags)Formatting;
+  OptionHidden getOptionHiddenFlag() const { return (OptionHidden)HiddenFlag; }
+  FormattingFlags getFormattingFlag() const {
+    return (FormattingFlags)Formatting;
   }
-  inline unsigned getMiscFlags() const { return Misc; }
-  inline unsigned getPosition() const { return Position; }
-  inline unsigned getNumAdditionalVals() const { return AdditionalVals; }
+  unsigned getMiscFlags() const { return Misc; }
+  unsigned getPosition() const { return Position; }
+  unsigned getNumAdditionalVals() const { return AdditionalVals; }
 
   // hasArgStr - Return true if the argstr != ""
-  bool hasArgStr() const { return ArgStr[0] != 0; }
+  bool hasArgStr() const { return ArgStr.empty() == false; }
+  bool hasDescriptionStr() const { return Description.empty() == false; }
+  bool hasValueStr() const { return ValueStr.empty() == false; }
 
   //-------------------------------------------------------------------------===
   // Accessor functions set by OptionModifiers
   //
-  void setArgStr(const char *S);
-  void setDescription(const char *S) { HelpStr = S; }
-  void setValueStr(const char *S) { ValueStr = S; }
-  void setNumOccurrencesFlag(enum NumOccurrencesFlag Val) { Occurrences = Val; }
-  void setValueExpectedFlag(enum ValueExpected Val) { Value = Val; }
-  void setHiddenFlag(enum OptionHidden Val) { HiddenFlag = Val; }
-  void setFormattingFlag(enum FormattingFlags V) { Formatting = V; }
-  void setMiscFlag(enum MiscFlags M) { Misc |= M; }
+  StringRef getArgStr() const { return ArgStr; }
+  StringRef getDescription() const { return Description; }
+  StringRef getValueStr() const { return ValueStr; }
+  void setArgStr(StringRef S);
+  void setDescription(StringRef S) { Description = S; }
+  void setValueStr(StringRef S) { ValueStr = S; }
+  void setNumOccurrencesFlag(NumOccurrencesFlag Val) { Occurrences = Val; }
+  void setValueExpectedFlag(ValueExpected Val) { Value = Val; }
+  void setHiddenFlag(OptionHidden Val) { HiddenFlag = Val; }
+  void setFormattingFlag(FormattingFlags V) { Formatting = V; }
+  void setMiscFlag(MiscFlags M) { Misc |= M; }
   void setPosition(unsigned pos) { Position = pos; }
   void setCategory(OptionCategory &C) { Category = &C; }
 
 protected:
-  explicit Option(enum NumOccurrencesFlag OccurrencesFlag,
-                  enum OptionHidden Hidden)
+  explicit Option(NumOccurrencesFlag OccurrencesFlag, OptionHidden Hidden)
       : NumOccurrences(0), Occurrences(OccurrencesFlag), Value(0),
         HiddenFlag(Hidden), Formatting(NormalFormatting), Misc(0), Position(0),
-        AdditionalVals(0), ArgStr(""), HelpStr(""), ValueStr(""),
-        Category(&GeneralCategory), FullyInitialized(false) {}
+        AdditionalVals(0), Category(&GeneralCategory), FullyInitialized(false) {
+  }
 
   inline void setNumAdditionalVals(unsigned n) { AdditionalVals = n; }
 

 
   virtual void printOptionValue(size_t GlobalWidth, bool Force) const = 0;
 
-  virtual void getExtraOptionNames(SmallVectorImpl<const char *> &) {}
+  virtual void getExtraOptionNames(SmallVectorImpl<StringRef> &) {}
 
   // addOccurrence - Wrapper around handleOccurrence that enforces Flags.
   //

 
 // desc - Modifier to set the description shown in the -help output...
 struct desc {
-  const char *Desc;
-  desc(const char *Str) : Desc(Str) {}
+  StringRef Desc;
+  desc(StringRef Str) : Desc(Str) {}
   void apply(Option &O) const { O.setDescription(Desc); }
 };
 
 // value_desc - Modifier to set the value description shown in the -help
 // output...
 struct value_desc {
-  const char *Desc;
-  value_desc(const char *Str) : Desc(Str) {}
+  StringRef Desc;
+  value_desc(StringRef Str) : Desc(Str) {}
   void apply(Option &O) const { O.setValueStr(Desc); }
 };
 

   // Use a vector instead of a map, because the lists should be short,
   // the overhead is less, and most importantly, it keeps them in the order
   // inserted so we can print our option out nicely.
-  SmallVector<std::pair<const char *, std::pair<int, const char *>>, 4> Values;
+  SmallVector<std::pair<StringRef, std::pair<int, StringRef>>, 4> Values;
   void processValues(va_list Vals);
 
 public:
-  ValuesClass(const char *EnumName, DataType Val, const char *Desc,
+  ValuesClass(StringRef EnumName, DataType Val, StringRef Desc,
               va_list ValueArgs) {
     // Insert the first value, which is required.
     Values.push_back(std::make_pair(EnumName, std::make_pair(Val, Desc)));

     // Process the varargs portion of the values...
     while (const char *enumName = va_arg(ValueArgs, const char *)) {
       DataType EnumVal = static_cast<DataType>(va_arg(ValueArgs, int));
-      const char *EnumDesc = va_arg(ValueArgs, const char *);
+      StringRef EnumDesc = va_arg(ValueArgs, const char *);
       Values.push_back(std::make_pair(enumName, // Add value to value map
                                       std::make_pair(EnumVal, EnumDesc)));
     }
   }
 
   template <class Opt> void apply(Opt &O) const {
-    for (size_t i = 0, e = Values.size(); i != e; ++i)
-      O.getParser().addLiteralOption(Values[i].first, Values[i].second.first,
-                                     Values[i].second.second);
+    for (const auto &I : Values)
+      O.getParser().addLiteralOption(I.first, I.second.first, I.second.second);
   }
 };
 
 template <class DataType>
 ValuesClass<DataType> LLVM_END_WITH_NULL
-values(const char *Arg, DataType Val, const char *Desc, ...) {
+values(StringRef Arg, DataType Val, const char *Desc, ...) {
   va_list ValueArgs;
   va_start(ValueArgs, Desc);
   ValuesClass<DataType> Vals(Arg, Val, Desc, ValueArgs);

 protected:
   class GenericOptionInfo {
   public:
-    GenericOptionInfo(const char *name, const char *helpStr)
+    GenericOptionInfo(StringRef name, StringRef helpStr)
         : Name(name), HelpStr(helpStr) {}
-    const char *Name;
-    const char *HelpStr;
+    StringRef Name;
+    StringRef HelpStr;
   };
 
 public:

   virtual unsigned getNumOptions() const = 0;
 
   // getOption - Return option name N.
-  virtual const char *getOption(unsigned N) const = 0;
+  virtual StringRef getOption(unsigned N) const = 0;
 
   // getDescription - Return description N
-  virtual const char *getDescription(unsigned N) const = 0;
+  virtual StringRef getDescription(unsigned N) const = 0;
 
   // Return the width of the option tag for printing...
   virtual size_t getOptionWidth(const Option &O) const;

 
   void initialize() {}
 
-  void getExtraOptionNames(SmallVectorImpl<const char *> &OptionNames) {
+  void getExtraOptionNames(SmallVectorImpl<StringRef> &OptionNames) {
     // If there has been no argstr specified, that means that we need to add an
     // argument for every possible option.  This ensures that our options are
     // vectored to us.

         OptionNames.push_back(getOption(i));
   }
 
-  enum ValueExpected getValueExpectedFlagDefault() const {
+  ValueExpected getValueExpectedFlagDefault() const {
     // If there is an ArgStr specified, then we are of the form:
     //
     //    -opt=O2   or   -opt O2  or  -optO2

   // findOption - Return the option number corresponding to the specified
   // argument string.  If the option is not found, getNumOptions() is returned.
   //
-  unsigned findOption(const char *Name);
+  unsigned findOption(StringRef Name);
 
 protected:
   Option &Owner;

 protected:
   class OptionInfo : public GenericOptionInfo {
   public:
-    OptionInfo(const char *name, DataType v, const char *helpStr)
+    OptionInfo(StringRef name, DataType v, StringRef helpStr)
         : GenericOptionInfo(name, helpStr), V(v) {}
     OptionValue<DataType> V;
   };

 
   // Implement virtual functions needed by generic_parser_base
   unsigned getNumOptions() const override { return unsigned(Values.size()); }
-  const char *getOption(unsigned N) const override { return Values[N].Name; }
-  const char *getDescription(unsigned N) const override {
+  StringRef getOption(unsigned N) const override { return Values[N].Name; }
+  StringRef getDescription(unsigned N) const override {
     return Values[N].HelpStr;
   }
 

     else
       ArgVal = ArgName;
 
-    for (size_t i = 0, e = Values.size(); i != e; ++i)
-      if (Values[i].Name == ArgVal) {
-        V = Values[i].V.getValue();
+    for (const auto &I : Values)
+      if (I.Name == ArgVal) {
+        V = I.V.getValue();
         return false;
       }
 

   /// addLiteralOption - Add an entry to the mapping table.
   ///
   template <class DT>
-  void addLiteralOption(const char *Name, const DT &V, const char *HelpStr) {
+  void addLiteralOption(StringRef Name, const DT &V, StringRef HelpStr) {
     assert(findOption(Name) == Values.size() && "Option already exists!");
     OptionInfo X(Name, static_cast<DataType>(V), HelpStr);
     Values.push_back(X);

 
   /// removeLiteralOption - Remove the specified option.
   ///
-  void removeLiteralOption(const char *Name) {
+  void removeLiteralOption(StringRef Name) {
     unsigned N = findOption(Name);
     assert(N != Values.size() && "Option not found!");
     Values.erase(Values.begin() + N);

 public:
   basic_parser_impl(Option &O) {}
 
+  ValueExpected getValueExpectedFlagDefault() const { return ValueRequired; }
 
-  enum ValueExpected getValueExpectedFlagDefault() const {
-    return ValueRequired;
-  }
-
-  void getExtraOptionNames(SmallVectorImpl<const char *> &) {}
+  void getExtraOptionNames(SmallVectorImpl<StringRef> &) {}
 
   void initialize() {}
 

   void printOptionNoValue(const Option &O, size_t GlobalWidth) const;
 
   // getValueName - Overload in subclass to provide a better default value.
-  virtual const char *getValueName() const { return "value"; }
+  virtual StringRef getValueName() const { return "value"; }
 
   // An out-of-line virtual method to provide a 'home' for this class.
   virtual void anchor();

 
   void initialize() {}
 
-  enum ValueExpected getValueExpectedFlagDefault() const {
-    return ValueOptional;
-  }
+  ValueExpected getValueExpectedFlagDefault() const { return ValueOptional; }
 
   // getValueName - Do not print =<value> at all.
-  const char *getValueName() const override { return nullptr; }
+  StringRef getValueName() const override { return StringRef(); }
 
   void printOptionDiff(const Option &O, bool V, OptVal Default,
                        size_t GlobalWidth) const;

   // parse - Return true on error.
   bool parse(Option &O, StringRef ArgName, StringRef Arg, boolOrDefault &Val);
 
-  enum ValueExpected getValueExpectedFlagDefault() const {
-    return ValueOptional;
-  }
+  ValueExpected getValueExpectedFlagDefault() const { return ValueOptional; }
 
   // getValueName - Do not print =<value> at all.
-  const char *getValueName() const override { return nullptr; }
+  StringRef getValueName() const override { return StringRef(); }
 
   void printOptionDiff(const Option &O, boolOrDefault V, OptVal Default,
                        size_t GlobalWidth) const;

   bool parse(Option &O, StringRef ArgName, StringRef Arg, int &Val);
 
   // getValueName - Overload in subclass to provide a better default value.
-  const char *getValueName() const override { return "int"; }
+  StringRef getValueName() const override { return "int"; }
 
   void printOptionDiff(const Option &O, int V, OptVal Default,
                        size_t GlobalWidth) const;

   bool parse(Option &O, StringRef ArgName, StringRef Arg, unsigned &Val);
 
   // getValueName - Overload in subclass to provide a better default value.
-  const char *getValueName() const override { return "uint"; }
+  StringRef getValueName() const override { return "uint"; }
 
   void printOptionDiff(const Option &O, unsigned V, OptVal Default,
                        size_t GlobalWidth) const;

              unsigned long long &Val);
 
   // getValueName - Overload in subclass to provide a better default value.
-  const char *getValueName() const override { return "uint"; }
+  StringRef getValueName() const override { return "uint"; }
 
   void printOptionDiff(const Option &O, unsigned long long V, OptVal Default,
                        size_t GlobalWidth) const;

   bool parse(Option &O, StringRef ArgName, StringRef Arg, double &Val);
 
   // getValueName - Overload in subclass to provide a better default value.
-  const char *getValueName() const override { return "number"; }
+  StringRef getValueName() const override { return "number"; }
 
   void printOptionDiff(const Option &O, double V, OptVal Default,
                        size_t GlobalWidth) const;

   bool parse(Option &O, StringRef ArgName, StringRef Arg, float &Val);
 
   // getValueName - Overload in subclass to provide a better default value.
-  const char *getValueName() const override { return "number"; }
+  StringRef getValueName() const override { return "number"; }
 
   void printOptionDiff(const Option &O, float V, OptVal Default,
                        size_t GlobalWidth) const;

   }
 
   // getValueName - Overload in subclass to provide a better default value.
-  const char *getValueName() const override { return "string"; }
+  StringRef getValueName() const override { return "string"; }
 
   void printOptionDiff(const Option &O, StringRef V, OptVal Default,
                        size_t GlobalWidth) const;

   }
 
   // getValueName - Overload in subclass to provide a better default value.
-  const char *getValueName() const override { return "char"; }
+  StringRef getValueName() const override { return "char"; }
 
   void printOptionDiff(const Option &O, char V, OptVal Default,
                        size_t GlobalWidth) const;

     return false;
   }
 
-  enum ValueExpected getValueExpectedFlagDefault() const override {
+  ValueExpected getValueExpectedFlagDefault() const override {
     return Parser.getValueExpectedFlagDefault();
   }
-  void
-  getExtraOptionNames(SmallVectorImpl<const char *> &OptionNames) override {
+  void getExtraOptionNames(SmallVectorImpl<StringRef> &OptionNames) override {
     return Parser.getExtraOptionNames(OptionNames);
   }
 

   std::vector<unsigned> Positions;
   ParserClass Parser;
 
-  enum ValueExpected getValueExpectedFlagDefault() const override {
+  ValueExpected getValueExpectedFlagDefault() const override {
     return Parser.getValueExpectedFlagDefault();
   }
-  void
-  getExtraOptionNames(SmallVectorImpl<const char *> &OptionNames) override {
+  void getExtraOptionNames(SmallVectorImpl<StringRef> &OptionNames) override {
     return Parser.getExtraOptionNames(OptionNames);
   }
 

   std::vector<unsigned> Positions;
   ParserClass Parser;
 
-  enum ValueExpected getValueExpectedFlagDefault() const override {
+  ValueExpected getValueExpectedFlagDefault() const override {
     return Parser.getValueExpectedFlagDefault();
   }
-  void
-  getExtraOptionNames(SmallVectorImpl<const char *> &OptionNames) override {
+  void getExtraOptionNames(SmallVectorImpl<StringRef> &OptionNames) override {
     return Parser.getExtraOptionNames(OptionNames);
   }
 

 // printed to stderr at the end of the regular help, just before
 // exit is called.
 struct extrahelp {
-  const char *morehelp;
-  explicit extrahelp(const char *help);
+  StringRef morehelp;
+  explicit extrahelp(StringRef help);
 };
 
 void PrintVersionMessage();

lib/Support/CommandLine.cpp

   // Globals for name and overview of program.  Program name is not a string to
   // avoid static ctor/dtor issues.
   std::string ProgramName;
-  const char *ProgramOverview;
+  StringRef ProgramOverview;
 
   // This collects additional help to be printed.
-  std::vector<const char *> MoreHelp;
+  std::vector<StringRef> MoreHelp;
 
   SmallVector<Option *, 4> PositionalOpts;
   SmallVector<Option *, 4> SinkOpts;

   // This collects the different option categories that have been registered.
   SmallPtrSet<OptionCategory *, 16> RegisteredOptionCategories;
 
-  CommandLineParser() : ProgramOverview(nullptr), ConsumeAfterOpt(nullptr) {}
+  CommandLineParser() : ConsumeAfterOpt(nullptr) {}
 
   void ParseCommandLineOptions(int argc, const char *const *argv,
-                               const char *Overview);
+                               StringRef Overview);
 
-  void addLiteralOption(Option &Opt, const char *Name) {
+  void addLiteralOption(Option &Opt, StringRef Name) {
     if (!Opt.hasArgStr()) {
       if (!OptionsMap.insert(std::make_pair(Name, &Opt)).second) {
         errs() << ProgramName << ": CommandLine Error: Option '" << Name

 
   void addOption(Option *O) {
     bool HadErrors = false;
-    if (O->ArgStr[0]) {
+    if (O->hasArgStr()) {
       // Add argument to the argument map!
-      if (!OptionsMap.insert(std::make_pair(O->ArgStr, O)).second) {
-        errs() << ProgramName << ": CommandLine Error: Option '" << O->ArgStr
-               << "' registered more than once!\n";
+      if (!OptionsMap.insert(std::make_pair(O->getArgStr(), O)).second) {
+        errs() << ProgramName << ": CommandLine Error: Option '"
+               << O->getArgStr() << "' registered more than once!\n";
         HadErrors = true;
       }
     }

   }
 
   void removeOption(Option *O) {
-    SmallVector<const char *, 16> OptionNames;
+    SmallVector<StringRef, 16> OptionNames;
     O->getExtraOptionNames(OptionNames);
-    if (O->ArgStr[0])
-      OptionNames.push_back(O->ArgStr);
+    if (O->hasArgStr())
+      OptionNames.push_back(O->getArgStr());
     for (auto Name : OptionNames)
-      OptionsMap.erase(StringRef(Name));
-
-    if (O->getFormattingFlag() == cl::Positional)
-      for (auto Opt = PositionalOpts.begin(); Opt != PositionalOpts.end();
-           ++Opt) {
-        if (*Opt == O) {
-          PositionalOpts.erase(Opt);
-          break;
-        }
-      }
-    else if (O->getMiscFlags() & cl::Sink)
-      for (auto Opt = SinkOpts.begin(); Opt != SinkOpts.end(); ++Opt) {
-        if (*Opt == O) {
-          SinkOpts.erase(Opt);
-          break;
-        }
-      }
-    else if (O == ConsumeAfterOpt)
+      OptionsMap.erase(Name);
+
+    if (O->getFormattingFlag() == cl::Positional) {
+      PositionalOpts.erase(
+          std::find(PositionalOpts.begin(), PositionalOpts.end(), O));
+    } else if (O->getMiscFlags() & cl::Sink) {
+      SinkOpts.erase(std::find(SinkOpts.begin(), SinkOpts.end(), O));
+    } else if (O == ConsumeAfterOpt) {
       ConsumeAfterOpt = nullptr;
+    }
   }
 
   bool hasOptions() {

             nullptr != ConsumeAfterOpt);
   }
 
-  void updateArgStr(Option *O, const char *NewName) {
+  void updateArgStr(Option *O, StringRef NewName) {
     if (!OptionsMap.insert(std::make_pair(NewName, O)).second) {
-      errs() << ProgramName << ": CommandLine Error: Option '" << O->ArgStr
+      errs() << ProgramName << ": CommandLine Error: Option '" << O->getArgStr()
              << "' registered more than once!\n";
       report_fatal_error("inconsistency in registered CommandLine options");
     }
-    OptionsMap.erase(StringRef(O->ArgStr));
+    OptionsMap.erase(O->getArgStr());
   }
 
   void printOptionValues();

 
 static ManagedStatic<CommandLineParser> GlobalParser;
 
-void cl::AddLiteralOption(Option &O, const char *Name) {
+void cl::AddLiteralOption(Option &O, StringRef Name) {
   GlobalParser->addLiteralOption(O, Name);
 }
 
-extrahelp::extrahelp(const char *Help) : morehelp(Help) {
+extrahelp::extrahelp(StringRef Help) : morehelp(Help) {
   GlobalParser->MoreHelp.push_back(Help);
 }
 

 
 void Option::removeArgument() { GlobalParser->removeOption(this); }
 
-void Option::setArgStr(const char *S) {
+void Option::setArgStr(StringRef S) {
   if (FullyInitialized)
     GlobalParser->updateArgStr(this, S);
   ArgStr = S;

   // Find the closest match.
   Option *Best = nullptr;
   unsigned BestDistance = 0;
-  for (StringMap<Option *>::const_iterator it = OptionsMap.begin(),
-                                           ie = OptionsMap.end();
-       it != ie; ++it) {
-    Option *O = it->second;
-    SmallVector<const char *, 16> OptionNames;
+  for (const auto &it : OptionsMap) {
+    Option *O = it.second;
+    SmallVector<StringRef, 16> OptionNames;
     O->getExtraOptionNames(OptionNames);
-    if (O->ArgStr[0])
-      OptionNames.push_back(O->ArgStr);
+    if (O->hasArgStr())
+      OptionNames.push_back(O->getArgStr());
 
     bool PermitValue = O->getValueExpectedFlag() != cl::ValueDisallowed;
     StringRef Flag = PermitValue ? LHS : Arg;
-    for (size_t i = 0, e = OptionNames.size(); i != e; ++i) {
-      StringRef Name = OptionNames[i];
-      unsigned Distance = StringRef(Name).edit_distance(
-          Flag, /*AllowReplacements=*/true, /*MaxEditDistance=*/BestDistance);
+    for (const auto &Name : OptionNames) {
+      unsigned Distance = Name.edit_distance(Flag, /*AllowReplacements=*/true,
+                                             /*MaxEditDistance=*/BestDistance);
       if (!Best || Distance < BestDistance) {
         Best = O;
         BestDistance = Distance;
         if (RHS.empty() || !PermitValue)
-          NearestString = OptionNames[i];
+          NearestString = Name;
         else
-          NearestString = (Twine(OptionNames[i]) + "=" + RHS).str();
+          NearestString = (Twine(Name) + "=" + RHS).str();
       }
     }
   }

 
 static bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i) {
   int Dummy = i;
-  return ProvideOption(Handler, Handler->ArgStr, Arg, 0, nullptr, Dummy);
+  return ProvideOption(Handler, Handler->getArgStr(), Arg, 0, nullptr, Dummy);
 }
 
 // Option predicates...

   return (S.size() >= 3 && S[0] == '\xef' && S[1] == '\xbb' && S[2] == '\xbf');
 }
 
-static bool ExpandResponseFile(const char *FName, StringSaver &Saver,
+static bool ExpandResponseFile(StringRef FName, StringSaver &Saver,
                                TokenizerCallback Tokenizer,
                                SmallVectorImpl<const char *> &NewArgv,
                                bool MarkEOLs = false) {

 /// from the caller (as PROGNAME) and its command-line arguments from
 /// an environment variable (whose name is given in ENVVAR).
 ///
-void cl::ParseEnvironmentOptions(const char *progName, const char *envVar,
-                                 const char *Overview) {
+void cl::ParseEnvironmentOptions(StringRef progName, StringRef envVar,
+                                 StringRef Overview) {
   // Check args.
-  assert(progName && "Program name not specified");
-  assert(envVar && "Environment variable name missing");
+  assert(!progName.empty() && "Program name not specified");
+  assert(!envVar.empty() && "Environment variable name missing");
 
   // Get the environment variable they want us to parse options out of.
-  const char *envValue = getenv(envVar);
+  const char *envValue = getenv(envVar.begin());
   if (!envValue)
     return;
 

 }
 
 void cl::ParseCommandLineOptions(int argc, const char *const *argv,
-                                 const char *Overview) {
+                                 StringRef Overview) {
   GlobalParser->ParseCommandLineOptions(argc, argv, Overview);
 }
 
 void CommandLineParser::ParseCommandLineOptions(int argc,
                                                 const char *const *argv,
-                                                const char *Overview) {
+                                                StringRef Overview) {
   assert(hasOptions() && "No options specified!");
 
   // Expand response files.

 
     // Calculate how many positional values are _required_.
     bool UnboundedFound = false;
-    for (size_t i = 0, e = PositionalOpts.size(); i != e; ++i) {
-      Option *Opt = PositionalOpts[i];
+    for (const auto &Opt : PositionalOpts) {
       if (RequiresValue(Opt))
         ++NumPositionalRequired;
       else if (ConsumeAfterOpt) {

               "error - this positional option will never be matched, "
               "because it does not Require a value, and a "
               "cl::ConsumeAfter option is active!");
-      } else if (UnboundedFound && !Opt->ArgStr[0]) {
+      } else if (UnboundedFound && !Opt->hasArgStr()) {
         // This option does not "require" a value...  Make sure this option is
         // not specified after an option that eats all extra arguments, or this
         // one will never get any!

                                    "another positional argument will match an "
                                    "unbounded number of values, and this option"
                                    " does not require a value!");
-        errs() << ProgramName << ": CommandLine Error: Option '" << Opt->ArgStr
-               << "' is all messed up!\n";
+        errs() << ProgramName << ": CommandLine Error: Option '"
+               << Opt->getArgStr() << "' is all messed up!\n";
         errs() << PositionalOpts.size();
       }
       UnboundedFound |= EatsUnboundedNumberOfValues(Opt);

 
         ErrorParsing = true;
       } else {
-        for (SmallVectorImpl<Option *>::iterator I = SinkOpts.begin(),
-                                                 E = SinkOpts.end();
-             I != E; ++I)
-          (*I)->addOccurrence(i, "", argv[i]);
+        for (auto &I : SinkOpts)
+          I->addOccurrence(i, "", argv[i]);
       }
       continue;
     }

   } else if (!ConsumeAfterOpt) {
     // Positional args have already been handled if ConsumeAfter is specified.
     unsigned ValNo = 0, NumVals = static_cast<unsigned>(PositionalVals.size());
-    for (size_t i = 0, e = PositionalOpts.size(); i != e; ++i) {
-      if (RequiresValue(PositionalOpts[i])) {
-        ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first,
+    for (const auto &Opt : PositionalOpts) {
+      if (RequiresValue(Opt)) {
+        ProvidePositionalOption(Opt, PositionalVals[ValNo].first,
                                 PositionalVals[ValNo].second);
         ValNo++;
         --NumPositionalRequired; // We fulfilled our duty...

       // do not give it values that others need.  'Done' controls whether the
       // option even _WANTS_ any more.
       //
-      bool Done = PositionalOpts[i]->getNumOccurrencesFlag() == cl::Required;
+      bool Done = Opt->getNumOccurrencesFlag() == cl::Required;
       while (NumVals - ValNo > NumPositionalRequired && !Done) {
-        switch (PositionalOpts[i]->getNumOccurrencesFlag()) {
+        switch (Opt->getNumOccurrencesFlag()) {
         case cl::Optional:
           Done = true; // Optional arguments want _at most_ one value
         // FALL THROUGH
         case cl::ZeroOrMore: // Zero or more will take all they can get...
         case cl::OneOrMore:  // One or more will take all they can get...
-          ProvidePositionalOption(PositionalOpts[i],
-                                  PositionalVals[ValNo].first,
+          ProvidePositionalOption(Opt, PositionalVals[ValNo].first,
                                   PositionalVals[ValNo].second);
           ValNo++;
           break;

   } else {
     assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size());
     unsigned ValNo = 0;
-    for (size_t j = 1, e = PositionalOpts.size(); j != e; ++j)
-      if (RequiresValue(PositionalOpts[j])) {
-        ErrorParsing |= ProvidePositionalOption(PositionalOpts[j],
-                                                PositionalVals[ValNo].first,
-                                                PositionalVals[ValNo].second);
+    for (const auto &Opt : PositionalOpts)
+      if (RequiresValue(Opt)) {
+        ErrorParsing |= ProvidePositionalOption(
+            Opt, PositionalVals[ValNo].first, PositionalVals[ValNo].second);
         ValNo++;
       }
 

   if (!ArgName.data())
     ArgName = ArgStr;
   if (ArgName.empty())
-    errs() << HelpStr; // Be nice for positional arguments
+    errs() << Description; // Be nice for positional arguments
   else
     errs() << GlobalParser->ProgramName << ": for the -" << ArgName;
 

 // getValueStr - Get the value description string, using "DefaultMsg" if nothing
 // has been specified yet.
 //
-static const char *getValueStr(const Option &O, const char *DefaultMsg) {
-  if (O.ValueStr[0] == 0)
+static StringRef getValueStr(const Option &O, StringRef DefaultMsg) {
+  if (!O.hasValueStr())
     return DefaultMsg;
-  return O.ValueStr;
+  return O.getValueStr();
 }
 
 //===----------------------------------------------------------------------===//

 //
 
 // Return the width of the option tag for printing...
-size_t alias::getOptionWidth() const { return std::strlen(ArgStr) + 6; }
+size_t alias::getOptionWidth() const { return ArgStr.size() + 6; }
 
 static void printHelpStr(StringRef HelpStr, size_t Indent,
                          size_t FirstLineIndentedBy) {

 // Print out the option for the alias.
 void alias::printOptionInfo(size_t GlobalWidth) const {
   outs() << "  -" << ArgStr;
-  printHelpStr(HelpStr, GlobalWidth, std::strlen(ArgStr) + 6);
+  printHelpStr(Description, GlobalWidth, ArgStr.size() + 6);
 }
 
 //===----------------------------------------------------------------------===//

 
 // Return the width of the option tag for printing...
 size_t basic_parser_impl::getOptionWidth(const Option &O) const {
-  size_t Len = std::strlen(O.ArgStr);
-  if (const char *ValName = getValueName())
-    Len += std::strlen(getValueStr(O, ValName)) + 3;
+  size_t Len = O.getArgStr().size();
+  StringRef ValName = getValueName();
+  if (!ValName.empty())
+    Len += getValueStr(O, ValName).size() + 3;
 
   return Len + 6;
 }

 //
 void basic_parser_impl::printOptionInfo(const Option &O,
                                         size_t GlobalWidth) const {
-  outs() << "  -" << O.ArgStr;
+  outs() << "  -" << O.getArgStr();
 
-  if (const char *ValName = getValueName())
+  StringRef ValName = getValueName();
+  if (!ValName.empty())
     outs() << "=<" << getValueStr(O, ValName) << '>';
 
-  printHelpStr(O.HelpStr, GlobalWidth, getOptionWidth(O));
+  printHelpStr(O.getDescription(), GlobalWidth, getOptionWidth(O));
 }
 
 void basic_parser_impl::printOptionName(const Option &O,
                                         size_t GlobalWidth) const {
-  outs() << "  -" << O.ArgStr;
-  outs().indent(GlobalWidth - std::strlen(O.ArgStr));
+  outs() << "  -" << O.getArgStr();
+  outs().indent(GlobalWidth - O.getArgStr().size());
 }
 
 // parser<bool> implementation

 // findOption - Return the option number corresponding to the specified
 // argument string.  If the option is not found, getNumOptions() is returned.
 //
-unsigned generic_parser_base::findOption(const char *Name) {
+unsigned generic_parser_base::findOption(StringRef Name) {
   unsigned e = getNumOptions();
 
   for (unsigned i = 0; i != e; ++i) {
-    if (strcmp(getOption(i), Name) == 0)
+    if (getOption(i) == Name)
       return i;
   }
   return e;

 // Return the width of the option tag for printing...
 size_t generic_parser_base::getOptionWidth(const Option &O) const {
   if (O.hasArgStr()) {
-    size_t Size = std::strlen(O.ArgStr) + 6;
+    size_t Size = O.getArgStr().size() + 6;
     for (unsigned i = 0, e = getNumOptions(); i != e; ++i)
-      Size = std::max(Size, std::strlen(getOption(i)) + 8);
+      Size = std::max(Size, getOption(i).size() + 8);
     return Size;
-  } else {
-    size_t BaseSize = 0;
-    for (unsigned i = 0, e = getNumOptions(); i != e; ++i)
-      BaseSize = std::max(BaseSize, std::strlen(getOption(i)) + 8);
-    return BaseSize;
   }
+  size_t BaseSize = 0;
+  for (unsigned i = 0, e = getNumOptions(); i != e; ++i)
+    BaseSize = std::max(BaseSize, getOption(i).size() + 8);
+  return BaseSize;
 }
 
 // printOptionInfo - Print out information about this option.  The

 void generic_parser_base::printOptionInfo(const Option &O,
                                           size_t GlobalWidth) const {
   if (O.hasArgStr()) {
-    outs() << "  -" << O.ArgStr;
-    printHelpStr(O.HelpStr, GlobalWidth, std::strlen(O.ArgStr) + 6);
+    outs() << "  -" << O.getArgStr();
+    printHelpStr(O.getDescription(), GlobalWidth, O.getArgStr().size() + 6);
 
     for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
-      size_t NumSpaces = GlobalWidth - strlen(getOption(i)) - 8;
+      size_t NumSpaces = GlobalWidth - getOption(i).size() - 8;
       outs() << "    =" << getOption(i);
       outs().indent(NumSpaces) << " -   " << getDescription(i) << '\n';
     }
   } else {
-    if (O.HelpStr[0])
-      outs() << "  " << O.HelpStr << '\n';
+    if (O.hasDescriptionStr())
+      outs() << "  " << O.getDescription() << '\n';
     for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
-      const char *Option = getOption(i);
+      StringRef Option = getOption(i);
       outs() << "    -" << Option;
-      printHelpStr(getDescription(i), GlobalWidth, std::strlen(Option) + 8);
+      printHelpStr(getDescription(i), GlobalWidth, Option.size() + 8);
     }
   }
 }

 void generic_parser_base::printGenericOptionDiff(
     const Option &O, const GenericOptionValue &Value,
     const GenericOptionValue &Default, size_t GlobalWidth) const {
-  outs() << "  -" << O.ArgStr;
-  outs().indent(GlobalWidth - std::strlen(O.ArgStr));
+  outs() << "  -" << O.getArgStr();
+  outs().indent(GlobalWidth - O.getArgStr().size());
 
   unsigned NumOpts = getNumOptions();
   for (unsigned i = 0; i != NumOpts; ++i) {

       continue;
 
     outs() << "= " << getOption(i);
-    size_t L = std::strlen(getOption(i));
+    size_t L = getOption(i).size();
     size_t NumSpaces = MaxOptWidth > L ? MaxOptWidth - L : 0;
     outs().indent(NumSpaces) << " (default: ";
     for (unsigned j = 0; j != NumOpts; ++j) {

 // -help and -help-hidden option implementation
 //
 
-static int OptNameCompare(const std::pair<const char *, Option *> *LHS,
-                          const std::pair<const char *, Option *> *RHS) {
-  return strcmp(LHS->first, RHS->first);
+static int OptNameCompare(const std::pair<StringRef, Option *> *LHS,
+                          const std::pair<StringRef, Option *> *RHS) {
+  return LHS->first.compare(RHS->first);
 }
 
 // Copy Options into a vector so we can sort them as we like.
 static void sortOpts(StringMap<Option *> &OptMap,
-                     SmallVectorImpl<std::pair<const char *, Option *>> &Opts,
+                     SmallVectorImpl<std::pair<StringRef, Option *>> &Opts,
                      bool ShowHidden) {
   SmallPtrSet<Option *, 128> OptionSet; // Duplicate option detection.
 
-  for (StringMap<Option *>::iterator I = OptMap.begin(), E = OptMap.end();
-       I != E; ++I) {
+  for (const auto &I : OptMap) {
     // Ignore really-hidden options.
-    if (I->second->getOptionHiddenFlag() == ReallyHidden)
+    if (I.second->getOptionHiddenFlag() == ReallyHidden)
       continue;
 
     // Unless showhidden is set, ignore hidden flags.
-    if (I->second->getOptionHiddenFlag() == Hidden && !ShowHidden)
+    if (I.second->getOptionHiddenFlag() == Hidden && !ShowHidden)
       continue;
 
     // If we've already seen this option, don't add it to the list again.
-    if (!OptionSet.insert(I->second).second)
+    if (!OptionSet.insert(I.second).second)
       continue;
 
-    Opts.push_back(
-        std::pair<const char *, Option *>(I->getKey().data(), I->second));
+    Opts.push_back(std::pair<StringRef, Option *>(I.getKey().data(), I.second));
   }
 
   // Sort the options list alphabetically.

 class HelpPrinter {
 protected:
   const bool ShowHidden;
-  typedef SmallVector<std::pair<const char *, Option *>, 128>
-      StrOptionPairVector;
+  typedef SmallVector<std::pair<StringRef, Option *>, 128> StrOptionPairVector;
   // Print the options. Opts is assumed to be alphabetically sorted.
   virtual void printOptions(StrOptionPairVector &Opts, size_t MaxArgLen) {
-    for (size_t i = 0, e = Opts.size(); i != e; ++i)
-      Opts[i].second->printOptionInfo(MaxArgLen);
+    for (const auto &Opt : Opts)
+      Opt.second->printOptionInfo(MaxArgLen);
   }
 
 public:

     StrOptionPairVector Opts;
     sortOpts(GlobalParser->OptionsMap, Opts, ShowHidden);
 
-    if (GlobalParser->ProgramOverview)
+    if (GlobalParser->ProgramOverview.empty() == false)
       outs() << "OVERVIEW: " << GlobalParser->ProgramOverview << "\n";
 
     outs() << "USAGE: " << GlobalParser->ProgramName << " [options]";
 
     for (auto Opt : GlobalParser->PositionalOpts) {
-      if (Opt->ArgStr[0])
-        outs() << " --" << Opt->ArgStr;
-      outs() << " " << Opt->HelpStr;
+      if (Opt->hasArgStr())
+        outs() << " --" << Opt->getArgStr();
+      outs() << " " << Opt->getDescription();
     }
 
     // Print the consume after option info if it exists...
     if (GlobalParser->ConsumeAfterOpt)
-      outs() << " " << GlobalParser->ConsumeAfterOpt->HelpStr;
+      outs() << " " << GlobalParser->ConsumeAfterOpt->getDescription();
 
     outs() << "\n\n";
 
     // Compute the maximum argument length...
     size_t MaxArgLen = 0;
-    for (size_t i = 0, e = Opts.size(); i != e; ++i)
-      MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth());
+    for (const auto &Opt : Opts)
+      MaxArgLen = std::max(MaxArgLen, Opt.second->getOptionWidth());
 
     outs() << "OPTIONS:\n";
     printOptions(Opts, MaxArgLen);

   // ordered before B's name. It returns a value greater equal zero otherwise.
   static int OptionCategoryCompare(OptionCategory *const *A,
                                    OptionCategory *const *B) {
-    return strcmp((*A)->getName(), (*B)->getName());
+    return (*A)->getName().compare((*B)->getName());
   }
 
   // Make sure we inherit our base class's operator=()

 
     // Collect registered option categories into vector in preparation for
     // sorting.
-    for (auto I = GlobalParser->RegisteredOptionCategories.begin(),
-              E = GlobalParser->RegisteredOptionCategories.end();
-         I != E; ++I) {
-      SortedCategories.push_back(*I);
+    for (const auto &I : GlobalParser->RegisteredOptionCategories) {
+      SortedCategories.push_back(I);
     }
 
     // Sort the different option categories alphabetically.

                    OptionCategoryCompare);
 
     // Create map to empty vectors.
-    for (std::vector<OptionCategory *>::const_iterator
-             I = SortedCategories.begin(),
-             E = SortedCategories.end();
-         I != E; ++I)
-      CategorizedOptions[*I] = std::vector<Option *>();
+    for (const auto &I : SortedCategories)
+      CategorizedOptions[I] = std::vector<Option *>();
 
     // Walk through pre-sorted options and assign into categories.
     // Because the options are already alphabetically sorted the
     // options within categories will also be alphabetically sorted.
-    for (size_t I = 0, E = Opts.size(); I != E; ++I) {
-      Option *Opt = Opts[I].second;
+    for (const auto &I : Opts) {
+      Option *Opt = I.second;
       assert(CategorizedOptions.count(Opt->Category) > 0 &&
              "Option has an unregistered category");
       CategorizedOptions[Opt->Category].push_back(Opt);
     }
 
     // Now do printing.
-    for (std::vector<OptionCategory *>::const_iterator
-             Category = SortedCategories.begin(),
-             E = SortedCategories.end();
-         Category != E; ++Category) {
+    for (const auto &Category : SortedCategories) {
       // Hide empty categories for -help, but show for -help-hidden.
-      bool IsEmptyCategory = CategorizedOptions[*Category].size() == 0;
+      bool IsEmptyCategory = CategorizedOptions[Category].size() == 0;
       if (!ShowHidden && IsEmptyCategory)
         continue;
 
       // Print category information.
       outs() << "\n";
-      outs() << (*Category)->getName() << ":\n";
+      outs() << Category->getName() << ":\n";
 
       // Check if description is set.
-      if ((*Category)->getDescription() != nullptr)
-        outs() << (*Category)->getDescription() << "\n\n";
+      if (!Category->getDescription().empty())
+        outs() << Category->getDescription() << "\n\n";
       else
         outs() << "\n";
 

         continue;
       }
       // Loop over the options in the category and print.
-      for (std::vector<Option *>::const_iterator
-               Opt = CategorizedOptions[*Category].begin(),
-               E = CategorizedOptions[*Category].end();
-           Opt != E; ++Opt)
-        (*Opt)->printOptionInfo(MaxArgLen);
+      for (const auto &Opt : CategorizedOptions[Category])
+        Opt->printOptionInfo(MaxArgLen);
     }
   }
 };

   if (!PrintOptions && !PrintAllOptions)
     return;
 
-  SmallVector<std::pair<const char *, Option *>, 128> Opts;
+  SmallVector<std::pair<StringRef, Option *>, 128> Opts;
   sortOpts(OptionsMap, Opts, /*ShowHidden*/ true);
 
   // Compute the maximum argument length...
   size_t MaxArgLen = 0;
-  for (size_t i = 0, e = Opts.size(); i != e; ++i)
-    MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth());
+  for (const auto &Opt : Opts)
+    MaxArgLen = std::max(MaxArgLen, Opt.second->getOptionWidth());
 
-  for (size_t i = 0, e = Opts.size(); i != e; ++i)
-    Opts[i].second->printOptionValue(MaxArgLen, PrintAllOptions);
+  for (const auto &Opt : Opts)
+    Opt.second->printOptionValue(MaxArgLen, PrintAllOptions);
 }
 
 static void (*OverrideVersionPrinter)() = nullptr;

     // information.
     if (ExtraVersionPrinters != nullptr) {
       outs() << '\n';
-      for (std::vector<void (*)()>::iterator I = ExtraVersionPrinters->begin(),
-                                             E = ExtraVersionPrinters->end();
-           I != E; ++I)
-        (*I)();
+      for (const auto &I : *ExtraVersionPrinters)
+        I();
     }
 
     exit(0);

tools/llvm-stress/llvm-stress.cpp

     return false;
   }
 
-  const char *getValueName() const override { return "IR scalar type"; }
+  StringRef getValueName() const override { return "IR scalar type"; }
 };
 }
 

unittests/Support/CommandLineTest.cpp

     "Failed to modify option's option category.";
 
   Retrieved->setDescription(Description);
-  ASSERT_STREQ(Retrieved->HelpStr, Description) <<
+  ASSERT_STREQ(Retrieved->getDescription().begin(), Description) <<
     "Changing option description failed.";
 
   Retrieved->setArgStr(ArgString);
-  ASSERT_STREQ(ArgString, Retrieved->ArgStr) <<
+  ASSERT_STREQ(ArgString, Retrieved->getArgStr().begin()) <<
     "Failed to modify option's Argument string.";
 
   Retrieved->setValueStr(ValueString);
-  ASSERT_STREQ(Retrieved->ValueStr, ValueString) <<
+  ASSERT_STREQ(Retrieved->getValueStr().begin(), ValueString) <<
     "Failed to modify option's Value string.";
 
   Retrieved->setHiddenFlag(cl::Hidden);

utils/FileCheck/FileCheck.cpp

   for (const auto &PatternString : ImplicitCheckNot) {
     // Create a buffer with fake command line content in order to display the
     // command line option responsible for the specific implicit CHECK-NOT.
-    std::string Prefix = std::string("-") + ImplicitCheckNot.ArgStr + "='";
+    std::string Prefix =
+        std::string("-") + ImplicitCheckNot.getArgStr().str() + "='";
     std::string Suffix = "'";
     std::unique_ptr<MemoryBuffer> CmdLine = MemoryBuffer::getMemBufferCopy(
         Prefix + PatternString + Suffix, "command line");