[lldb-vscode] Prior to running the launchCommands during a launch request set the launch info so the configured launch information is accessible by the launch commands.

[ashgti]

Summary

[lldb-vscode] Adding support for column break points.

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

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.

lldb/tools/lldb-vscode/JSONUtils.h

 ///
 /// \param[in] request_line
 ///     An optional line to use when creating the resulting "Breakpoint" object.
 ///     It is used if the breakpoint has no valid locations.
 ///     It is useful to ensure the same line
 ///     provided by the setBreakpoints request are returned to the IDE as a
 ///     fallback.
 ///
+/// \param[in] request_column
+///     An optional column to use when creating the resulting "Breakpoint" object.
+///     It is used if the breakpoint has no valid locations.
+///     It is useful to ensure the same column
+///     provided by the setBreakpoints request are returned to the IDE as a
+///     fallback.
+///
 /// \return
 ///     A "Breakpoint" JSON object with that follows the formal JSON
 ///     definition outlined by Microsoft.
 llvm::json::Value
 CreateBreakpoint(lldb::SBBreakpoint &bp,
                  std::optional<llvm::StringRef> request_path = std::nullopt,
-                 std::optional<uint32_t> request_line = std::nullopt);
+                 std::optional<uint32_t> request_line = std::nullopt,
+                 std::optional<uint32_t> request_column = std::nullopt);
 
 /// Converts a LLDB module to a VS Code DAP module for use in "modules" events.
 ///
 /// \param[in] module
 ///     A LLDB module object to convert into a JSON value
 ///
 /// \return
 ///     A "Module" JSON object with that follows the formal JSON

lldb/tools/lldb-vscode/JSONUtils.cpp

 //                       the breakpoint. If no end line is given, then the end
 //                       column is assumed to be in the start line."
 //     }
 //   },
 //   "required": [ "verified" ]
 // }
 llvm::json::Value CreateBreakpoint(lldb::SBBreakpoint &bp,
                                    std::optional<llvm::StringRef> request_path,
-                                   std::optional<uint32_t> request_line) {
+                                   std::optional<uint32_t> request_line,
+                                   std::optional<uint32_t> request_column) {
   // Each breakpoint location is treated as a separate breakpoint for VS code.
   // They don't have the notion of a single breakpoint with multiple locations.
   llvm::json::Object object;
   if (!bp.IsValid())
     return llvm::json::Value(std::move(object));
 
   object.try_emplace("verified", bp.GetNumResolvedLocations() > 0);
   object.try_emplace("id", bp.GetID());
llvm::json::Value CreateBreakpoint(lldb::SBBreakpoint &bp,
   if (request_path)
     object.try_emplace("source", CreateSource(*request_path));
 
   if (bp_addr.IsValid()) {
     auto line_entry = bp_addr.GetLineEntry();
     const auto line = line_entry.GetLine();
     if (line != UINT32_MAX)
       object.try_emplace("line", line);
+    const auto column = line_entry.GetColumn();
+    if (column != 0)
+      object.try_emplace("column", column);
     object.try_emplace("source", CreateSource(line_entry));
   }
   // We try to add request_line as a fallback
   if (request_line)
     object.try_emplace("line", *request_line);
+  if (request_column)
+    object.try_emplace("column", *request_column);
   return llvm::json::Value(std::move(object));
 }
 
 static uint64_t GetDebugInfoSizeInSection(lldb::SBSection section) {
   uint64_t debug_info_size = 0;
   llvm::StringRef section_name(section.GetName());
   if (section_name.startswith(".debug") || section_name.startswith("__debug") ||
       section_name.startswith(".apple") || section_name.startswith("__apple"))
if (exc_bp) {
       EmplaceSafeString(body, "description", exc_bp->label);
     } else {
       body.try_emplace("reason", "breakpoint");
       char desc_str[64];
       uint64_t bp_id = thread.GetStopReasonDataAtIndex(0);
       uint64_t bp_loc_id = thread.GetStopReasonDataAtIndex(1);
       snprintf(desc_str, sizeof(desc_str), "breakpoint %" PRIu64 ".%" PRIu64,
                bp_id, bp_loc_id);
+      body.try_emplace("hitBreakpointIds", llvm::json::Array{llvm::json::Value(bp_id)});
       EmplaceSafeString(body, "description", desc_str);
     }
   } break;
   case lldb::eStopReasonWatchpoint:
   case lldb::eStopReasonInstrumentation:
     body.try_emplace("reason", "breakpoint");
     break;
   case lldb::eStopReasonProcessorTrace:
llvm::json::Value CreateThreadStopped(lldb::SBThread &thread,
   // description. If we have breakpoints that get hit and shouldn't be reported
   // as breakpoints, then they will set the description above.
   if (!ObjectContainsKey(body, "description")) {
     char description[1024];
     if (thread.GetStopDescription(description, sizeof(description))) {
       EmplaceSafeString(body, "description", std::string(description));
     }
   }
-  if (tid == g_vsc.focus_tid) {
-    body.try_emplace("threadCausedFocus", true);
-  }
   body.try_emplace("preserveFocusHint", tid != g_vsc.focus_tid);
   body.try_emplace("allThreadsStopped", true);
   event.try_emplace("body", std::move(body));
   return llvm::json::Value(std::move(event));
 }
 
 const char *GetNonNullVariableName(lldb::SBValue v) {
   const char *name = v.GetName();

lldb/tools/lldb-vscode/Options.td

def: Flag<["-"], "h">,
   HelpText<"Alias for --help">;
 
 def wait_for_debugger: F<"wait-for-debugger">,
   HelpText<"Pause the program at startup.">;
 def: Flag<["-"], "g">,
   Alias<wait_for_debugger>,
   HelpText<"Alias for --wait-for-debugger">;
 
-def port: Separate<["--", "-"], "port">,
+def port: S<"port">,
   MetaVarName<"<port>">,
   HelpText<"Communicate with the lldb-vscode tool over the defined port.">;
 def: Separate<["-"], "p">,
   Alias<port>,
   HelpText<"Alias for --port">;
 
-def launch_target: Separate<["--", "-"], "launch-target">,
+def launch_target: S<"launch-target">,
   MetaVarName<"<target>">,
   HelpText<"Launch a target for the launchInTerminal request. Any argument "
     "provided after this one will be passed to the target. The parameter "
     "--comm-file must also be specified.">;
 
-def comm_file: Separate<["--", "-"], "comm-file">,
+def comm_file: S<"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">,
+def debugger_pid: S<"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

 |**program**        |string|Y| Path to the executable to launch.
 |**args**           |[string]|| An array of command line argument strings to be passed to the program being launched.
 |**cwd**            |string| | The program working directory.
 |**env**            |dictionary| | Environment variables to set when launching the program. The format of each environment variable string is "VAR=VALUE" for environment variables with values or just "VAR" for environment variables with no values.
 |**stopOnEntry**    |boolean| | Whether to stop program immediately after launching.
 |**initCommands**   |[string]| | LLDB commands executed upon debugger startup prior to creating the LLDB target. Commands and command output will be sent to the debugger console when they are executed.
 |**preRunCommands** |[string]| | LLDB commands executed just before launching after the LLDB target has been created. Commands and command output will be sent to the debugger console when they are executed.
 |**stopCommands**   |[string]| | LLDB commands executed just after each stop. Commands and command output will be sent to the debugger console when they are executed.
+|**launchCommands** |[string]| | LLDB commands executed to launch the program. Commands and command output will be sent to the debugger console when they are executed.
 |**exitCommands**   |[string]| | LLDB commands executed when the program exits. Commands and command output will be sent to the debugger console when they are executed.
 |**terminateCommands** |[string]| | LLDB commands executed when the debugging session ends. Commands and command output will be sent to the debugger console when they are executed.
 |**sourceMap**      |[string[2]]| | Specify an array of path re-mappings. Each element in the array must be a two element array containing a source and destination pathname.
 |**debuggerRoot**   | string| |Specify a working directory to use when launching lldb-vscode. If the debug information in your executable contains relative paths, this option can be used so that `lldb-vscode` can find source files and object files that have relative paths.
 
 ## Attaching Settings
 
 When attaching to a process using LLDB you can attach in a few ways

 ```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. Due to the heuristic for determining the
+   expression, variables that have the same name as an lldb command will only be
+   accessible via an explicit expression command. For example, if the current
+   frame contains a variable `help` and a repl evaluation expression is only the
+   value `"help"` then the lldb help command will be invoked. To access the
+   local variable use `p help`, `po help` or `var help`.
+
+The initial repl-mode can be configured with the cli flag `--repl-mode=<mode>`
+and may also be adjusted at runtime using `lldb-vscode repl-mode <mode>`.

lldb/tools/lldb-vscode/SourceBreakpoint.cpp

 
 namespace lldb_vscode {
 
 SourceBreakpoint::SourceBreakpoint(const llvm::json::Object &obj)
     : BreakpointBase(obj), line(GetUnsigned(obj, "line", 0)),
       column(GetUnsigned(obj, "column", 0)) {}
 
 void SourceBreakpoint::SetBreakpoint(const llvm::StringRef source_path) {
-  bp = g_vsc.target.BreakpointCreateByLocation(source_path.str().c_str(), line);
+  lldb::SBFileSpecList module_list;
+  bp = g_vsc.target.BreakpointCreateByLocation(source_path.str().c_str(), line, column, 0, module_list);
   // See comments in BreakpointBase::GetBreakpointLabel() for details of why
   // we add a label to our breakpoints.
   bp.AddName(GetBreakpointLabel());
   if (!condition.empty())
     SetCondition();
   if (!hitCondition.empty())
     SetHitCondition();
   if (!logMessage.empty())
     SetLogMessage();
 }
 
 } // namespace lldb_vscode

lldb/tools/lldb-vscode/VSCode.h

 
 enum class PacketStatus {
   Success = 0,
   EndOfFile,
   JSONMalformed,
   JSONNotObject
 };
 
+enum class ReplMode {
+  Variable = 0,
+  Command,
+  Auto
+};
+
+/// A huersitic for determining the context of an evaluation.
+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;
 
   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(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) {
   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(std::string &text) {
+  switch (repl_mode) {
+  case ReplMode::Variable:
+    if (!text.empty() && text[0] == '`') {
+      text = text.substr(1);
+      return ExpressionContext::Command;
+    }
+
+    return ExpressionContext::Variable;
+  case ReplMode::Command:
+    return ExpressionContext::Command;
+  case ReplMode::Auto:
+    lldb::SBCommandReturnObject result;
+    g_vsc.debugger.GetCommandInterpreter().ResolveCommand(text.data(), result);
+    if (result.GetStatus() != lldb::eReturnStatusSuccessFinishResult) {
+      return ExpressionContext::Variable;
+    }
+    
+    llvm::StringRef output = result.GetOutput();
+    if (output.starts_with("frame variable")) {
+      return ExpressionContext::Variable;
+    }
+
+    return ExpressionContext::Command;
+  }
+}
+
 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);

 
 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 (!command || llvm::StringRef(command[0]).empty()) {
+    std::string mode = "lldb-vscode repl-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.AppendMessage(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;
+    result.AppendMessage("lldb-vscode repl-mode variable set.");
+  } else if (new_mode == "command") {
+    g_vsc.repl_mode = ReplMode::Command;
+    result.AppendMessage("lldb-vscode repl-mode command set.");
+  } else if (new_mode == "auto") {
+    g_vsc.repl_mode = ReplMode::Auto;
+    result.AppendMessage("lldb-vscode repl-mode auto set.");
+  } else {
+    std::string error = "Unknown repl-mode '" + new_mode.str() + "'.";
+    result.SetError(error.c_str());
+    result.SetStatus(lldb::eReturnStatusFailed);
+    return false;
+  }
+
+  result.SetStatus(lldb::eReturnStatusSuccessFinishNoResult);
+  return true;
+}
+
 } // namespace lldb_vscode

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

if (state == lldb::eStateStopped) {
         }
         if (has_reason) {
           ++num_threads_with_reason;
           if (first_tid_with_reason == LLDB_INVALID_THREAD_ID)
             first_tid_with_reason = tid;
         }
       }
 
-      // We will have cleared g_vsc.focus_tid if he focus thread doesn't have
+      // We will have cleared g_vsc.focus_tid if the focus thread doesn't have
       // a stop reason, so if it was cleared, or wasn't set, or doesn't exist,
       // then set the focus thread to the first thread with a stop reason.
       if (!focus_thread_exists || g_vsc.focus_tid == LLDB_INVALID_THREAD_ID)
         g_vsc.focus_tid = first_tid_with_reason;
 
       // If no threads stopped with a reason, then report the first one so
       // we at least let the UI know we stopped.
       if (num_threads_with_reason == 0) {

 //   "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");
+  
+  // 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 = std::string(GetString(arguments, "text"));
   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::StringRef text_ref{text};
+    ::llvm::SmallVector<::llvm::StringRef, 2> lines;
+    text_ref.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 {
-    char command[] = "expression -- ";
+
+  if (g_vsc.DetectExpressionContext(text) == ExpressionContext::Variable) {
+    char command[] = "frame variable ";
     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.
+    targets.reserve(matches.GetSize() - 1);
+    std::string common_pattern = matches.GetStringAtIndex(0);
+    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] == '`') {
+  if (context == "repl" && g_vsc.DetectExpressionContext(expression) == ExpressionContext::Command) {
+    // If we're evaluating a command relative to the current frame, set the 
+    // focus_tid to prevent steps from changing focus.
+    if (frame.IsValid()) {
+      g_vsc.focus_tid = frame.GetThread().GetThreadID();
+    }
     auto result =
-        RunLLDBCommands(llvm::StringRef(), {std::string(expression.substr(1))});
+        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.");
   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.");
+    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) {
   //   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);
+  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
if (llvm::Error err = request_runInTerminal(request, timeout_seconds))
       error.SetErrorString(llvm::toString(std::move(err)).c_str());
   } else if (launchCommands.empty()) {
     // Disable async events so the launch will be successful when we return from
     // the launch call and the launch will happen synchronously
     g_vsc.debugger.SetAsync(false);
     g_vsc.target.Launch(launch_info, error);
     g_vsc.debugger.SetAsync(true);
   } else {
+    // Set the launch info so that run commands can access the configured 
+    // launch details.
+    g_vsc.target.SetLaunchInfo(launch_info);
     g_vsc.RunLLDBCommands("Running launchCommands:", launchCommands);
     // The custom commands might have created a new target so we should use the
     // selected target after these commands are run.
     g_vsc.target = g_vsc.debugger.GetSelectedTarget();
     // Make sure the process is launched and stopped at the entry point before
     // proceeding as the the launch commands are not run using the synchronous
     // mode.
     error = g_vsc.WaitForProcessToStop(timeout_seconds);
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 "