feat(watches): setExpression and setVariable requests (#48)

* feat(watches): `setExpression` request

* fix(watches): no need to worry about duplicates

In fact, allowing duplicates is nice to reevaluate an expression, in
some circumstances

* refactor(watches): in fact, inline function

* fix(watches): set default value properly

* fix: type annotation

* fix(watches): early return and check type to avoid err

* refactor(watches): it's big brain time

(expensively?) reevaluate all expressions after setting the value of any
expression, to guarantee up to date values

* refactor: minor cleanup

* refactor: I didn't even realize this function became useless

* refactor: earlier refactor broke code

* refactor: no longer using alternative types

* feat(watches): `setVariable` request

* bump docs

* feat: `o` to open menu in scopes view

Author: igorlfs

README.md

@@ -81,6 +81,7 @@ The plugin provides 6 "views" that share the same window (so there's clutter)
     - Shows a list of user defined expressions, that are evaluated by the debug adapter
     - Add, edit and delete expressions from the watch list
         - Add variable under the cursor using a command
+    - Set the value of an expression or variable (if supported by debug adapter)
     - Copy the value of an expression or variable
 
 ![watches view](https://github.com/user-attachments/assets/381a5c9c-7eea-4cdc-8358-a2afe9f247b2)
@@ -209,11 +210,12 @@ in the `'winbar'` (e.g., `B` for the breakpoints view).
 
 The breakpoints view, the exceptions view and the scopes view only have 1
 mapping: `<CR>`. It jumps to a breakpoint, toggles an exception filter, and
-expands a variable, respectively. The watches view comes with 4 mappings:
+expands a variable, respectively. The watches view comes with 5 mappings:
 
 - `i` to insert a new expression
 - `e` to edit an expression
 - `c` to copy an expression or variable
+- `s` to change the value of an expression or variable
 - `d` to delete an expression
 
 Though, the preferred way of adding a new expression is using the

lua/dap-view/events.lua

@@ -88,6 +88,14 @@ dap.listeners.after.event_stopped[SUBSCRIPTION_ID] = function()
     winbar.redraw_controls()
 end
 
+dap.listeners.after.setExpression[SUBSCRIPTION_ID] = function()
+    eval.reeval()
+end
+
+dap.listeners.after.setVariable[SUBSCRIPTION_ID] = function()
+    eval.reeval()
+end
+
 dap.listeners.after.initialize[SUBSCRIPTION_ID] = function(session, _)
     state.exceptions_options = vim.iter(session.capabilities.exceptionBreakpointFilters or {})
         :map(function(filter)

lua/dap-view/state.lua

@@ -11,16 +11,16 @@
 ---@field term_bufnr? integer
 ---@field term_winnr? integer
 ---@field last_active_adapter? string
+---@field subtle_frames boolean
 ---@field current_section? SectionType
 ---@field exceptions_options ExceptionsOption[]
 ---@field threads ThreadWithErr[]
 ---@field threads_err? string
 ---@field frames_by_line {[number]: dap.StackFrame[]}
----@field expressions_by_line {[integer]: string}
+---@field expressions_by_line {[integer]: {name: string, response: dap.EvaluateResponse | string}}
 ---@field variables_by_reference table<integer, {variable: dap.Variable, updated: boolean}[] | string>
----@field variables_by_line {[integer]: dap.Variable}
----@field subtle_frames boolean
----@field watched_expressions table<string,{response?: (dap.EvaluateResponse | string), updated?: boolean}>
+---@field variables_by_line table<integer, {response: dap.Variable, reference: number}>
+---@field watched_expressions table<string,{response?: dap.EvaluateResponse | string, updated?: boolean}>
 local M = {
     exceptions_options = {},
     threads = {},

lua/dap-view/views/keymaps.lua

@@ -18,6 +18,12 @@ M.set_keymaps = function()
         end
     end, { buffer = state.bufnr })
 
+    vim.keymap.set("n", "o", function()
+        if state.current_section == "scopes" then
+            require("dap.ui").trigger_actions()
+        end
+    end)
+
     vim.keymap.set("n", "i", function()
         if state.current_section == "watches" then
             vim.ui.input({ prompt = "Expression: " }, function(input)
@@ -42,14 +48,14 @@ M.set_keymaps = function()
         if state.current_section == "watches" then
             local cursor_line = vim.api.nvim_win_get_cursor(state.winnr)[1]
 
-            vim.ui.input(
-                { prompt = "Expression: ", default = state.expressions_by_line[cursor_line] },
-                function(input)
+            local expression = state.expressions_by_line[cursor_line]
+            if expression then
+                vim.ui.input({ prompt = "Expression: ", default = expression.name }, function(input)
                     if input then
                         watches_actions.edit_watch_expr(input, cursor_line)
                     end
-                end
-            )
+                end)
+            end
         end
     end, { buffer = state.bufnr })
 
@@ -61,6 +67,32 @@ M.set_keymaps = function()
         end
     end, { buffer = state.bufnr, nowait = true })
 
+    vim.keymap.set("n", "s", function()
+        if state.current_section == "watches" then
+            local cursor_line = vim.api.nvim_win_get_cursor(state.winnr)[1]
+
+            local get_default = function()
+                local expr = state.expressions_by_line[cursor_line]
+                if expr and type(expr.response) ~= "string" then
+                    return expr.response.result
+                end
+
+                local var = state.variables_by_line[cursor_line]
+                if var then
+                    return var.response.value
+                end
+
+                return ""
+            end
+
+            vim.ui.input({ prompt = "New value: ", default = get_default() }, function(input)
+                if input then
+                    watches_actions.set_watch_expr(input, cursor_line)
+                end
+            end)
+        end
+    end, { buffer = state.bufnr })
+
     vim.keymap.set("n", "t", function()
         if state.current_section == "threads" then
             state.subtle_frames = not state.subtle_frames

lua/dap-view/watches/actions.lua

@@ -1,19 +1,14 @@
 local state = require("dap-view.state")
 local guard = require("dap-view.guard")
 local eval = require("dap-view.watches.eval")
+local set = require("dap-view.watches.set")
 
 local M = {}
 
----@param expr string
-local is_expr_valid = function(expr)
-    -- Avoid duplicate expressions
-    return #expr > 0 and state.watched_expressions[expr] == nil
-end
-
 ---@param expr string
 ---@return boolean
 M.add_watch_expr = function(expr)
-    if not is_expr_valid(expr) or not guard.expect_session() then
+    if #expr == 0 or not guard.expect_session() then
         return false
     end
 
@@ -26,9 +21,9 @@ end
 M.remove_watch_expr = function(line)
     local expr = state.expressions_by_line[line]
     if expr then
-        local eval_result = state.watched_expressions[expr].response
+        local eval_result = state.watched_expressions[expr.name].response
 
-        state.watched_expressions[expr] = nil
+        state.watched_expressions[expr.name] = nil
         state.expressions_by_line[line] = nil
 
         -- If the result is a string, it's the error
@@ -47,12 +42,12 @@ end
 M.copy_watch_expr = function(line)
     local expr = state.expressions_by_line[line]
     if expr then
-        eval.copy_expr(expr)
+        eval.copy_expr(expr.name)
     else
         local var = state.variables_by_line[line]
         if var then
-            if var.evaluateName then
-                eval.copy_expr(var.evaluateName)
+            if var.response.evaluateName then
+                eval.copy_expr(var.response.evaluateName)
             else
                 vim.notify("Missing `evaluateName`, can't copy variable")
             end
@@ -62,10 +57,59 @@ M.copy_watch_expr = function(line)
     end
 end
 
+---@param value string
+---@param line number
+M.set_watch_expr = function(value, line)
+    if not guard.expect_session() then
+        return
+    end
+
+    local expr = state.expressions_by_line[line]
+    if expr then
+        -- Top level expressions are responses for the `evaluate` request, they have no `evaluateName`
+        -- Therefore, we can always use `setExpression` if the adapter supports it
+        set.set_expr(expr.name, value)
+    else
+        local var = state.variables_by_line[line]
+
+        if var then
+            -- From the protocol:
+            --
+            -- "If a debug adapter implements both `setExpression` and `setVariable`,
+            -- a client uses `setExpression` if the variable has an evaluateName property."
+            local session = assert(require("dap").session(), "has active session")
+            local hasExpression = session.capabilities.supportsSetExpression
+            local hasVariable = session.capabilities.supportsSetVariable
+
+            if hasExpression and hasVariable then
+                if var.response.evaluateName then
+                    set.set_expr(var.response.evaluateName, value)
+                else
+                    set.set_var(var.response.name, value, var.reference)
+                end
+            elseif hasExpression then
+                if var.response.evaluateName then
+                    set.set_expr(var.response.evaluateName, value)
+                else
+                    vim.notify(
+                        "Can't set value for " .. var.response.name .. " because it lacks an `evaluateName`"
+                    )
+                end
+            elseif hasVariable then
+                set.set_var(var.response.name, value, var.reference)
+            else
+                vim.notify("Adapter lacks support for both `setExpression` and `setVariable` requests")
+            end
+        else
+            vim.notify("No expression or variable under the under cursor")
+        end
+    end
+end
+
 ---@param expr string
 ---@param line number
 M.edit_watch_expr = function(expr, line)
-    if not is_expr_valid(expr) or not guard.expect_session() then
+    if #expr == 0 or not guard.expect_session() then
         return
     end
 

lua/dap-view/watches/eval.lua

@@ -1,3 +1,4 @@
+local watches = require("dap-view.watches.view")
 local state = require("dap-view.state")
 
 local M = {}
@@ -22,7 +23,7 @@ local eval_variables = function(variables_reference, frame_id)
     -- Lua's type checking is a lackluster
     if type(variables) ~= "string" and type(response) ~= "string" then
         for k, var in pairs(response or {}) do
-            local updated = type(original) == "table" and original[k].variable.value ~= var.value or false
+            local updated = type(original) == "table" and original[k].variable.value ~= var.value
             table.insert(variables, { variable = var, updated = updated })
         end
     end
@@ -73,4 +74,15 @@ M.copy_expr = function(expr)
     end
 end
 
+M.reeval = function()
+    -- Reevaluate expressions which may depend on the changed value
+    for expr, _ in pairs(state.watched_expressions) do
+        M.eval_expr(expr)
+    end
+
+    if state.current_section == "watches" then
+        watches.show()
+    end
+end
+
 return M

lua/dap-view/watches/set.lua

@@ -0,0 +1,46 @@
+local M = {}
+
+---@param expr string
+---@param value string
+M.set_expr = function(expr, value)
+    local session = assert(require("dap").session(), "has active session")
+
+    if session.capabilities.supportsSetExpression then
+        coroutine.wrap(function()
+            local frame_id = session.current_frame and session.current_frame.id
+
+            local err, _ =
+                session:request("setExpression", { expression = expr, value = value, frameId = frame_id })
+
+            if err then
+                vim.notify("Failed to set expression " .. expr .. " to value " .. value)
+            end
+        end)()
+    else
+        vim.notify("Adapter doesn't support `setExpression` request")
+    end
+end
+
+---@param name string
+---@param value string
+---@param variables_reference number
+M.set_var = function(name, value, variables_reference)
+    local session = assert(require("dap").session(), "has active session")
+
+    if session.capabilities.supportsSetVariable then
+        coroutine.wrap(function()
+            local err, _ = session:request(
+                "setVariable",
+                { name = name, value = value, variablesReference = variables_reference }
+            )
+
+            if err then
+                vim.notify("Failed to set variable " .. name .. " to value " .. value)
+            end
+        end)()
+    else
+        vim.notify("Adapter doesn't support `setVariable` request")
+    end
+end
+
+return M

lua/dap-view/watches/view.lua

@@ -54,7 +54,8 @@ local show_variables = function(line, response)
 
                 line = line + 1
 
-                state.variables_by_line[line] = variable
+                state.variables_by_line[line] =
+                    { response = variable, reference = response.variablesReference }
             end
         end
     end
@@ -107,7 +108,7 @@ M.show = function()
 
             line = line + 1
 
-            state.expressions_by_line[line] = expr
+            state.expressions_by_line[line] = { name = expr, response = response }
 
             line = show_variables(line, response)
         end