Improve raw_ostream so that you can "write" colors using operator<<

[ruiu]

Summary

1. raw_ostream supports ANSI colors so that you can write messages

to the termina with colors. Previously, in order to change and reset
color, you had to call changeColor and resetColor functions,
respectively.

So, if you print out "error: " in red, for example, you had to do
something like this:

OS.changeColor(raw_ostream::RED);
OS << "error: ";
OS.resetColor();

With this patch, you can write the same code as follows:

OS << raw_ostream::RED << "error: " << raw_ostream::RESET;

2. Add a boolean flag to raw_ostream so that you can disable colored

output. If you disable colors, changeColor, operator<<(Color), resetColor
and other color-related functions have no effect.

Most LLVM tools automatically prints out messages using colors, and
you can disable it by passing a flag such as --disable-colors.
This new flag makes it easy to write code that works that way.

[grimar]

It looks good to me. A minor nit is inlined.

clang/tools/diagtool/TreeView.cpp

30 ↗

(On Diff #212758)

nit: Seems out should be uppercase here.
(I see it was like that before your changes, but seems you touching all the places where it was used, so seems you can fix it).

[MaskRay]

LGTM

[andreadb]

LGTM too.

[seiya]

LGTM too.

[ruiu]

clang/tools/diagtool/TreeView.cpp

30 ↗

(On Diff #212758)

Yes, this is inconsistent, but we probably shouldn't change this in this patch.

[ruiu]

• rebased

cfe/trunk/include/clang/AST/ASTDumperUtils.h

enum ASTDumpOutputFormat {
   ADOF_Default,
   ADOF_JSON
 };
 
 // Colors used for various parts of the AST dump
 // Do not use bold yellow for any text.  It is hard to read on white screens.
 
 struct TerminalColor {
-  llvm::raw_ostream::Colors Color;
+  llvm::raw_ostream::Color Color;
   bool Bold;
 };
 
 // Red           - CastColor
 // Green         - TypeColor
 // Bold Green    - DeclKindNameColor, UndeserializedColor
 // Yellow        - AddressColor, LocationColor
 // Blue          - CommentColor, NullColor, IndentColor

cfe/trunk/lib/Analysis/CFG.cpp

if (B.getTerminator().isValid()) {
 
     if (ShowColors)
       OS.resetColor();
   }
 
   if (print_edges) {
     // Print the predecessors of this block.
     if (!B.pred_empty()) {
-      const raw_ostream::Colors Color = raw_ostream::BLUE;
+      const raw_ostream::Color Color = raw_ostream::BLUE;
       if (ShowColors)
         OS.changeColor(Color);
       OS << "   Preds " ;
       if (ShowColors)
         OS.resetColor();
       OS << '(' << B.pred_size() << "):";
       unsigned i = 0;
 
if (!B.pred_empty()) {
       if (ShowColors)
         OS.resetColor();
 
       OS << '\n';
     }
 
     // Print the successors of this block.
     if (!B.succ_empty()) {
-      const raw_ostream::Colors Color = raw_ostream::MAGENTA;
+      const raw_ostream::Color Color = raw_ostream::MAGENTA;
       if (ShowColors)
         OS.changeColor(Color);
       OS << "   Succs ";
       if (ShowColors)
         OS.resetColor();
       OS << '(' << B.succ_size() << "):";
       unsigned i = 0;
 

cfe/trunk/lib/Frontend/CompilerInvocation.cpp

bool clang::ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
   Opts.ShowFixits = !Args.hasArg(OPT_fno_diagnostics_fixit_info);
   Opts.ShowLocation = !Args.hasArg(OPT_fno_show_source_location);
   Opts.AbsolutePath = Args.hasArg(OPT_fdiagnostics_absolute_paths);
   Opts.ShowOptionNames =
       Args.hasFlag(OPT_fdiagnostics_show_option,
                    OPT_fno_diagnostics_show_option, DefaultShowOpt);
 
   llvm::sys::Process::UseANSIEscapeCodes(Args.hasArg(OPT_fansi_escape_codes));
+  if (Opts.ShowColors) {
+    llvm::outs().enable_colors();
+    llvm::errs().enable_colors();
+  }
 
   // Default behavior is to not to show note include stacks.
   Opts.ShowNoteIncludeStack = false;
   if (Arg *A = Args.getLastArg(OPT_fdiagnostics_show_note_include_stack,
                                OPT_fno_diagnostics_show_note_include_stack))
     if (A->getOption().matches(OPT_fdiagnostics_show_note_include_stack))
       Opts.ShowNoteIncludeStack = true;
 

cfe/trunk/lib/Frontend/TextDiagnostic.cpp

 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Locale.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 
 using namespace clang;
 
-static const enum raw_ostream::Colors noteColor =
-  raw_ostream::BLACK;
-static const enum raw_ostream::Colors remarkColor =
-  raw_ostream::BLUE;
-static const enum raw_ostream::Colors fixitColor =
-  raw_ostream::GREEN;
-static const enum raw_ostream::Colors caretColor =
-  raw_ostream::GREEN;
-static const enum raw_ostream::Colors warningColor =
-  raw_ostream::MAGENTA;
-static const enum raw_ostream::Colors templateColor =
-  raw_ostream::CYAN;
-static const enum raw_ostream::Colors errorColor = raw_ostream::RED;
-static const enum raw_ostream::Colors fatalColor = raw_ostream::RED;
+static const raw_ostream::Color noteColor = raw_ostream::BLACK;
+static const raw_ostream::Color remarkColor = raw_ostream::BLUE;
+static const raw_ostream::Color fixitColor = raw_ostream::GREEN;
+static const raw_ostream::Color caretColor = raw_ostream::GREEN;
+static const raw_ostream::Color warningColor = raw_ostream::MAGENTA;
+static const raw_ostream::Color templateColor = raw_ostream::CYAN;
+static const raw_ostream::Color errorColor = raw_ostream::RED;
+static const raw_ostream::Color fatalColor = raw_ostream::RED;
 // Used for changing only the bold attribute.
-static const enum raw_ostream::Colors savedColor =
-  raw_ostream::SAVEDCOLOR;
+static const raw_ostream::Color savedColor = raw_ostream::SAVEDCOLOR;
 
 /// Add highlights to differences in template strings.
 static void applyTemplateHighlighting(raw_ostream &OS, StringRef Str,
                                       bool &Normal, bool Bold) {
   while (1) {
     size_t Pos = Str.find(ToggleHighlight);
     OS << Str.slice(0, Pos);
     if (Pos == StringRef::npos)

cfe/trunk/tools/diagtool/TreeView.cpp

 #include "llvm/Support/Format.h"
 #include "llvm/Support/Process.h"
 
 DEF_DIAGTOOL("tree", "Show warning flags in a tree view", TreeView)
 
 using namespace clang;
 using namespace diagtool;
 
-static bool hasColors(const llvm::raw_ostream &out) {
-  if (&out != &llvm::errs() && &out != &llvm::outs())
-    return false;
-  return llvm::errs().is_displayed() && llvm::outs().is_displayed();
-}
-
 class TreePrinter {
+  using Color = llvm::raw_ostream::Color;
+
 public:
   llvm::raw_ostream &out;
-  const bool ShowColors;
   bool Internal;
 
-  TreePrinter(llvm::raw_ostream &out)
-      : out(out), ShowColors(hasColors(out)), Internal(false) {}
-
-  void setColor(llvm::raw_ostream::Colors Color) {
-    if (ShowColors)
-      out << llvm::sys::Process::OutputColor(Color, false, false);
-  }
-
-  void resetColor() {
-    if (ShowColors)
-      out << llvm::sys::Process::ResetColor();
+  TreePrinter(llvm::raw_ostream &out) : out(out), Internal(false) {
+    if (&out != &llvm::errs() && &out != &llvm::outs())
+      out.disable_colors();
   }
 
   static bool isIgnored(unsigned DiagID) {
     // FIXME: This feels like a hack.
     static clang::DiagnosticsEngine Diags(new DiagnosticIDs,
                                           new DiagnosticOptions);
     return Diags.isIgnored(DiagID, SourceLocation());
   }
static bool enabledByDefault(const GroupRecord &Group) {
 
     return true;
   }
 
   void printGroup(const GroupRecord &Group, unsigned Indent = 0) {
     out.indent(Indent * 2);
 
     if (enabledByDefault(Group))
-      setColor(llvm::raw_ostream::GREEN);
+      out << Color::GREEN;
     else
-      setColor(llvm::raw_ostream::YELLOW);
+      out << Color::YELLOW;
 
-    out << "-W" << Group.getName() << "\n";
-    resetColor();
+    out << "-W" << Group.getName() << "\n" << Color::RESET;
 
     ++Indent;
     for (const GroupRecord &GR : Group.subgroups()) {
       printGroup(GR, Indent);
     }
 
     if (Internal) {
       for (const DiagnosticRecord &DR : Group.diagnostics()) {
-        if (ShowColors && !isIgnored(DR.DiagID))
-          setColor(llvm::raw_ostream::GREEN);
+        if (!isIgnored(DR.DiagID))
+          out << Color::GREEN;
         out.indent(Indent * 2);
-        out << DR.getName();
-        resetColor();
-        out << "\n";
+        out << DR.getName() << Color::RESET << "\n";
       }
     }
   }
 
   int showGroup(StringRef RootGroup) {
     ArrayRef<GroupRecord> AllGroups = getDiagnosticGroups();
 
     if (RootGroup.size() > UINT16_MAX) {
for (unsigned i = 0, e = AllGroups.size(); i != e; ++i) {
       if (!NonRootGroupIDs.count(i))
         printGroup(AllGroups[i]);
     }
 
     return 0;
   }
 
   void showKey() {
-    if (ShowColors) {
-      out << '\n';
-      setColor(llvm::raw_ostream::GREEN);
-      out << "GREEN";
-      resetColor();
-      out << " = enabled by default\n\n";
-    }
+    out << '\n'
+        << Color::GREEN << "GREEN" << Color::RESET
+        << " = enabled by default\n\n";
   }
 };
 
 static void printUsage() {
   llvm::errs() << "Usage: diagtool tree [--internal] [<diagnostic-group>]\n";
 }
 
 int TreeView::run(unsigned int argc, char **argv, llvm::raw_ostream &out) {

lld/trunk/COFF/Driver.cpp

 static Timer inputFileTimer("Input File Reading", Timer::root());
 
 Configuration *config;
 LinkerDriver *driver;
 
 bool link(ArrayRef<const char *> args, bool canExitEarly, raw_ostream &diag) {
   errorHandler().logName = args::getFilenameWithoutExe(args[0]);
   errorHandler().errorOS = &diag;
-  errorHandler().colorDiagnostics = diag.has_colors();
   errorHandler().errorLimitExceededMsg =
       "too many errors emitted, stopping now"
       " (use /errorlimit:0 to see all errors)";
   errorHandler().exitEarly = canExitEarly;
   config = make<Configuration>();
 
   symtab = make<SymbolTable>();
 

lld/trunk/COFF/DriverUtils.cpp

 
 // Set color diagnostics according to --color-diagnostics={auto,always,never}
 // or --no-color-diagnostics flags.
 static void handleColorDiagnostics(opt::InputArgList &args) {
   auto *arg = args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq,
                               OPT_no_color_diagnostics);
   if (!arg)
     return;
+
   if (arg->getOption().getID() == OPT_color_diagnostics) {
-    errorHandler().colorDiagnostics = true;
+    errorHandler().errorOS->enable_colors();
   } else if (arg->getOption().getID() == OPT_no_color_diagnostics) {
-    errorHandler().colorDiagnostics = false;
+    errorHandler().errorOS->disable_colors();
   } else {
     StringRef s = arg->getValue();
     if (s == "always")
-      errorHandler().colorDiagnostics = true;
+      errorHandler().errorOS->enable_colors();
     else if (s == "never")
-      errorHandler().colorDiagnostics = false;
+      errorHandler().errorOS->disable_colors();
     else if (s != "auto")
       error("unknown option: --color-diagnostics=" + s);
   }
 }
 
 static cl::TokenizerCallback getQuotingStyle(opt::InputArgList &args) {
   if (auto *arg = args.getLastArg(OPT_rsp_quoting)) {
     StringRef s = arg->getValue();

lld/trunk/Common/ErrorHandler.cpp

void lld::diagnosticHandler(const DiagnosticInfo &di) {
   }
 }
 
 void lld::checkError(Error e) {
   handleAllErrors(std::move(e),
                   [&](ErrorInfoBase &eib) { error(eib.message()); });
 }
 
-static std::string getLocation(std::string msg, std::string defaultMsg) {
-  static std::vector<std::regex> Regexes{
-      std::regex(R"(^undefined (?:\S+ )?symbol:.*\n>>> referenced by (\S+):(\d+)\n.*)"),
+std::string ErrorHandler::getLocation(const Twine &msg) {
+  if (!vsDiagnostics)
+    return logName;
+
+  static std::regex regexes[] = {
+      std::regex(
+          R"(^undefined (?:\S+ )?symbol:.*\n>>> referenced by (\S+):(\d+)\n.*)"),
       std::regex(R"(^undefined symbol:.*\n>>> referenced by (.*):)"),
       std::regex(
           R"(^duplicate symbol: .*\n>>> defined in (\S+)\n>>> defined in.*)"),
-      std::regex(
-          R"(^duplicate symbol: .*\n>>> defined at (\S+):(\d+).*)"),
-      std::regex(
-          R"(.*\n>>> defined in .*\n>>> referenced by (\S+):(\d+))"),
+      std::regex(R"(^duplicate symbol: .*\n>>> defined at (\S+):(\d+).*)"),
+      std::regex(R"(.*\n>>> defined in .*\n>>> referenced by (\S+):(\d+))"),
       std::regex(R"((\S+):(\d+): unclosed quote)"),
   };
 
-  std::smatch Match;
-  for (std::regex &Re : Regexes) {
-    if (std::regex_search(msg, Match, Re)) {
-      return Match.size() > 2 ? Match.str(1) + "(" + Match.str(2) + ")"
-                              : Match.str(1);
-    }
-  }
-  return defaultMsg;
-}
+  std::string str = msg.str();
 
-void ErrorHandler::printHeader(StringRef s, raw_ostream::Colors c,
-                               const Twine &msg) {
+  for (std::regex &re : regexes) {
+    std::smatch match;
+    if (!std::regex_search(str, match, re))
+      continue;
 
-  if (vsDiagnostics) {
-    // A Visual Studio-style error message starts with an error location.
-    // If a location cannot be extracted then we default to LogName.
-    *errorOS << getLocation(msg.str(), logName) << ": ";
-  } else {
-    *errorOS << logName << ": ";
+    if (match.size() > 2)
+      return match.str(1) + "(" + match.str(2) + ")";
+    return match.str(1);
   }
 
-  if (colorDiagnostics) {
-    errorOS->changeColor(c, true);
-    *errorOS << s;
-    errorOS->resetColor();
-  } else {
-    *errorOS << s;
-  }
+  return logName;
 }
 
 void ErrorHandler::log(const Twine &msg) {
-  if (verbose) {
-    std::lock_guard<std::mutex> lock(mu);
-    *errorOS << logName << ": " << msg << "\n";
-  }
-}
+  if (!verbose)
+    return;
 
 void ErrorHandler::message(const Twine &msg) {
   std::lock_guard<std::mutex> lock(mu);
   outs() << msg << "\n";
   outs().flush();
 }
 
 void ErrorHandler::warn(const Twine &msg) {
   if (fatalWarnings) {
     error(msg);
     return;
   }
 
   std::lock_guard<std::mutex> lock(mu);
   newline(errorOS, msg);
-  printHeader("warning: ", raw_ostream::MAGENTA, msg);
-  *errorOS << msg << "\n";
+  *errorOS << getLocation(msg) << ": " << Color::MAGENTA
+           << "warning: " << Color::RESET << msg << "\n";
 }
 
-void ErrorHandler::printErrorMsg(const Twine &msg) {
-  newline(errorOS, msg);
-  printHeader("error: ", raw_ostream::RED, msg);
-  *errorOS << msg << "\n";
-}
-
-void ErrorHandler::printError(const Twine &msg) {
+void ErrorHandler::error(const Twine &msg) {
+  // If Microsoft Visual Studio-style error message mode is enabled,
+  // this particular error is printed out as two errors.
   if (vsDiagnostics) {
-    static std::regex reDuplicateSymbol(
-        R"(^(duplicate symbol: .*))"
+    static std::regex re(R"(^(duplicate symbol: .*))"
                          R"((\n>>> defined at \S+:\d+\n>>>.*))"
                          R"((\n>>> defined at \S+:\d+\n>>>.*))");
-    std::string msgStr = msg.str();
-    std::smatch match;
-    if (std::regex_match(msgStr, match, reDuplicateSymbol)) {
-      printErrorMsg(match.str(1) + match.str(2));
-      printErrorMsg(match.str(1) + match.str(3));
+    std::string str = msg.str();
+    std::smatch m;
+
+    if (std::regex_match(str, m, re)) {
+      error(m.str(1) + m.str(2));
+      error(m.str(1) + m.str(3));
       return;
     }
   }
-  printErrorMsg(msg);
-}
 
-void ErrorHandler::error(const Twine &msg) {
   std::lock_guard<std::mutex> lock(mu);
 
   if (errorLimit == 0 || errorCount < errorLimit) {
-    printError(msg);
+    newline(errorOS, msg);
+    *errorOS << getLocation(msg) << ": " << Color::RED
+             << "error: " << Color::RESET << msg << "\n";
   } else if (errorCount == errorLimit) {
     newline(errorOS, msg);
-    printHeader("error: ", raw_ostream::RED, msg);
-    *errorOS << errorLimitExceededMsg << "\n";
+    *errorOS << getLocation(msg) << ": " << Color::RED
+             << "error: " << Color::RESET << errorLimitExceededMsg << "\n";
     if (exitEarly)
       exitLld(1);
   }
 
   ++errorCount;
 }
 
 void ErrorHandler::fatal(const Twine &msg) {
   error(msg);
   exitLld(1);
 }

lld/trunk/ELF/Driver.cpp

 bool elf::link(ArrayRef<const char *> args, bool canExitEarly,
                raw_ostream &error) {
   errorHandler().logName = args::getFilenameWithoutExe(args[0]);
   errorHandler().errorLimitExceededMsg =
       "too many errors emitted, stopping now (use "
       "-error-limit=0 to see all errors)";
   errorHandler().errorOS = &error;
   errorHandler().exitEarly = canExitEarly;
-  errorHandler().colorDiagnostics = error.has_colors();
 
   inputSections.clear();
   outputSections.clear();
   binaryFiles.clear();
   bitcodeFiles.clear();
   objectFiles.clear();
   sharedFiles.clear();
 

lld/trunk/ELF/DriverUtils.cpp

 
 // Set color diagnostics according to -color-diagnostics={auto,always,never}
 // or -no-color-diagnostics flags.
 static void handleColorDiagnostics(opt::InputArgList &args) {
   auto *arg = args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq,
                               OPT_no_color_diagnostics);
   if (!arg)
     return;
+
   if (arg->getOption().getID() == OPT_color_diagnostics) {
-    errorHandler().colorDiagnostics = true;
+    errorHandler().errorOS->enable_colors();
   } else if (arg->getOption().getID() == OPT_no_color_diagnostics) {
-    errorHandler().colorDiagnostics = false;
+    errorHandler().errorOS->disable_colors();
   } else {
     StringRef s = arg->getValue();
     if (s == "always")
-      errorHandler().colorDiagnostics = true;
+      errorHandler().errorOS->enable_colors();
     else if (s == "never")
-      errorHandler().colorDiagnostics = false;
+      errorHandler().errorOS->disable_colors();
     else if (s != "auto")
       error("unknown option: --color-diagnostics=" + s);
   }
 }
 
 static cl::TokenizerCallback getQuotingStyle(opt::InputArgList &args) {
   if (auto *arg = args.getLastArg(OPT_rsp_quoting)) {
     StringRef s = arg->getValue();

lld/trunk/include/lld/Common/ErrorHandler.h

 
 class ErrorHandler {
 public:
   uint64_t errorCount = 0;
   uint64_t errorLimit = 20;
   StringRef errorLimitExceededMsg = "too many errors emitted, stopping now";
   StringRef logName = "lld";
   llvm::raw_ostream *errorOS = &llvm::errs();
-  bool colorDiagnostics = llvm::errs().has_colors();
   bool exitEarly = true;
   bool fatalWarnings = false;
   bool verbose = false;
   bool vsDiagnostics = false;
 
   void error(const Twine &msg);
   LLVM_ATTRIBUTE_NORETURN void fatal(const Twine &msg);
   void log(const Twine &msg);
   void message(const Twine &msg);
   void warn(const Twine &msg);
 
   std::unique_ptr<llvm::FileOutputBuffer> outputBuffer;
 
 private:
-  void printHeader(StringRef s, raw_ostream::Colors c, const Twine &msg);
-  void printErrorMsg(const Twine &msg);
-  void printError(const Twine &msg);
+  using Color = raw_ostream::Color;
+
+  std::string getLocation(const Twine &msg);
 };
 
 /// Returns the default error handler.
 ErrorHandler &errorHandler();
 
 inline void error(const Twine &msg) { errorHandler().error(msg); }
 inline LLVM_ATTRIBUTE_NORETURN void fatal(const Twine &msg) {
   errorHandler().fatal(msg);

lld/trunk/lib/Driver/DarwinLdDriver.cpp

 bool link(llvm::ArrayRef<const char *> args, bool CanExitEarly,
           raw_ostream &Error) {
   errorHandler().logName = args::getFilenameWithoutExe(args[0]);
   errorHandler().errorLimitExceededMsg =
       "too many errors emitted, stopping now (use "
       "'-error-limit 0' to see all errors)";
   errorHandler().errorOS = &Error;
   errorHandler().exitEarly = CanExitEarly;
-  errorHandler().colorDiagnostics = Error.has_colors();
 
   MachOLinkingContext ctx;
   if (!parse(args, ctx))
     return false;
   if (ctx.doNothing())
     return true;
   if (ctx.getNodes().empty())
     return false;

lld/trunk/test/COFF/color-diagnostics.test

 # Windows command prompt doesn't support ANSI escape sequences.
 # REQUIRES: shell
 
 # RUN: not lld-link -xyz --color-diagnostics /nosuchfile 2>&1 \
 # RUN:   | FileCheck -check-prefix=COLOR %s
 # RUN: not lld-link -xyz --color-diagnostics=always /nosuchfile 2>&1 \
 # RUN:   | FileCheck -check-prefix=COLOR %s
 
-# COLOR: {{lld-link: .\[0;1;35mwarning: .\[0mignoring unknown argument '-xyz'}}
-# COLOR: {{lld-link: .\[0;1;31merror: .\[0mcould not open '/nosuchfile'}}
+# COLOR: {{lld-link: .\[0;35mwarning: .\[0mignoring unknown argument '-xyz'}}
+# COLOR: {{lld-link: .\[0;31merror: .\[0mcould not open '/nosuchfile'}}
 
 # RUN: not lld-link /nosuchfile 2>&1 | FileCheck -check-prefix=NOCOLOR %s
 # RUN: not lld-link -color-diagnostics=never /nosuchfile 2>&1 \
 # RUN:   | FileCheck -check-prefix=NOCOLOR %s
 # RUN: not lld-link -color-diagnostics=always -no-color-diagnostics \
 # RUN:   /nosuchfile 2>&1 | FileCheck -check-prefix=NOCOLOR %s
 
 # NOCOLOR: lld-link: error: could not open '/nosuchfile'

lld/trunk/test/ELF/color-diagnostics.test

 # Windows command prompt doesn't support ANSI escape sequences.
 # REQUIRES: shell
 
 # RUN: not ld.lld -xyz -color-diagnostics /nosuchfile 2>&1 \
 # RUN:   | FileCheck -check-prefix=COLOR %s
 # RUN: not ld.lld -xyz -color-diagnostics=always /nosuchfile 2>&1 \
 # RUN:   | FileCheck -check-prefix=COLOR %s
 
-# COLOR: {{ld.lld: .\[0;1;31merror: .\[0munknown argument '-xyz'}}
-# COLOR: {{ld.lld: .\[0;1;31merror: .\[0mcannot open /nosuchfile}}
+# COLOR: {{ld.lld: .\[0;31merror: .\[0munknown argument '-xyz'}}
+# COLOR: {{ld.lld: .\[0;31merror: .\[0mcannot open /nosuchfile}}
 
 # RUN: not ld.lld -color-diagnostics=foobar 2>&1 | FileCheck -check-prefix=ERR %s
 # ERR: unknown option: --color-diagnostics=foobar
 
 # RUN: not ld.lld /nosuchfile 2>&1 | FileCheck -check-prefix=NOCOLOR %s
 # RUN: not ld.lld -color-diagnostics=never /nosuchfile 2>&1 \
 # RUN:   | FileCheck -check-prefix=NOCOLOR %s
 # RUN: not ld.lld -color-diagnostics=always -no-color-diagnostics \
 # RUN:   /nosuchfile 2>&1 | FileCheck -check-prefix=NOCOLOR %s
 
 # NOCOLOR: ld.lld: error: cannot open /nosuchfile

lld/trunk/wasm/Driver.cpp

private:
   std::vector<InputFile *> files;
 };
 } // anonymous namespace
 
 bool lld::wasm::link(ArrayRef<const char *> args, bool canExitEarly,
                      raw_ostream &error) {
   errorHandler().logName = args::getFilenameWithoutExe(args[0]);
   errorHandler().errorOS = &error;
-  errorHandler().colorDiagnostics = error.has_colors();
   errorHandler().errorLimitExceededMsg =
       "too many errors emitted, stopping now (use "
       "-error-limit=0 to see all errors)";
 
   config = make<Configuration>();
   symtab = make<SymbolTable>();
 
   initLLVM();

 
 // Set color diagnostics according to -color-diagnostics={auto,always,never}
 // or -no-color-diagnostics flags.
 static void handleColorDiagnostics(opt::InputArgList &args) {
   auto *arg = args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq,
                               OPT_no_color_diagnostics);
   if (!arg)
     return;
+
   if (arg->getOption().getID() == OPT_color_diagnostics) {
-    errorHandler().colorDiagnostics = true;
+    errorHandler().errorOS->enable_colors();
   } else if (arg->getOption().getID() == OPT_no_color_diagnostics) {
-    errorHandler().colorDiagnostics = false;
+    errorHandler().errorOS->disable_colors();
   } else {
     StringRef s = arg->getValue();
     if (s == "always")
-      errorHandler().colorDiagnostics = true;
+      errorHandler().errorOS->enable_colors();
     else if (s == "never")
-      errorHandler().colorDiagnostics = false;
+      errorHandler().errorOS->disable_colors();
     else if (s != "auto")
       error("unknown option: --color-diagnostics=" + s);
   }
 }
 
 // Find a file by concatenating given paths.
 static Optional<std::string> findFile(StringRef path1, const Twine &path2) {
   SmallString<128> s;

llvm/trunk/include/llvm/Support/FormattedStream.h

raw_ostream &resetColor() override {
     return *this;
   }
 
   raw_ostream &reverseColor() override {
     TheStream->reverseColor();
     return *this;
   }
 
-  raw_ostream &changeColor(enum Colors Color, bool Bold, bool BG) override {
-    TheStream->changeColor(Color, Bold, BG);
+  raw_ostream &changeColor(Color C, bool Bold, bool BG) override {
+    TheStream->changeColor(C, Bold, BG);
     return *this;
   }
 
   bool is_displayed() const override {
     return TheStream->is_displayed();
   }
 
 private:

llvm/trunk/include/llvm/Support/WithColor.h

public:
   /// To be used like this: WithColor(OS, raw_ostream::Black) << "text";
   /// @param OS The output stream
   /// @param Color ANSI color to use, the special SAVEDCOLOR can be used to
   /// change only the bold attribute, and keep colors untouched
   /// @param Bold Bold/brighter text, default false
   /// @param BG If true, change the background, default: change foreground
   /// @param DisableColors Whether to ignore color changes regardless of -color
   /// and support in OS
-  WithColor(raw_ostream &OS,
-            raw_ostream::Colors Color = raw_ostream::SAVEDCOLOR,
+  WithColor(raw_ostream &OS, raw_ostream::Color Color = raw_ostream::SAVEDCOLOR,
             bool Bold = false, bool BG = false, bool DisableColors = false)
       : OS(OS), DisableColors(DisableColors) {
     changeColor(Color, Bold, BG);
   }
   ~WithColor();
 
   raw_ostream &get() { return OS; }
   operator raw_ostream &() { return OS; }
public:
   /// Determine whether colors are displayed.
   bool colorsEnabled();
 
   /// Change the color of text that will be output from this point forward.
   /// @param Color ANSI color to use, the special SAVEDCOLOR can be used to
   /// change only the bold attribute, and keep colors untouched
   /// @param Bold Bold/brighter text, default false
   /// @param BG If true, change the background, default: change foreground
-  WithColor &changeColor(raw_ostream::Colors Color, bool Bold = false,
+  WithColor &changeColor(raw_ostream::Color Color, bool Bold = false,
                          bool BG = false);
 
   /// Reset the colors to terminal defaults. Call this when you are done
   /// outputting colored text, or before program exit.
   WithColor &resetColor();
 };
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_DEBUGINFO_WITHCOLOR_H

llvm/trunk/include/llvm/Support/raw_ostream.h

private:
   enum BufferKind {
     Unbuffered = 0,
     InternalBuffer,
     ExternalBuffer
   } BufferMode;
 
 public:
   // color order matches ANSI escape sequence, don't change
-  enum Colors {
+  enum class Color {
     BLACK = 0,
     RED,
     GREEN,
     YELLOW,
     BLUE,
     MAGENTA,
     CYAN,
     WHITE,
-    SAVEDCOLOR
+    SAVEDCOLOR,
+    RESET,
   };
 
+  static const Color BLACK = Color::BLACK;
+  static const Color RED = Color::RED;
+  static const Color GREEN = Color::GREEN;
+  static const Color YELLOW = Color::YELLOW;
+  static const Color BLUE = Color::BLUE;
+  static const Color MAGENTA = Color::MAGENTA;
+  static const Color CYAN = Color::CYAN;
+  static const Color WHITE = Color::WHITE;
+  static const Color SAVEDCOLOR = Color::SAVEDCOLOR;
+  static const Color RESET = Color::RESET;
+
   explicit raw_ostream(bool unbuffered = false)
       : BufferMode(unbuffered ? Unbuffered : InternalBuffer) {
     // Start out ready to flush.
     OutBufStart = OutBufEnd = OutBufCur = nullptr;
   }
 
   raw_ostream(const raw_ostream &) = delete;
   void operator=(const raw_ostream &) = delete;
raw_ostream &operator<<(int N) {
     return this->operator<<(static_cast<long>(N));
   }
 
   raw_ostream &operator<<(double N);
 
   /// Output \p N in hexadecimal, without any prefix or padding.
   raw_ostream &write_hex(unsigned long long N);
 
+  // Change the foreground color of text.
+  raw_ostream &operator<<(Color C);
+
   /// Output a formatted UUID with dash separators.
   using uuid_t = uint8_t[16];
   raw_ostream &write_uuid(const uuid_t UUID);
 
   /// Output \p Str, turning '\\', '\t', '\n', '"', and anything that doesn't
   /// satisfy llvm::isPrint into an escape sequence.
   raw_ostream &write_escaped(StringRef Str, bool UseHexEscapes = false);
 
public:
   /// indent - Insert 'NumSpaces' spaces.
   raw_ostream &indent(unsigned NumSpaces);
 
   /// write_zeros - Insert 'NumZeros' nulls.
   raw_ostream &write_zeros(unsigned NumZeros);
 
   /// Changes the foreground color of text that will be output from this point
   /// forward.
-  /// @param Color ANSI color to use, the special SAVEDCOLOR can be used to
+  /// @param C ANSI color to use, the special SAVEDCOLOR can be used to
   /// change only the bold attribute, and keep colors untouched
   /// @param Bold bold/brighter text, default false
   /// @param BG if true change the background, default: change foreground
   /// @returns itself so it can be used within << invocations
-  virtual raw_ostream &changeColor(enum Colors Color,
-                                   bool Bold = false,
+  virtual raw_ostream &changeColor(Color C, bool Bold = false,
                                    bool BG = false) {
-    (void)Color;
+    (void)C;
     (void)Bold;
     (void)BG;
     return *this;
   }
 
   /// Resets the colors to terminal defaults. Call this when you are done
   /// outputting colored text, or before program exit.
   virtual raw_ostream &resetColor() { return *this; }
 
   /// Reverses the foreground and background colors.
   virtual raw_ostream &reverseColor() { return *this; }
 
   /// This function determines if this stream is connected to a "tty" or
   /// "console" window. That is, the output would be displayed to the user
   /// rather than being put on a pipe or stored in a file.
   virtual bool is_displayed() const { return false; }
 
   /// This function determines if this stream is displayed and supports colors.
   virtual bool has_colors() const { return is_displayed(); }
 
+  // Enable or disable colors. Once disable_colors() is called,
+  // changeColor() has no effect until enable_colors() is called.
+  virtual void enable_colors() {}
+  virtual void disable_colors() {}
+
   //===--------------------------------------------------------------------===//
   // Subclass Interface
   //===--------------------------------------------------------------------===//
 
 private:
   /// The is the piece of the class that is implemented by subclasses.  This
   /// writes the \p Size bytes starting at
   /// \p Ptr to the underlying stream.

 /// A raw_ostream that writes to a file descriptor.
 ///
 class raw_fd_ostream : public raw_pwrite_stream {
   int FD;
   bool ShouldClose;
 
   bool SupportsSeeking;
 
+  bool ColorEnabled;
+
 #ifdef _WIN32
   /// True if this fd refers to a Windows console device. Mintty and other
   /// terminal emulators are TTYs, but they are not consoles.
   bool IsWindowsConsole = false;
 #endif
 
   std::error_code EC;
 
public:
   void close();
 
   bool supportsSeeking() { return SupportsSeeking; }
 
   /// Flushes the stream and repositions the underlying file descriptor position
   /// to the offset specified from the beginning of the file.
   uint64_t seek(uint64_t off);
 
-  raw_ostream &changeColor(enum Colors colors, bool bold=false,
-                           bool bg=false) override;
+  raw_ostream &changeColor(Color C, bool bold = false,
+                           bool bg = false) override;
   raw_ostream &resetColor() override;
 
   raw_ostream &reverseColor() override;
 
   bool is_displayed() const override;
 
   bool has_colors() const override;
 
+  void enable_colors() override { ColorEnabled = true; }
+
+  void disable_colors() override { ColorEnabled = false; }
+
   std::error_code error() const { return EC; }
 
   /// Return the value of the flag in this raw_fd_ostream indicating whether an
   /// output error has been encountered.
   /// This doesn't implicitly flush any pending output.  Also, it doesn't
   /// guarantee to detect all errors unless the stream has been closed.
   bool has_error() const { return bool(EC); }
 

llvm/trunk/lib/Support/WithColor.cpp

static cl::opt<cl::boolOrDefault>
     UseColor("color", cl::cat(ColorCategory),
              cl::desc("Use colors in output (default=autodetect)"),
              cl::init(cl::BOU_UNSET));
 
 WithColor::WithColor(raw_ostream &OS, HighlightColor Color, bool DisableColors)
     : OS(OS), DisableColors(DisableColors) {
   // Detect color from terminal type unless the user passed the --color option.
   if (colorsEnabled()) {
+    OS.enable_colors();
+
     switch (Color) {
     case HighlightColor::Address:
       OS.changeColor(raw_ostream::YELLOW);
       break;
     case HighlightColor::String:
       OS.changeColor(raw_ostream::GREEN);
       break;
     case HighlightColor::Tag:

 bool WithColor::colorsEnabled() {
   if (DisableColors)
     return false;
   if (UseColor == cl::BOU_UNSET)
     return OS.has_colors();
   return UseColor == cl::BOU_TRUE;
 }
 
-WithColor &WithColor::changeColor(raw_ostream::Colors Color, bool Bold,
-                                  bool BG) {
+WithColor &WithColor::changeColor(raw_ostream::Color C, bool Bold, bool BG) {
   if (colorsEnabled())
-    OS.changeColor(Color, Bold, BG);
+    OS.changeColor(C, Bold, BG);
   return *this;
 }
 
 WithColor &WithColor::resetColor() {
   if (colorsEnabled())
     OS.resetColor();
   return *this;
 }
 
 WithColor::~WithColor() { resetColor(); }

llvm/trunk/lib/Support/raw_ostream.cpp

 
 #ifdef _WIN32
 #include "llvm/Support/ConvertUTF.h"
 #include "Windows/WindowsSupport.h"
 #endif
 
 using namespace llvm;
 
+const raw_ostream::Color raw_ostream::BLACK;
+const raw_ostream::Color raw_ostream::RED;
+const raw_ostream::Color raw_ostream::GREEN;
+const raw_ostream::Color raw_ostream::YELLOW;
+const raw_ostream::Color raw_ostream::BLUE;
+const raw_ostream::Color raw_ostream::MAGENTA;
+const raw_ostream::Color raw_ostream::CYAN;
+const raw_ostream::Color raw_ostream::WHITE;
+const raw_ostream::Color raw_ostream::SAVEDCOLOR;
+const raw_ostream::Color raw_ostream::RESET;
+
 raw_ostream::~raw_ostream() {
   // raw_ostream's subclasses should take care to flush the buffer
   // in their destructors.
   assert(OutBufCur == OutBufStart &&
          "raw_ostream destructor called with non-empty buffer!");
 
   if (BufferMode == InternalBuffer)
     delete [] OutBufStart;
raw_ostream &raw_ostream::operator<<(long long N) {
   return *this;
 }
 
 raw_ostream &raw_ostream::write_hex(unsigned long long N) {
   llvm::write_hex(*this, N, HexPrintStyle::Lower);
   return *this;
 }
 
+raw_ostream &raw_ostream::operator<<(Color C) {
+  if (C == Color::RESET)
+    resetColor();
+  else
+    changeColor(C);
+  return *this;
+}
+
 raw_ostream &raw_ostream::write_uuid(const uuid_t UUID) {
   for (int Idx = 0; Idx < 16; ++Idx) {
     *this << format("%02" PRIX32, UUID[Idx]);
     if (Idx == 3 || Idx == 5 || Idx == 7 || Idx == 9)
       *this << "-";
   }
   return *this;
 }
raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
                                sys::fs::CreationDisposition Disp,
                                sys::fs::FileAccess Access,
                                sys::fs::OpenFlags Flags)
     : raw_fd_ostream(getFD(Filename, EC, Disp, Access, Flags), true) {}
 
 /// FD is the file descriptor that this writes to.  If ShouldClose is true, this
 /// closes the file when the stream is destroyed.
 raw_fd_ostream::raw_fd_ostream(int fd, bool shouldClose, bool unbuffered)
-    : raw_pwrite_stream(unbuffered), FD(fd), ShouldClose(shouldClose) {
-  if (FD < 0 ) {
+    : raw_pwrite_stream(unbuffered), FD(fd), ShouldClose(shouldClose),
+      ColorEnabled(sys::Process::FileDescriptorHasColors(fd)) {
+  if (FD < 0) {
     ShouldClose = false;
     return;
   }
 
   // Do not attempt to close stdout or stderr. We used to try to maintain the
   // property that tools that support writing file to stdout should not also
   // write informational output to stdout, but in practice we were never able to
   // maintain this invariant. Many features have been added to LLVM and clang
if (S_ISCHR(statbuf.st_mode) && isatty(FD))
     return 0;
   // Return the preferred block size.
   return statbuf.st_blksize;
 #else
   return raw_ostream::preferred_buffer_size();
 #endif
 }
 
-raw_ostream &raw_fd_ostream::changeColor(enum Colors colors, bool bold,
-                                         bool bg) {
+raw_ostream &raw_fd_ostream::changeColor(Color color, bool bold, bool bg) {
+  if (!ColorEnabled)
+    return *this;
+
   if (sys::Process::ColorNeedsFlush())
     flush();
   const char *colorcode =
-    (colors == SAVEDCOLOR) ? sys::Process::OutputBold(bg)
-    : sys::Process::OutputColor(colors, bold, bg);
+      (color == Color::SAVEDCOLOR)
+          ? sys::Process::OutputBold(bg)
+          : sys::Process::OutputColor(static_cast<char>(color), bold, bg);
   if (colorcode) {
     size_t len = strlen(colorcode);
     write(colorcode, len);
     // don't account colors towards output characters
     pos -= len;
   }
   return *this;
 }
 
 raw_ostream &raw_fd_ostream::resetColor() {
+  if (!ColorEnabled)
+    return *this;
+
   if (sys::Process::ColorNeedsFlush())
     flush();
   const char *colorcode = sys::Process::ResetColor();
   if (colorcode) {
     size_t len = strlen(colorcode);
     write(colorcode, len);
     // don't account colors towards output characters
     pos -= len;
   }
   return *this;
 }
 
 raw_ostream &raw_fd_ostream::reverseColor() {
+  if (!ColorEnabled)
+    return *this;
+
   if (sys::Process::ColorNeedsFlush())
     flush();
   const char *colorcode = sys::Process::OutputReverse();
   if (colorcode) {
     size_t len = strlen(colorcode);
     write(colorcode, len);
     // don't account colors towards output characters
     pos -= len;

llvm/trunk/tools/llvm-cov/CoverageReport.cpp

void renderDivider(ArrayRef<size_t> ColumnWidths, raw_ostream &OS) {
   size_t Length = std::accumulate(ColumnWidths.begin(), ColumnWidths.end(), 0);
   for (size_t I = 0; I < Length; ++I)
     OS << '-';
 }
 
 /// Return the color which correponds to the coverage percentage of a
 /// certain metric.
 template <typename T>
-raw_ostream::Colors determineCoveragePercentageColor(const T &Info) {
+raw_ostream::Color determineCoveragePercentageColor(const T &Info) {
   if (Info.isFullyCovered())
     return raw_ostream::GREEN;
   return Info.getPercentCovered() >= 80.0 ? raw_ostream::YELLOW
                                           : raw_ostream::RED;
 }
 
 /// Get the number of redundant path components in each path in \p Paths.
 unsigned getNumRedundantPathComponents(ArrayRef<std::string> Paths) {

llvm/trunk/tools/llvm-cov/CoverageViewOptions.h

struct CoverageViewOptions {
   std::vector<std::string> DemanglerOpts;
   uint32_t TabSize;
   std::string ProjectTitle;
   std::string CreatedTimeStr;
   unsigned NumThreads;
 
   /// Change the output's stream color if the colors are enabled.
   ColoredRawOstream colored_ostream(raw_ostream &OS,
-                                    raw_ostream::Colors Color) const {
+                                    raw_ostream::Color Color) const {
     return llvm::colored_ostream(OS, Color, Colors);
   }
 
   /// Check if an output directory has been specified.
   bool hasOutputDirectory() const { return !ShowOutputDirectory.empty(); }
 
   /// Check if a demangler has been specified.
   bool hasDemangler() const { return !DemanglerOpts.empty(); }

llvm/trunk/tools/llvm-cov/RenderingSupport.h

 template <typename T>
 inline raw_ostream &operator<<(const ColoredRawOstream &OS, T &&Value) {
   return OS.OS << std::forward<T>(Value);
 }
 
 /// Change the color of the output stream if the `IsColorUsed` flag
 /// is true. Returns an object that resets the color when destroyed.
 inline ColoredRawOstream colored_ostream(raw_ostream &OS,
-                                         raw_ostream::Colors Color,
+                                         raw_ostream::Color Color,
                                          bool IsColorUsed = true,
                                          bool Bold = false, bool BG = false) {
   if (IsColorUsed)
     OS.changeColor(Color, Bold, BG);
   return ColoredRawOstream(OS, IsColorUsed);
 }
 
 } // namespace llvm
 
 #endif // LLVM_COV_RENDERINGSUPPORT_H

llvm/trunk/tools/llvm-cov/SourceCoverageViewText.cpp

void SourceCoverageViewText::renderLine(raw_ostream &OS, LineRef L,
                                         const LineCoverageStats &LCS,
                                         unsigned ExpansionCol,
                                         unsigned ViewDepth) {
   StringRef Line = L.Line;
   unsigned LineNumber = L.LineNo;
   auto *WrappedSegment = LCS.getWrappedSegment();
   CoverageSegmentArray Segments = LCS.getLineSegments();
 
-  Optional<raw_ostream::Colors> Highlight;
+  Optional<raw_ostream::Color> Highlight;
   SmallVector<std::pair<unsigned, unsigned>, 2> HighlightedRanges;
 
   // The first segment overlaps from a previous line, so we treat it specially.
   if (WrappedSegment && !WrappedSegment->IsGapRegion &&
       WrappedSegment->HasCount && WrappedSegment->Count == 0)
     Highlight = raw_ostream::RED;
 
   // Output each segment of the line, possibly highlighted.

llvm/trunk/tools/llvm-cov/llvm-cov.cpp

if (argc > 1) {
 
     if (Func) {
       std::string Invocation = std::string(argv[0]) + " " + argv[1];
       argv[1] = Invocation.c_str();
       return Func(argc - 1, argv + 1);
     }
   }
 
-  if (argc > 1) {
-    if (sys::Process::StandardErrHasColors())
-      errs().changeColor(raw_ostream::RED);
-    errs() << "Unrecognized command: " << argv[1] << ".\n\n";
-    if (sys::Process::StandardErrHasColors())
-      errs().resetColor();
-  }
+  if (argc > 1)
+    errs() << raw_ostream::RED << "Unrecognized command: " << argv[1] << ".\n\n"
+           << raw_ostream::RESET;
+
   helpMain(argc, argv);
   return 1;
 }

llvm/trunk/tools/llvm-mca/Views/TimelineView.cpp

case HWInstructionEvent::Dispatched:
     break;
   default:
     return;
   }
   if (CurrentCycle < MaxCycle)
     LastCycle = std::max(LastCycle, CurrentCycle);
 }
 
-static raw_ostream::Colors chooseColor(unsigned CumulativeCycles,
-                                       unsigned Executions, int BufferSize) {
+static raw_ostream::Color chooseColor(unsigned CumulativeCycles,
   if (CumulativeCycles && BufferSize < 0)
     return raw_ostream::MAGENTA;
   unsigned Size = static_cast<unsigned>(BufferSize);
   if (CumulativeCycles >= Size * Executions)
     return raw_ostream::RED;
   if ((CumulativeCycles * 2) >= Size * Executions)
     return raw_ostream::YELLOW;
   return raw_ostream::SAVEDCOLOR;
 }
 
 static void tryChangeColor(raw_ostream &OS, unsigned Cycles,
                            unsigned Executions, int BufferSize) {
   if (!OS.has_colors())
     return;
 
-  raw_ostream::Colors Color = chooseColor(Cycles, Executions, BufferSize);
+  raw_ostream::Color Color = chooseColor(Cycles, Executions, BufferSize);
   if (Color == raw_ostream::SAVEDCOLOR) {
     OS.resetColor();
     return;
   }
   OS.changeColor(Color, /* bold */ true, /* BG */ false);
 }
 
 void TimelineView::printWaitTimeEntry(formatted_raw_ostream &OS,

llvm/trunk/utils/FileCheck/FileCheck.cpp

for (int I = 0; I < argc; I++)
     errs() << " " << argv[I];
   errs() << "\n";
 }
 
 struct MarkerStyle {
   /// The starting char (before tildes) for marking the line.
   char Lead;
   /// What color to use for this annotation.
-  raw_ostream::Colors Color;
+  raw_ostream::Color Color;
   /// A note to follow the marker, or empty string if none.
   std::string Note;
   MarkerStyle() {}
-  MarkerStyle(char Lead, raw_ostream::Colors Color,
-              const std::string &Note = "")
+  MarkerStyle(char Lead, raw_ostream::Color Color, const std::string &Note = "")
       : Lead(Lead), Color(Color), Note(Note) {}
 };
 
 static MarkerStyle GetMarker(FileCheckDiag::MatchType MatchTy) {
   switch (MatchTy) {
   case FileCheckDiag::MatchFoundAndExpected:
     return MarkerStyle('^', raw_ostream::GREEN);
   case FileCheckDiag::MatchFoundButExcluded: