[lldb] Getting the suggestions also from previous sessions

[gedatsu217]

Summary

I implemented features that get the suggestions also from previous sessions.

If users use autosuggestion, it set the previous history in the constructor of IOHandlerEditline.

[teemperor]

What I actually meant was that you upload the diff between this and the previous patch (e.g. all the parts like GetAutoSuggestionForCommand shouldn't be in here). Otherwise it's not really obvious what this patch is actually changing. You can just make two git commits locally (one for this and one for the first patch) and then split the diffs this way.

From what I can see the changes here seems mostly fine.

Regarding the expected test: This isn't really related to the autosuggestion feature but a more generic feature, so I would make a new separate test where you check that the command history is persistent across lldb instances. The easiest way to check this is to add a unique command to the history and then relaunch LLDB and check its still there (you can list the command history via session history. If your branch isn't fully up-to-date, the command might still be named command history).

lldb/include/lldb/Host/Editline.h

215

I'm a bit surprised that a Add* function is actually just returning a value. Maybe GetCommandHistory().

lldb/source/Host/common/Editline.cpp

293

Maybe name this GetAsStringList.

lldb/source/Interpreter/CommandInterpreter.cpp

129

Each string is a command from the command history (I would say the single std::vector is a single "command history"), so this seems more logical:

for (const std::string &command : history)
  m_command_history.AppendString(command);

Also you don't need the this-> and another small thing: AppendString takes a StringRef, which is just a reference to a string. So if you take std::string as the command here, then you make a copy if each command but then AppendString also has to take another copy (to convert StringRef back to a std::string).

[gedatsu217]

Regarding the expected test: This isn't really related to the autosuggestion feature but a more generic feature, so I would make a new separate test where you check that the command history is persistent across lldb instances. The easiest way to check this is to add a unique command to the history and then relaunch LLDB and check its still there (you can list the command history via session history. If your branch isn't fully up-to-date, the command might still be named command history).

What command should be saved? Everyone has different saved commands, so I do not know what is unique.

And now, I try the below code, but it does not work. Do you know the causes?

self.launch(extra_args=["-o", "settings set show-autosuggestion true", "-o", "settings set use-color true"])

self.child.send("help frame\n")
self.child.send("breakpoint\n")

self.quit()

self.launch(extra_args=["-o", "settings set show-autosuggestion true", "-o", "settings set use-color true"])

self.child.send("session history\n")
self.child.expect_exact("help frame")
self.child.expect_exact("breakpoint")
self.quit()

[gedatsu217]

ping

[teemperor]

In D84355#2200813, @gedatsu217 wrote:

Regarding the expected test: This isn't really related to the autosuggestion feature but a more generic feature, so I would make a new separate test where you check that the command history is persistent across lldb instances. The easiest way to check this is to add a unique command to the history and then relaunch LLDB and check its still there (you can list the command history via session history. If your branch isn't fully up-to-date, the command might still be named command history).

What command should be saved? Everyone has different saved commands, so I do not know what is unique.

And now, I try the below code, but it does not work. Do you know the causes?

self.launch(extra_args=["-o", "settings set show-autosuggestion true", "-o", "settings set use-color true"])

self.child.send("help frame\n")
self.child.send("breakpoint\n")

self.quit()

self.launch(extra_args=["-o", "settings set show-autosuggestion true", "-o", "settings set use-color true"])

self.child.send("session history\n")
self.child.expect_exact("help frame")
self.child.expect_exact("breakpoint")
self.quit()

What exactly isn't working? If you could upload the test with the patch I could try reproducing it here.

Some general feedback: You probably don't just want to do self.child.send(...) but just self.expect("help frame"). self.child.send just sends the string and then instantly returns and doesn't wait for an answer from LLDB. You probably also want to do the same for the second check self.expect("session history", substrs=["help frame", "breakpoint"])

With unique command I mean: The test currently adds help frame to the history. But now all future test runs also have help frame in the command history, which means that your test will always pass even if it doesn't read the last commands. But if your command is something like " expr " + unique_time_stamp_number then the test can't pass by accident because the old commands were different. E.g., expr 1 and later one you do expr 2 (something like POSIX seconds since epoch is probably a good source for a unique number).

[gedatsu217]

Revise the code according to your advice.

And, test does not work well. Would you check it?
Maybe, command history on pexpect is not saved.

[teemperor]

This is great, thanks! I have some small final comments but after that this is ready to land!

lldb/source/Core/IOHandler.cpp

269

You can actually move this out of the if. Having previous sessions in the command history is a nice feature even without using autosuggestions.

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

28 ↗

(On Diff #284837)

Actually just doing now_time = str(time.time()) is good enough.

29 ↗

(On Diff #284837)

If you move the code out of the if (see the first inline comment), then you can also remove the extra_args here.

Also the test can be renamed to just iohandler/TestCommandHistoryFromPrevioiusSession.py (it shouldn't be related to autosuggestions).

[gedatsu217]

And, the test does not work well. Would you check it?

Did you check it? This test seems to work well, but an error occurs.

def test_autosuggestion_from_previous_sessions(self):
        now_time = str(time.time())
        self.launch()
        
        # Check if histories are saved after quit.       
        self.expect("expr " + now_time)
        self.quit()

        self.launch()

        self.expect("session history", substrs=[now_time])
        self.quit()

When I remove self.quit() and self.launch() in the middle of this code, this test passes. So, if pexpect finishes once, histories are not probably saved.

[teemperor]

In D84355#2218229, @gedatsu217 wrote:

And, the test does not work well. Would you check it?

Did you check it? This test seems to work well, but an error occurs.

def test_autosuggestion_from_previous_sessions(self):
        now_time = str(time.time())
        self.launch()
        
        # Check if histories are saved after quit.       
        self.expect("expr " + now_time)
        self.quit()

        self.launch()

        self.expect("session history", substrs=[now_time])
        self.quit()

When I remove self.quit() and self.launch() in the middle of this code, this test passes. So, if pexpect finishes once, histories are not probably saved.

What error do you get? For me the test seems to fail because we apparently don't save the session history for the first session. It doesn't show up in any history files in .lldb, but the session history does show up. I assume we don't shut down LLDB correctly. You could try sending quit\n, then sleep(3) after the expect("expr ... line.

[gedatsu217]

def test_autosuggestion_from_previous_sessions(self):
        now_time = str(time.time())
        self.launch()
        
        # Check if histories are saved after quit.       
        self.expect("expr " + now_time)
        time.sleep(3)
        self.child.send("quit\n")
        self.quit()

        self.launch()

        self.expect("session history", substrs=[now_time])
        self.quit()

Like this? It seems not to work well...
I'm looking for a good solution to this problem and trying various ways now.

[gedatsu217]

Although I tried some ways, none went well. In addition, I looked into several tests about session history, but I did not come up with a good way.
Do you know other ways to shut down lldb correctly?

What error do you get? For me the test seems to fail because we apparently don't save the session history for the first session.

It is the same as me.

lldb/include/lldb/Core/Debugger.h

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

lldb/include/lldb/Core/IOHandler.h

IOHandlerDelegate(Completion completion = Completion::None)
       : m_completion(completion) {}
 
   virtual ~IOHandlerDelegate() = default;
 
   virtual void IOHandlerActivated(IOHandler &io_handler, bool interactive) {}
 
   virtual void IOHandlerDeactivated(IOHandler &io_handler) {}
 
+  virtual llvm::Optional<std::string> IOHandlerSuggestion(IOHandler &io_handler,
+                                                          llvm::StringRef line);
+
   virtual void IOHandlerComplete(IOHandler &io_handler,
                                  CompletionRequest &request);
 
   virtual const char *IOHandlerGetFixIndentationCharacters() { return nullptr; }
 
   /// Called when a new line is created or one of an identified set of
   /// indentation characters is typed.
   ///

 private:
 #if LLDB_ENABLE_LIBEDIT
   static bool IsInputCompleteCallback(Editline *editline, StringList &lines,
                                       void *baton);
 
   static int FixIndentationCallback(Editline *editline, const StringList &lines,
                                     int cursor_position, void *baton);
 
+  static llvm::Optional<std::string> SuggestionCallback(llvm::StringRef line,
+                                                        void *baton);
+
   static void AutoCompleteCallback(CompletionRequest &request, void *baton);
 #endif
 
 protected:
 #if LLDB_ENABLE_LIBEDIT
   std::unique_ptr<Editline> m_editline_up;
 #endif
   IOHandlerDelegate &m_delegate;

lldb/include/lldb/Host/Editline.h

 
 typedef bool (*IsInputCompleteCallbackType)(Editline *editline,
                                             StringList &lines, void *baton);
 
 typedef int (*FixIndentationCallbackType)(Editline *editline,
                                           const StringList &lines,
                                           int cursor_position, void *baton);
 
+typedef llvm::Optional<std::string> (*SuggestionCallbackType)(
+    llvm::StringRef line, void *baton);
+
 typedef void (*CompleteCallbackType)(CompletionRequest &request, void *baton);
 
 /// Status used to decide when and how to start editing another line in
 /// multi-line sessions
 enum class EditorStatus {
 
   /// The default state proceeds to edit the current line
   Editing,
public:
   uint32_t GetCurrentLine();
 
   /// Interrupt the current edit as if ^C was pressed
   bool Interrupt();
 
   /// Cancel this edit and oblitarate all trace of it
   bool Cancel();
 
+  /// Register a callback for autosuggestion.
+  void SetSuggestionCallback(SuggestionCallbackType callback, void *baton);
+
   /// Register a callback for the tab key
   void SetAutoCompleteCallback(CompleteCallbackType callback, void *baton);
 
   /// Register a callback for testing whether multi-line input is complete
   void SetIsInputCompleteCallback(IsInputCompleteCallbackType callback,
                                   void *baton);
 
   /// Register a callback for determining the appropriate indentation for a line
   /// when creating a newline.  An optional set of insertable characters can
   /// also
   /// trigger the callback.
   bool SetFixIndentationCallback(FixIndentationCallbackType callback,
                                  void *baton, const char *indent_chars);
 
   /// 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);
 
+  std::vector<std::string> AddHistories();
+
 private:
   /// Sets the lowest line number for multi-line editing sessions.  A value of
   /// zero suppresses
   /// line number printing in the prompt.
   void SetBaseLineNumber(int line_number);
 
   /// Returns the complete prompt by combining the prompt or continuation prompt
   /// with line numbers
private:
 
   /// Buffer end command used when Esc > is typed in multi-line emacs mode.
   unsigned char BufferEndCommand(int ch);
 
   /// Context-sensitive tab insertion or code completion command used when the
   /// tab key is typed.
   unsigned char TabCommand(int ch);
 
+  /// Apply autosuggestion part in gray as editline.
+  unsigned char ApplyAutosuggestCommand(int ch);
+
+  /// Command used when a character is typed.
+  unsigned char TypedCharacter(int ch);
+
   /// Respond to normal character insertion by fixing line indentation
   unsigned char FixIndentationCommand(int ch);
 
   /// Revert line command used when moving between lines.
   unsigned char RevertLineCommand(int ch);
 
   /// Ensures that the current EditLine instance is properly configured for
   /// single or multi-line editing.
#endif
   FILE *m_output_file;
   FILE *m_error_file;
   ConnectionFileDescriptor m_input_connection;
   IsInputCompleteCallbackType m_is_input_complete_callback = nullptr;
   void *m_is_input_complete_callback_baton = nullptr;
   FixIndentationCallbackType m_fix_indentation_callback = nullptr;
   void *m_fix_indentation_callback_baton = nullptr;
   const char *m_fix_indentation_callback_chars = nullptr;
+  SuggestionCallbackType m_suggestion_callback = nullptr;
+  void *m_suggestion_callback_baton = nullptr;
   CompleteCallbackType m_completion_callback = nullptr;
   void *m_completion_callback_baton = nullptr;
-
   std::mutex m_output_mutex;
 };
 }
 
 #endif // #if defined(__cplusplus)
 #endif // LLDB_HOST_EDITLINE_H

lldb/include/lldb/Interpreter/CommandInterpreter.h

public:
   ///    and failed with some explanation if we aborted executing the commands
   ///    at some point.
   void HandleCommandsFromFile(FileSpec &file, ExecutionContext *context,
                               CommandInterpreterRunOptions &options,
                               CommandReturnObject &result);
 
   CommandObject *GetCommandObjectForCommand(llvm::StringRef &command_line);
 
+  /// Returns the auto-suggestion string that should be added to the given
+  /// command line.
+  llvm::Optional<std::string> GetAutoSuggestionForCommand(llvm::StringRef line);
+
   // This handles command line completion.
   void HandleCompletion(CompletionRequest &request);
 
   // This version just returns matches, and doesn't compute the substring. It
   // is here so the Help command can call it for the first argument.
   void HandleCompletionMatches(CompletionRequest &request);
 
   int GetCommandNamesMatchingPartialString(const char *cmd_cstr,
public:
 
   void GetPythonCommandsFromIOHandler(const char *prompt,
                                       IOHandlerDelegate &delegate,
                                       void *baton = nullptr);
 
   const char *GetCommandPrefix();
 
   // Properties
+  void AddCommandHistory(std::vector<std::string> histories);
+
   bool GetExpandRegexAliases() const;
 
   bool GetPromptOnQuit() const;
 
   void SetPromptOnQuit(bool enable);
 
   bool GetEchoCommands() const;
   void SetEchoCommands(bool enable);

lldb/source/Core/CoreProperties.td

let Definition = "debugger" in {
   def EscapeNonPrintables: Property<"escape-non-printables", "Boolean">,
     Global,
     DefaultTrue,
     Desc<"If true, LLDB will automatically escape non-printable and escape characters when formatting strings.">;
   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.">;
 }

lldb/source/Core/Debugger.cpp

 
 bool Debugger::SetUseColor(bool b) {
   const uint32_t idx = ePropertyUseColor;
   bool ret = m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
   SetPrompt(GetPrompt());
   return ret;
 }
 
+bool Debugger::GetUseAutosuggestion() const {
+  const uint32_t idx = ePropertyShowAutosuggestion;
+  return m_collection_sp->GetPropertyAtIndexAsBoolean(
+      nullptr, idx, g_debugger_properties[idx].default_uint_value != 0);
+}
+
 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

if (line == "yes" || line == "YES" || line == "Yes") {
     m_user_response = true;
     io_handler.SetIsDone(true);
   } else if (line == "no" || line == "NO" || line == "No") {
     m_user_response = false;
     io_handler.SetIsDone(true);
   }
 }
 
+llvm::Optional<std::string>
+IOHandlerDelegate::IOHandlerSuggestion(IOHandler &io_handler,
+                                       llvm::StringRef line) {
+  return io_handler.GetDebugger()
+      .GetCommandInterpreter()
+      .GetAutoSuggestionForCommand(line);
+}
+
 void IOHandlerDelegate::IOHandlerComplete(IOHandler &io_handler,
                                           CompletionRequest &request) {
   switch (m_completion) {
   case Completion::None:
     break;
   case Completion::LLDBCommand:
     io_handler.GetDebugger().GetCommandInterpreter().HandleCompletion(request);
     break;
use_editline = GetInputFILE() && GetOutputFILE() && GetErrorFILE() &&
                  m_input_sp && m_input_sp->GetIsRealTerminal();
 
   if (use_editline) {
     m_editline_up.reset(new Editline(editline_name, GetInputFILE(),
                                      GetOutputFILE(), GetErrorFILE(),
                                      m_color_prompts));
     m_editline_up->SetIsInputCompleteCallback(IsInputCompleteCallback, this);
     m_editline_up->SetAutoCompleteCallback(AutoCompleteCallback, this);
+    if (debugger.GetUseAutosuggestion())
+      m_editline_up->SetSuggestionCallback(SuggestionCallback, this);
+    std::vector<std::string> histories = m_editline_up->AddHistories();
+    this->GetDebugger().GetCommandInterpreter().AddCommandHistory(histories);
     // 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
       m_editline_up->SetFixIndentationCallback(FixIndentationCallback, this,
                                                indent_chars);
     }
int IOHandlerEditline::FixIndentationCallback(Editline *editline,
                                               const StringList &lines,
                                               int cursor_position,
                                               void *baton) {
   IOHandlerEditline *editline_reader = (IOHandlerEditline *)baton;
   return editline_reader->m_delegate.IOHandlerFixIndentation(
       *editline_reader, lines, cursor_position);
 }
 
+llvm::Optional<std::string>
+IOHandlerEditline::SuggestionCallback(llvm::StringRef line, void *baton) {
+  IOHandlerEditline *editline_reader = static_cast<IOHandlerEditline *>(baton);
+  if (editline_reader)
+    return editline_reader->m_delegate.IOHandlerSuggestion(*editline_reader,
+                                                           line);
+
+  return llvm::None;
+}
+
 void IOHandlerEditline::AutoCompleteCallback(CompletionRequest &request,
                                              void *baton) {
   IOHandlerEditline *editline_reader = (IOHandlerEditline *)baton;
   if (editline_reader)
     editline_reader->m_delegate.IOHandlerComplete(*editline_reader, request);
 }
 #endif
 

lldb/source/Host/common/Editline.cpp

 //===-- Editline.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 <iomanip>
 #include <iostream>
 #include <limits.h>
 
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Editline.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Utility/AnsiTerminal.h"
 #include "lldb/Utility/CompletionRequest.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/SelectHelper.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StringList.h"
 #include "lldb/Utility/Timeout.h"
if (m_history) {
       if (path) {
         history_w(m_history, &m_event, H_SAVE, path);
         return true;
       }
     }
     return false;
   }
 
+  std::vector<std::string> HistoryList() {
+    this->Load();
+    std::vector<std::string> histories;
+    if (m_history) {
+      const char *path = GetHistoryFilePath();
+      if (path) {
+        history_w(m_history, &m_event, H_GETSIZE);
+        int num = m_event.num;
+        for (int i = 0; i < num; ++i) {
+          history_w(m_history, &m_event, H_SET, i);
+          history_w(m_history, &m_event, H_CURR);
+          std::string string_history =
+              std::wstring_convert<std::codecvt_utf8<wchar_t>>().to_bytes(
+                  m_event.str);
+          histories.push_back(
+              string_history.substr(0, string_history.length() - 1));
+        }
+      }
+    }
+    return histories;
+  }
+
 protected:
   HistoryW *m_history; // The history object
   HistEventW m_event;  // The history event needed to contain all history events
   std::string m_prefix; // The prefix name (usually the editline program name)
                         // to use when loading/saving history
   std::string m_path;   // Path to the history file
 };
 }
if (results.size() == 1) {
     switch (completion.GetMode()) {
     case CompletionMode::Normal: {
       std::string to_add = completion.GetCompletion();
       to_add = to_add.substr(request.GetCursorArgumentPrefix().size());
       if (request.GetParsedArg().IsQuoted())
         to_add.push_back(request.GetParsedArg().GetQuoteChar());
       to_add.push_back(' ');
       el_insertstr(m_editline, to_add.c_str());
-      break;
+      return CC_REFRESH;
     }
     case CompletionMode::Partial: {
       std::string to_add = completion.GetCompletion();
       to_add = to_add.substr(request.GetCursorArgumentPrefix().size());
       el_insertstr(m_editline, to_add.c_str());
       break;
     }
     case CompletionMode::RewriteLine: {
unsigned char Editline::TabCommand(int ch) {
 
   DisplayCompletions(m_editline, m_output_file, results);
 
   DisplayInput();
   MoveCursor(CursorLocation::BlockEnd, CursorLocation::EditingCursor);
   return CC_REDISPLAY;
 }
 
+unsigned char Editline::ApplyAutosuggestCommand(int ch) {
+  const LineInfo *line_info = el_line(m_editline);
+  llvm::StringRef line(line_info->buffer,
+                       line_info->lastchar - line_info->buffer);
+
+  if (llvm::Optional<std::string> to_add =
+          m_suggestion_callback(line, m_suggestion_callback_baton)) {
+    el_insertstr(m_editline, to_add.getValue().c_str());
+    return CC_REFRESH;
+  }
+
+  return CC_REDISPLAY;
+}
+
+unsigned char Editline::TypedCharacter(int ch) {
+  std::string typed = std::string(1, ch);
+  el_insertstr(m_editline, typed.c_str());
+  const LineInfo *line_info = el_line(m_editline);
+  llvm::StringRef line(line_info->buffer,
+                       line_info->lastchar - line_info->buffer);
+
+  if (llvm::Optional<std::string> to_add =
+          m_suggestion_callback(line, m_suggestion_callback_baton)) {
+    std::string to_add_color = ansi::FormatAnsiTerminalCodes("${ansi.faint}") +
+                               to_add.getValue() +
+                               ansi::FormatAnsiTerminalCodes("${ansi.normal}");
+    fputs(typed.c_str(), m_output_file);
+    fputs(to_add_color.c_str(), m_output_file);
+    MoveCursor(CursorLocation::BlockEnd, CursorLocation::EditingPrompt);
+    return CC_REFRESH;
+  }
+
+  return CC_REDISPLAY;
+}
+
 void Editline::ConfigureEditor(bool multiline) {
   if (m_editline && m_multiline_enabled == multiline)
     return;
   m_multiline_enabled = multiline;
 
   if (m_editline) {
     // Disable edit mode to stop the terminal from flushing all input during
     // the call to el_end() since we expect to have multiple editline instances
el_wset(m_editline, EL_ADDFN, EditLineConstString("lldb-complete"),
           EditLineConstString("Invoke completion"), complete_callback);
   el_wset(m_editline, EL_ADDFN, EditLineConstString("lldb_complete"),
           EditLineConstString("Invoke completion"), complete_callback);
 
   // General bindings we don't mind being overridden
   if (!multiline) {
     el_set(m_editline, EL_BIND, "^r", "em-inc-search-prev",
            NULL); // Cycle through backwards search, entering string
+
+    if (m_suggestion_callback) {
+      el_wset(m_editline, EL_ADDFN, EditLineConstString("lldb-apply-complete"),
+              EditLineConstString("Adopt autocompletion"),
+              (EditlineCommandCallbackType)([](EditLine *editline, int ch) {
+                return Editline::InstanceFor(editline)->ApplyAutosuggestCommand(
+                    ch);
+              }));
+
+      el_set(m_editline, EL_BIND, "^f", "lldb-apply-complete",
+             NULL); // Apply a part that is suggested automatically
+
+      el_wset(m_editline, EL_ADDFN, EditLineConstString("lldb-typed-character"),
+              EditLineConstString("Typed character"),
+              (EditlineCommandCallbackType)([](EditLine *editline, int ch) {
+                return Editline::InstanceFor(editline)->TypedCharacter(ch);
+              }));
+
+      char bind_key[2] = {0, 0};
+      llvm::StringRef ascii_chars =
+          "abcdefghijklmnopqrstuvwxzyABCDEFGHIJKLMNOPQRSTUVWXZY1234567890!\"#$%"
+          "&'()*+,./:;<=>?@[]_`{|}~ ";
+      for (char c : ascii_chars) {
+        bind_key[0] = c;
+        el_set(m_editline, EL_BIND, bind_key, "lldb-typed-character", NULL);
+      }
+      el_set(m_editline, EL_BIND, "\\-", "lldb-typed-character", NULL);
+      el_set(m_editline, EL_BIND, "\\^", "lldb-typed-character", NULL);
+      el_set(m_editline, EL_BIND, "\\\\", "lldb-typed-character", NULL);
+    }
   }
+
   el_set(m_editline, EL_BIND, "^w", "ed-delete-prev-word",
          NULL); // Delete previous word, behave like bash in emacs mode
+
   el_set(m_editline, EL_BIND, "\t", "lldb-complete",
          NULL); // Bind TAB to auto complete
 
   // Allow ctrl-left-arrow and ctrl-right-arrow for navigation, behave like
   // bash in emacs mode.
   el_set(m_editline, EL_BIND, ESCAPE "[1;5C", "em-next-word", NULL);
   el_set(m_editline, EL_BIND, ESCAPE "[1;5D", "ed-prev-word", NULL);
   el_set(m_editline, EL_BIND, ESCAPE "[5C", "em-next-word", NULL);
if (m_editor_status == EditorStatus::Editing) {
     MoveCursor(CursorLocation::EditingCursor, CursorLocation::BlockStart);
     fprintf(m_output_file, ANSI_CLEAR_BELOW);
     result = m_input_connection.InterruptRead();
   }
   m_editor_status = EditorStatus::Interrupted;
   return result;
 }
 
+void Editline::SetSuggestionCallback(SuggestionCallbackType callback,
+                                     void *baton) {
+  m_suggestion_callback = callback;
+  m_suggestion_callback_baton = baton;
+}
+
 void Editline::SetAutoCompleteCallback(CompleteCallbackType callback,
                                        void *baton) {
   m_completion_callback = callback;
   m_completion_callback_baton = baton;
 }
 
 void Editline::SetIsInputCompleteCallback(IsInputCompleteCallbackType callback,
                                           void *baton) {
case std::codecvt_base::partial:
           &ch, 1, std::chrono::seconds(0), status, nullptr);
       if (read_count == 0)
         return false;
       break;
     }
   }
 #endif
 }
+
+std::vector<std::string> Editline::AddHistories() {
+  return m_history_sp->HistoryList();
+}

lldb/source/Interpreter/CommandInterpreter.cpp

CommandInterpreter::CommandInterpreter(Debugger &debugger,
   SetEventName(eBroadcastBitThreadShouldExit, "thread-should-exit");
   SetEventName(eBroadcastBitResetPrompt, "reset-prompt");
   SetEventName(eBroadcastBitQuitCommandReceived, "quit");
   SetSynchronous(synchronous_execution);
   CheckInWithManager();
   m_collection_sp->Initialize(g_interpreter_properties);
 }
 
+void CommandInterpreter::AddCommandHistory(std::vector<std::string> histories) {
+  for (std::string history : histories) {
+    this->m_command_history.AppendString(history);
+  }
+}
+
 bool CommandInterpreter::GetExpandRegexAliases() const {
   const uint32_t idx = ePropertyExpandRegexAliases;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_interpreter_properties[idx].default_uint_value != 0);
 }
 
 bool CommandInterpreter::GetPromptOnQuit() const {
   const uint32_t idx = ePropertyPromptOnQuit;
if (first_arg.front() == CommandHistory::g_repeat_char) {
                               CompletionMode::RewriteLine);
       return;
     }
   }
 
   HandleCompletionMatches(request);
 }
 
+llvm::Optional<std::string>
+CommandInterpreter::GetAutoSuggestionForCommand(llvm::StringRef line) {
+  const size_t s = m_command_history.GetSize();
+  for (int i = s - 1; i >= 0; --i) {
+    llvm::StringRef entry = m_command_history.GetStringAtIndex(i);
+    if (entry.consume_front(line))
+      return entry.str();
+  }
+  return llvm::None;
+}
+
 CommandInterpreter::~CommandInterpreter() {}
 
 void CommandInterpreter::UpdatePrompt(llvm::StringRef new_prompt) {
   EventSP prompt_change_event_sp(
       new Event(eBroadcastBitResetPrompt, new EventDataBytes(new_prompt)));
   ;
   BroadcastEvent(prompt_change_event_sp);
   if (m_command_io_handler_sp)

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

+"""
+Tests autosuggestion using pexpect.
+"""
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.lldbpexpect import PExpectTest
+
+class TestCase(PExpectTest):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    # PExpect uses many timeouts internally and doesn't play well
+    # under ASAN on a loaded machine..
+    @skipIfAsan
+    @skipIfEditlineSupportMissing
+    def test_autosuggestion(self):
+        self.launch(extra_args=["-o", "settings set show-autosuggestion true"])
+
+        # Common input codes and escape sequences. 
+        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(faint_color + "p frame" + reset + "\x1b[1G")
+        
+        # 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")
+        self.child.expect_exact(frame_output_needle)
+
+        # Try autosuggestion using tab and ^f.         
+        # \t makes "help" and ^f makes "help frame". If everything went 
+        # correct we should see the 'help frame' output again.
+        self.child.send("hel\t" + ctrl_f + "\n")
+        self.child.expect_exact(frame_output_needle)
+
+        # Check that pressing Ctrl+F in an empty prompt does nothing. 
+        self.child.send(ctrl_f)
+        self.child.expect_exact("")
+        self.child.send("\n")
+        
+        # Check that autosuggestion works after delete.
+        self.child.send("a1234" + 5 * delete + "hel" + ctrl_f + "\n")
+        self.child.expect_exact(frame_output_needle)
+        
+        # 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.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(faint_color + "p apropos" + reset + "\x1b[1G")
+                                                                                
+        # Run the command and expect the 'help apropos' output.                 
+        self.child.send(ctrl_f + "\n")
+        self.child.expect_exact(apropos_output_needle)
+        
+        self.quit()
+    
 No newline at end of file