[lldb/Interpreter] Color "error:" and "warning:" in the CommandReturnObject output.

[JDevlieghere]

Summary

Color the error: and warning: part of the CommandReturnObject output, similar to how an error is printed from the driver when colors are enabled.

Here's a screenshot of the output: https://jonasdevlieghere.com/static/colors.png

[teemperor]

That was also on my list but it seems you beat me to it. I couldn't resist some smaller nit-picks but otherwise this LGTM beside that.

lldb/include/lldb/Interpreter/CommandReturnObject.h

27

I think a documentation line like "use_colors Use colors to highlight parts of the command output" would make this more obvious (also use_colors would bring this in line to what we call this setting in other parts of LLDB).

lldb/include/lldb/Utility/Stream.h

417

Nit: This can all be PutCString(colorcode) (which handles the nullptr check and the strlen). Same as below.

[labath]

I'm wondering if it would be possible/acceptable to move the color-related code from llvm::raw_fd_ostream (where the RawOstreamForward code is copied from) into the raw_ostream base class (except that it would default to false, of course). Outputting the color escape codes to a non-terminal, is not a completely unreasonable thing to do. For example, one gather the codes into a string stream, and later output the string to a real terminal -- which, incidentally, is exactly what we are doing here. Then all we would need is to plumb the "color" flag into the appropriate stream object.

One possible objection to that idea might be that this trick will work on windows only if we are using ansi emulation, which isn't always possible (I believe it's not available before windows 10). However, that objection applies regardless of where the feature is implemented -- the only difference is that we may be more willing to throw windows under the bus.

Another thing that would be good to check is whether these color codes make their way through the SB API (SBCommandReturnObject). I don't think that's a bad thing -- the embedding application might actually want to print lldb command results in color. And also, it provides a nice way to test this feature.

[labath]

Let's talk about this more. I don't think we should cargo-cult code from llvm, especially when the cargo-culting won't actually work for the given use case. On windows, the llvm::sys::Process::*** functions will be messing with the terminal which does not sound like a good thing to do from a generic place like this.

[teemperor]

lldb/include/lldb/Utility/Stream.h

417

Actually nvm, I thought this is in the Stream class (not our own raw_ostream subclass).

[amccarth]

I'm just responding to the questions @labath raised without really looking at the details of the code.

I agree that there's nothing wrong with having the ability to output color codes to a file, but it's a surprising default and experience tells me it would break a lot of tests that are rightfully looking just at the content rather than the styling. But having the ability to turn on color for file output would make it possible to also test styling, an ability we don't currently have.

Plumbing the option for color and other niceties down to a low level sounds like a great idea, as long as we get the defaults right. For Windows (for now) and for output redirected to a file, the default should be off. That said, I could see lowering of the color option being a separate effort outside the scope of this patch. For one thing, we'd have to get buy-in from the more general LLVM folks. And several of the llvm utilities currently use the WithColor approach, so there could be a lot of work updating those (or they would continue to use the old approach indefinitely).

[JDevlieghere]

Rebase on top of parent patches.

[labath]

lldb/source/Utility/Stream.cpp

178

It looks like the only use for this function and the member variable is to initialize the ColorEnabled field of the raw_ostream forwarder. Can we delete this and pass the value via a constructor argument instead?

(I don't mind the method itself, just the fact that information on whether colors are "enabled" is stored in two places (m_color_enabled, ColorEnabled). The simplest way to fix that is to delete these things.)

[JDevlieghere]

Address feedback

[JDevlieghere]

Add unstaged file.

[labath]

I think this looks good now. All that's now left is a test case. I think it should be possible to test this in a number of ways:

• CommandReturnObject unittest
• a shell test which forces use-color to true
• a python test which forces use-color to true
• a pexpect test

lldb/include/lldb/Utility/Stream.h

402–403

This is not consistent with the intend of this method (This function determines if this stream is displayed and supports colors.). One could argue whether this could be "true" for CommandObjectResult streams which are destined to be later printed to a terminal, but it's definitely not a good default.

However, all of that is irrelevant, as this should not be needed anymore. Is that correct?

lldb/source/Interpreter/CommandInterpreter.cpp

212

I'm wondering in how many places do we construct CommandReturnObjects. If it's not too many, it may make sense to remove the =false from the colors argument, to force the user to think about the right value...

[JDevlieghere]

• Remove default value for color in CommandReturnObject.
• Add test

[JDevlieghere]

lldb/include/lldb/Utility/Stream.h

402–403

Correct!

[JDevlieghere]

• Update ctors in lldb-test and unit test

lldb/include/lldb/Interpreter/CommandReturnObject.h

 
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StreamTee.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/WithColor.h"
 
 #include <memory>
 
 namespace lldb_private {
 
 class CommandReturnObject {
 public:
-  CommandReturnObject();
+  CommandReturnObject(bool colors);
 
   ~CommandReturnObject();
 
   llvm::StringRef GetOutputData() {
     lldb::StreamSP stream_sp(m_out_stream.GetStreamAtIndex(eStreamStringIndex));
     if (stream_sp)
       return std::static_pointer_cast<StreamString>(stream_sp)->GetString();
     return llvm::StringRef();

lldb/include/lldb/Utility/Stream.h

public:
     /// ByteDelta object was created.
     size_t operator*() const { return m_stream->GetWrittenBytes() - m_start; }
   };
 
   /// Construct with flags and address size and byte order.
   ///
   /// Construct with dump flags \a flags and the default address size. \a
   /// flags can be any of the above enumeration logical OR'ed together.
-  Stream(uint32_t flags, uint32_t addr_size, lldb::ByteOrder byte_order);
+  Stream(uint32_t flags, uint32_t addr_size, lldb::ByteOrder byte_order,
+         bool colors = false);
 
   /// Construct a default Stream, not binary, host byte order and host addr
   /// size.
   ///
-  Stream();
+  Stream(bool colors = false);
 
   // FIXME: Streams should not be copyable.
   Stream(const Stream &other) : m_forwarder(*this) { (*this) = other; }
 
   Stream &operator=(const Stream &rhs) {
     m_flags = rhs.m_flags;
     m_addr_size = rhs.m_addr_size;
     m_byte_order = rhs.m_byte_order;
class RawOstreamForward : public llvm::raw_ostream {
     // differ from the actually written bytes by the size of the internal
     // raw_ostream buffer.
 
     Stream &m_target;
     void write_impl(const char *Ptr, size_t Size) override {
       m_target.Write(Ptr, Size);
     }
 
     uint64_t current_pos() const override {
       return m_target.GetWrittenBytes();
     }
 
   public:
-    RawOstreamForward(Stream &target)
-        : llvm::raw_ostream(/*unbuffered*/ true), m_target(target) {}
+    RawOstreamForward(Stream &target, bool colors = false)
+        : llvm::raw_ostream(/*unbuffered*/ true), m_target(target) {
+      enable_colors(colors);
+    }
   };
   RawOstreamForward m_forwarder;
 };
 
 /// Output an address value to this stream.
 ///
 /// Put an address \a addr out to the stream with optional \a prefix and \a
 /// suffix strings.
 ///
 /// \param[in] s
 ///     The output stream.
 ///
 /// \param[in] addr
 ///     An address value.
 ///

lldb/include/lldb/Utility/StreamTee.h

 #include <mutex>
 
 #include "lldb/Utility/Stream.h"
 
 namespace lldb_private {
 
 class StreamTee : public Stream {
 public:
-  StreamTee() : Stream(), m_streams_mutex(), m_streams() {}
+  StreamTee(bool colors = false)
+      : Stream(colors), m_streams_mutex(), m_streams() {}
 
   StreamTee(lldb::StreamSP &stream_sp)
       : Stream(), m_streams_mutex(), m_streams() {
     // No need to lock mutex during construction
     if (stream_sp)
       m_streams.push_back(stream_sp);
   }
 

lldb/source/API/SBCommandReturnObject.cpp

 #include "lldb/Utility/Status.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 class lldb_private::SBCommandReturnObjectImpl {
 public:
   SBCommandReturnObjectImpl()
-      : m_ptr(new CommandReturnObject()), m_owned(true) {}
+      : m_ptr(new CommandReturnObject(false)), m_owned(true) {}
   SBCommandReturnObjectImpl(CommandReturnObject &ref)
       : m_ptr(&ref), m_owned(false) {}
   SBCommandReturnObjectImpl(const SBCommandReturnObjectImpl &rhs)
       : m_ptr(new CommandReturnObject(*rhs.m_ptr)), m_owned(rhs.m_owned) {}
   SBCommandReturnObjectImpl &operator=(const SBCommandReturnObjectImpl &rhs) {
     SBCommandReturnObjectImpl copy(rhs);
     std::swap(*this, copy);
     return *this;

lldb/source/Breakpoint/BreakpointOptions.cpp

bool BreakpointOptions::BreakpointOptionsCallbackFunction(
 
   CommandData *data = (CommandData *)baton;
   StringList &commands = data->user_source;
 
   if (commands.GetSize() > 0) {
     ExecutionContext exe_ctx(context->exe_ctx_ref);
     Target *target = exe_ctx.GetTargetPtr();
     if (target) {
-      CommandReturnObject result;
       Debugger &debugger = target->GetDebugger();
+      CommandReturnObject result(debugger.GetUseColor());
+
       // Rig up the results secondary output stream to the debugger's, so the
       // output will come out synchronously if the debugger is set up that way.
-
       StreamSP output_stream(debugger.GetAsyncOutputStream());
       StreamSP error_stream(debugger.GetAsyncErrorStream());
       result.SetImmediateOutputStream(output_stream);
       result.SetImmediateErrorStream(error_stream);
 
       CommandInterpreterRunOptions options;
       options.SetStopOnContinue(true);
       options.SetStopOnError(data->stop_on_error);

lldb/source/Commands/CommandObjectExpression.cpp

void CommandObjectExpression::IOHandlerInputComplete(IOHandler &io_handler,
                                                      std::string &line) {
   io_handler.SetIsDone(true);
   //    StreamSP output_stream =
   //    io_handler.GetDebugger().GetAsyncOutputStream();
   //    StreamSP error_stream = io_handler.GetDebugger().GetAsyncErrorStream();
   StreamFileSP output_sp = io_handler.GetOutputStreamFileSP();
   StreamFileSP error_sp = io_handler.GetErrorStreamFileSP();
 
-  CommandReturnObject return_obj;
+  CommandReturnObject return_obj(
+      GetCommandInterpreter().GetDebugger().GetUseColor());
   EvaluateExpression(line.c_str(), *output_sp, *error_sp, return_obj);
   if (output_sp)
     output_sp->Flush();
   if (error_sp)
     error_sp->Flush();
 }
 
 bool CommandObjectExpression::IOHandlerIsInputComplete(IOHandler &io_handler,

lldb/source/Commands/CommandObjectWatchpointCommand.cpp

WatchpointOptionsCallbackFunction(void *baton,
     WatchpointOptions::CommandData *data =
         (WatchpointOptions::CommandData *)baton;
     StringList &commands = data->user_source;
 
     if (commands.GetSize() > 0) {
       ExecutionContext exe_ctx(context->exe_ctx_ref);
       Target *target = exe_ctx.GetTargetPtr();
       if (target) {
-        CommandReturnObject result;
         Debugger &debugger = target->GetDebugger();
+        CommandReturnObject result(debugger.GetUseColor());
+
         // Rig up the results secondary output stream to the debugger's, so the
         // output will come out synchronously if the debugger is set up that
         // way.
-
         StreamSP output_stream(debugger.GetAsyncOutputStream());
         StreamSP error_stream(debugger.GetAsyncErrorStream());
         result.SetImmediateOutputStream(output_stream);
         result.SetImmediateErrorStream(error_stream);
 
         CommandInterpreterRunOptions options;
         options.SetStopOnContinue(true);
         options.SetStopOnError(data->stop_on_error);

lldb/source/Expression/REPL.cpp

if (code[0] == ':') {
         // the results
 
         // Turn off prompt on quit in case the user types ":quit"
         const bool saved_prompt_on_quit = ci.GetPromptOnQuit();
         if (saved_prompt_on_quit)
           ci.SetPromptOnQuit(false);
 
         // Execute the command
-        CommandReturnObject result;
+        CommandReturnObject result(debugger.GetUseColor());
         result.SetImmediateOutputStream(output_sp);
         result.SetImmediateErrorStream(error_sp);
         ci.HandleCommand(code.c_str(), eLazyBoolNo, result);
 
         if (saved_prompt_on_quit)
           ci.SetPromptOnQuit(true);
 
         if (result.GetStatus() == lldb::eReturnStatusQuit) {

lldb/source/Interpreter/CommandAlias.cpp

static bool ProcessAliasOptionsArgs(lldb::CommandObjectSP &cmd_obj_sp,
 
   if (options_args.size() < 1)
     return true;
 
   Args args(options_args);
   std::string options_string(options_args);
   // TODO: Find a way to propagate errors in this CommandReturnObject up the
   // stack.
-  CommandReturnObject result;
+  CommandReturnObject result(false);
   // Check to see if the command being aliased can take any command options.
   Options *options = cmd_obj_sp->GetOptions();
   if (options) {
     // See if any options were specified as part of the alias;  if so, handle
     // them appropriately.
     ExecutionContext exe_ctx =
         cmd_obj_sp->GetCommandInterpreter().GetExecutionContext();
     options->NotifyOptionParsingStarting(&exe_ctx);

lldb/source/Interpreter/CommandInterpreter.cpp

   return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_interpreter_properties[idx].default_uint_value != 0);
 }
 
 void CommandInterpreter::Initialize() {
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
 
-  CommandReturnObject result;
+  CommandReturnObject result(m_debugger.GetUseColor());
 
   LoadCommandDictionary();
 
   // An alias arguments vector to reuse - reset it before use...
   OptionArgVectorSP alias_arguments_vector_sp(new OptionArgVector);
 
   // Set up some initial aliases.
   CommandObjectSP cmd_obj_sp = GetCommandSPExact("quit", false);

       continue;
 
     if (options.GetEchoCommands()) {
       // TODO: Add Stream support.
       result.AppendMessageWithFormat("%s %s\n",
                                      m_debugger.GetPrompt().str().c_str(), cmd);
     }
 
-    CommandReturnObject tmp_result;
+    CommandReturnObject tmp_result(m_debugger.GetUseColor());
     // If override_context is not NULL, pass no_context_switching = true for
     // HandleCommand() since we updated our context already.
 
     // We might call into a regex or alias command, in which case the
     // add_to_history will get lost.  This m_command_source_depth dingus is the
     // way we turn off adding to the history in that case, so set it up here.
     if (!options.GetAddToHistory())
       m_command_source_depth++;

     // command output and no command...
     if (EchoCommandNonInteractive(line, io_handler.GetFlags()))
       io_handler.GetOutputStreamFileSP()->Printf(
           "%s%s\n", io_handler.GetPrompt(), line.c_str());
   }
 
   StartHandlingCommand();
 
-  lldb_private::CommandReturnObject result;
+  lldb_private::CommandReturnObject result(m_debugger.GetUseColor());
   HandleCommand(line.c_str(), eLazyBoolCalculate, result);
 
   // Now emit the command output text from the command we just executed
   if ((result.Succeeded() &&
        io_handler.GetFlags().Test(eHandleCommandFlagPrintResult)) ||
       io_handler.GetFlags().Test(eHandleCommandFlagPrintErrors)) {
     // Display any STDOUT/STDERR _prior_ to emitting the command result text
     GetProcessOutput();

lldb/source/Interpreter/CommandObject.cpp

void CommandObject::HandleCompletion(CompletionRequest &request) {
   // completion should override WantsCompletion() to return true, instead.
   if (WantsRawCommandString() && !WantsCompletion()) {
     // FIXME: Abstract telling the completion to insert the completion
     // character.
     return;
   } else {
     // Can we do anything generic with the options?
     Options *cur_options = GetOptions();
-    CommandReturnObject result;
+    CommandReturnObject result(m_interpreter.GetDebugger().GetUseColor());
     OptionElementVector opt_element_vector;
 
     if (cur_options != nullptr) {
       opt_element_vector = cur_options->ParseForCompletion(
           request.GetParsedLine(), request.GetCursorIndex());
 
       bool handled_by_options = cur_options->HandleOptionCompletion(
           request, opt_element_vector, GetCommandInterpreter());

lldb/source/Interpreter/CommandReturnObject.cpp

 //===-- CommandReturnObject.cpp -------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/CommandReturnObject.h"
 
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
+static llvm::raw_ostream &error(Stream &strm) {
+  return llvm::WithColor(strm.AsRawOstream(), llvm::HighlightColor::Error,
+                         llvm::ColorMode::Enable)
+         << "error: ";
+}
+
+static llvm::raw_ostream &warning(Stream &strm) {
+  return llvm::WithColor(strm.AsRawOstream(), llvm::HighlightColor::Warning,
+                         llvm::ColorMode::Enable)
+         << "warning: ";
+}
+
 static void DumpStringToStreamWithNewline(Stream &strm, const std::string &s) {
   bool add_newline = false;
   if (!s.empty()) {
     // We already checked for empty above, now make sure there is a newline in
     // the error, and if there isn't one, add one.
     strm.Write(s.c_str(), s.size());
 
     const char last_char = *s.rbegin();
     add_newline = last_char != '\n' && last_char != '\r';
   }
   if (add_newline)
     strm.EOL();
 }
 
-CommandReturnObject::CommandReturnObject()
-    : m_out_stream(), m_err_stream(), m_status(eReturnStatusStarted),
-      m_did_change_process_state(false), m_interactive(true) {}
+CommandReturnObject::CommandReturnObject(bool colors)
+    : m_out_stream(colors), m_err_stream(colors),
+      m_status(eReturnStatusStarted), m_did_change_process_state(false),
+      m_interactive(true) {}
 
 CommandReturnObject::~CommandReturnObject() {}
 
 void CommandReturnObject::AppendErrorWithFormat(const char *format, ...) {
   if (!format)
     return;
   va_list args;
   va_start(args, format);
   StreamString sstrm;
   sstrm.PrintfVarArg(format, args);
   va_end(args);
 
   const std::string &s = std::string(sstrm.GetString());
   if (!s.empty()) {
-    Stream &error_strm = GetErrorStream();
-    error_strm.PutCString("error: ");
-    DumpStringToStreamWithNewline(error_strm, s);
+    error(GetErrorStream());
+    DumpStringToStreamWithNewline(GetErrorStream(), s);
   }
 }
 
 void CommandReturnObject::AppendMessageWithFormat(const char *format, ...) {
   if (!format)
     return;
   va_list args;
   va_start(args, format);
   StreamString sstrm;
   sstrm.PrintfVarArg(format, args);
   va_end(args);
 
   GetOutputStream() << sstrm.GetString();
 }
 
 void CommandReturnObject::AppendWarningWithFormat(const char *format, ...) {
   if (!format)
     return;
   va_list args;
   va_start(args, format);
   StreamString sstrm;
   sstrm.PrintfVarArg(format, args);
   va_end(args);
 
-  GetErrorStream() << "warning: " << sstrm.GetString();
+  warning(GetErrorStream()) << sstrm.GetString();
 }
 
 void CommandReturnObject::AppendMessage(llvm::StringRef in_string) {
   if (in_string.empty())
     return;
   GetOutputStream() << in_string << "\n";
 }
 
 void CommandReturnObject::AppendWarning(llvm::StringRef in_string) {
   if (in_string.empty())
     return;
-  GetErrorStream() << "warning: " << in_string << "\n";
+  warning(GetErrorStream()) << in_string << '\n';
 }
 
 // Similar to AppendWarning, but do not prepend 'warning: ' to message, and
 // don't append "\n" to the end of it.
 
 void CommandReturnObject::AppendRawWarning(llvm::StringRef in_string) {
   if (in_string.empty())
     return;
   GetErrorStream() << in_string;
 }
 
 void CommandReturnObject::AppendError(llvm::StringRef in_string) {
   if (in_string.empty())
     return;
-  GetErrorStream() << "error: " << in_string << "\n";
+  error(GetErrorStream()) << in_string << '\n';
 }
 
 void CommandReturnObject::SetError(const Status &error,
                                    const char *fallback_error_cstr) {
   const char *error_cstr = error.AsCString();
   if (error_cstr == nullptr)
     error_cstr = fallback_error_cstr;
   SetError(error_cstr);

lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

EnableOptionsSP ParseAutoEnableOptions(Status &error, Debugger &debugger) {
   // We have an empty execution context at this point.  We only want to parse
   // options, and we don't need any context to do this here. In fact, we want
   // to be able to parse the enable options before having any context.
   ExecutionContext exe_ctx;
 
   EnableOptionsSP options_sp(new EnableOptions());
   options_sp->NotifyOptionParsingStarting(&exe_ctx);
 
-  CommandReturnObject result;
+  CommandReturnObject result(debugger.GetUseColor());
 
   // Parse the arguments.
   auto options_property_sp =
       debugger.GetPropertyValue(nullptr, "plugin.structured-data.darwin-log."
                                          "auto-enable-options",
                                 false, error);
   if (!error.Success())
     return EnableOptionsSP();
bool RunEnableCommand(CommandInterpreter &interpreter) {
   command_stream << "plugin structured-data darwin-log enable";
   auto enable_options = GetGlobalProperties()->GetAutoEnableOptions();
   if (!enable_options.empty()) {
     command_stream << ' ';
     command_stream << enable_options;
   }
 
   // Run the command.
-  CommandReturnObject return_object;
+  CommandReturnObject return_object(interpreter.GetDebugger().GetUseColor());
   interpreter.HandleCommand(command_stream.GetData(), eLazyBoolNo,
                             return_object);
   return return_object.Succeeded();
 }
 }
 using namespace sddarwinlog_private;
 
 #pragma mark -

lldb/source/Target/Target.cpp

     if (hook.second->IsActive()) {
       any_active_hooks = true;
       auto_continue |= hook.second->GetAutoContinue();
     }
   }
   if (!any_active_hooks)
     return;
 
-  CommandReturnObject result;
+  CommandReturnObject result(m_debugger.GetUseColor());
 
   std::vector<ExecutionContext> exc_ctx_with_reasons;
   std::vector<SymbolContext> sym_ctx_with_reasons;
 
   ThreadList &cur_threadlist = m_process_sp->GetThreadList();
   size_t num_threads = cur_threadlist.GetSize();
   for (size_t i = 0; i < num_threads; i++) {
     lldb::ThreadSP cur_thread_sp = cur_threadlist.GetThreadAtIndex(i);

lldb/source/Utility/Stream.cpp

 #include <string>
 
 #include <inttypes.h>
 #include <stddef.h>
 
 using namespace lldb;
 using namespace lldb_private;
 
-Stream::Stream(uint32_t flags, uint32_t addr_size, ByteOrder byte_order)
+Stream::Stream(uint32_t flags, uint32_t addr_size, ByteOrder byte_order,
+               bool colors)
     : m_flags(flags), m_addr_size(addr_size), m_byte_order(byte_order),
-      m_indent_level(0), m_forwarder(*this) {}
+      m_indent_level(0), m_forwarder(*this, colors) {}
 
-Stream::Stream()
+Stream::Stream(bool colors)
     : m_flags(0), m_addr_size(4), m_byte_order(endian::InlHostByteOrder()),
-      m_indent_level(0), m_forwarder(*this) {}
+      m_indent_level(0), m_forwarder(*this, colors) {}
 
 // Destructor
 Stream::~Stream() {}
 
 ByteOrder Stream::SetByteOrder(ByteOrder byte_order) {
   ByteOrder old_byte_order = m_byte_order;
   m_byte_order = byte_order;
   return old_byte_order;

 // Decrement the current indentation level
 void Stream::IndentLess(unsigned amount) {
   if (m_indent_level >= amount)
     m_indent_level -= amount;
   else
     m_indent_level = 0;
 }
 
 // Get the address size in bytes
 uint32_t Stream::GetAddressByteSize() const { return m_addr_size; }
 
 // Set the address size in bytes
 void Stream::SetAddressByteSize(uint32_t addr_size) { m_addr_size = addr_size; }
 
 // The flags get accessor
 Flags &Stream::GetFlags() { return m_flags; }
 

lldb/test/Shell/Driver/TestNoUseColor.test

-# RUN: %lldb --no-use-colors -s %s | FileCheck %s
-settings show use-color
-# CHECK: use-color (boolean) = false
-q
+RUN: not %lldb -b --no-use-colors -o 'settings show use-color' -o 'bogus' 2>&1 | FileCheck %s --check-prefix NOCOLOR
+NOCOLOR: use-color (boolean) = false
+NOCOLOR: error: 'bogus' is not a valid command

lldb/test/Shell/Driver/TestUseColor.test

+UNSUPPORTED: system-windows
+
+RUN: not %lldb -b -o 'settings set use-color true' -o 'settings show use-color' -o 'bogus' > %t 2>&1
+RUN: cat -e %t | FileCheck %s --check-prefix COLOR
+COLOR: use-color (boolean) = true
+# The [[ confuses FileCheck so regex match it.
+COLOR: {{.+}}0;1;31merror: {{.+}}0m'bogus' is not a valid command

lldb/tools/lldb-test/lldb-test.cpp

while (!Rest.empty()) {
     if (Line.empty() || Line[0] == '#')
       continue;
 
     if (!Persistent)
       Target->RemoveAllBreakpoints(/*internal_also*/ true);
 
     std::string Command = substitute(Line);
     P.formatLine("Command: {0}", Command);
-    CommandReturnObject Result;
+    CommandReturnObject Result(/*colors*/ false);
     if (!Dbg.GetCommandInterpreter().HandleCommand(
             Command.c_str(), /*add_to_history*/ eLazyBoolNo, Result)) {
       P.formatLine("Failed: {0}", Result.GetErrorData());
       HadErrors = 1;
       continue;
     }
 
     dumpState(Target->GetBreakpointList(/*internal*/ false), P);
Error opts::symbols::findTypes(lldb_private::Module &Module) {
   if (!ContextOr)
     return ContextOr.takeError();
   const CompilerDeclContext &ContextPtr =
       ContextOr->IsValid() ? *ContextOr : CompilerDeclContext();
 
   LanguageSet languages;
   if (!Language.empty())
     languages.Insert(Language::GetLanguageTypeFromString(Language));
-  
   DenseSet<SymbolFile *> SearchedFiles;
   TypeMap Map;
   if (!Name.empty())
     Symfile.FindTypes(ConstString(Name), ContextPtr, UINT32_MAX, SearchedFiles,
                       Map);
   else
     Module.FindTypes(parseCompilerContext(), languages, SearchedFiles, Map);
 

 }
 
 int opts::irmemorymap::evaluateMemoryMapCommands(Debugger &Dbg) {
   // Set up a Target.
   TargetSP Target = opts::createTarget(Dbg, irmemorymap::Target);
 
   // Set up a Process. In order to allocate memory within a target, this
   // process must be alive and must support JIT'ing.
-  CommandReturnObject Result;
+  CommandReturnObject Result(/*colors*/ false);
   Dbg.SetAsyncExecution(false);
   CommandInterpreter &CI = Dbg.GetCommandInterpreter();
   auto IssueCmd = [&](const char *Cmd) -> bool {
     return CI.HandleCommand(Cmd, eLazyBoolNo, Result);
   };
   if (!IssueCmd("b main") || !IssueCmd("run")) {
     outs() << formatv("Failed: {0}\n", Result.GetErrorData());
     exit(1);
if (auto e = DebuggerLifetime.Initialize(
     return 1;
   }
 
   auto TerminateDebugger =
       llvm::make_scope_exit([&] { DebuggerLifetime.Terminate(); });
 
   auto Dbg = lldb_private::Debugger::CreateInstance();
   ModuleList::GetGlobalModuleListProperties().SetEnableExternalLookup(false);
-  CommandReturnObject Result;
+  CommandReturnObject Result(/*colors*/ false);
   Dbg->GetCommandInterpreter().HandleCommand(
       "settings set plugin.process.gdb-remote.packet-timeout 60",
       /*add_to_history*/ eLazyBoolNo, Result);
 
   if (!opts::Log.empty())
     Dbg->EnableLog("lldb", {"all"}, opts::Log, 0, errs());
 
   if (opts::BreakpointSubcommand)

lldb/unittests/ScriptInterpreter/Lua/ScriptInterpreterTests.cpp

EXPECT_EQ(ScriptInterpreterLua::GetPluginDescriptionStatic(),
             "Lua script interpreter");
 }
 
 TEST_F(ScriptInterpreterTest, ExecuteOneLine) {
   DebuggerSP debugger_sp = Debugger::CreateInstance();
   ASSERT_TRUE(debugger_sp);
 
   ScriptInterpreterLua script_interpreter(*debugger_sp);
-  CommandReturnObject result;
+  CommandReturnObject result(/*colors*/ false);
   EXPECT_TRUE(script_interpreter.ExecuteOneLine("foo = 1", &result));
   EXPECT_FALSE(script_interpreter.ExecuteOneLine("nil = foo", &result));
   EXPECT_TRUE(result.GetErrorData().startswith(
       "error: lua failed attempting to evaluate 'nil = foo'"));
 }