Convert Arg, ArgList, and Option to dump() to dbgs() rather than errs().

[jlebar]

Summary

Also add print() functions.

[echristo]

LGTM, thanks!

-eric

[echristo]

Committed thusly:

M lib/Option/Option.cpp
M lib/Option/Arg.cpp
M lib/Option/ArgList.cpp
M include/llvm/Option/Option.h
M include/llvm/Option/Arg.h
M include/llvm/Option/ArgList.h
r256010 = f306cdcf52a89377dc703502d1067577789eb348 (refs/remotes/origin/master)

include/llvm/Option/Arg.h

public:
 
   /// \brief Append the argument, render as an input, onto the given
   /// array as strings.
   ///
   /// The distinction is that some options only render their values
   /// when rendered as a input (e.g., Xlinker).
   void renderAsInput(const ArgList &Args, ArgStringList &Output) const;
 
+  void print(raw_ostream &O) const;
   void dump() const;
 
   /// \brief Return a formatted version of the argument and
   /// its values, for debugging and diagnostics.
   std::string getAsString(const ArgList &Args) const;
 };
 
 } // end namespace opt
 } // end namespace llvm
 
 #endif

include/llvm/Option/ArgList.h

const char *MakeArgString(const Twine &Str) const {
     return MakeArgStringRef(Str.toStringRef(Buf));
   }
 
   /// \brief Create an arg string for (\p LHS + \p RHS), reusing the
   /// string at \p Index if possible.
   const char *GetOrMakeJoinedArgString(unsigned Index, StringRef LHS,
                                         StringRef RHS) const;
 
+  void print(raw_ostream &O) const;
   void dump() const;
 
   /// @}
 };
 
 class InputArgList final : public ArgList {
 private:
   /// List of argument strings used by the contained Args.

include/llvm/Option/Option.h

public:
   /// Index to the position where argument parsing should resume
   /// (even if the argument is missing values).
   ///
   /// \param ArgSize The number of bytes taken up by the matched Option prefix
   ///                and name. This is used to determine where joined values
   ///                start.
   Arg *accept(const ArgList &Args, unsigned &Index, unsigned ArgSize) const;
 
+  void print(raw_ostream &O) const;
   void dump() const;
 };
 
 } // end namespace opt
 } // end namespace llvm
 
 #endif

lib/Option/Arg.cpp

 //===--- Arg.cpp - Argument Implementations -------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Option/Arg.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/Debug.h"
 
 using namespace llvm;
 using namespace llvm::opt;
 
 Arg::Arg(const Option Opt, StringRef S, unsigned Index, const Arg *BaseArg)
     : Opt(Opt), BaseArg(BaseArg), Spelling(S), Index(Index), Claimed(false),
       OwnsValues(false) {}
 

 
 Arg::~Arg() {
   if (OwnsValues) {
     for (unsigned i = 0, e = Values.size(); i != e; ++i)
       delete[] Values[i];
   }
 }
 
-void Arg::dump() const {
-  llvm::errs() << "<";
+void Arg::print(raw_ostream& O) const {
+  O << "<";
 
-  llvm::errs() << " Opt:";
-  Opt.dump();
+  O << " Opt:";
+  Opt.print(O);
 
-  llvm::errs() << " Index:" << Index;
+  O << " Index:" << Index;
 
-  llvm::errs() << " Values: [";
+  O << " Values: [";
   for (unsigned i = 0, e = Values.size(); i != e; ++i) {
-    if (i) llvm::errs() << ", ";
-    llvm::errs() << "'" << Values[i] << "'";
+    if (i) O << ", ";
+    O << "'" << Values[i] << "'";
   }
 
-  llvm::errs() << "]>\n";
+  O << "]>\n";
 }
 
+LLVM_DUMP_METHOD void Arg::dump() const { print(dbgs()); }
+
 std::string Arg::getAsString(const ArgList &Args) const {
   SmallString<256> Res;
   llvm::raw_svector_ostream OS(Res);
 
   ArgStringList ASL;
   render(Args, ASL);
   for (ArgStringList::iterator
          it = ASL.begin(), ie = ASL.end(); it != ie; ++it) {

lib/Option/ArgList.cpp

 //===--- ArgList.cpp - Argument List Management ---------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Option/ArgList.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/Option.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::opt;
 
 void arg_iterator::SkipToNextArg() {
   for (; Current != Args.end(); ++Current) {
     // Done if there are no filters.
const char *ArgList::GetOrMakeJoinedArgString(unsigned Index,
   StringRef Cur = getArgString(Index);
   if (Cur.size() == LHS.size() + RHS.size() &&
       Cur.startswith(LHS) && Cur.endswith(RHS))
     return Cur.data();
 
   return MakeArgString(LHS + RHS);
 }
 
-LLVM_DUMP_METHOD void ArgList::dump() const {
+void ArgList::print(raw_ostream &O) const {
   for (Arg *A : *this) {
-    llvm::errs() << "* ";
-    A->dump();
+    O << "* ";
+    A->print(O);
   }
 }
 
+LLVM_DUMP_METHOD void ArgList::dump() const { print(dbgs()); }
+
 //
 
 void InputArgList::releaseMemory() {
   // An InputArgList always owns its arguments.
   for (Arg *A : *this)
     delete A;
 }
 

lib/Option/Option.cpp

 //===--- Option.cpp - Abstract Driver Options -----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Option/Option.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 
 using namespace llvm;
 using namespace llvm::opt;
 
 Option::Option(const OptTable::Info *info, const OptTable *owner)
   : Info(info), Owner(owner) {
 
   // Multi-level aliases are not supported. This just simplifies option
   // tracking, it is not an inherent limitation.
   assert((!Info || !getAlias().isValid() || !getAlias().getAlias().isValid()) &&
          "Multi-level aliases are not supported.");
 
   if (Info && getAliasArgs()) {
     assert(getAlias().isValid() && "Only alias options can have alias args.");
     assert(getKind() == FlagClass && "Only Flag aliases can have alias args.");
     assert(getAlias().getKind() != FlagClass &&
            "Cannot provide alias args to a flag option.");
   }
 }
 
-void Option::dump() const {
-  llvm::errs() << "<";
+void Option::print(raw_ostream &O) const {
+  O << "<";
   switch (getKind()) {
-#define P(N) case N: llvm::errs() << #N; break
+#define P(N) case N: O << #N; break
     P(GroupClass);
     P(InputClass);
     P(UnknownClass);
     P(FlagClass);
     P(JoinedClass);
     P(SeparateClass);
     P(CommaJoinedClass);
     P(MultiArgClass);
     P(JoinedOrSeparateClass);
     P(JoinedAndSeparateClass);
     P(RemainingArgsClass);
 #undef P
   }
 
   if (Info->Prefixes) {
-    llvm::errs() << " Prefixes:[";
-    for (const char * const *Pre = Info->Prefixes; *Pre != nullptr; ++Pre) {
-      llvm::errs() << '"' << *Pre << (*(Pre + 1) == nullptr ? "\"" : "\", ");
+    O << " Prefixes:[";
+    for (const char *const *Pre = Info->Prefixes; *Pre != nullptr; ++Pre) {
+      O << '"' << *Pre << (*(Pre + 1) == nullptr ? "\"" : "\", ");
     }
-    llvm::errs() << ']';
+    O << ']';
   }
 
-  llvm::errs() << " Name:\"" << getName() << '"';
+  O << " Name:\"" << getName() << '"';
 
   const Option Group = getGroup();
   if (Group.isValid()) {
-    llvm::errs() << " Group:";
-    Group.dump();
+    O << " Group:";
+    Group.print(O);
   }
 
   const Option Alias = getAlias();
   if (Alias.isValid()) {
-    llvm::errs() << " Alias:";
-    Alias.dump();
+    O << " Alias:";
+    Alias.print(O);
   }
 
   if (getKind() == MultiArgClass)
-    llvm::errs() << " NumArgs:" << getNumArgs();
+    O << " NumArgs:" << getNumArgs();
 
-  llvm::errs() << ">\n";
+  O << ">\n";
 }
 
+void Option::dump() const { print(dbgs()); }
+
 bool Option::matches(OptSpecifier Opt) const {
   // Aliases are never considered in matching, look through them.
   const Option Alias = getAlias();
   if (Alias.isValid())
     return Alias.matches(Opt);
 
   // Check exact match.
   if (getID() == Opt.getID())