fix: more robust timer closing

Author: lewis6991

lua/gitsigns/debounce.lua

@@ -2,6 +2,10 @@ local uv = vim.uv or vim.loop ---@diagnostic disable-line: deprecated
 
 local M = {}
 
+--- @class gitsigns.debounce.debounce_trailing.Opts
+--- @field timeout integer|fun():integer Timeout in ms
+--- @field hash? integer|fun(...): any Function that determines id from arguments to `fn`
+
 --- Debounces a function on the trailing edge.
 ---
 --- Example waveform
@@ -13,16 +17,24 @@ local M = {}
 ---   With a debounce period of 3 units, the debounced function fires at 3 and 9.
 ---
 --- @generic F: function
---- @param timeout integer|fun():integer Timeout in ms
+--- @param opts gitsigns.debounce.debounce_trailing.Opts|integer|fun():integer
 --- @param fn F Function to debounce
---- @param hash? integer|fun(...): any Function that determines id from arguments to fn
 --- @return F Debounced function.
-function M.debounce_trailing(timeout, fn, hash)
-  local running = {} --- @type table<any, uv.uv_timer_t>
+function M.debounce_trailing(opts, fn)
+  local timeout --- @type (integer|fun():integer)?
+  local hash --- @type (integer|fun(...): any)?
+
+  if type(opts) == 'table' then
+    timeout = opts.timeout
+    hash = opts.hash
+  else
+    timeout = opts
+  end
 
   -- Normalize hash to a function if it's a number (argument index)
   if type(hash) == 'number' then
     local hash_i = hash
+    --- @return any
     hash = function(...)
       return select(hash_i, ...)
     end
@@ -38,22 +50,22 @@ function M.debounce_trailing(timeout, fn, hash)
     end
   end
 
+  local running = {} --- @type table<any, uv.uv_timer_t?>
+
   return function(...)
     local id = hash and hash(...) or true
-    local argv = { ... }
+    local argv, argc = { ... }, select('#', ...)
 
     local timer = running[id]
     if not timer or timer:is_closing() then
       timer = assert(uv.new_timer())
       running[id] = timer
     end
 
-    timer:stop() -- Always stop before (re)starting
     timer:start(timeout(), 0, function()
-      timer:stop()
-      running[id] = nil
-      fn(unpack(argv, 1, table.maxn(argv)))
       timer:close()
+      running[id] = nil
+      fn(unpack(argv, 1, argc))
     end)
   end
 end

lua/gitsigns/manager.lua

@@ -455,11 +455,14 @@ M.update = throttle_async({ hash = 1, schedule = true }, function(bufnr)
   end)
 end)
 
-M.update_sync_debounced = debounce_trailing(function()
-  return config.update_debounce
-end, function(bufnr)
+M.update_sync_debounced = debounce_trailing({
+  timeout = function()
+    return config.update_debounce
+  end,
+  hash = 1,
+}, function(bufnr)
   async.run(M.update, bufnr):raise_on_error()
-end, 1)
+end)
 
 --- @param bufnr integer
 --- @param keep_signs? boolean

test/debounce_spec.lua

@@ -0,0 +1,126 @@
+--- @diagnostic disable: global-in-non-module, redundant-parameter
+local helpers = require('test.gs_helpers')
+
+local clear = helpers.clear
+local eq = helpers.eq
+local exec_lua = helpers.exec_lua
+
+helpers.env()
+
+describe('debounce', function()
+  before_each(function()
+    clear()
+    helpers.setup_path()
+  end)
+
+  it('closes the timer even if the function errors', function()
+    exec_lua(function()
+      local uv = vim.uv or vim.loop ---@diagnostic disable-line: deprecated
+
+      _G._debounce_close_called = 0
+
+      local orig_new_timer = uv.new_timer
+
+      uv.new_timer = function(...)
+        local t = assert(orig_new_timer(...))
+        local proxy = { _t = t }
+
+        function proxy:start(...)
+          return self._t:start(...)
+        end
+
+        function proxy:close(...)
+          _G._debounce_close_called = _G._debounce_close_called + 1
+          return self._t:close(...)
+        end
+
+        return proxy
+      end
+
+      local debounce_trailing = require('gitsigns.debounce').debounce_trailing
+      local debounced = debounce_trailing(1, function()
+        error('GS_DEBOUNCE_TEST_CLOSE')
+      end)
+      debounced()
+    end)
+
+    helpers.expectf(function()
+      eq(1, exec_lua('return _G._debounce_close_called'))
+    end)
+  end)
+
+  it('prints a full stacktrace if the function errors', function()
+    exec_lua(function()
+      local debounce_trailing = require('gitsigns.debounce').debounce_trailing
+      local debounced = debounce_trailing(1, function()
+        error('GS_DEBOUNCE_TEST_STACK')
+      end)
+      debounced()
+    end)
+
+    helpers.expectf(function()
+      local messages = exec_lua(function()
+        return vim.api.nvim_exec2('messages', { output = true }).output
+      end) ---@type string
+      assert(messages:match('debounce_spec.lua:%d+: GS_DEBOUNCE_TEST_STACK'), messages)
+      assert(messages:match('stack traceback'), messages)
+      assert(messages:match('lua/gitsigns/debounce.lua'), messages)
+    end)
+  end)
+
+  it('debounces independently by hash key', function()
+    exec_lua(function()
+      local debounce_trailing = require('gitsigns.debounce').debounce_trailing
+
+      _G._debounce_hash_calls = {}
+
+      local debounced = debounce_trailing({
+        timeout = 10,
+        hash = 1,
+      }, function(id, value)
+        local t = _G._debounce_hash_calls[id] or { count = 0, value = nil }
+        t.count = t.count + 1
+        t.value = value
+        _G._debounce_hash_calls[id] = t
+      end)
+
+      debounced('a', 1)
+      debounced('a', 2)
+      debounced('b', 3)
+      debounced('b', 4)
+    end)
+
+    helpers.expectf(function()
+      eq({
+        a = { count = 1, value = 2 },
+        b = { count = 1, value = 4 },
+      }, exec_lua('return _G._debounce_hash_calls'))
+    end)
+  end)
+
+  it('accepts a hash function for ids', function()
+    exec_lua(function()
+      local debounce_trailing = require('gitsigns.debounce').debounce_trailing
+
+      _G._debounce_hash_fn_calls = {}
+
+      local debounced = debounce_trailing({
+        timeout = 10,
+        hash = function(id)
+          return id
+        end,
+      }, function(id, value)
+        _G._debounce_hash_fn_calls[id] = (_G._debounce_hash_fn_calls[id] or 0) + 1
+        _G._debounce_hash_fn_value = value
+      end)
+
+      debounced('a', 1)
+      debounced('a', 2)
+    end)
+
+    helpers.expectf(function()
+      eq(1, exec_lua("return _G._debounce_hash_fn_calls['a']"))
+      eq(2, exec_lua('return _G._debounce_hash_fn_value'))
+    end)
+  end)
+end)

test/gs_helpers.lua

@@ -229,11 +229,17 @@ function M.match_debug_messages(spec)
   end)
 end
 
+function M.setup_path()
+  exec_lua(function(path)
+    package.path = path
+  end, package.path)
+end
+
 --- @param config? table
 --- @param on_attach? boolean
 function M.setup_gitsigns(config, on_attach)
-  exec_lua(function(path, config0, on_attach0)
-    package.path = path
+  M.setup_path()
+  exec_lua(function(config0, on_attach0)
     if config0 and config0.on_attach then
       local maps = config0.on_attach --[[@as [string,string,string][] ]]
       config0.on_attach = function(bufnr)
@@ -249,7 +255,7 @@ function M.setup_gitsigns(config, on_attach)
     end
     require('gitsigns').setup(config0)
     vim.o.diffopt = 'internal,filler,closeoff'
-  end, package.path, config, on_attach)
+  end, config, on_attach)
 end
 
 --- @param status table<string,string|integer>