Use std::function and remove the boilerplate in the SB API

Author: JDevlieghere

lldb/include/lldb/Interpreter/CommandInterpreter.h

@@ -254,8 +254,9 @@ class CommandInterpreter : public Broadcaster,
     eCommandTypesAllThem = 0xFFFF  //< all commands
   };
 
-  typedef lldb::CommandReturnObjectCallbackResult (
-      *CommandReturnObjectCallback)(CommandReturnObject &, void *);
+  using CommandReturnObjectCallback =
+      std::function<lldb::CommandReturnObjectCallbackResult(
+          CommandReturnObject &)>;
 
   // The CommandAlias and CommandInterpreter both have a hand in
   // substituting for alias commands.  They work by writing special tokens
@@ -668,8 +669,7 @@ class CommandInterpreter : public Broadcaster,
     ++m_command_usages[cmd_obj.GetCommandName()];
   }
 
-  void SetPrintCallback(CommandReturnObjectCallback callback,
-                        lldb::BatonSP baton_sp);
+  void SetPrintCallback(CommandReturnObjectCallback callback);
 
   llvm::json::Value GetStatistics();
   const StructuredData::Array &GetTranscript() const;
@@ -782,10 +782,7 @@ class CommandInterpreter : public Broadcaster,
   CommandInterpreterRunResult m_result;
 
   /// An optional callback to handle printing the CommandReturnObject.
-  /// @{
-  CommandReturnObjectCallback m_print_callback = nullptr;
-  lldb::BatonSP m_print_callback_baton_sp;
-  /// @}
+  CommandReturnObjectCallback m_print_callback;
 
   // The exit code the user has requested when calling the 'quit' command.
   // No value means the user hasn't set a custom exit code so far.

lldb/source/API/SBCommandInterpreter.cpp

@@ -98,8 +98,8 @@ SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs)
 
 SBCommandInterpreter::~SBCommandInterpreter() = default;
 
-const SBCommandInterpreter &SBCommandInterpreter::
-operator=(const SBCommandInterpreter &rhs) {
+const SBCommandInterpreter &
+SBCommandInterpreter::operator=(const SBCommandInterpreter &rhs) {
   LLDB_INSTRUMENT_VA(this, rhs);
 
   m_opaque_ptr = rhs.m_opaque_ptr;
@@ -222,8 +222,7 @@ void SBCommandInterpreter::HandleCommandsFromFile(
   if (override_context.get())
     m_opaque_ptr->HandleCommandsFromFile(tmp_spec,
                                          override_context.get()->Lock(true),
-                                         options.ref(),
-                                         result.ref());
+                                         options.ref(), result.ref());
 
   else
     m_opaque_ptr->HandleCommandsFromFile(tmp_spec, options.ref(), result.ref());
@@ -649,7 +648,8 @@ SBCommand::operator bool() const {
 const char *SBCommand::GetName() {
   LLDB_INSTRUMENT_VA(this);
 
-  return (IsValid() ? ConstString(m_opaque_sp->GetCommandName()).AsCString() : nullptr);
+  return (IsValid() ? ConstString(m_opaque_sp->GetCommandName()).AsCString()
+                    : nullptr);
 }
 
 const char *SBCommand::GetHelp() {
@@ -744,40 +744,14 @@ void SBCommand::SetFlags(uint32_t flags) {
     m_opaque_sp->GetFlags().Set(flags);
 }
 
-namespace lldb_private {
-struct CommandCallbackData {
-  SBCommandPrintCallback callback;
-  void *callback_baton;
-};
-
-class CommandPrintCallbackBaton
-    : public lldb_private::TypedBaton<CommandCallbackData> {
-public:
-  CommandPrintCallbackBaton(SBCommandPrintCallback callback, void *baton)
-      : TypedBaton(std::make_unique<CommandCallbackData>()) {
-    getItem()->callback = callback;
-    getItem()->callback_baton = baton;
-  }
-
-  static lldb::CommandReturnObjectCallbackResult
-  PrivateCallback(lldb_private::CommandReturnObject &result, void *baton) {
-    if (baton) {
-      CommandCallbackData *data = (CommandCallbackData *)baton;
-      SBCommandReturnObject sb_result(result);
-      return data->callback(sb_result, data->callback_baton);
-    }
-    return eCommandReturnObjectPrintCallbackSkipped;
-  }
-};
-} // namespace lldb_private
-
 void SBCommandInterpreter::SetPrintCallback(
     lldb::SBCommandPrintCallback callback, void *baton) {
   LLDB_INSTRUMENT_VA(this, callback, baton);
 
-  BatonSP baton_sp =
-      std::make_shared<CommandPrintCallbackBaton>(callback, baton);
   if (m_opaque_ptr)
     return m_opaque_ptr->SetPrintCallback(
-        &CommandPrintCallbackBaton::PrivateCallback, baton_sp);
+        [callback, baton](lldb_private::CommandReturnObject &result) {
+          SBCommandReturnObject sb_result(result);
+          return callback(sb_result, baton);
+        });
 }

lldb/source/Interpreter/CommandInterpreter.cpp

@@ -3215,11 +3215,7 @@ void CommandInterpreter::IOHandlerInputComplete(IOHandler &io_handler,
     };
 
     if (m_print_callback) {
-      void *baton = m_print_callback_baton_sp
-                        ? m_print_callback_baton_sp->data()
-                        : nullptr;
-      lldb::CommandReturnObjectCallbackResult callback_result =
-          m_print_callback(result, baton);
+      const auto callback_result = m_print_callback(result);
       if (callback_result == eCommandReturnObjectPrintCallbackSkipped)
         DefaultPrintCallback(result);
     } else {
@@ -3675,8 +3671,7 @@ const StructuredData::Array &CommandInterpreter::GetTranscript() const {
   return m_transcript;
 }
 
-void CommandInterpreter::SetPrintCallback(CommandReturnObjectCallback callback,
-                                          lldb::BatonSP baton_sp) {
+void CommandInterpreter::SetPrintCallback(
+    CommandReturnObjectCallback callback) {
   m_print_callback = callback;
-  m_print_callback_baton_sp = baton_sp;
 }