fix(watches): ensure redraw always happens after user actions

This fixes some regressions from 0746f35, which ended up massively
complicating stuff and introducing a bunch of bugs.

As it turns out, dealing with the coroutine shenanigans is a lot easier
than anticipated: if we are wrapping with a coroutine, there's not much
to worry about. There's no need to handle call `yield` and `resume`
manually, as `nvim-dap` abstracts that.

Author: igorlfs

lua/dap-view/actions.lua

@@ -121,8 +121,7 @@ end
 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
+        if require("dap-view.watches.actions").add_watch_expr(expr_, default_expanded) then
             require("dap-view.views").switch_to_view("watches")
         end
     end)()

lua/dap-view/refresher.lua

@@ -33,8 +33,9 @@ end
 
 M.refresh_all_expressions = function()
     coroutine.wrap(function()
-        local co = coroutine.running()
-        eval.reevaluate_all_expressions(co)
+        for expr, _ in pairs(state.watched_expressions) do
+            M.evaluate_expression(expr, true)
+        end
 
         if state.current_section == "watches" then
             require("dap-view.views").switch_to_view("watches")

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

@@ -24,9 +24,7 @@ M.views_keymaps = function()
             require("dap.ui").trigger_actions({ mode = "first" })
         elseif state.current_section == "watches" then
             coroutine.wrap(function()
-                local co = coroutine.running()
-
-                if watches_actions.expand_or_collapse(cursor_line, co) then
+                if watches_actions.expand_or_collapse(cursor_line) then
                     require("dap-view.views").switch_to_view("watches")
                 end
             end)()
@@ -84,9 +82,7 @@ M.views_keymaps = function()
             vim.ui.input({ prompt = "Expression: " }, function(input)
                 if input then
                     coroutine.wrap(function()
-                        local co = coroutine.running()
-
-                        if watches_actions.add_watch_expr(input, true, co) then
+                        if watches_actions.add_watch_expr(input, true) then
                             require("dap-view.views").switch_to_view("watches")
                         end
                     end)()
@@ -118,9 +114,7 @@ M.views_keymaps = function()
                 vim.ui.input({ prompt = "Expression: ", default = expression_view.expression }, function(input)
                     if input then
                         coroutine.wrap(function()
-                            local co = coroutine.running()
-
-                            if watches_actions.edit_watch_expr(input, cursor_line, co) then
+                            if watches_actions.edit_watch_expr(input, cursor_line) then
                                 require("dap-view.views").switch_to_view("watches")
                             end
                         end)()

lua/dap-view/watches/actions.lua

@@ -7,15 +7,12 @@ local M = {}
 
 ---@param expr string
 ---@param default_expanded boolean
----@param co thread
-M.add_watch_expr = function(expr, default_expanded, co)
+M.add_watch_expr = function(expr, default_expanded)
     if #expr == 0 or not guard.expect_session() then
         return false
     end
 
-    eval.evaluate_expression(expr, default_expanded, co)
-
-    coroutine.yield(co)
+    eval.evaluate_expression(expr, default_expanded)
 
     state.expr_count = state.expr_count + 1
 
@@ -118,8 +115,7 @@ end
 
 ---@param expr string
 ---@param line number
----@param co thread
-M.edit_watch_expr = function(expr, line, co)
+M.edit_watch_expr = function(expr, line)
     if #expr == 0 or not guard.expect_session() then
         return false
     end
@@ -131,16 +127,13 @@ M.edit_watch_expr = function(expr, line, co)
         return false
     end
 
-    eval.evaluate_expression(expr, expression_view.view.expanded, co)
-
-    coroutine.yield(co)
+    eval.evaluate_expression(expr, expression_view.view.expanded)
 
     return true
 end
 
 ---@param line number
----@param co thread
-M.expand_or_collapse = function(line, co)
+M.expand_or_collapse = function(line)
     if not guard.expect_session() then
         return
     end
@@ -150,9 +143,7 @@ M.expand_or_collapse = function(line, co)
     if expression_view then
         expression_view.view.expanded = not expression_view.view.expanded
 
-        eval.evaluate_expression(expression_view.expression, true, co)
-
-        coroutine.yield(co)
+        eval.evaluate_expression(expression_view.expression, true)
 
         return true
     else
@@ -167,7 +158,7 @@ M.expand_or_collapse = function(line, co)
                 if variable_view then
                     variable_view.expanded = not variable_view.expanded
 
-                    variable_view.children, variable_view.err = eval.expand_variable(reference, nil, co)
+                    variable_view.children, variable_view.err = eval.expand_variable(reference, nil)
 
                     return true
                 end

lua/dap-view/watches/eval.lua

@@ -4,66 +4,59 @@ local M = {}
 
 ---@param expression string
 ---@param default_expanded boolean
----@param co thread?
-M.evaluate_expression = function(expression, default_expanded, co)
+M.evaluate_expression = function(expression, default_expanded)
     local session = assert(require("dap").session(), "has active session")
 
-    coroutine.wrap(function()
-        local frame_id = session.current_frame and session.current_frame.id
-
-        local err, response =
-            session:request("evaluate", { expression = expression, context = "watch", frameId = frame_id })
+    local frame_id = session.current_frame and session.current_frame.id
 
-        local previous_expression_view = state.watched_expressions[expression]
+    local err, response =
+        session:request("evaluate", { expression = expression, context = "watch", frameId = frame_id })
 
-        local previous_result = previous_expression_view
-            and previous_expression_view.response
-            and previous_expression_view.response.result
+    local previous_expression_view = state.watched_expressions[expression]
 
-        if previous_expression_view and response then
-            previous_expression_view.updated = previous_result ~= response.result
-        end
+    local previous_result = previous_expression_view
+        and previous_expression_view.response
+        and previous_expression_view.response.result
 
-        if previous_expression_view and err then
-            previous_expression_view.children = nil
-            previous_expression_view.updated = false
-            previous_expression_view.expanded = false
-        end
+    if previous_expression_view and response then
+        previous_expression_view.updated = previous_result ~= response.result
+    end
 
-        ---@type dapview.ExpressionView
-        local default_expression_view = {
-            id = state.expr_count,
-            response = response,
-            err = err,
-            updated = false,
-            expanded = default_expanded,
-            children = nil,
-        }
+    if previous_expression_view and err then
+        previous_expression_view.children = nil
+        previous_expression_view.updated = false
+        previous_expression_view.expanded = false
+    end
 
-        if previous_expression_view then
-            previous_expression_view.response = response
-            previous_expression_view.err = err
-        end
+    ---@type dapview.ExpressionView
+    local default_expression_view = {
+        id = state.expr_count,
+        response = response,
+        err = err,
+        updated = false,
+        expanded = default_expanded,
+        children = nil,
+    }
+
+    if previous_expression_view then
+        previous_expression_view.response = response
+        previous_expression_view.err = err
+    end
 
-        ---@type dapview.ExpressionView
-        local new_expression_view = previous_expression_view or default_expression_view
+    ---@type dapview.ExpressionView
+    local new_expression_view = previous_expression_view or default_expression_view
 
-        if new_expression_view.expanded then
-            local variables_reference = response and response.variablesReference
+    if new_expression_view.expanded then
+        local variables_reference = response and response.variablesReference
 
-            if variables_reference and variables_reference > 0 then
-                new_expression_view.children = M.expand_variable(variables_reference, new_expression_view.children)
-            else
-                new_expression_view.children = nil
-            end
+        if variables_reference and variables_reference > 0 then
+            new_expression_view.children = M.expand_variable(variables_reference, new_expression_view.children)
+        else
+            new_expression_view.children = nil
         end
+    end
 
-        state.watched_expressions[expression] = new_expression_view
-
-        if co then
-            coroutine.resume(co)
-        end
-    end)()
+    state.watched_expressions[expression] = new_expression_view
 end
 
 ---@param expr string
@@ -91,8 +84,7 @@ end
 
 ---@param variables_reference number
 ---@param previous_expansion_result dapview.VariableView[]?
----@param co thread?
-M.expand_variable = function(variables_reference, previous_expansion_result, co)
+M.expand_variable = function(variables_reference, previous_expansion_result)
     local session = assert(require("dap").session(), "has active session")
 
     local frame_id = session.current_frame and session.current_frame.id
@@ -152,34 +144,15 @@ M.expand_variable = function(variables_reference, previous_expansion_result, co)
                 new_variable_view.children, new_variable_view.err =
                     M.expand_variable(variables_reference_, new_variable_view.children)
             else
-                -- We have to reset the children if the variable is no longer, otherwise it retains the old value indefinely
+                -- We have to reset the children if the variable is no longer, otherwise it retains the old value indefinitely
                 new_variable_view.children = nil
             end
         end
 
         varible_views[k] = new_variable_view
     end
 
-    if co then
-        coroutine.resume(co)
-    end
-
     return #varible_views > 0 and varible_views or nil, err
 end
 
----@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
-
-        -- 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