Migrate to llvm::unique_function instead of static member functions for callbacks

[nealsid]

Summary

A few cleanups suggested in another patch review's comments:

1. Use llvm:unique_function for storing & invoking callbacks from Editline to IOHandler
2. Change return type of one of the callback setters from bool to void, since it's return value was never used
3. Moved the callback setters inline & made them nonstatic, since that's more consistent with other setter definitions
4. Removed the baton parameter since we no longer need it anymore

[nealsid]

Fix unit test build

[zturner]

include/lldb/Host/Editline.h

94 ↗

(On Diff #159195)

Try llvm::unique_function instead of std::function (in other locations as well). I should have mentioned this earlier but forgot. It's basically the same except it doesn't require the callable to be copy constructible, which enables some optimizations. Not that this is a hot-path, but if we can use something strictly better, might as well.

179 ↗

(On Diff #159195)

= std::move(callback)

source/Core/IOHandler.cpp

314–315 ↗

(On Diff #159195)

I think we should avoid std::bind. Instead, just write

m_editline_ap->SetIsInputCompleteCallback([this](EditLine* a, StringList& b) { return IsInputCompleteCallback(a, b); });

similary for other places. I'd argue that std::bind actually makes the code *worse* since it's so hard to construct these bind statements and figure out what they do.

[Eugene.Zelenko]

include/lldb/Host/Editline.h

92 ↗

(On Diff #159195)

Please use using. Same in other places.

source/Core/IOHandler.cpp

315 ↗

(On Diff #159195)

See also Clang-tidy modernize-avoid-bind.

[nealsid]

Thanks for the comments! Will address and resend for review.

[nealsid]

include/lldb/Host/Editline.h

94 ↗

(On Diff #159195)

Ok, cool - so if I understand the optimizations we're trying to make, we want to make sure to use move semantics if were can. Doesn't std::function use move semantics when constructing itself from rvalue references to lambdas? Even if it didn't, would we benefit from llvm::unique_function since our cases are pretty simple?

[zturner]

std::function might be able to construct itself efficiently from a lambda,
but once it’s in the std::function all that info is lost and moving it
around more will always copy (unless you explicitly move). We only really
assign it once, so this isn’t an issue, but unique_function is nice from a
purist point of view in that it won’t ever allow std::function’s slow path
to be taken, even accidentally.

In practice this is a non issue because we’re talking about a couple of
cycles in code that isn’t even in a hot path, but it’s still nice for the
same reason you might use a singly linked list instead of a doubly linked
for a queue. It gives you as much as you need and nothing more.

So the benefit isn’t really one of performance. It’s more just a mindset
of, rather than saying “I’ll use the fast one if performance is a concern”,
saying instead “I’ll only use the slow one if it’s necessary for my use
case”

[nealsid]

Addressed code review feedback to move to llvm::unique_function instead of function pointers for callbacks and type aliases instead of typedefs.

[nealsid]

source/Core/IOHandler.cpp

315 ↗

(On Diff #159195)

I also ran clang-tidy and there's a few unrelated suggested cleanups to make, but I don't know what options to use to be consistent with the rest of the project.

[zturner]

Sorry for the delay, was on vacation last week.

[nealsid]

Fix 80 char line length violations

[zturner]

In D50299#1220983, @nealsid wrote:

Fix 80 char line length violations

Just curious, how did you fix them? Was it by running clang-format, or manually?

[nealsid]

Ran clang-format

[nealsid]

I'm updating this very old patch that I forgot about in 2018. This one removes the use of batons in the edit line callbacks, replaces typedefs with using declarations, and uses unique_function instead of callbacks.
Thanks,
Neal

[JDevlieghere]

Thanks Neal. Can you run clang-format again and upload the diff with context (git diff -U9999). Overall this looks pretty good.

[nealsid]

In D50299#2589289, @JDevlieghere wrote:

Thanks Neal. Can you run clang-format again and upload the diff with context (git diff -U9999). Overall this looks pretty good.

Thanks for the review. I have run clang-format and am currently running through a bunch of testing with the completion/suggestion features just to make sure. Hope to get it updated in the next couple of days.

[nealsid]

Updated diff with run of clang-format and added a check for function pointer validity. Thanks.

[JDevlieghere]

LGTM!

lldb/include/lldb/Host/Editline.h

58

[nealsid]

Removed comment on #include line and organized the #includes to match coding guidelines better (I wasn't sure about whether the project uses blank lines in between #includes from different subproject like lldb/clang/llvm so I didn't make the change more broadly)

[JDevlieghere]

In D50299#2596008, @nealsid wrote:

Removed comment on #include line and organized the #includes to match coding guidelines better (I wasn't sure about whether the project uses blank lines in between #includes from different subproject like lldb/clang/llvm so I didn't make the change more broadly)

Looks good. Let me know if you don't have commit access and need me to land this for you.

[nealsid]

In D50299#2596141, @JDevlieghere wrote:

In D50299#2596008, @nealsid wrote:

Removed comment on #include line and organized the #includes to match coding guidelines better (I wasn't sure about whether the project uses blank lines in between #includes from different subproject like lldb/clang/llvm so I didn't make the change more broadly)

Looks good. Let me know if you don't have commit access and need me to land this for you.

I do not have commit access, so if you could land it, that would be great. Appreciate the review.

lldb/include/lldb/Core/IOHandler.h

 //===-- IOHandler.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 LLDB_CORE_IOHANDLER_H
 #define LLDB_CORE_IOHANDLER_H
 
 #include "lldb/Core/ValueObjectList.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Utility/CompletionRequest.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Flags.h"
 #include "lldb/Utility/Predicate.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StringList.h"
 #include "lldb/lldb-defines.h"
public:
   const StringList *GetCurrentLines() const { return m_current_lines_ptr; }
 
   uint32_t GetCurrentLineIndex() const;
 
   void PrintAsync(Stream *stream, const char *s, size_t len) override;
 
 private:
 #if LLDB_ENABLE_LIBEDIT
-  static bool IsInputCompleteCallback(Editline *editline, StringList &lines,
-                                      void *baton);
+  bool IsInputCompleteCallback(Editline *editline, StringList &lines);
 
-  static int FixIndentationCallback(Editline *editline, const StringList &lines,
-                                    int cursor_position, void *baton);
+  int FixIndentationCallback(Editline *editline, const StringList &lines,
+                             int cursor_position);
 
-  static llvm::Optional<std::string> SuggestionCallback(llvm::StringRef line,
-                                                        void *baton);
+  llvm::Optional<std::string> SuggestionCallback(llvm::StringRef line);
 
-  static void AutoCompleteCallback(CompletionRequest &request, void *baton);
+  void AutoCompleteCallback(CompletionRequest &request);
 #endif
 
 protected:
 #if LLDB_ENABLE_LIBEDIT
   std::unique_ptr<Editline> m_editline_up;
 #endif
   IOHandlerDelegate &m_delegate;
   std::string m_prompt;

lldb/include/lldb/Host/Editline.h

 // ANSI sequences starting with escape.
 // d) Emoji support is fairly terrible, presumably it doesn't understand
 // composed characters?
 
 #ifndef LLDB_HOST_EDITLINE_H
 #define LLDB_HOST_EDITLINE_H
 #if defined(__cplusplus)
 
 #include "lldb/Host/Config.h"
 
 #if LLDB_EDITLINE_USE_WCHAR
 #include <codecvt>
 #endif
 #include <locale>
 #include <sstream>
 #include <vector>
 
-#include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/lldb-private.h"
 
 #if defined(_WIN32)
 #include "lldb/Host/windows/editlinewin.h"
 #elif !defined(__ANDROID__)
 #include <histedit.h>
 #endif
 
 #include <csignal>
 #include <mutex>
 #include <string>
 #include <vector>
 
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Utility/CompletionRequest.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Predicate.h"
+#include "lldb/Utility/StringList.h"
+
+#include "llvm/ADT/FunctionExtras.h"
 
 namespace lldb_private {
 namespace line_editor {
 
 // type alias's to help manage 8 bit and wide character versions of libedit
 #if LLDB_EDITLINE_USE_WCHAR
 using EditLineStringType = std::wstring;
 using EditLineStringStreamType = std::wstringstream;

 // versions exactly, but this is a pretty good approximation and allows us to
 // build against almost any editline version out there.
 #if LLDB_EDITLINE_USE_WCHAR || defined(EL_CLIENTDATA) || LLDB_HAVE_EL_RFUNC_T
 using EditLineGetCharType = wchar_t;
 #else
 using EditLineGetCharType = char;
 #endif
 
-typedef int (*EditlineGetCharCallbackType)(::EditLine *editline,
+using EditlineGetCharCallbackType = int (*)(::EditLine *editline,
                                             EditLineGetCharType *c);
-typedef unsigned char (*EditlineCommandCallbackType)(::EditLine *editline,
+using EditlineCommandCallbackType = unsigned char (*)(::EditLine *editline,
                                                       int ch);
-typedef const char *(*EditlinePromptCallbackType)(::EditLine *editline);
+using EditlinePromptCallbackType = const char *(*)(::EditLine *editline);
 
 class EditlineHistory;
 
-typedef std::shared_ptr<EditlineHistory> EditlineHistorySP;
+using EditlineHistorySP = std::shared_ptr<EditlineHistory>;
 
-typedef bool (*IsInputCompleteCallbackType)(Editline *editline,
-                                            StringList &lines, void *baton);
+using IsInputCompleteCallbackType =
+    llvm::unique_function<bool(Editline *, StringList &)>;
 
-typedef int (*FixIndentationCallbackType)(Editline *editline,
-                                          const StringList &lines,
-                                          int cursor_position, void *baton);
+using FixIndentationCallbackType =
+    llvm::unique_function<int(Editline *, StringList &, int)>;
 
-typedef llvm::Optional<std::string> (*SuggestionCallbackType)(
-    llvm::StringRef line, void *baton);
+using SuggestionCallbackType =
+    llvm::unique_function<llvm::Optional<std::string>(llvm::StringRef)>;
 
-typedef void (*CompleteCallbackType)(CompletionRequest &request, void *baton);
+using CompleteCallbackType = llvm::unique_function<void(CompletionRequest &)>;
 
 /// 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:
 
   /// 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);
+  void SetSuggestionCallback(SuggestionCallbackType callback) {
+    m_suggestion_callback = std::move(callback);
+  }
 
   /// Register a callback for the tab key
-  void SetAutoCompleteCallback(CompleteCallbackType callback, void *baton);
+  void SetAutoCompleteCallback(CompleteCallbackType callback) {
+    m_completion_callback = std::move(callback);
+  }
 
   /// Register a callback for testing whether multi-line input is complete
-  void SetIsInputCompleteCallback(IsInputCompleteCallbackType callback,
-                                  void *baton);
+  void SetIsInputCompleteCallback(IsInputCompleteCallbackType callback) {
+    m_is_input_complete_callback = std::move(callback);
+  }
 
   /// 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);
+  /// 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;
+  }
 
   /// 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
   std::string m_current_prompt;
   bool m_needs_prompt_repaint = false;
   volatile std::sig_atomic_t m_terminal_size_has_changed = 0;
   std::string m_editor_name;
   FILE *m_input_file;
   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;
+
+  IsInputCompleteCallbackType m_is_input_complete_callback;
+
+  FixIndentationCallbackType m_fix_indentation_callback;
   const char *m_fix_indentation_callback_chars = nullptr;
-  CompleteCallbackType m_completion_callback = nullptr;
-  void *m_completion_callback_baton = nullptr;
-  SuggestionCallbackType m_suggestion_callback = nullptr;
-  void *m_suggestion_callback_baton = nullptr;
+
+  CompleteCallbackType m_completion_callback;
+
+  SuggestionCallbackType m_suggestion_callback;
+
   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/IOHandler.cpp

 //===-- IOHandler.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/Core/IOHandler.h"
 
 #if defined(__APPLE__)
 #include <deque>
 #endif
 #include <string>
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/StreamFile.h"
#if LLDB_ENABLE_LIBEDIT
 
   use_editline = GetInputFILE() && GetOutputFILE() && GetErrorFILE() &&
                  m_input_sp && m_input_sp->GetIsRealTerminal();
 
   if (use_editline) {
     m_editline_up = std::make_unique<Editline>(editline_name, GetInputFILE(),
                                                GetOutputFILE(), GetErrorFILE(),
                                                m_color_prompts);
-    m_editline_up->SetIsInputCompleteCallback(IsInputCompleteCallback, this);
-    m_editline_up->SetAutoCompleteCallback(AutoCompleteCallback, this);
-    if (debugger.GetUseAutosuggestion() && debugger.GetUseColor())
-      m_editline_up->SetSuggestionCallback(SuggestionCallback, this);
+    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()) {
+      m_editline_up->SetSuggestionCallback([this](llvm::StringRef line) {
+        return this->SuggestionCallback(line);
+      });
+    }
     // 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);
+      FixIndentationCallbackType f = [this](Editline *editline,
+                                            const StringList &lines,
+                                            int cursor_position) {
+        return this->FixIndentationCallback(editline, lines, cursor_position);
+      };
+      m_editline_up->SetFixIndentationCallback(std::move(f), indent_chars);
     }
   }
 #endif
   SetBaseLineNumber(m_base_line_number);
   SetPrompt(prompt);
   SetContinuationPrompt(continuation_prompt);
 }
 
if (m_data_recorder)
       m_data_recorder->Record(line, true);
   }
 
   return (bool)got_line;
 }
 
 #if LLDB_ENABLE_LIBEDIT
 bool IOHandlerEditline::IsInputCompleteCallback(Editline *editline,
-                                                StringList &lines,
-                                                void *baton) {
-  IOHandlerEditline *editline_reader = (IOHandlerEditline *)baton;
-  return editline_reader->m_delegate.IOHandlerIsInputComplete(*editline_reader,
-                                                              lines);
+                                                StringList &lines) {
+  return m_delegate.IOHandlerIsInputComplete(*this, lines);
 }
 
 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);
+                                              int cursor_position) {
+  return m_delegate.IOHandlerFixIndentation(*this, 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;
+IOHandlerEditline::SuggestionCallback(llvm::StringRef line) {
+  return m_delegate.IOHandlerSuggestion(*this, line);
 }
 
-void IOHandlerEditline::AutoCompleteCallback(CompletionRequest &request,
-                                             void *baton) {
-  IOHandlerEditline *editline_reader = (IOHandlerEditline *)baton;
-  if (editline_reader)
-    editline_reader->m_delegate.IOHandlerComplete(*editline_reader, request);
+void IOHandlerEditline::AutoCompleteCallback(CompletionRequest &request) {
+  m_delegate.IOHandlerComplete(*this, request);
 }
 #endif
 
 const char *IOHandlerEditline::GetPrompt() {
 #if LLDB_ENABLE_LIBEDIT
   if (m_editline_up) {
     return m_editline_up->GetPrompt();
   } else {

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 <limits.h>
 
-#include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Editline.h"
+
+#include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.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"
if (!IsInputPending(m_input_file)) {
     if (m_fix_indentation_callback) {
       StringList lines = GetInputAsStringList(m_current_line_index + 1);
 #if LLDB_EDITLINE_USE_WCHAR
       lines.AppendString(m_utf8conv.to_bytes(new_line_fragment));
 #else
       lines.AppendString(new_line_fragment);
 #endif
 
-      int indent_correction = m_fix_indentation_callback(
-          this, lines, 0, m_fix_indentation_callback_baton);
+      int indent_correction = m_fix_indentation_callback(this, lines, 0);
       new_line_fragment = FixIndentation(new_line_fragment, indent_correction);
       m_revert_cursor_index = GetIndentation(new_line_fragment);
     }
   }
 
   // Insert the new line and repaint everything from the split line on down
   m_input_lines.insert(m_input_lines.begin() + m_current_line_index + 1,
                        new_line_fragment);
unsigned char Editline::EndOrAddLineCommand(int ch) {
 
   // If this is the end of the last line, consider whether to add a line
   // instead
   const LineInfoW *info = el_wline(m_editline);
   if (m_current_line_index == m_input_lines.size() - 1 &&
       info->cursor == info->lastchar) {
     if (m_is_input_complete_callback) {
       auto lines = GetInputAsStringList();
-      if (!m_is_input_complete_callback(this, lines,
-                                        m_is_input_complete_callback_baton)) {
+      if (!m_is_input_complete_callback(this, lines)) {
         return BreakLineCommand(ch);
       }
 
       // The completion test is allowed to change the input lines when complete
       m_input_lines.clear();
       for (unsigned index = 0; index < lines.GetSize(); index++) {
 #if LLDB_EDITLINE_USE_WCHAR
         m_input_lines.insert(m_input_lines.end(),
if (IsOnlySpaces()) {
       return RecallHistory(HistoryOperation::Newer);
     }
 
     // Determine indentation for the new line
     int indentation = 0;
     if (m_fix_indentation_callback) {
       StringList lines = GetInputAsStringList();
       lines.AppendString("");
-      indentation = m_fix_indentation_callback(
-          this, lines, 0, m_fix_indentation_callback_baton);
+      indentation = m_fix_indentation_callback(this, lines, 0);
     }
     m_input_lines.insert(
         m_input_lines.end(),
         EditLineStringType(indentation, EditLineCharType(' ')));
   }
 
   // Move down past the current line using newlines to force scrolling if
   // needed
unsigned char Editline::FixIndentationCommand(int ch) {
   EditLineCharType inserted[] = {(EditLineCharType)ch, 0};
   el_winsertstr(m_editline, inserted);
   LineInfoW *info = const_cast<LineInfoW *>(el_wline(m_editline));
   int cursor_position = info->cursor - info->buffer;
 
   // Save the edits and determine the correct indentation level
   SaveEditedLine();
   StringList lines = GetInputAsStringList(m_current_line_index + 1);
-  int indent_correction = m_fix_indentation_callback(
-      this, lines, cursor_position, m_fix_indentation_callback_baton);
+  int indent_correction =
+      m_fix_indentation_callback(this, lines, cursor_position);
 
   // If it is already correct no special work is needed
   if (indent_correction == 0)
     return CC_REFRESH;
 
   // Change the indentation level of the line
   std::string currentLine = lines.GetStringAtIndex(m_current_line_index);
   if (indent_correction > 0) {
while (cur_pos < results.size()) {
     if (got_char == -1 || reply == 'n')
       break;
     if (reply == 'a')
       all = true;
   }
 }
 
 unsigned char Editline::TabCommand(int ch) {
-  if (m_completion_callback == nullptr)
+  if (!m_completion_callback)
     return CC_ERROR;
 
   const LineInfo *line_info = el_line(m_editline);
 
   llvm::StringRef line(line_info->buffer,
                        line_info->lastchar - line_info->buffer);
   unsigned cursor_index = line_info->cursor - line_info->buffer;
   CompletionResult result;
   CompletionRequest request(line, cursor_index, result);
 
-  m_completion_callback(request, m_completion_callback_baton);
+  m_completion_callback(request);
 
   llvm::ArrayRef<CompletionResult::Completion> results = result.GetResults();
 
   StringList completions;
   result.GetMatches(completions);
 
   if (results.size() == 0)
     return CC_ERROR;
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) {
+  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);
 
-  if (llvm::Optional<std::string> to_add =
-          m_suggestion_callback(line, m_suggestion_callback_baton))
+  if (llvm::Optional<std::string> to_add = m_suggestion_callback(line))
     el_insertstr(m_editline, to_add->c_str());
 
   return CC_REDISPLAY;
 }
 
 unsigned char Editline::TypedCharacter(int ch) {
   std::string typed = std::string(1, ch);
   el_insertstr(m_editline, typed.c_str());
+
+  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);
 
-  if (llvm::Optional<std::string> to_add =
-          m_suggestion_callback(line, m_suggestion_callback_baton)) {
+  if (llvm::Optional<std::string> to_add = m_suggestion_callback(line)) {
     std::string to_add_color = ANSI_FAINT + to_add.getValue() + ANSI_UNFAINT;
     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;
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) {
-  m_is_input_complete_callback = callback;
-  m_is_input_complete_callback_baton = baton;
-}
-
-bool Editline::SetFixIndentationCallback(FixIndentationCallbackType callback,
-                                         void *baton,
-                                         const char *indent_chars) {
-  m_fix_indentation_callback = callback;
-  m_fix_indentation_callback_baton = baton;
-  m_fix_indentation_callback_chars = indent_chars;
-  return false;
-}
-
 bool Editline::GetLine(std::string &line, bool &interrupted) {
   ConfigureEditor(false);
   m_input_lines = std::vector<EditLineStringType>();
   m_input_lines.insert(m_input_lines.begin(), EditLineConstString(""));
 
   std::lock_guard<std::mutex> guard(m_output_mutex);
 
   lldbassert(m_editor_status != EditorStatus::Editing);

lldb/unittests/Editline/EditlineTest.cpp

 //===-- EditlineTest.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/Host/Config.h"
 
 #if LLDB_ENABLE_LIBEDIT
 
 #define EDITLINE_TEST_DUMP_OUTPUT 0
 
 #include <stdio.h>
 #include <unistd.h>
 
public:
   bool GetLine(std::string &line, bool &interrupted, size_t timeout_millis);
 
   bool GetLines(lldb_private::StringList &lines, bool &interrupted,
                 size_t timeout_millis);
 
   void ConsumeAllOutput();
 
 private:
-  static bool IsInputComplete(lldb_private::Editline *editline,
-                              lldb_private::StringList &lines, void *baton);
+  bool IsInputComplete(lldb_private::Editline *editline,
+                       lldb_private::StringList &lines);
 
   std::unique_ptr<lldb_private::Editline> _editline_sp;
 
   PseudoTerminal _pty;
   int _pty_master_fd;
   int _pty_secondary_fd;
 
   std::unique_ptr<FilePointer> _el_secondary_file;
EditlineAdapter::EditlineAdapter()
 
   // Create an Editline instance.
   _editline_sp.reset(new lldb_private::Editline(
       "gtest editor", *_el_secondary_file, *_el_secondary_file,
       *_el_secondary_file, false));
   _editline_sp->SetPrompt("> ");
 
   // Hookup our input complete callback.
-  _editline_sp->SetIsInputCompleteCallback(IsInputComplete, this);
+  auto input_complete_cb = [this](Editline *editline, StringList &lines) {
+    return this->IsInputComplete(editline, lines);
+  };
+  _editline_sp->SetIsInputCompleteCallback(input_complete_cb);
 }
 
 void EditlineAdapter::CloseInput() {
   if (_el_secondary_file != nullptr)
     _el_secondary_file.reset(nullptr);
 }
 
 bool EditlineAdapter::SendLine(const std::string &line) {
bool EditlineAdapter::GetLines(lldb_private::StringList &lines,
   if (!IsValid())
     return false;
 
   _editline_sp->GetLines(1, lines, interrupted);
   return true;
 }
 
 bool EditlineAdapter::IsInputComplete(lldb_private::Editline *editline,
-                                      lldb_private::StringList &lines,
-                                      void *baton) {
+                                      lldb_private::StringList &lines) {
   // We'll call ourselves complete if we've received a balanced set of braces.
   int start_block_count = 0;
   int brace_balance = 0;
 
   for (const std::string &line : lines) {
     for (auto ch : line) {
       if (ch == '{') {
         ++start_block_count;