[lldb] Add a setting to change the autosuggestion ANSI escape codes

[JDevlieghere]

Summary

I'm a big fan of the autosuggestion feature but my terminal/color scheme doesn't display faint any differently than regular lldb output, which makes the feature a little confusing. This patch add a setting to change the autosuggestion ANSI escape codes.

For example, to display the autosuggestion in italic, you can add this to your ~/.lldbinit

settings set show-autosuggestion-ansi-prefix ${ansi.italic}
setting set show-autosuggestion-ansi-suffix ${ansi.normal}

[teemperor]

LGTM, thanks! FWIW, if you have fish installed you might wanna check what they are doing on your terminal for its autosuggestions (and we might wanna steal their default, even though I thought this was 'faint').

[JDevlieghere]

In D121064#3362890, @teemperor wrote:

LGTM, thanks! FWIW, if you have fish installed you might wanna check what they are doing on your terminal for its autosuggestions (and we might wanna steal their default, even though I thought this was 'faint').

That's exactly what I did. Fish is using bright yellow, which is something we don't support yet, which is why I've put up https://reviews.llvm.org/D121131

lldb/include/lldb/Core/Debugger.h

public:
   bool SetUseExternalEditor(bool use_external_editor_p);
 
   bool GetUseColor() const;
 
   bool SetUseColor(bool use_color);
 
   bool GetUseAutosuggestion() const;
 
+  llvm::StringRef GetAutosuggestionAnsiPrefix() const;
+
+  llvm::StringRef GetAutosuggestionAnsiSuffix() const;
+
   bool GetUseSourceCache() const;
 
   bool SetUseSourceCache(bool use_source_cache);
 
   bool GetHighlightSource() const;
 
   lldb::StopShowColumn GetStopShowColumn() const;
 

lldb/include/lldb/Host/Editline.h

public:
   /// when creating a newline.  An optional set of insertable characters can
   /// also trigger the callback.
   void SetFixIndentationCallback(FixIndentationCallbackType callback,
                                  const char *indent_chars) {
     m_fix_indentation_callback = std::move(callback);
     m_fix_indentation_callback_chars = indent_chars;
   }
 
+  void SetSuggestionAnsiPrefix(std::string prefix) {
+    m_suggestion_ansi_prefix = std::move(prefix);
+  }
+
+  void SetSuggestionAnsiSuffix(std::string suffix) {
+    m_suggestion_ansi_suffix = std::move(suffix);
+  }
+
   /// Prompts for and reads a single line of user input.
   bool GetLine(std::string &line, bool &interrupted);
 
   /// Prompts for and reads a multi-line batch of user input.
   bool GetLines(int first_line_number, StringList &lines, bool &interrupted);
 
   void PrintAsync(Stream *stream, const char *s, size_t len);
 
#endif
   ConnectionFileDescriptor m_input_connection;
 
   IsInputCompleteCallbackType m_is_input_complete_callback;
 
   FixIndentationCallbackType m_fix_indentation_callback;
   const char *m_fix_indentation_callback_chars = nullptr;
 
   CompleteCallbackType m_completion_callback;
-
   SuggestionCallbackType m_suggestion_callback;
 
+  std::string m_suggestion_ansi_prefix;
+  std::string m_suggestion_ansi_suffix;
+
   std::size_t m_previous_autosuggestion_size = 0;
   std::mutex m_output_mutex;
 };
 }
 
 #endif // #if defined(__cplusplus)
 #endif // LLDB_HOST_EDITLINE_H

lldb/source/Core/CoreProperties.td

let Definition = "debugger" in {
   def FrameFormatUnique: Property<"frame-format-unique", "FormatEntity">,
     Global,
     DefaultStringValue<"frame #${frame.index}: ${ansi.fg.yellow}${frame.pc}${ansi.normal}{ ${module.file.basename}{`${function.name-without-args}{${frame.no-debug}${function.pc-offset}}}}{ at ${ansi.fg.cyan}${line.file.basename}${ansi.normal}:${ansi.fg.yellow}${line.number}${ansi.normal}{:${ansi.fg.yellow}${line.column}${ansi.normal}}}{${function.is-optimized} [opt]}{${frame.is-artificial} [artificial]}\\\\n">,
     Desc<"The default frame format string to use when displaying stack frameinformation for threads from thread backtrace unique.">;
   def ShowAutosuggestion: Property<"show-autosuggestion", "Boolean">,
     Global,
     DefaultFalse,
     Desc<"If true, LLDB will show suggestions to complete the command the user typed. Suggestions may be accepted using Ctrl-F.">;
+  def ShowAutosuggestionAnsiPrefix: Property<"show-autosuggestion-ansi-prefix", "String">,
+    Global,
+    DefaultStringValue<"${ansi.faint}">,
+    Desc<"When displaying suggestion in a color-enabled (i.e. ANSI) terminal, use the ANSI terminal code specified in this format immediately before the suggestion.">;
+  def ShowAutosuggestionAnsiSuffix: Property<"show-autosuggestion-ansi-suffix", "String">,
+    Global,
+    DefaultStringValue<"${ansi.normal}">,
+    Desc<"When displaying suggestion in a color-enabled (i.e. ANSI) terminal, use the ANSI terminal code specified in this format immediately after the suggestion.">;
 }

lldb/source/Core/Debugger.cpp

 }
 
 bool Debugger::GetUseAutosuggestion() const {
   const uint32_t idx = ePropertyShowAutosuggestion;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_debugger_properties[idx].default_uint_value != 0);
 }
 
+llvm::StringRef Debugger::GetAutosuggestionAnsiPrefix() const {
+  const uint32_t idx = ePropertyShowAutosuggestionAnsiPrefix;
+  return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, "");
+}
+
+llvm::StringRef Debugger::GetAutosuggestionAnsiSuffix() const {
+  const uint32_t idx = ePropertyShowAutosuggestionAnsiSuffix;
+  return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, "");
+}
+
 bool Debugger::GetUseSourceCache() const {
   const uint32_t idx = ePropertyUseSourceCache;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_debugger_properties[idx].default_uint_value != 0);
 }
 
 bool Debugger::SetUseSourceCache(bool b) {
   const uint32_t idx = ePropertyUseSourceCache;

lldb/source/Core/IOHandler.cpp

 #include <deque>
 #endif
 #include <string>
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Host/File.h"
+#include "lldb/Utility/AnsiTerminal.h"
 #include "lldb/Utility/Predicate.h"
 #include "lldb/Utility/ReproducerProvider.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StringList.h"
 #include "lldb/lldb-forward.h"
 
 #if LLDB_ENABLE_LIBEDIT
m_editline_up->SetIsInputCompleteCallback(
         [this](Editline *editline, StringList &lines) {
           return this->IsInputCompleteCallback(editline, lines);
         });
 
     m_editline_up->SetAutoCompleteCallback([this](CompletionRequest &request) {
       this->AutoCompleteCallback(request);
     });
 
-    if (debugger.GetUseAutosuggestion() && debugger.GetUseColor()) {
+    if (debugger.GetUseAutosuggestion()) {
       m_editline_up->SetSuggestionCallback([this](llvm::StringRef line) {
         return this->SuggestionCallback(line);
       });
+      m_editline_up->SetSuggestionAnsiPrefix(ansi::FormatAnsiTerminalCodes(
+          debugger.GetAutosuggestionAnsiPrefix()));
+      m_editline_up->SetSuggestionAnsiSuffix(ansi::FormatAnsiTerminalCodes(
+          debugger.GetAutosuggestionAnsiSuffix()));
     }
     // See if the delegate supports fixing indentation
     const char *indent_chars = delegate.IOHandlerGetFixIndentationCharacters();
     if (indent_chars) {
       // The delegate does support indentation, hook it up so when any
       // indentation character is typed, the delegate gets a chance to fix it
       FixIndentationCallbackType f = [this](Editline *editline,
                                             const StringList &lines,

lldb/source/Host/common/Editline.cpp

unsigned char Editline::TypedCharacter(int ch) {
   if (!m_suggestion_callback) {
     return CC_REDISPLAY;
   }
 
   const LineInfo *line_info = el_line(m_editline);
   llvm::StringRef line(line_info->buffer,
                        line_info->lastchar - line_info->buffer);
 
+  const char *ansi_prefix =
+      m_color_prompts ? m_suggestion_ansi_prefix.c_str() : "";
+  const char *ansi_suffix =
+      m_color_prompts ? m_suggestion_ansi_suffix.c_str() : "";
+
   if (llvm::Optional<std::string> to_add = m_suggestion_callback(line)) {
-    std::string to_add_color = ANSI_FAINT + to_add.getValue() + ANSI_UNFAINT;
+    std::string to_add_color = ansi_prefix + to_add.getValue() + ansi_suffix;
     fputs(typed.c_str(), m_output_file);
     fputs(to_add_color.c_str(), m_output_file);
     size_t new_autosuggestion_size = line.size() + to_add->length();
     // Print spaces to hide any remains of a previous longer autosuggestion.
     if (new_autosuggestion_size < m_previous_autosuggestion_size) {
       size_t spaces_to_print =
           m_previous_autosuggestion_size - new_autosuggestion_size;
       std::string spaces = std::string(spaces_to_print, ' ');

lldb/test/API/iohandler/autosuggestion/TestAutosuggestion.py

def cursor_horizontal_abs(s):
     return "\x1b[" + str(len(s) + 1) + "G"
 
 
 
 class TestCase(PExpectTest):
 
     mydir = TestBase.compute_mydir(__file__)
 
+    ANSI_FAINT = "\x1b[2m"
+    ANSI_RESET = "\x1b[0m"
+    ANSI_RED = "\x1b[31m"
+    ANSI_CYAN = "\x1b[36m"
+
     # PExpect uses many timeouts internally and doesn't play well
     # under ASAN on a loaded machine..
     @skipIfAsan
     @skipIfEditlineSupportMissing
     def test_autosuggestion_add_spaces(self):
         self.launch(extra_args=["-o", "settings set show-autosuggestion true", "-o", "settings set use-color true"])
 
-        # Common input codes and escape sequences.
-        faint_color = "\x1b[2m"
-        reset = "\x1b[0m"
 
         # Check if spaces are added to hide the previous gray characters.
         self.expect("help frame var")
         self.expect("help frame info")
         self.child.send("help frame v")
-        self.child.expect_exact(cursor_horizontal_abs("(lldb) help frame ") + "v" + faint_color + "ar" + reset + " ")
+        self.child.expect_exact(cursor_horizontal_abs("(lldb) help frame ") + "v" + self.ANSI_FAINT + "ar" + self.ANSI_RESET + " ")
 
         self.quit()
 
     @skipIfAsan
     @skipIfEditlineSupportMissing
     def test_autosuggestion(self):
         self.launch(extra_args=["-o", "settings set show-autosuggestion true", "-o", "settings set use-color true"])
 
-        # Common input codes and escape sequences.
+        # Common input codes.
         ctrl_f = "\x06"
-        faint_color = "\x1b[2m"
-        reset = "\x1b[0m"
         delete = chr(127)
 
         frame_output_needle = "Syntax: frame <subcommand>"
         # Run 'help frame' once to put it into the command history.
         self.expect("help frame", substrs=[frame_output_needle])
 
         # Check that LLDB shows the autosuggestion in gray behind the text.
         self.child.send("hel")
-        self.child.expect_exact(cursor_horizontal_abs("(lldb) he") + "l" + faint_color + "p frame" + reset)
+        self.child.expect_exact(cursor_horizontal_abs("(lldb) he") + "l" + self.ANSI_FAINT + "p frame" + self.ANSI_RESET)
 
         # Apply the autosuggestion and press enter. This should print the
         # 'help frame' output if everything went correctly.
         self.child.send(ctrl_f + "\n")
         self.child.expect_exact(frame_output_needle)
 
         # Check that pressing Ctrl+F directly after Ctrl+F again does nothing.
         self.child.send("hel" + ctrl_f + ctrl_f + "\n")
def test_autosuggestion(self):
 
         # Check that autosuggestion works after delete.
         self.child.send("help x" + delete + ctrl_f + "\n")
         self.child.expect_exact(frame_output_needle)
 
         # Check that autosuggestion complete to the most recent one.
         self.child.send("help frame variable\n")
         self.child.send("help fr")
-        self.child.expect_exact(faint_color + "ame variable" + reset)
+        self.child.expect_exact(self.ANSI_FAINT + "ame variable" + self.ANSI_RESET)
         self.child.send("\n")
 
         # Try another command.
         apropos_output_needle = "Syntax: apropos <search-word>"
         # Run 'help frame' once to put it into the command history.
         self.expect("help apropos", substrs=[apropos_output_needle])
 
         # Check that 'hel' should have an autosuggestion for 'help apropos' now.
         self.child.send("hel")
-        self.child.expect_exact(cursor_horizontal_abs("(lldb) he") + "l" + faint_color + "p apropos" + reset)
+        self.child.expect_exact(cursor_horizontal_abs("(lldb) he") + "l" + self.ANSI_FAINT + "p apropos" + self.ANSI_RESET)
 
         # Run the command and expect the 'help apropos' output.
         self.child.send(ctrl_f + "\n")
         self.child.expect_exact(apropos_output_needle)
 
         # Check that pressing Ctrl+F in an empty prompt does nothing.
         breakpoint_output_needle = "Syntax: breakpoint <subcommand>"
         self.child.send(ctrl_f + "help breakpoint" +"\n")
         self.child.expect_exact(breakpoint_output_needle)
 
 
         self.quit()
+
+    @skipIfAsan
+    @skipIfEditlineSupportMissing
+    def test_autosuggestion_custom_ansi_prefix_suffix(self):
+        self.launch(extra_args=["-o", "settings set show-autosuggestion true",
+                                "-o", "settings set use-color true",
+                                "-o", "settings set show-autosuggestion-ansi-prefix ${ansi.fg.red}",
+                                "-o", "setting set show-autosuggestion-ansi-suffix ${ansi.fg.cyan}"])
+
+        self.child.send("help frame variable\n")
+        self.child.send("help fr")
+        self.child.expect_exact(self.ANSI_RED + "ame variable" + self.ANSI_CYAN)
+        self.child.send("\n")
+
+        self.quit()