fix(timing): matching and timing were overwhelming main loop

Author: asmodeus812

README.md

@@ -1,11 +1,24 @@
 local Pool = require("fuzzy.pool")
 local Registry = require("fuzzy.registry")
 local Scheduler = require("fuzzy.scheduler")
+local group = vim.api.nvim_create_augroup("FUZZYMATCH", { clear = true })
 
 local M = {
     config = {},
 }
 
+function M.teardown()
+    if Scheduler and Scheduler.close then
+        Scheduler.close()
+    end
+    if Registry and Registry.close then
+        Registry.close()
+    end
+    if Pool and Pool.close then
+        Pool.close()
+    end
+end
+
 function M.setup(opts)
     M.config = vim.tbl_deep_extend("keep", opts or {}, {
         general = {
@@ -63,6 +76,8 @@ function M.setup(opts)
 
     vim.api.nvim_set_hl(0, "SelectLineHighlight", { link = "Normal", default = false })
     vim.api.nvim_set_hl(0, "SelectDecoratorDefault", { link = "Normal", default = false })
+
+    vim.api.nvim_create_autocmd("VimLeavePre", { group = group, callback = M.teardown })
 end
 
 return M

lua/fuzzy/init.lua

@@ -103,7 +103,8 @@ function Match:_stop_processing()
         -- kill the timer if it is still active, this will stop any further processing, we do not wait for the current processing to finish,
         -- since it is expected that the callback will handle nil results as a signal that processing was aborted
         if vim.loop.is_closing(self._state.timer) == false then
-            pcall(vim.loop.stop, self._state.timer)
+            pcall(self._state.timer.stop, self._state.timer)
+            pcall(self._state.timer.close, self._state.timer)
         end
         self._state.timer = nil
     end
@@ -179,9 +180,11 @@ function Match:_clean_context()
     self.transform = nil
 end
 
-function Match:_bind_method(method)
+function Match:_bind_guarded(method, token)
     return function(...)
-        return method(self, ...)
+        if self._state.token == token then
+            return method(self, ...)
+        end
     end
 end
 
@@ -334,15 +337,12 @@ function Match:match(list, pattern, callback, transform)
         end
     end
 
-    -- ensure we drop the old results first, these will be re-referenced only when the matching process finishes after this matching process
-    -- that is currently being started now
-    if self.results then
-        self.results = nil
-    end
-
-    -- init core match context
+    -- version the current run, into an incrementing token, that is to ensure that older matching does not start operating on new
+    -- state or on new starts and ensures older ticks get terminated safely
     self._state.token = (self._state.token or 0) + 1
     local token = self._state.token
+
+    -- init core match context
     self.list = assert(list)
     self.pattern = assert(pattern)
     self.callback = assert(callback)
@@ -370,15 +370,22 @@ function Match:match(list, pattern, callback, transform)
     -- ensure offset restored
     self._state.offset = 0
 
+    if self.results then
+        -- ensure we drop the old results first, these will be re-referenced only when the matching process finishes after this matching process
+        -- that is currently being started now
+        self.results = nil
+    end
+
     if not self._state.accum then
-        -- prepare accumulator for results
+        -- the accumulator is an array of 3 sub-arrays, the first sub-array is the matching elements, the second is the matching
+        -- positions and the third is the score, the 3 sub-arrays are always guaranteed to be of the same size.
         self._state.accum = {}
     end
 
     if not self._state.chunks then
         -- chunks are reused to avoid frequent allocations, they represent the part of the whole source list currently being processed
         -- for matches, the chunks are first filled from the source list and then used in the matchfuzzy call
-        local size = self._options.step
+        local size = self._options.step or 0
         self._state.chunks = Pool.obtain(size)
     end
 
@@ -400,12 +407,9 @@ function Match:match(list, pattern, callback, transform)
     self._state.timer = vim.loop.new_timer()
     self._state.timer:start(0,
         self._options.timer,
-        vim.schedule_wrap(function()
-            if self._state.token ~= token then
-                return
-            end
-            Match._match_worker(self)
-        end)
+        vim.schedule_wrap(self:_bind_guarded(
+            Match._match_worker, token
+        ))
     )
 
     -- run one cycle immediately now

lua/fuzzy/match.lua

@@ -313,7 +313,7 @@ end
 function Picker:_input_prompt()
     -- debounce the user input to avoid flooding the matching and rendering logic with too many updates, especially when dealing
     -- with large result sets or fast typers
-    return utils.debounce_callback(self._options.prompt_debounce, function(query)
+    local debounced = utils.debounce_callback(self._options.prompt_debounce, function(query)
         self.select:move_top()
         self.select:toggle_clear()
 
@@ -410,11 +410,18 @@ function Picker:_input_prompt()
             self:_running_match()
         end
     end)
+
+    return function(query)
+        if query ~= nil then
+            self.match:stop()
+        end
+        return debounced(query)
+    end
 end
 
 function Picker:_create_stage()
     local function _input_prompt()
-        return utils.debounce_callback(self._options.prompt_debounce, function(query)
+        local debounced = utils.debounce_callback(self._options.prompt_debounce, function(query)
             local stage = self._state.stage
             assert(stage and next(stage))
             stage.select:move_top()
@@ -460,6 +467,16 @@ function Picker:_create_stage()
                 end
             end
         end)
+
+        return function(query)
+            if query ~= nil then
+                local state = self._state.stage
+                if state and state.match then
+                    state.match:stop()
+                end
+            end
+            return debounced(query)
+        end
     end
 
     local function _cancel_prompt()
@@ -575,11 +592,13 @@ end
 
 function Picker:_matching_worker(mode, list, match_query, total, __type)
     if __type == 1 then
+        -- stop any ongoing matcher work so the debounced call can run promptly
         if self._matching_worker_debounced == nil then
             self._matching_worker_debounced = utils.debounce_callback(
                 self._options.stream_debounce, self._matching_worker
             )
         end
+        self.match:stop()
         self._matching_worker_debounced(
             self, mode, list,
             match_query, total

lua/fuzzy/picker.lua

@@ -319,4 +319,13 @@ function Pool.prune(now)
     end
 end
 
+--- Stop and close the prune timer.
+function Pool.close()
+    if Pool.prune_timer and not vim.uv.is_closing(Pool.prune_timer) then
+        pcall(Pool.prune_timer.stop, Pool.prune_timer)
+        pcall(Pool.prune_timer.close, Pool.prune_timer)
+    end
+    Pool.prune_timer = nil
+end
+
 return Pool

lua/fuzzy/pool.lua

@@ -116,4 +116,13 @@ function Registry.prune(now)
     end
 end
 
+--- Stop and close the prune timer.
+function Registry.close()
+    if Registry.prune_timer and not vim.uv.is_closing(Registry.prune_timer) then
+        pcall(Registry.prune_timer.stop, Registry.prune_timer)
+        pcall(Registry.prune_timer.close, Registry.prune_timer)
+    end
+    Registry.prune_timer = nil
+end
+
 return Registry

lua/fuzzy/registry.lua

@@ -54,6 +54,9 @@ end
 --- @param async Async Async object to add to the scheduler
 function Scheduler.add(async)
     assert(async and async._step)
+    if not Scheduler._executor then
+        Scheduler.new({})
+    end
     table.insert(Scheduler._queue, async)
     if not Scheduler._executor:is_active() then
         local wrapped = vim.schedule_wrap(Scheduler.step)
@@ -74,4 +77,15 @@ function Scheduler.get(thread)
     return nil
 end
 
+--- Stop and close the scheduler executor.
+function Scheduler.close()
+    if Scheduler._executor and not vim.uv.is_closing(Scheduler._executor) then
+        pcall(Scheduler._executor.stop, Scheduler._executor)
+        pcall(Scheduler._executor.close, Scheduler._executor)
+    end
+    Scheduler._executor = nil
+    Scheduler._queue = nil
+    Scheduler._budget = nil
+end
+
 return Scheduler

lua/fuzzy/scheduler.lua

@@ -10,6 +10,22 @@ local detailed_extmark_opts = { limit = 4, type = "highlight", details = true, h
 local padding = { " ", "SelectHeaderPadding" }
 local spacing = { ",", "SelectHeaderDelimiter" }
 
+local PREVIEW_EVENTIGNORE = table.concat({
+    "FileType",
+    "BufEnter",
+    "BufLeave",
+    "BufWinEnter",
+    "BufWinLeave",
+    "WinEnter",
+    "WinLeave",
+    "WinNew",
+    "WinClosed",
+    "CursorMoved",
+    "CursorMovedI",
+    "CursorHold",
+    "CursorHoldI",
+}, ",")
+
 local utils = require("fuzzy.utils")
 local Async = require("fuzzy.async")
 local Worker = require("fuzzy.worker")
@@ -850,7 +866,7 @@ local function display_default(content, window, buffer)
     end
     if buffer ~= nil and vim.api.nvim_buf_is_valid(buffer) then
         local old_ignore = vim.o.eventignore
-        vim.o.eventignore = "all"
+        vim.o.eventignore = PREVIEW_EVENTIGNORE
         pcall(populate_buffer, buffer, content)
         vim.api.nvim_win_set_buf(window, buffer)
         vim.api.nvim_win_set_cursor(window, { 1, 0 })
@@ -868,7 +884,7 @@ local function display_entry(previewer, entry, window, buffer)
         return
     end
     local old_ignore = vim.o.eventignore
-    vim.o.eventignore = "all"
+    vim.o.eventignore = PREVIEW_EVENTIGNORE
     local ok, res, msg = pcall(previewer.preview, previewer, entry, window)
     if not ok then
         display_default({ res or msg or "Unable to preview current entry" }, window, buffer)
@@ -2409,15 +2425,17 @@ end
 --- Checks if the selection interface is currently open, this is determined by checking if both the prompt and list windows are valid.
 --- @return boolean True if the selection interface is open, false otherwise.
 function Select:isopen()
-    local prompt = self.prompt_window and vim.api.nvim_win_is_valid(self.prompt_window)
+    local prompt = not (self._options.prompt_input ~= false)
+        or (self.prompt_window and vim.api.nvim_win_is_valid(self.prompt_window))
     local list = self.list_window and vim.api.nvim_win_is_valid(self.list_window)
     return list ~= nil and prompt ~= nil and list and prompt
 end
 
 --- Checks if the selection interface is valid, meaning that it has been initialized/opened at least once and has not been destroyed by calling the `close` method which would invalidate its curent state
 --- @return boolean True if the select interface is still valid, false otherwise.
 function Select:isvalid()
-    local prompt = self.prompt_buffer and vim.api.nvim_buf_is_valid(self.prompt_buffer)
+    local prompt = not (self._options.prompt_input ~= false)
+        or (self.prompt_buffer and vim.api.nvim_buf_is_valid(self.prompt_buffer))
     local list = self.list_buffer and vim.api.nvim_buf_is_valid(self.list_buffer)
     return list ~= nil and prompt ~= nil and list and prompt
 end
@@ -2468,6 +2486,9 @@ function Select:list(entries, positions)
         self._state.positions = positions
         self._state.entries = entries
         self._state.streaming = true
+        if not self:isvalid() then
+            return
+        end
         self:_render_list()
     elseif positions == nil then
         self._state.streaming = false
@@ -2573,8 +2594,14 @@ function Select:open()
     end
 
     if not self._state.renderer then
+        -- every select has a stateful renderer, in this case this rednerer worker ensures that only the last render job that is
+        -- queried is run, that makes sure that intermediate render jobs that would otherwise be overridden immediately by new
+        -- ones are discarded. This is the worker.coalesce job type
         self._state.renderer = Worker.coalesce()
     end
+
+    -- the source window has to be remembered, that source windo is the source from which the selection interface was initiated,
+    -- that is then later used for a target for future select actions that are performed by the interface
     self.source_window = vim.api.nvim_get_current_win()
     local factor = (opts.prompt_list and opts.preview) and 2.0 or 1.0
     local size = compute_height(opts.window_ratio, factor)
@@ -2596,7 +2623,7 @@ function Select:open()
                     if self._state.query ~= query then
                         self:_prompt_input(query, opts.prompt_input)
                         if query == nil then self:close() end
-                        self._state.query = query
+                        self._state.query = query or ""
                     end
                 end
             })
@@ -2740,7 +2767,7 @@ function Select:open()
                 pattern = "*",
                 callback = function()
                     if vim.tbl_contains(vim.v.event.windows, self.list_window) and
-                        not self:_is_rendering() and vim.api.nvim_buf_line_count(list_buffer) >= 1
+                        self:isvalid() and vim.api.nvim_buf_line_count(list_buffer) >= 1
                     then
                         utils.timed_call(Select._render_list, self, false)
                     end