helpers: run dynamic_command immediately when opening a buffer (#220)

Author: jfly

doc/HELPERS.md

@@ -106,10 +106,17 @@ directory defaults to the project's root.
 ### dynamic_command
 
 Optional callback to set `command` dynamically. Takes two arguments, a `params`
-table and a `done` callback. The generator's original command (if set) is
-available as `params.command`. The `done` callback should be invoked with a
-string containing the command to run or `nil`, meaning that no command should
-run.
+table and a `done` callback.
+
+`params` is a table with the following keys:
+
+- `bufnr`
+- `bufname`
+- `root`
+- `command`: The generator's original command (if set)
+
+The `done` callback should be invoked with a string containing the command to
+run or `nil`, meaning that no command should run.
 
 `dynamic_command` runs every time its parent generator runs and can affect
 performance, so it's best to cache its output when possible.
@@ -281,6 +288,7 @@ helpers.make_builtin({
     factory, -- function (optional)
     filetypes, -- table
     generator, -- function (optional, but required if factory is not set)
+    setup_buffer_async, -- function (optional)
     generator_opts, -- table
     method, -- internal null-ls method (string)
     meta, -- table

lua/null-ls/builtins/_test/dynamic_command_code_action.lua

@@ -0,0 +1,27 @@
+local h = require("null-ls.helpers")
+local methods = require("null-ls.methods")
+
+local CODE_ACTION = methods.internal.CODE_ACTION
+
+return h.make_builtin({
+    method = CODE_ACTION,
+    filetypes = { "text" },
+    generator_opts = {
+        on_output = function(_params, done)
+            return done({
+                {
+                    title = "an action",
+                    action = function() end,
+                },
+            })
+        end,
+    },
+    factory = function(opts)
+        opts._dynamic_command_call_count = 0
+        opts.dynamic_command = function(_params, done)
+            opts._dynamic_command_call_count = opts._dynamic_command_call_count + 1
+            done("ls")
+        end
+        return h.generator_factory(opts)
+    end,
+})

lua/null-ls/client.lua

@@ -173,6 +173,17 @@ M.setup_buffer = function(bufnr)
         return
     end
 
+    -- Notify each generator for this filetype. This gives them a chance to
+    -- precompute information.
+    local filetype = api.nvim_get_option_value("filetype", { buf = bufnr })
+    for _, source in ipairs(require("null-ls.sources").get({ filetype = filetype })) do
+        if source.generator.setup_buffer_async then
+            source.generator.setup_buffer_async(bufnr, function()
+                -- Nothing to do here.
+            end)
+        end
+    end
+
     local on_attach = c.get().on_attach
     if on_attach then
         on_attach(client, bufnr)

lua/null-ls/helpers/cache.lua

@@ -8,9 +8,13 @@ end
 
 M._reset()
 
+---@class NullLsCacheParams
+---@field bufnr number
+---@field root string
+
 --- creates a function that caches the output of a callback, indexed by bufnr
 ---@param cb function
----@return fun(params: NullLsParams): any
+---@return fun(params: NullLsCacheParams): any
 M.by_bufnr = function(cb)
     -- assign next available key, since we just want to avoid collisions
     local key = next_key
@@ -35,7 +39,7 @@ end
 
 --- creates a function that caches the output of an async callback, indexed by bufnr
 ---@param cb function
----@return fun(params: NullLsParams): any
+---@return fun(params: NullLsCacheParams): any
 M.by_bufnr_async = function(cb)
     -- assign next available key, since we just want to avoid collisions
     local key = next_key

lua/null-ls/helpers/command_resolver.lua

@@ -29,8 +29,7 @@ end
 --- creates a resolver that searches for a local executable and caches results by bufnr
 ---@param prefix string|nil
 M.generic = function(prefix)
-    ---@param params NullLsParams
-    ---@return string|nil
+    ---@param params NullLsDynamicCommandParams
     return cache.by_bufnr_async(function(params, done)
         local executable_to_find = prefix and u.path.join(prefix, params.command) or params.command
         if not executable_to_find then

lua/null-ls/helpers/generator_factory.lua

@@ -3,6 +3,12 @@ local log = require("null-ls.logger")
 local s = require("null-ls.state")
 local u = require("null-ls.utils")
 
+---@class NullLsDynamicCommandParams
+---@field bufnr number
+---@field root string
+---@field bufname string
+---@field command string?
+
 local output_formats = {
     raw = "raw", -- receive error_output and output directly
     none = nil, -- same as raw but will not send error output
@@ -133,12 +139,6 @@ return function(opts)
         end
     end
 
-    if dynamic_command == nil then
-        dynamic_command = function(params, done)
-            done(params.command)
-        end
-    end
-
     local is_nil_table_or_func = function(v)
         return v == nil or vim.tbl_contains({ "function", "table" }, type(v))
     end
@@ -184,7 +184,27 @@ return function(opts)
         return true
     end
 
+    local function get_command_async(bufnr, done)
+        if dynamic_command then
+            dynamic_command({
+                bufnr = bufnr,
+                bufname = vim.api.nvim_buf_get_name(0),
+                root = u.get_root(),
+                command = command,
+            }, done)
+        else
+            done(command)
+        end
+    end
+
     return {
+        setup_buffer_async = function(bufnr, done)
+            -- Here we invoke `get_command_async` and throw away the result. Why? If
+            -- the underlying `dynamic_command` is expensive to compute, it's
+            -- nice to immediately start computing it, rather than waiting for
+            -- someone to need it.
+            get_command_async(bufnr, done)
+        end,
         fn = function(params, done)
             local loop = require("null-ls.loop")
 
@@ -285,7 +305,7 @@ return function(opts)
 
             params.command = command
 
-            dynamic_command(params, function(resolved_command)
+            get_command_async(params.bufnr, function(resolved_command)
                 -- if dynamic_command returns nil, don't fall back to command
                 if not resolved_command then
                     log:debug(string.format("unable to resolve command %s; aborting", command))

test/spec/e2e_spec.lua

@@ -612,6 +612,32 @@ describe("e2e", function()
         end)
     end)
 
+    describe("dynamic_command", function()
+        it("should run immediately, plus each time we need a command", function()
+            local source = builtins._test.dynamic_command_code_action
+            sources.register(source)
+            tu.edit_test_file("test-file.txt")
+            tu.wait()
+
+            -- Make sure we already ran `dynamic_command` once, even though we haven't needed it yet.
+            -- This allows generators to pre-compute `dynamic_command` if it's
+            -- time consuming to compute.
+            assert.equals(1, source._opts._dynamic_command_call_count)
+
+            -- Query for code actions, make sure we've run `dynamic_command` twice.
+            local actions = get_code_actions()
+            tu.wait()
+            assert.equals("ls", source._opts._last_command)
+            assert.equals(2, source._opts._dynamic_command_call_count)
+
+            -- Query for code actions, make sure we've run `dynamic_command` thrice.
+            local actions = get_code_actions()
+            tu.wait()
+            assert.equals("ls", source._opts._last_command)
+            assert.equals(3, source._opts._dynamic_command_call_count)
+        end)
+    end)
+
     -- https://github.com/neovim/neovim/commit/8260e4860b27a54a061bd8e2a9da23069993953a
     -- hover no longer supports handler
     if not vim.fn.has("nvim-0.11") == 1 then