[LLDB] Add a hook to notify REPLs that an expression was evaluated

[wallace]

Summary

REPL implementations don't have an easy way to know that an expression has been evaluated, so I'm adding a simple function for that. In the future we can add another hook for meta commands.

[bulbazord]

lldb/include/lldb/Expression/REPL.h

115–120

Why not return a Status object instead of having the return type be void? Or instead of Status you could use llvm::Error so we are forced to check it.

[wallace]

lldb/include/lldb/Expression/REPL.h

115–120

my initial idea was to make this a simple observer, but a llvm::Error is probably more generic. I'll do that

[wallace]

address comments

[bulbazord]

lldb/include/lldb/Expression/REPL.h

124

Do you still need the Status parameter?

[wallace]

lldb/include/lldb/Expression/REPL.h

124

that status is the result of the expression evaluation, so it's useful to have it here

lldb/include/lldb/Expression/REPL.h

public:
 
   void IOHandlerInputComplete(IOHandler &io_handler,
                               std::string &line) override;
 
   void IOHandlerComplete(IOHandler &io_handler,
                          CompletionRequest &request) override;
 
 protected:
+  /// Method that can be optionally overriden by subclasses to get notified
+  /// whenever an expression has been evaluated. The params of this method
+  /// include the inputs and outputs of the expression evaluation.
+  ///
+  /// Note: meta commands that start with : are not covered by this method.
+  ///
+  /// \return
+  ///   An \a Error object that, if it is a failure, aborts the regular
+  ///   REPL expression result handling.
+  virtual llvm::Error
+  OnExpressionEvaluated(const ExecutionContext &exe_ctx, llvm::StringRef code,
+                        const EvaluateExpressionOptions &expr_options,
+                        lldb::ExpressionResults execution_results,
+                        const lldb::ValueObjectSP &result_valobj_sp,
+                        const Status &error) {
+    return llvm::Error::success();
+  }
+
   static int CalculateActualIndentation(const StringList &lines);
 
   // Subclasses should override these functions to implement a functional REPL.
 
   virtual Status DoInitialization() = 0;
 
   virtual ConstString GetSourceFileBasename() = 0;
 

lldb/source/Expression/REPL.cpp

if (code[0] == ':') {
       const char *expr_prefix = nullptr;
       lldb::ValueObjectSP result_valobj_sp;
       Status error;
       lldb::ExpressionResults execution_results =
           UserExpression::Evaluate(exe_ctx, expr_options, code.c_str(),
                                    expr_prefix, result_valobj_sp, error,
                                    nullptr); // fixed expression
 
-      // CommandInterpreter &ci = debugger.GetCommandInterpreter();
-
-      if (process_sp && process_sp->IsAlive()) {
+      if (llvm::Error err = OnExpressionEvaluated(exe_ctx, code, expr_options,
+                                                  execution_results,
+                                                  result_valobj_sp, error)) {
+        *error_sp << llvm::toString(std::move(err)) << "\n";
+      } else if (process_sp && process_sp->IsAlive()) {
         bool add_to_code = true;
         bool handled = false;
         if (result_valobj_sp) {
           lldb::Format format = m_format_options.GetFormat();
 
           if (result_valobj_sp->GetError().Success()) {
             handled |= PrintOneVariable(debugger, output_sp, result_valobj_sp);
           } else if (result_valobj_sp->GetError().GetError() ==