[Support] Allow the ability to change WithColor's auto detection function

[JDevlieghere]

Summary

WithColor has an "auto detection mode" which looks whether the corresponding whether the corresponding cl::opt is enabled or not. While this is great when opting into cl::opt, it's not so great for downstream users of this utility, which might have their own competing options to enable or disable colors. The WithColor constructor takes a color mode, but the big benefit of the class are its static error and warning helpers and default error handlers.

In order to allow users of this utility to enable or disable colors globally, this patch adds the ability to specify a global auto detection function. By default, the auto detection function behaves the way that it does today. The benefit of this patch lies in that it can be overwritten. In addition to a ability to change the auto detection function, I've also made it possible to get your hands on the default auto detection function, so you swap it back if if you so desire.

This patch allow downstream users (like LLDB) to globally disable colors with its own command line flag.

[tmatheson]

llvm/include/llvm/Support/WithColor.h

142

This introduces a global constructor call into libSupport, which it should not. See https://reviews.llvm.org/rG5eb2e9aa64b7be7cd8ed7f36de19c2c9bdf1977c

lldb/tools/driver/Driver.cpp

SBError Driver::ProcessArgs(const opt::InputArgList &args, bool &exiting) {
   // constructor, we can't know at that point whether we should read in init
   // files yet.  So we don't read them in in the Driver constructor, then set
   // the flags back to "read them in" here, and then if we see the "-n" flag,
   // we'll turn it off again.  Finally we have to read them in by hand later in
   // the main loop.
   m_debugger.SkipLLDBInitFiles(false);
   m_debugger.SkipAppInitFiles(false);
 
+  if (args.hasArg(OPT_no_use_colors)) {
+    m_debugger.SetUseColor(false);
+    WithColor::setAutoDetectFunction(
+        [](const llvm::raw_ostream &OS) { return false; });
+    m_option_data.m_debug_mode = true;
+  }
+
   if (args.hasArg(OPT_version)) {
     m_option_data.m_print_version = true;
   }
 
   if (args.hasArg(OPT_python_path)) {
     m_option_data.m_print_python_path = true;
   }
   if (args.hasArg(OPT_print_script_interpreter_info)) {
if (args.hasArg(OPT_no_lldbinit)) {
     m_debugger.SkipAppInitFiles(true);
   }
 
   if (args.hasArg(OPT_local_lldbinit)) {
     lldb::SBDebugger::SetInternalVariable("target.load-cwd-lldbinit", "true",
                                           m_debugger.GetInstanceName());
   }
 
-  if (args.hasArg(OPT_no_use_colors)) {
-    m_debugger.SetUseColor(false);
-    m_option_data.m_debug_mode = true;
-  }
-
   if (auto *arg = args.getLastArg(OPT_file)) {
     auto arg_value = arg->getValue();
     SBFileSpec file(arg_value);
     if (file.Exists()) {
       m_option_data.m_args.emplace_back(arg_value);
     } else if (file.ResolveExecutableLocation()) {
       char path[PATH_MAX];
       file.GetPath(path, sizeof(path));

llvm/include/llvm/Support/WithColor.h

 //===- WithColor.h ----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_WITHCOLOR_H
 #define LLVM_SUPPORT_WITHCOLOR_H
 
 #include "llvm/Support/raw_ostream.h"
 
+#include <functional>
+
 namespace llvm {
 
 class Error;
 class StringRef;
 
 namespace cl {
 class OptionCategory;
 }

 };
 
 /// An RAII object that temporarily switches an output stream to a specific
 /// color.
 class WithColor {
   raw_ostream &OS;
   ColorMode Mode;
 
+  using AutoDetectFunctionType = std::function<bool(const raw_ostream &OS)>;
+  static AutoDetectFunctionType AutoDetectFunction;
+
 public:
   /// To be used like this: WithColor(OS, HighlightColor::String) << "text";
   /// @param OS The output stream
   /// @param S Symbolic name for syntax element to color
   /// @param Mode Enable, disable or compute whether to use colors.
   WithColor(raw_ostream &OS, HighlightColor S,
             ColorMode Mode = ColorMode::Auto);
   /// To be used like this: WithColor(OS, raw_ostream::Black) << "text";
public:
 
   /// Implement default handling for Error.
   /// Print "error: " to stderr.
   static void defaultErrorHandler(Error Err);
 
   /// Implement default handling for Warning.
   /// Print "warning: " to stderr.
   static void defaultWarningHandler(Error Warning);
+
+  /// Retrieve the default color auto detection function.
+  static AutoDetectFunctionType defaultAutoDetectFunction();
+
+  /// Change the global auto detection function.
+  static void
+  setAutoDetectFunction(AutoDetectFunctionType NewAutoDetectFunction);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_WITHCOLOR_H

llvm/lib/Support/WithColor.cpp

return new cl::opt<cl::boolOrDefault>(
         cl::desc("Use colors in output (default=autodetect)"),
         cl::init(cl::BOU_UNSET));
   }
 };
 } // namespace
 static ManagedStatic<cl::opt<cl::boolOrDefault>, CreateUseColor> UseColor;
 void llvm::initWithColorOptions() { *UseColor; }
 
+WithColor::AutoDetectFunctionType WithColor::AutoDetectFunction =
+    WithColor::defaultAutoDetectFunction();
+
 WithColor::WithColor(raw_ostream &OS, HighlightColor Color, ColorMode Mode)
     : OS(OS), Mode(Mode) {
   // Detect color from terminal type unless the user passed the --color option.
   if (colorsEnabled()) {
     switch (Color) {
     case HighlightColor::Address:
       OS.changeColor(raw_ostream::YELLOW);
       break;

 
 bool WithColor::colorsEnabled() {
   switch (Mode) {
   case ColorMode::Enable:
     return true;
   case ColorMode::Disable:
     return false;
   case ColorMode::Auto:
-    return *UseColor == cl::BOU_UNSET ? OS.has_colors()
-                                      : *UseColor == cl::BOU_TRUE;
+    return AutoDetectFunction(OS);
   }
   llvm_unreachable("All cases handled above.");
 }
 
 WithColor &WithColor::changeColor(raw_ostream::Colors Color, bool Bold,
                                   bool BG) {
   if (colorsEnabled())
     OS.changeColor(Color, Bold, BG);
void WithColor::defaultErrorHandler(Error Err) {
   });
 }
 
 void WithColor::defaultWarningHandler(Error Warning) {
   handleAllErrors(std::move(Warning), [](ErrorInfoBase &Info) {
     WithColor::warning() << Info.message() << '\n';
   });
 }
+
+WithColor::AutoDetectFunctionType WithColor::defaultAutoDetectFunction() {
+  return [](const raw_ostream &OS) {
+    return *UseColor == cl::BOU_UNSET ? OS.has_colors()
+                                      : *UseColor == cl::BOU_TRUE;
+  };
+}
+
+void WithColor::setAutoDetectFunction(
+    AutoDetectFunctionType NewAutoDetectFunction) {
+  AutoDetectFunction = std::move(NewAutoDetectFunction);
+}