[lldb-vscode] Creating a new flag for adjusting the behavior of evaluation repl expressions to allow users to more easily invoke lldb commands.

[ashgti]

Summary

This adds a new flag and lldb runtime command to allow users to manage the behavior of the lldb-vscode evaluate repl request.

When evaluating a repl context this now has runtime managed flag for control how the repl behaviors with the follow values:

• variable - the existing behavior, with this mode requests are evaluted in the current frame context as variable expressions. To trigger a lldb command prefix an expression with ` and it will be evaluted as an lldb command.
• command - all expressions are evaluated as lldb commands.
• auto - An alternative mode that will attempt to determine if the expression is an lldb command or a variable expression. Based off the intepreted results the expression will be evaluted either as a command or an expression.

Additionally, I enabled completions and ensured they work with the new repl expression behavior to provide auto-completes.

This commit includes updates to the tests to verify the new behavior after the previous failures from submitting https://reviews.llvm.org/D154030.

[ashgti]

Applying formatting.

[ashgti]

Adjusting the startDebugging test.

[ashgti]

Hi wallace, this is a second attempt at this change set including updates to existing tests to check the behavior changes. LMKWYT

[wallace]

fingers crossed

[ashgti]

Updating patch.

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/vscode.py

def get_stackFrame(self, frameIndex=0, threadId=None):
             print("invalid threadId")
             return None
         response = self.request_stackTrace(threadId, startFrame=frameIndex, levels=1)
         if response:
             return response["body"]["stackFrames"][0]
         print("invalid response")
         return None
 
-    def get_completions(self, text):
-        response = self.request_completions(text)
+    def get_completions(self, text, frameId=None):
+        if frameId is None:
+            stackFrame = self.get_stackFrame()
+            frameId = stackFrame["id"]
+        response = self.request_completions(text, frameId)
         return response["body"]["targets"]
 
     def get_scope_variables(self, scope_name, frameIndex=0, threadId=None):
         stackFrame = self.get_stackFrame(frameIndex=frameIndex, threadId=threadId)
         if stackFrame is None:
             return []
         frameId = stackFrame["id"]
         if frameId in self.frame_scopes:
def request_initialize(self, sourceInitFile):
                 "clientID": "vscode",
                 "columnsStartAt1": True,
                 "linesStartAt1": True,
                 "locale": "en-us",
                 "pathFormat": "path",
                 "supportsRunInTerminalRequest": True,
                 "supportsVariablePaging": True,
                 "supportsVariableType": True,
+                "supportsStartDebuggingRequest": True,
                 "sourceInitFile": sourceInitFile,
             },
         }
         response = self.send_recv(command_dict)
         if response:
             if "body" in response:
                 self.initialize_body = response["body"]
         return response
def request_compileUnits(self, moduleId):
         command_dict = {
             "command": "compileUnits",
             "type": "request",
             "arguments": args_dict,
         }
         response = self.send_recv(command_dict)
         return response
 
-    def request_completions(self, text):
+    def request_completions(self, text, frameId=None):
         args_dict = {"text": text, "column": len(text)}
+        if frameId:
+            args_dict["frameId"] = frameId
         command_dict = {
             "command": "completions",
             "type": "request",
             "arguments": args_dict,
         }
         return self.send_recv(command_dict)
 
     def request_modules(self):

lldb/test/API/tools/lldb-vscode/completions/TestVSCode_completions.py

 """
 Test lldb-vscode completions request
 """
 
 
 import lldbvscode_testcase
 import vscode
 from lldbsuite.test import lldbutil
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 
 
-class TestVSCode_variables(lldbvscode_testcase.VSCodeTestCaseBase):
+class TestVSCode_completions(lldbvscode_testcase.VSCodeTestCaseBase):
     def verify_completions(self, actual_list, expected_list, not_expected_list=[]):
         for expected_item in expected_list:
             self.assertIn(expected_item, actual_list)
 
         for not_expected_item in not_expected_list:
             self.assertNotIn(not_expected_item, actual_list)
 
     @skipIfWindows
def test_completions(self):
         self.verify_completions(
             self.vscode.get_completions("var"),
             [
                 {
                     "text": "var",
                     "label": "var -- vector<basic_string<char>> &",
                 }
             ],
-            [{"text": "var1", "label": "var1 -- int &"}],
+            [
+                {
+                    "text": "var",
+                    "label": "var -- Show variables for the current stack frame. Defaults to all arguments and local variables in scope. Names of argument, local, file static and file global variables can be specified.",
+                },
+                {"text": "var1", "label": "var1 -- int &"},
+            ],
         )
 
         # should see global keywords but not variables inside main
         self.verify_completions(
             self.vscode.get_completions("str"),
             [{"text": "struct", "label": "struct"}],
             [{"text": "str1", "label": "str1 -- std::string &"}],
         )

lldb/test/API/tools/lldb-vscode/console/TestVSCode_console.py

 """
 Test lldb-vscode setBreakpoints request
 """
 
 import vscode
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 import lldbvscode_testcase
 
 
 class TestVSCode_console(lldbvscode_testcase.VSCodeTestCaseBase):
     def check_lldb_command(self, lldb_command, contains_string, assert_msg):
-        response = self.vscode.request_evaluate("`%s" % (lldb_command))
+        response = self.vscode.request_evaluate("`%s" % (lldb_command), context="repl")
         output = response["body"]["result"]
         self.assertIn(
             contains_string,
             output,
             (
                 """Verify %s by checking the command output:\n"""
                 """'''\n%s'''\nfor the string: "%s" """
                 % (assert_msg, output, contains_string)

lldb/test/API/tools/lldb-vscode/module/TestVSCode_module.py

def run_test(self, symbol_basename, expect_debug_info_size):
         self.assertEqual(program, program_module["path"])
         self.assertNotIn(
             "symbolFilePath",
             program_module,
             "Make sure a.out.stripped has no debug info",
         )
         symbols_path = self.getBuildArtifact(symbol_basename)
         self.vscode.request_evaluate(
-            "`%s" % ('target symbols add -s "%s" "%s"' % (program, symbols_path))
+            "`%s" % ('target symbols add -s "%s" "%s"' % (program, symbols_path)),
+            context="repl",
         )
 
         def checkSymbolsLoadedWithSize():
             active_modules = self.vscode.get_modules()
             program_module = active_modules[program_basename]
             self.assertIn("symbolFilePath", program_module)
             self.assertIn(symbols_path, program_module["symbolFilePath"])
             symbol_regex = re.compile(r"[0-9]+(\.[0-9]*)?[KMG]?B")

lldb/test/API/tools/lldb-vscode/startDebugging/TestVSCode_startDebugging.py

 """
 Test lldb-vscode startDebugging reverse request
 """
 
 
 import vscode
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 import lldbvscode_testcase
 
 
 class TestVSCode_startDebugging(lldbvscode_testcase.VSCodeTestCaseBase):
     def test_startDebugging(self):
         """
-            Tests the "startDebugging" reverse request. It makes sure that the IDE can
-            start a child debug session.
         """
         program = self.getBuildArtifact("a.out")
         source = "main.c"
         self.build_and_launch(program)
 
         breakpoint_line = line_number(source, "// breakpoint")
 
         self.set_source_breakpoints(source, [breakpoint_line])
         self.continue_to_next_stop()
         self.vscode.request_evaluate(
-            '`lldb-vscode startDebugging attach \'{"pid":321}\'', context='repl'
+            "`lldb-vscode startDebugging attach '{\"pid\":321}'", context="repl"
         )
 
+        self.continue_to_exit()
+
         self.assertEqual(
-            len(self.vscode.reverse_requests), 
-            1, 
-            "make sure we got a reverse request"
+            len(self.vscode.reverse_requests), 1, "make sure we got a reverse request"
         )
 
         request = self.vscode.reverse_requests[0]
         self.assertEqual(request["arguments"]["configuration"]["pid"], 321)
-        self.assertEqual(request["arguments"]["request"], "attach")
+        self.assertEqual(request["arguments"]["request"], "attach")
 

lldb/tools/lldb-vscode/Options.td

def comm_file: Separate<["--", "-"], "comm-file">,
   MetaVarName<"<file>">,
   HelpText<"The fifo file used to communicate the with the debug adaptor "
     "when using --launch-target.">;
 
 def debugger_pid: Separate<["--", "-"], "debugger-pid">,
   MetaVarName<"<pid>">,
   HelpText<"The PID of the lldb-vscode instance that sent the launchInTerminal "
     "request when using --launch-target.">;
+
+def repl_mode: S<"repl-mode">,
+  MetaVarName<"<mode>">,
+  HelpText<"The mode for handling repl evaluation requests, supported modes: variable, command, auto.">;

lldb/tools/lldb-vscode/README.md

 ```javascript
 {
   "program": "server",
   "postRunCommand": [
     "lldb-vscode startDebugging launch '{\"program\":\"client\"}'"
   ]
 }
 ```
+
+## repl-mode
+
+Inspect or adjust the behavior of lldb-vscode repl evaluation requests. The
+supported modes are `variable`, `command` and `auto`.
+
+*  `variable` - Variable mode expressions are evaluated in the context of the
+   current frame. Use a `\`` prefix on the command to run an lldb command.
+*  `command` - Command mode expressions are evaluated as lldb commands, as a
+   result, values printed by lldb are always stringified representations of the
+   expression output.
+*  `auto` - Auto mode will attempt to infer if the expression represents an lldb
+   command or a variable expression. A heuristic is used to infer if the input
+   represents a variable or a command. Use a `\`` prefix to ensure an expression
+   is evaluated as a command.
+
+The initial repl-mode can be configured with the cli flag `--repl-mode=<mode>`
+and may also be adjusted at runtime using the lldb command
+`lldb-vscode repl-mode <mode>`.

lldb/tools/lldb-vscode/VSCode.h

 
 enum class PacketStatus {
   Success = 0,
   EndOfFile,
   JSONMalformed,
   JSONNotObject
 };
 
+enum class ReplMode { Variable = 0, Command, Auto };
+
+/// The detected context of an expression based off the current repl mode.
+enum class ExpressionContext {
+  Variable = 0,
+  Command,
+};
+
 struct Variables {
   /// Variable_reference start index of permanent expandable variable.
   static constexpr int64_t PermanentVariableStartIndex = (1ll << 32);
 
   lldb::SBValueList locals;
   lldb::SBValueList globals;
   lldb::SBValueList registers;
 
struct Variables {
 
   /// Check if \p var_ref points to a variable that should persist for the
   /// entire duration of the debug session, e.g. repl expandable variables
   static bool IsPermanentVariableReference(int64_t var_ref);
 
   /// \return a new variableReference.
   /// Specify is_permanent as true for variable that should persist entire
   /// debug session.
-  int64_t GetNewVariableRefence(bool is_permanent);
+  int64_t GetNewVariableReference(bool is_permanent);
 
   /// \return the expandable variable corresponding with variableReference
   /// value of \p value.
   /// If \p var_ref is invalid an empty SBValue is returned.
   lldb::SBValue GetVariable(int64_t var_ref) const;
 
   /// Insert a new \p variable.
   /// \return variableReference assigned to this expandable variable.
   int64_t InsertExpandableVariable(lldb::SBValue variable, bool is_permanent);
 
   /// Clear all scope variables and non-permanent expandable variables.
   void Clear();
 };
 
 struct StartDebuggingRequestHandler : public lldb::SBCommandPluginInterface {
   bool DoExecute(lldb::SBDebugger debugger, char **command,
                  lldb::SBCommandReturnObject &result) override;
 };
 
+struct ReplModeRequestHandler : public lldb::SBCommandPluginInterface {
+  bool DoExecute(lldb::SBDebugger debugger, char **command,
+                 lldb::SBCommandReturnObject &result) override;
+};
+
 struct VSCode {
   std::string debug_adaptor_path;
   InputStream input;
   OutputStream output;
   lldb::SBDebugger debugger;
   lldb::SBTarget target;
   Variables variables;
   lldb::SBBroadcaster broadcaster;
struct VSCode {
   // Keep track of the last stop thread index IDs as threads won't go away
   // unless we send a "thread" event to indicate the thread exited.
   llvm::DenseSet<lldb::tid_t> thread_ids;
   uint32_t reverse_request_seq;
   std::mutex call_mutex;
   std::map<int /* request_seq */, ResponseCallback /* reply handler */>
       inflight_reverse_requests;
   StartDebuggingRequestHandler start_debugging_request_handler;
+  ReplModeRequestHandler repl_mode_request_handler;
+  ReplMode repl_mode;
+  bool auto_repl_mode_collision_warning;
 
   VSCode();
   ~VSCode();
   VSCode(const VSCode &rhs) = delete;
   void operator=(const VSCode &rhs) = delete;
   int64_t GetLineForPC(int64_t sourceReference, lldb::addr_t pc) const;
   ExceptionBreakpoint *GetExceptionBreakpoint(const std::string &filter);
   ExceptionBreakpoint *GetExceptionBreakpoint(const lldb::break_id_t bp_id);
struct VSCode {
   ExceptionBreakpoint *GetExceptionBPFromStopReason(lldb::SBThread &thread);
 
   lldb::SBThread GetLLDBThread(const llvm::json::Object &arguments);
 
   lldb::SBFrame GetLLDBFrame(const llvm::json::Object &arguments);
 
   llvm::json::Value CreateTopLevelScopes();
 
+  ExpressionContext DetectExpressionContext(lldb::SBFrame &frame,
+                                            std::string &text);
+
   void RunLLDBCommands(llvm::StringRef prefix,
                        const std::vector<std::string> &commands);
 
   void RunInitCommands();
   void RunPreRunCommands();
   void RunStopCommands();
   void RunExitCommands();
   void RunTerminateCommands();

lldb/tools/lldb-vscode/VSCode.cpp

: broadcaster("lldb-vscode"),
            {"swift_catch", "Swift Catch", lldb::eLanguageTypeSwift},
            {"swift_throw", "Swift Throw", lldb::eLanguageTypeSwift}}),
       focus_tid(LLDB_INVALID_THREAD_ID), sent_terminated_event(false),
       stop_at_entry(false), is_attach(false),
       restarting_process_id(LLDB_INVALID_PROCESS_ID),
       configuration_done_sent(false), waiting_for_run_in_terminal(false),
       progress_event_reporter(
           [&](const ProgressEvent &event) { SendJSON(event.ToJSON()); }),
-      reverse_request_seq(0) {
+      reverse_request_seq(0), repl_mode(ReplMode::Auto),
+      auto_repl_mode_collision_warning(false) {
   const char *log_file_path = getenv("LLDBVSCODE_LOG");
 #if defined(_WIN32)
   // Windows opens stdout and stdin in text mode which converts \n to 13,10
   // while the value is just 10 on Darwin/Linux. Setting the file mode to binary
   // fixes this.
   int result = _setmode(fileno(stdout), _O_BINARY);
   assert(result);
   result = _setmode(fileno(stdin), _O_BINARY);
scopes.emplace_back(CreateScope("Locals", VARREF_LOCALS,
                                   g_vsc.variables.locals.GetSize(), false));
   scopes.emplace_back(CreateScope("Globals", VARREF_GLOBALS,
                                   g_vsc.variables.globals.GetSize(), false));
   scopes.emplace_back(CreateScope("Registers", VARREF_REGS,
                                   g_vsc.variables.registers.GetSize(), false));
   return llvm::json::Value(std::move(scopes));
 }
 
+ExpressionContext VSCode::DetectExpressionContext(lldb::SBFrame &frame,
+                                                  std::string &text) {
+  // Include ` as an escape hatch.
+  if (!text.empty() && text[0] == '`') {
+    text = text.substr(1);
+    return ExpressionContext::Command;
+  }
+
+  switch (repl_mode) {
+  case ReplMode::Variable:
+    return ExpressionContext::Variable;
+  case ReplMode::Command:
+    return ExpressionContext::Command;
+  case ReplMode::Auto:
+    // If the frame is invalid then there is no variables to complete, assume
+    // this is an lldb command instead.
+    if (!frame.IsValid()) {
+      return ExpressionContext::Command;
+    }
+
+    lldb::SBCommandReturnObject result;
+    debugger.GetCommandInterpreter().ResolveCommand(text.data(), result);
+
+    // If this command is a simple expression like `var + 1` check if there is
+    // a local variable name that is in the current expression. If so, ensure
+    // the expression runs in the variable context.
+    lldb::SBValueList variables = frame.GetVariables(true, true, true, true);
+    llvm::StringRef input = text;
+    for (uint32_t i = 0; i < variables.GetSize(); i++) {
+      llvm::StringRef name = variables.GetValueAtIndex(i).GetName();
+      // Check both directions in case the input is a partial of a variable
+      // (e.g. input = `va` and local variable = `var1`).
+      if (input.contains(name) || name.contains(input)) {
+        if (!auto_repl_mode_collision_warning) {
+          llvm::errs() << "Variable expression '" << text
+                       << "' is hiding an lldb command, prefix an expression "
+                          "with ` to ensure it runs as a lldb command.\n";
+          auto_repl_mode_collision_warning = true;
+        }
+        return ExpressionContext::Variable;
+      }
+    }
+
+    if (result.Succeeded()) {
+      return ExpressionContext::Command;
+    }
+  }
+
+  return ExpressionContext::Variable;
+}
+
 void VSCode::RunLLDBCommands(llvm::StringRef prefix,
                              const std::vector<std::string> &commands) {
   SendOutput(OutputType::Console,
              llvm::StringRef(::RunLLDBCommands(prefix, commands)));
 }
 
 void VSCode::RunInitCommands() {
   RunLLDBCommands("Running initCommands:", init_commands);
bool VSCode::HandleObject(const llvm::json::Object &object) {
   if (packet_type == "request") {
     const auto command = GetString(object, "command");
     auto handler_pos = request_handlers.find(std::string(command));
     if (handler_pos != request_handlers.end()) {
       handler_pos->second(object);
       return true; // Success
     } else {
       if (log)
-        *log << "error: unhandled command \"" << command.data() << std::endl;
+        *log << "error: unhandled command \"" << command.data() << "\""
+             << std::endl;
       return false; // Fail
     }
   }
 
   if (packet_type == "response") {
     auto id = GetSigned(object, "request_seq", 0);
     ResponseCallback response_handler = [](llvm::Expected<llvm::json::Value>) {
       llvm::errs() << "Unhandled response\n";

 
 void Variables::Clear() {
   locals.Clear();
   globals.Clear();
   registers.Clear();
   expandable_variables.clear();
 }
 
-int64_t Variables::GetNewVariableRefence(bool is_permanent) {
+int64_t Variables::GetNewVariableReference(bool is_permanent) {
   if (is_permanent)
     return next_permanent_var_ref++;
   return next_temporary_var_ref++;
 }
 
 bool Variables::IsPermanentVariableReference(int64_t var_ref) {
   return var_ref >= PermanentVariableStartIndex;
 }
 
 lldb::SBValue Variables::GetVariable(int64_t var_ref) const {
   if (IsPermanentVariableReference(var_ref)) {
     auto pos = expandable_permanent_variables.find(var_ref);
     if (pos != expandable_permanent_variables.end())
       return pos->second;
   } else {
     auto pos = expandable_variables.find(var_ref);
     if (pos != expandable_variables.end())
       return pos->second;
   }
   return lldb::SBValue();
 }
 
 int64_t Variables::InsertExpandableVariable(lldb::SBValue variable,
                                             bool is_permanent) {
-  int64_t var_ref = GetNewVariableRefence(is_permanent);
+  int64_t var_ref = GetNewVariableReference(is_permanent);
   if (is_permanent)
     expandable_permanent_variables.insert(std::make_pair(var_ref, variable));
   else
     expandable_variables.insert(std::make_pair(var_ref, variable));
   return var_ref;
 }
 
 bool StartDebuggingRequestHandler::DoExecute(
g_vsc.SendReverseRequest(
         }
       });
 
   result.SetStatus(lldb::eReturnStatusSuccessFinishNoResult);
 
   return true;
 }
 
+bool ReplModeRequestHandler::DoExecute(lldb::SBDebugger debugger,
+                                       char **command,
+                                       lldb::SBCommandReturnObject &result) {
+  // Command format like: `repl-mode <variable|command|auto>?`
+  // If a new mode is not specified report the current mode.
+  if (!command || llvm::StringRef(command[0]).empty()) {
+    std::string mode;
+    switch (g_vsc.repl_mode) {
+    case ReplMode::Variable:
+      mode = "variable";
+      break;
+    case ReplMode::Command:
+      mode = "command";
+      break;
+    case ReplMode::Auto:
+      mode = "auto";
+      break;
+    }
+
+    result.Printf("lldb-vscode repl-mode %s.\n", mode.c_str());
+    result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
+
+    return true;
+  }
+
+  llvm::StringRef new_mode{command[0]};
+
+  if (new_mode == "variable") {
+    g_vsc.repl_mode = ReplMode::Variable;
+  } else if (new_mode == "command") {
+    g_vsc.repl_mode = ReplMode::Command;
+  } else if (new_mode == "auto") {
+    g_vsc.repl_mode = ReplMode::Auto;
+  } else {
+    lldb::SBStream error_message;
+    error_message.Printf("Invalid repl-mode '%s'. Expected one of 'variable', "
+                         "'command' or 'auto'.\n",
+                         new_mode.data());
+    result.SetError(error_message.GetData());
+    return false;
+  }
+
+  result.Printf("lldb-vscode repl-mode %s set.\n", new_mode.data());
+  result.SetStatus(lldb::eReturnStatusSuccessFinishNoResult);
+  return true;
+}
+
 } // namespace lldb_vscode

lldb/tools/lldb-vscode/lldb-vscode.cpp

 //   "interface", "module", "property", "unit", "value", "enum", "keyword",
 //   "snippet", "text", "color", "file", "reference", "customcolor" ]
 // }
 void request_completions(const llvm::json::Object &request) {
   llvm::json::Object response;
   FillResponse(request, response);
   llvm::json::Object body;
   auto arguments = request.getObject("arguments");
-  std::string text = std::string(GetString(arguments, "text"));
+
+  // If we have a frame, try to set the context for variable completions.
+  lldb::SBFrame frame = g_vsc.GetLLDBFrame(*arguments);
+  if (frame.IsValid()) {
+    frame.GetThread().GetProcess().SetSelectedThread(frame.GetThread());
+    frame.GetThread().SetSelectedFrame(frame.GetFrameID());
+  }
+
+  std::string text = GetString(arguments, "text").str();
   auto original_column = GetSigned(arguments, "column", text.size());
-  auto actual_column = original_column - 1;
+  auto original_line = GetSigned(arguments, "line", 1);
+  auto offset = original_column - 1;
+  if (original_line > 1) {
+    llvm::SmallVector<::llvm::StringRef, 2> lines;
+    llvm::StringRef(text).split(lines, '\n');
+    for (int i = 0; i < original_line - 1; i++) {
+      offset += lines[i].size();
+    }
+  }
   llvm::json::Array targets;
-  // NOTE: the 'line' argument is not needed, as multiline expressions
-  // work well already
-  // TODO: support frameID. Currently
-  // g_vsc.debugger.GetCommandInterpreter().HandleCompletionWithDescriptions
-  // is frame-unaware.
-
-  if (!text.empty() && text[0] == '`') {
-    text = text.substr(1);
-    actual_column--;
-  } else {
+
+  if (g_vsc.DetectExpressionContext(frame, text) ==
+      ExpressionContext::Variable) {
     char command[] = "expression -- ";
     text = command + text;
-    actual_column += strlen(command);
+    offset += strlen(command);
   }
   lldb::SBStringList matches;
   lldb::SBStringList descriptions;
-  g_vsc.debugger.GetCommandInterpreter().HandleCompletionWithDescriptions(
-      text.c_str(), actual_column, 0, -1, matches, descriptions);
-  size_t count = std::min((uint32_t)100, matches.GetSize());
-  targets.reserve(count);
-  for (size_t i = 0; i < count; i++) {
+
+  if (g_vsc.debugger.GetCommandInterpreter().HandleCompletionWithDescriptions(
+          text.c_str(), offset, 0, 100, matches, descriptions)) {
+    // The first element is the common substring after the cursor position for
+    // all the matches. The rest of the elements are the matches so ignore the
+    // first result.
+    targets.reserve(matches.GetSize() - 1);
+    for (size_t i = 1; i < matches.GetSize(); i++) {
       std::string match = matches.GetStringAtIndex(i);
       std::string description = descriptions.GetStringAtIndex(i);
 
       llvm::json::Object item;
-
       llvm::StringRef match_ref = match;
       for (llvm::StringRef commit_point : {".", "->"}) {
         if (match_ref.contains(commit_point)) {
           match_ref = match_ref.rsplit(commit_point).second;
         }
       }
       EmplaceSafeString(item, "text", match_ref);
 
       if (description.empty())
         EmplaceSafeString(item, "label", match);
       else
         EmplaceSafeString(item, "label", match + " -- " + description);
 
       targets.emplace_back(std::move(item));
     }
+  }
 
   body.try_emplace("targets", std::move(targets));
   response.try_emplace("body", std::move(body));
   g_vsc.SendJSON(llvm::json::Value(std::move(response)));
 }
 
 //  "EvaluateRequest": {
 //    "allOf": [ { "$ref": "#/definitions/Request" }, {

 //    }]
 //  }
 void request_evaluate(const llvm::json::Object &request) {
   llvm::json::Object response;
   FillResponse(request, response);
   llvm::json::Object body;
   auto arguments = request.getObject("arguments");
   lldb::SBFrame frame = g_vsc.GetLLDBFrame(*arguments);
-  const auto expression = GetString(arguments, "expression");
+  std::string expression = GetString(arguments, "expression").str();
   llvm::StringRef context = GetString(arguments, "context");
 
-  if (!expression.empty() && expression[0] == '`') {
-    auto result =
-        RunLLDBCommands(llvm::StringRef(), {std::string(expression.substr(1))});
+  if (context == "repl" && g_vsc.DetectExpressionContext(frame, expression) ==
+                               ExpressionContext::Command) {
+    // If we're evaluating a command relative to the current frame, set the
+    // focus_tid to the current frame for any thread related events.
+    if (frame.IsValid()) {
+      g_vsc.focus_tid = frame.GetThread().GetThreadID();
+    }
+    auto result = RunLLDBCommands(llvm::StringRef(), {std::string(expression)});
     EmplaceSafeString(body, "result", result);
     body.try_emplace("variablesReference", (int64_t)0);
   } else {
     // Always try to get the answer from the local variables if possible. If
     // this fails, then if the context is not "hover", actually evaluate an
     // expression using the expression parser.
     //
     // "frame variable" is more reliable than the expression parser in
void request_initialize(const llvm::json::Object &request) {
   // sourceInitFile option is not from formal DAP specification. It is only
   // used by unit tests to prevent sourcing .lldbinit files from environment
   // which may affect the outcome of tests.
   bool source_init_file = GetBoolean(arguments, "sourceInitFile", true);
 
   g_vsc.debugger =
       lldb::SBDebugger::Create(source_init_file, log_cb, nullptr);
   auto cmd = g_vsc.debugger.GetCommandInterpreter().AddMultiwordCommand(
-      "lldb-vscode", nullptr);
+      "lldb-vscode", "Commands for managing lldb-vscode.");
+  if (GetBoolean(arguments, "supportsStartDebuggingRequest", false)) {
     cmd.AddCommand(
         "startDebugging", &g_vsc.start_debugging_request_handler,
-      "Sends a startDebugging request from the debug adapter to the client to "
-      "start a child debug session of the same type as the caller.");
+        "Sends a startDebugging request from the debug adapter to the client "
+        "to start a child debug session of the same type as the caller.");
+  }
+  cmd.AddCommand(
+      "repl-mode", &g_vsc.repl_mode_request_handler,
+      "Get or set the repl behavior of vscode-lldb evaluation requests.");
 
   g_vsc.progress_event_thread = std::thread(ProgressEventThreadFunction);
 
   // Start our event thread so we can receive events from the debugger, target,
   // process and more.
   g_vsc.event_thread = std::thread(EventThreadFunction);
 
   llvm::json::Object response;
void request_initialize(const llvm::json::Object &request) {
   // The debug adapter supports setting a variable to a value.
   body.try_emplace("supportsSetVariable", true);
   // The debug adapter supports restarting a frame.
   body.try_emplace("supportsRestartFrame", false);
   // The debug adapter supports the gotoTargetsRequest.
   body.try_emplace("supportsGotoTargetsRequest", false);
   // The debug adapter supports the stepInTargetsRequest.
   body.try_emplace("supportsStepInTargetsRequest", false);
-  // We need to improve the current implementation of completions in order to
-  // enable it again. For some context, this is how VSCode works:
-  // - VSCode sends a completion request whenever chars are added, the user
-  //   triggers completion manually via CTRL-space or similar mechanisms, but
-  //   not when there's a deletion. Besides, VSCode doesn't let us know which
-  //   of these events we are handling. What is more, the use can paste or cut
-  //   sections of the text arbitrarily.
-  //   https://github.com/microsoft/vscode/issues/89531 tracks part of the
-  //   issue just mentioned.
-  // This behavior causes many problems with the current way completion is
-  // implemented in lldb-vscode, as these requests could be really expensive,
-  // blocking the debugger, and there could be many concurrent requests unless
-  // the user types very slowly... We need to address this specific issue, or
-  // at least trigger completion only when the user explicitly wants it, which
-  // is the behavior of LLDB CLI, that expects a TAB.
-  body.try_emplace("supportsCompletionsRequest", false);
+  // The debug adapter supports the completions request.
+  body.try_emplace("supportsCompletionsRequest", true);
+
+  llvm::json::Array completion_characters;
+  completion_characters.emplace_back(".");
+  completion_characters.emplace_back(" ");
+  completion_characters.emplace_back("\t");
+  body.try_emplace("completionTriggerCharacters",
+                   std::move(completion_characters));
+
   // The debug adapter supports the modules request.
   body.try_emplace("supportsModulesRequest", true);
   // The set of additional module information exposed by the debug adapter.
   //   body.try_emplace("additionalModuleColumns"] = ColumnDescriptor
   // Checksum algorithms supported by the debug adapter.
   //   body.try_emplace("supportedChecksumAlgorithms"] = ChecksumAlgorithm
   // The debug adapter supports the RestartRequest. In this case a client
   // should not implement 'restart' by terminating and relaunching the adapter
void request_scopes(const llvm::json::Object &request) {
   // users switches threads with a lldb command like "`thread select 14", the
   // GUI will not update as there are no "event" notification packets that
   // allow us to change the currently selected thread or frame in the GUI that
   // I am aware of.
   if (frame.IsValid()) {
     frame.GetThread().GetProcess().SetSelectedThread(frame.GetThread());
     frame.GetThread().SetSelectedFrame(frame.GetFrameID());
   }
+
   g_vsc.variables.locals = frame.GetVariables(/*arguments=*/true,
                                               /*locals=*/true,
                                               /*statics=*/false,
                                               /*in_scope_only=*/true);
   g_vsc.variables.globals = frame.GetVariables(/*arguments=*/false,
                                                /*locals=*/false,
                                                /*statics=*/true,
                                                /*in_scope_only=*/true);
int main(int argc, char *argv[]) {
   llvm::ArrayRef<const char *> ArgsArr = llvm::ArrayRef(argv + 1, argc);
   llvm::opt::InputArgList input_args = T.ParseArgs(ArgsArr, MAI, MAC);
 
   if (input_args.hasArg(OPT_help)) {
     printHelp(T, llvm::sys::path::filename(argv[0]));
     return EXIT_SUCCESS;
   }
 
+  if (input_args.hasArg(OPT_repl_mode)) {
+    llvm::opt::Arg *repl_mode = input_args.getLastArg(OPT_repl_mode);
+    llvm::StringRef repl_mode_value = repl_mode->getValue();
+    if (repl_mode_value == "auto") {
+      g_vsc.repl_mode = ReplMode::Auto;
+    } else if (repl_mode_value == "variable") {
+      g_vsc.repl_mode = ReplMode::Variable;
+    } else if (repl_mode_value == "command") {
+      g_vsc.repl_mode = ReplMode::Command;
+    } else {
+      llvm::errs()
+          << "'" << repl_mode_value
+          << "' is not a valid option, use 'variable', 'command' or 'auto'.\n";
+      return EXIT_FAILURE;
+    }
+  }
+
   if (llvm::opt::Arg *target_arg = input_args.getLastArg(OPT_launch_target)) {
     if (llvm::opt::Arg *comm_file = input_args.getLastArg(OPT_comm_file)) {
       lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
       llvm::opt::Arg *debugger_pid = input_args.getLastArg(OPT_debugger_pid);
       if (debugger_pid) {
         llvm::StringRef debugger_pid_value = debugger_pid->getValue();
         if (debugger_pid_value.getAsInteger(10, pid)) {
           llvm::errs() << "'" << debugger_pid_value << "' is not a valid "