feat(watches): do not use virtual lines

top level variables

improve handling of errors

refactor: no need for stopped_thread_id state

feat: colors, handle deleting expressions

feat: edit expressions

refactor: simplify implementation by indexing with strings

The downside is that the ordering is kinda awkward, but that's fine by
me

feat: update and highlight changed expressions

refactor(watches): cleaner eval variables

feat: allow collapsing via foldmethod = indent

feat: copy expression to clipboard

chore: appease type checker

feat(watches): highlight updated variables

some fixes for keymaps

chore: add type annotation

update docs

Author: igorlfs

README.md

@@ -77,11 +77,12 @@ return {
 The plugin provides 6 "views" that share the same window (so there's clutter)
 
 - Watches view
-    - Shows a list of (user defined) expressions, that are evaluated by the debug adapter
+    - Shows a list of user defined expressions, that are evaluated by the debug adapter
     - Add, edit and delete expressions from the watch list
-        - Including adding the variable under the cursor
+        - Add variable under the cursor using a command
+    - Copy the value of an expression
 
-![watches view](https://github.com/user-attachments/assets/c6838700-95ed-4b39-9ab5-e0ed0e753995)
+![watches view](https://github.com/user-attachments/assets/381a5c9c-7eea-4cdc-8358-a2afe9f247b2)
 
 - Exceptions view
     - Control when the debugger should stop, outside of breakpoints (e.g.,
@@ -173,10 +174,11 @@ 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 3 mappings:
+expands a variable, respectively. The watches view comes with 4 mappings:
 
 - `i` to insert a new expression
 - `e` to edit an expression
+- `c` to copy an expression (can't copy inner variables for now)
 - `d` to delete an expression
 
 Though, the preferred way of adding a new expression is using the

lua/dap-view/events.lua

@@ -77,17 +77,11 @@ dap.listeners.after.stackTrace[SUBSCRIPTION_ID] = function()
     end
 end
 
-dap.listeners.after.event_stopped[SUBSCRIPTION_ID] = function(_, body)
-    state.stopped_thread = body.threadId
-
+dap.listeners.after.event_stopped[SUBSCRIPTION_ID] = function()
     require("dap-view.threads").get_threads()
 
-    for i, expr in ipairs(state.watched_expressions) do
-        eval.eval_expr(expr, function(result)
-            local has_changed = state.expression_results[i] ~= result
-            state.updated_evaluations[i] = state.expression_results[i] and has_changed
-            state.expression_results[i] = result
-        end)
+    for expr, _ in pairs(state.watched_expressions) do
+        eval.eval_expr(expr)
     end
 end
 
@@ -116,9 +110,4 @@ dap.listeners.after.event_terminated[SUBSCRIPTION_ID] = function()
     if state.current_section == "threads" then
         threads.show()
     end
-
-    -- Clear evaluations so new sessions don't get highlighted as changed
-    for k in ipairs(state.expression_results) do
-        state.expression_results[k] = nil
-    end
 end

lua/dap-view/highlight.lua

@@ -8,15 +8,24 @@ end
 
 local define_base_links = function()
     hl_create("MissingData", "DapBreakpoint")
-    hl_create("WatchText", "Comment")
-    hl_create("WatchTextChanged", "DiagnosticVirtualTextWarn")
-    hl_create("ExceptionFilterEnabled", "DiagnosticOk")
-    hl_create("ExceptionFilterDisabled", "DiagnosticError")
     hl_create("FileName", "qfFileName")
     hl_create("LineNumber", "qfLineNr")
     hl_create("Separator", "Comment")
     hl_create("Thread", "@namespace")
     hl_create("ThreadStopped", "@conditional")
+
+    hl_create("ExceptionFilterEnabled", "DiagnosticOk")
+    hl_create("ExceptionFilterDisabled", "DiagnosticError")
+
+    hl_create("WatchExpr", "Identifier")
+    hl_create("WatchError", "DiagnosticError")
+    hl_create("WatchUpdated", "DiagnosticVirtualTextWarn")
+
+    hl_create("Boolean", "Boolean")
+    hl_create("String", "String")
+    hl_create("Number", "Number")
+    hl_create("Float", "Float")
+    hl_create("Function", "Function")
 end
 
 define_base_links()

lua/dap-view/state.lua

@@ -10,25 +10,24 @@
 ---@field winnr? integer
 ---@field term_bufnr? integer
 ---@field term_winnr? integer
----@field stopped_thread? integer
 ---@field last_active_adapter? string
 ---@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 variables_by_reference table<integer, {variable: dap.Variable, updated: boolean}[] | string>
 ---@field subtle_frames boolean
----@field watched_expressions string[]
----@field expression_results string[]
----@field updated_evaluations boolean[]
+---@field watched_expressions table<string,{response?: (dap.EvaluateResponse | string), updated?: boolean}>
 local M = {
     exceptions_options = {},
     threads = {},
     frames_by_line = {},
+    expressions_by_line = {},
+    variables_by_reference = {},
     subtle_frames = false,
     watched_expressions = {},
-    expression_results = {},
-    updated_evaluations = {},
 }
 
 return M

lua/dap-view/threads/view.lua

@@ -16,7 +16,9 @@ M.show = function()
         -- Clear previous content
         api.nvim_buf_set_lines(state.bufnr, 0, -1, true, {})
 
-        if views.cleanup_view(not dap.session(), "No active session") then
+        local session = dap.session()
+        -- Redundant check to appease the type checker
+        if views.cleanup_view(session == nil, "No active session") or session == nil then
             return
         end
 
@@ -35,7 +37,7 @@ M.show = function()
         local line = 0
         for _, thread in pairs(state.threads) do
             api.nvim_buf_set_lines(state.bufnr, line, -1, false, { thread.name })
-            local is_stopped_thread = state.stopped_thread == thread.id
+            local is_stopped_thread = session.stopped_thread_id == thread.id
             hl.hl_range(is_stopped_thread and "ThreadStopped" or "Thread", { line, 0 }, { line, -1 })
 
             local valid_frames = vim.iter(thread.frames or {})

lua/dap-view/views/keymaps.lua

@@ -30,36 +30,44 @@ M.set_keymaps = function()
 
     vim.keymap.set("n", "d", function()
         if state.current_section == "watches" then
-            local line = vim.api.nvim_win_get_cursor(state.winnr)[1]
+            local cursor_line = vim.api.nvim_win_get_cursor(state.winnr)[1]
 
-            watches_actions.remove_watch_expr(line)
+            watches_actions.remove_watch_expr(cursor_line)
 
             watches_view.show()
         end
     end, { buffer = state.bufnr, nowait = true })
 
     vim.keymap.set("n", "e", function()
         if state.current_section == "watches" then
-            local line = vim.api.nvim_win_get_cursor(state.winnr)[1]
+            local cursor_line = vim.api.nvim_win_get_cursor(state.winnr)[1]
 
             vim.ui.input(
-                { prompt = "Expression: ", default = state.watched_expressions[line] },
+                { prompt = "Expression: ", default = state.expressions_by_line[cursor_line] },
                 function(input)
                     if input then
-                        watches_actions.edit_watch_expr(input, line)
+                        watches_actions.edit_watch_expr(input, cursor_line)
                     end
                 end
             )
         end
     end, { buffer = state.bufnr })
 
+    vim.keymap.set("n", "c", function()
+        if state.current_section == "watches" then
+            local cursor_line = vim.api.nvim_win_get_cursor(state.winnr)[1]
+
+            watches_actions.copy_watch_expr(cursor_line)
+        end
+    end, { buffer = state.bufnr, nowait = true })
+
     vim.keymap.set("n", "t", function()
         if state.current_section == "threads" then
             state.subtle_frames = not state.subtle_frames
 
             threads_view.show()
         end
-    end, { buffer = state.bufnr })
+    end, { buffer = state.bufnr, nowait = true })
 end
 
 return M

lua/dap-view/views/options.lua

@@ -13,6 +13,7 @@ M.set_options = function()
     win.cursorline = true
     win.statuscolumn = ""
     win.foldcolumn = "0"
+    win.foldmethod = "indent"
 
     local buf = vim.bo[state.bufnr]
     buf.buftype = "nofile"

lua/dap-view/watches/actions.lua

@@ -7,7 +7,7 @@ local M = {}
 ---@param expr string
 local is_expr_valid = function(expr)
     -- Avoid duplicate expressions
-    return #expr > 0 and not vim.tbl_contains(state.watched_expressions, expr)
+    return #expr > 0 and state.watched_expressions[expr] == nil
 end
 
 ---@param expr string
@@ -17,19 +17,40 @@ M.add_watch_expr = function(expr)
         return false
     end
 
-    eval.eval_expr(expr, function(result)
-        table.insert(state.expression_results, result)
-    end)
-
-    table.insert(state.watched_expressions, expr)
+    eval.eval_expr(expr)
 
     return true
 end
 
 ---@param line number
 M.remove_watch_expr = function(line)
-    table.remove(state.watched_expressions, line)
-    table.remove(state.expression_results, line)
+    local expr = state.expressions_by_line[line]
+    if expr then
+        local eval_result = state.watched_expressions[expr].response
+
+        state.watched_expressions[expr] = nil
+        state.expressions_by_line[line] = nil
+
+        -- If the result is a string, it's the error
+        if type(eval_result) ~= "string" then
+            local ref = eval_result and eval_result.variablesReference
+            if ref then
+                state.variables_by_reference[ref] = nil
+            end
+        end
+    else
+        vim.notify("No expression under the under cursor")
+    end
+end
+
+---@param line number
+M.copy_watch_expr = function(line)
+    local expr = state.expressions_by_line[line]
+    if expr then
+        eval.copy_expr(expr)
+    else
+        vim.notify("No expression under the under cursor")
+    end
 end
 
 ---@param expr string
@@ -39,11 +60,10 @@ M.edit_watch_expr = function(expr, line)
         return
     end
 
-    state.watched_expressions[line] = expr
+    -- The easiest way to edit is to delete and insert again
+    M.remove_watch_expr(line)
 
-    eval.eval_expr(expr, function(result)
-        state.expression_results[line] = result
-    end)
+    eval.eval_expr(expr)
 end
 
 return M

lua/dap-view/watches/eval.lua

@@ -1,8 +1,37 @@
+local state = require("dap-view.state")
+
 local M = {}
 
+---@param variables_reference number
+---@param frame_id? number
+local eval_variables = function(variables_reference, frame_id)
+    local session = assert(require("dap").session(), "has active session")
+
+    local err, result = session:request(
+        "variables",
+        { variablesReference = variables_reference, context = "watch", frameId = frame_id }
+    )
+
+    local response = err and tostring(err) or result and result.variables
+
+    --[[@type {variable?: dap.Variable, updated?: boolean}[] | string]]
+    local variables = type(response) == "string" and response or {}
+
+    local original = state.variables_by_reference[variables_reference]
+
+    -- 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
+            table.insert(variables, { variable = var, updated = updated })
+        end
+    end
+
+    state.variables_by_reference[variables_reference] = variables
+end
+
 ---@param expr string
----@param callback fun(result: string): nil
-M.eval_expr = function(expr, callback)
+M.eval_expr = function(expr)
     local session = assert(require("dap").session(), "has active session")
 
     coroutine.wrap(function()
@@ -11,35 +40,37 @@ M.eval_expr = function(expr, callback)
         local err, result =
             session:request("evaluate", { expression = expr, context = "watch", frameId = frame_id })
 
-        local expr_result = result and result.result or err and tostring(err):gsub("%s+", " ") or ""
+        local original = state.watched_expressions[expr] and state.watched_expressions[expr].response.result
+        local response = err and tostring(err) or result
+        local updated = original and response and original ~= response.result
+        state.watched_expressions[expr] = { response = response, updated = updated }
 
-        -- TODO currently, we only check for variables reference for the top level expression
-        -- It would be nice to expose functionality to let the user control the depth
-        -- This could be a config parameter (eg, base depth) but could also extend with an action (BFS)
         local variables_reference = result and result.variablesReference
         if variables_reference and variables_reference > 0 then
-            local enhanced_expr_result = { expr_result }
-
-            local var_ref_err, var_ref_result = session:request(
-                "variables",
-                { variablesReference = variables_reference, context = "watch", frameId = frame_id }
-            )
-
-            if var_ref_err then
-                table.insert(enhanced_expr_result, tostring(err))
-            elseif var_ref_result then
-                for _, k in pairs(var_ref_result.variables) do
-                    table.insert(enhanced_expr_result, "\t" .. k.name .. " = " .. k.value)
-                end
-            end
-
-            local final_result = table.concat(enhanced_expr_result, "\n")
-
-            callback(final_result)
-        else
-            callback(expr_result)
+            eval_variables(variables_reference, frame_id)
         end
     end)()
 end
 
+---@param expr string
+M.copy_expr = function(expr)
+    local session = assert(require("dap").session(), "has active session")
+
+    if session.capabilities.supportsClipboardContext then
+        coroutine.wrap(function()
+            local frame_id = session.current_frame and session.current_frame.id
+
+            local err, result =
+                session:request("evaluate", { expression = expr, context = "clipboard", frameId = frame_id })
+
+            if err == nil and result then
+                -- TODO uses system clipboard, could be a parameter instead
+                vim.fn.setreg("+", result.result)
+            end
+        end)()
+    else
+        vim.notify("Adapter doesn't support clipboard evaluation")
+    end
+end
+
 return M