refactor(watches): try to be more coroutine friendly

Previous implementation would rely on a callback to keep the memory up
to date with the view. This is an attempt to avoid having the refresh
tied to the eval method (usually the refresh is called separately).

Additionally, this implements #120

Author: igorlfs

docs/src/routes/api/+page.md

@@ -34,10 +34,11 @@ Calls `require("dap-view").open()` if there's no views window. Else, behaves lik
 
 ```lua
 ---@param expr? string
-require("dap-view").add_expr(expr)
+---@param default_expanded? boolean
+require("dap-view").add_expr(expr, default_expanded)
 ```
 
-In normal mode, adds the expression under the cursor to the watch list (see [caveats](faq#Why-is-DapViewWatch-not-adding-the-whole-variable-)). In visual mode, adds the selection to the watch list. If `expr` is specified, adds the expression directly, overriding previous conditions.
+In normal mode, adds the expression under the cursor to the watch list (see [caveats](faq#Why-is-DapViewWatch-not-adding-the-whole-variable-)). In visual mode, adds the selection to the watch list. If `expr` is specified, adds the expression directly, overriding previous conditions. Expressions are expanded (non recursively). This behavior can be overridden by setting `default_expanded` to false.
 
 ## Jump To View
 

lua/dap-view.lua

@@ -26,8 +26,9 @@ M.toggle = function(hide_terminal)
 end
 
 ---@param expr? string
-M.add_expr = function(expr)
-    actions.add_expr(expr)
+---@param default_expanded? boolean
+M.add_expr = function(expr, default_expanded)
+    actions.add_expr(expr, default_expanded == nil or default_expanded)
 end
 
 ---@param view dapview.Section

lua/dap-view/actions.lua

@@ -115,11 +115,15 @@ M.open = function(hide_terminal)
 end
 
 ---@param expr? string
-M.add_expr = function(expr)
-    local final_expr = expr or require("dap-view.util.exprs").get_current_expr()
-    if require("dap-view.watches.actions").add_watch_expr(final_expr) then
-        require("dap-view.views").switch_to_view("watches")
-    end
+---@param default_expanded boolean
+M.add_expr = function(expr, default_expanded)
+    local expr_ = expr or require("dap-view.util.exprs").get_current_expr()
+    coroutine.wrap(function()
+        local co = coroutine.running()
+        if require("dap-view.watches.actions").add_watch_expr(expr_, default_expanded, co) then
+            require("dap-view.views").switch_to_view("watches")
+        end
+    end)()
 end
 
 ---@param view dapview.Section|string

lua/dap-view/listeners.lua

@@ -6,7 +6,6 @@ local scopes = require("dap-view.scopes.view")
 local sessions = require("dap-view.sessions.view")
 local util = require("dap-view.util")
 local term = require("dap-view.console.view")
-local eval = require("dap-view.watches.eval")
 local setup = require("dap-view.setup")
 local refresher = require("dap-view.refresher")
 local winbar = require("dap-view.options.winbar")
@@ -48,7 +47,7 @@ dap.listeners.on_session[SUBSCRIPTION_ID] = function(_, new)
                 end
             end
             if new.stopped_thread_id then
-                eval.reevaluate_all_expressions()
+                refresher.refresh_all_expressions()
             end
         end
     else
@@ -118,7 +117,7 @@ dap.listeners.after.scopes[SUBSCRIPTION_ID] = function(session)
 
     -- Do not use `event_stopped`
     -- It may cause race conditions
-    eval.reevaluate_all_expressions()
+    refresher.refresh_all_expressions()
 end
 
 local continue = { "event_continued", "continue" }
@@ -167,7 +166,7 @@ end
 local reeval = { "setExpression", "setVariable" }
 
 for _, listener in ipairs(reeval) do
-    dap.listeners.after[listener][SUBSCRIPTION_ID] = eval.reevaluate_all_expressions
+    dap.listeners.after[listener][SUBSCRIPTION_ID] = refresher.refresh_all_expressions
 end
 
 dap.listeners.after.initialize[SUBSCRIPTION_ID] = function(session)

lua/dap-view/refresher.lua

@@ -3,6 +3,7 @@ local threads = require("dap-view.threads.view")
 local scopes = require("dap-view.scopes.view")
 local sessions = require("dap-view.sessions.view")
 local exceptions = require("dap-view.exceptions.view")
+local eval = require("dap-view.watches.eval")
 local util = require("dap-view.util")
 
 local M = {}
@@ -31,4 +32,15 @@ M.refresh_session_based_views = function()
     end
 end
 
+M.refresh_all_expressions = function()
+    coroutine.wrap(function()
+        local co = coroutine.running()
+        eval.reevaluate_all_expressions(co)
+
+        if state.current_section == "watches" then
+            require("dap-view.views").switch_to_view("watches")
+        end
+    end)()
+end
+
 return M

lua/dap-view/views/keymaps/views.lua

@@ -21,7 +21,13 @@ M.views_keymaps = function()
         elseif state.current_section == "scopes" or state.current_section == "sessions" then
             require("dap.ui").trigger_actions({ mode = "first" })
         elseif state.current_section == "watches" then
-            watches_actions.expand_or_collapse(cursor_line)
+            coroutine.wrap(function()
+                local co = coroutine.running()
+
+                if watches_actions.expand_or_collapse(cursor_line, co) then
+                    require("dap-view.views").switch_to_view("watches")
+                end
+            end)()
         end
 
         -- Selecting a session triggers a full redraw
@@ -81,7 +87,13 @@ M.views_keymaps = function()
         if state.current_section == "watches" then
             vim.ui.input({ prompt = "Expression: " }, function(input)
                 if input then
-                    watches_actions.add_watch_expr(input)
+                    coroutine.wrap(function()
+                        local co = coroutine.running()
+
+                        if watches_actions.add_watch_expr(input, true, co) then
+                            require("dap-view.views").switch_to_view("watches")
+                        end
+                    end)()
                 end
             end)
         end
@@ -109,7 +121,13 @@ M.views_keymaps = function()
             if expression_view then
                 vim.ui.input({ prompt = "Expression: ", default = expression_view.expression }, function(input)
                     if input then
-                        watches_actions.edit_watch_expr(input, cursor_line)
+                        coroutine.wrap(function()
+                            local co = coroutine.running()
+
+                            if watches_actions.edit_watch_expr(input, cursor_line, co) then
+                                require("dap-view.views").switch_to_view("watches")
+                            end
+                        end)()
                     end
                 end)
             end

lua/dap-view/watches/actions.lua

@@ -6,13 +6,16 @@ local set = require("dap-view.watches.set")
 local M = {}
 
 ---@param expr string
----@return boolean
-M.add_watch_expr = function(expr)
+---@param default_expanded boolean
+---@param co thread
+M.add_watch_expr = function(expr, default_expanded, co)
     if #expr == 0 or not guard.expect_session() then
         return false
     end
 
-    eval.evaluate_expression(expr)
+    eval.evaluate_expression(expr, default_expanded, co)
+
+    coroutine.yield(co)
 
     state.expr_count = state.expr_count + 1
 
@@ -25,6 +28,8 @@ M.remove_watch_expr = function(line)
 
     if expression_view then
         state.watched_expressions[expression_view.expression] = nil
+
+        return expression_view
     else
         vim.notify("No expression under the under cursor")
     end
@@ -113,19 +118,29 @@ end
 
 ---@param expr string
 ---@param line number
-M.edit_watch_expr = function(expr, line)
+---@param co thread
+M.edit_watch_expr = function(expr, line, co)
     if #expr == 0 or not guard.expect_session() then
-        return
+        return false
     end
 
     -- The easiest way to edit is to delete and insert again
-    M.remove_watch_expr(line)
+    local expression_view = M.remove_watch_expr(line)
+
+    if expression_view == nil then
+        return false
+    end
+
+    eval.evaluate_expression(expr, expression_view.view.expanded, co)
+
+    coroutine.yield(co)
 
-    eval.evaluate_expression(expr)
+    return true
 end
 
 ---@param line number
-M.expand_or_collapse = function(line)
+---@param co thread
+M.expand_or_collapse = function(line, co)
     if not guard.expect_session() then
         return
     end
@@ -135,7 +150,11 @@ M.expand_or_collapse = function(line)
     if expression_view then
         expression_view.view.expanded = not expression_view.view.expanded
 
-        eval.evaluate_expression(expression_view.expression)
+        eval.evaluate_expression(expression_view.expression, true, co)
+
+        coroutine.yield(co)
+
+        return true
     else
         local variable_reference = state.variable_views_by_line[line]
 

lua/dap-view/watches/eval.lua

@@ -3,8 +3,9 @@ local state = require("dap-view.state")
 local M = {}
 
 ---@param expression string
----@param skip_redraw boolean?
-M.evaluate_expression = function(expression, skip_redraw)
+---@param default_expanded boolean
+---@param co thread?
+M.evaluate_expression = function(expression, default_expanded, co)
     local session = assert(require("dap").session(), "has active session")
 
     coroutine.wrap(function()
@@ -35,7 +36,7 @@ M.evaluate_expression = function(expression, skip_redraw)
             response = response,
             err = err,
             updated = false,
-            expanded = true,
+            expanded = default_expanded,
             children = nil,
         }
 
@@ -59,8 +60,8 @@ M.evaluate_expression = function(expression, skip_redraw)
 
         state.watched_expressions[expression] = new_expression_view
 
-        if state.current_section == "watches" and not skip_redraw then
-            require("dap-view.views").switch_to_view("watches")
+        if co then
+            coroutine.resume(co)
         end
     end)()
 end
@@ -161,16 +162,19 @@ M.expand_variable = function(variables_reference, previous_expansion_result)
     return #varible_views > 0 and varible_views or nil, err
 end
 
-M.reevaluate_all_expressions = function()
+---@param co thread?
+M.reevaluate_all_expressions = function(co)
     local i = 0
     local size = vim.tbl_count(state.watched_expressions)
 
     for expr, _ in pairs(state.watched_expressions) do
         i = i + 1
 
-        -- Avoid needless redrawing by waiting for the last expression
-        M.evaluate_expression(expr, i < size)
+        -- This assumes that the last evaluation will be the last one to fnish, but I'm not sure that's the case?
+        M.evaluate_expression(expr, true, i == size and co or nil)
     end
+
+    coroutine.yield(co)
 end
 
 return M