[mini.completion] Autoimport on a keymap using ctrl-n and ctrl-y with noselect

[abeldekat]

Contributing guidelines

• I have read CODE_OF_CONDUCT.md

Module(s)

mini.completion

Question

local keycode = vim.keycode or function(x) return vim.api.nvim_replace_termcodes(x, true, true, true) end
local keys = {
  ["ctrl-k"] = keycode("<C-k>"), -- enter digraph, the default
  ["ctrl-y"] = keycode("<C-y>"), -- confirm selected item
  ["ctrl-n_ctrl-y"] = keycode("<C-n><C-y>"), -- no selection by user, confirm first item
}

---@diagnostic disable-next-line: duplicate-set-field
_G.confirm_action = function()
  if vim.fn.pumvisible() ~= 0 then
    local item_selected = vim.fn.complete_info()["selected"] ~= -1
    return item_selected and keys["ctrl-y"] or keys["ctrl-n_ctrl-y"]
  else
    return keys["ctrl-k"] -- enter digraph
  end
end

-- Prefer typing c-k over c-y to accept completion
vim.keymap.set("i", "<C-k>", "v:lua._G.confirm_action()", { expr = true })

The code above is working with vim.o.completeopt = "menuone,noinsert,fuzzy".

It's also working with vim.o.completeopt = "menuone,noselect,fuzzy".
Unfortunately, noselect breaks autoimport in that case. I am using the example from issue 1721.

// rust...
fn main() {
    println!("Hello, world!");
}

struct Dog<Breed> {
    name: String,
}

• Below name, type breed: Phant and accept completion item for PhantomData
• notice the auto-import at the top of the file

[echasnovski]

Yes, this seems to be a result of this caveat as rust-analyzer seems to provide additionalTextEdits only after completionItem/resolve request.

With 'noinsert' the item is selected immediately and for the long enough duration (longer than config.delay.info) for completionItem/resolve to be requested.

With 'noselect' the item is selected only for a very-very brief moment of time before being accepted (all due to <C-n><C-y> path), so there is no completionItem/resolve request -> no additionalTextEdits -> no auto-import.

This all seems to work as expected. Does this answer the question (as there is no explicit one, I am not sure)?

[abeldekat]

Thanks!

This all seems to work as expected. Does this answer the question (as there is no explicit one, I am not sure)?

How can I fix the _G.confirm_action = to support both autoimport and noselect?

[abeldekat]

For reference: It is possible with blink:

local opts = {
  completion =  { 
    -- Preselect false is less intrusive: no automatic docs, no automatic *visible*   selection
    list = { selection = { preselect = false, auto_insert = true } },
  }
}

[echasnovski]

This all seems to work as expected. Does this answer the question (as there is no explicit one, I am not sure)?

How can I fix the _G.confirm_action = to support both autoimport and noselect?

By making sure that this caveat is taken care of. I.e. instead of keycode("<C-n><C-y>") mimic pressing <C-n>, wait for a bit, mimic pressing <C-y>. Things that can make this more usable are:

• Lower config.delay.info.
• Doing this only if the first match doesn't have additionalTextEdits. It is a bit tricky and relies on implementation detail of complete-item having original LSP item as lsp.item in complete-item's user_data field. The vim.fn.complete_info() can be used to get the first matched complete-item.

But the proper answer here is that 'mini.completion' is built with "explicit select" workflow in mind. I.e. for user first explicitly selecting an item which gets later accepted. This allows to not deal with asynchronous nature of resolving accepted but not selected item, which can get messy and error-prone (all the 'mini.snippets' issues with 'nvim-cmp' and 'blink.cmp', extra delay before receiving a response from the server or having to deal with changed buffer state, etc.).

So my real suggestion would be to explicitly select in case of 'noselect'.

[abeldekat]

Thanks!

vim.o.completeopt = "menuone,noselect,fuzzy"

local keycode = vim.keycode or function(x) return vim.api.nvim_replace_termcodes(x, true, true, true) end
local keys = {
  ["ctrl-k"] = keycode("<C-k>"), -- enter digraph, the default
  ["ctrl-n"] = keycode("<C-n>"), -- autoselect first item
  ["ctrl-y"] = keycode("<C-y>"), -- confirm selected item
}


local autoselect_delay = MiniCompletion.config.delay.info + 25 -- delay.info = 25
local autoselect_timer = vim.loop.new_timer()
local scheduled_confirm = vim.schedule_wrap(function() vim.api.nvim_feedkeys(keys["ctrl-y"], "i", false) end)
local confirm = function()
  -- ...
  vim.api.nvim_feedkeys(keys["ctrl-n"], "i", false)
  autoselect_timer:start(autoselect_delay, 0, scheduled_confirm)
  -- ...
end
vim.keymap.set("i", "<C-k>", confirm, {})

It's working, but I understand your point of view. Also, there is a short flash, as the automatic select is visible for a brief moment. Thus, I will keep using "noinsert".

[abeldekat]

Regarding your comment in beta testing mini.keymap: I am glad you changed your mind.

Module mini.keymap allows for a better "smart ctrl-k".

• Before mini.keymap
• With mini.keymap.

---@diagnostic disable: undefined-doc-name, undefined-global

local function setup_deps(path_to_site)
  local mini_path = path_to_site .. "pack/deps/start/mini.nvim"
  if not vim.uv.fs_stat(mini_path) then
    vim.cmd('echo "Installing `mini.nvim`" | redraw')
    vim.fn.system({ "git", "clone", "--filter=blob:none", "https://github.com/echasnovski/mini.nvim", mini_path })
    vim.cmd("packadd mini.nvim | helptags ALL")
    vim.cmd('echo "Installed `mini.nvim`" | redraw')
  end
  require("mini.deps").setup({ path = { package = path_to_site } })
end
setup_deps(vim.fn.stdpath("data") .. "/site/")

vim.o.completeopt = "menuone,noselect,fuzzy"
vim.o.shortmess = "CFOSWaco"
vim.g.mapleader = " "
MiniDeps.now(function()
  require("mini.notify").setup()
  require("mini.icons").setup()
  MiniIcons.tweak_lsp_kind()

  -- See discussion #1771: Fuzzy matching with blink.cmp algorithm
  local lsp_get_filterword = function(x) return x.filterText or x.label end
  local filtersort = function(items, base)
    if base == "" then return vim.deepcopy(items) end
    return vim.fn.matchfuzzy(items, base, { text_cb = lsp_get_filterword, camelcase = false })
  end
  local process_opts = { filtersort = filtersort }
  local process_items = function(items, base) return MiniCompletion.default_process_items(items, base, process_opts) end

  local lsp_completion = { auto_setup = false, source_func = "omnifunc", process_items = process_items }
  require("mini.completion").setup({ delay = { info = 50 }, lsp_completion = lsp_completion })

  -- See discussion #1767: Autoimport on a keymap using ctrl-n and ctrl-y with noselect
  local function make_steps_smart_confirm()
    local autoselect_delay = MiniCompletion.config.delay.info * 2
    local autoselect_timer = vim.loop.new_timer() or {}
    local keys = { ["ctrl-n"] = vim.keycode("<C-n>"), ["ctrl-y"] = vim.keycode("<C-y>") }
    local pumvisible_org = vim.fn.pumvisible -- backup the core function

    local condition_selectconfirm = function()
      return vim.fn.pumvisible() ~= 0 and vim.fn.complete_info()["selected"] == -1
    end
    local action_selectconfirm = function()
      vim.fn.pumvisible = function() return 0 end -- HACK: H.show_info_window: prevent flashing info window
      local hl_org = vim.api.nvim_get_hl(0, { name = "PmenuSel", link = false }) --[[@as vim.api.keyset.highlight]]
      vim.api.nvim_set_hl(0, "PmenuSel", { link = "Pmenu" }) -- HACK: prevent flashing on automatic select...

      vim.api.nvim_feedkeys(keys["ctrl-n"], "i", false) -- 1. select first item without extra hl
      local confirm_and_restore = vim.schedule_wrap(function()
        vim.api.nvim_feedkeys(keys["ctrl-y"], "i", false) -- 2. confirm first item
        vim.fn.pumvisible = pumvisible_org -- 3. restore
        vim.api.nvim_set_hl(0, "PmenuSel", hl_org) -- 3. restore
      end)
      autoselect_timer:start(autoselect_delay, 0, confirm_and_restore)
    end

    local condition_confirm = function() return vim.fn.pumvisible() ~= 0 and vim.fn.complete_info()["selected"] ~= -1 end
    local action_confirm = function() return "<C-y>" end

    local steps_selectconfirm = { condition = condition_selectconfirm, action = action_selectconfirm }
    local steps_confirm = { condition = condition_confirm, action = action_confirm }
    return { steps_selectconfirm, steps_confirm }
  end
  require("mini.keymap").map_multistep("i", "<C-k>", make_steps_smart_confirm(), { desc = "Smart control k" })

  MiniDeps.add("neovim/nvim-lspconfig")
  vim.api.nvim_create_autocmd("LspAttach", {
    group = vim.api.nvim_create_augroup("my.lsp", {}),
    callback = function(args) vim.bo[args.buf].omnifunc = "v:lua.MiniCompletion.completefunc_lsp" end,
  })
  vim.lsp.config("*", { capabilities = MiniCompletion.get_lsp_capabilities() })
  vim.lsp.enable({ "rust_analyzer", "lua_ls" })
end)

I have been testing this for a while and it is working very well with noselect.

EDIT: Also, I am happy I can do something similar for snippets. To me it seems very natural to extend ctrl-h and ctrl-l with tabout behavior, since some call snippets from the lsp don't have the $0 at the end...