Apply additional text edits after resolve timeout

[psznm]

Make sure you have done the following

• Updated to the latest version of blink.cmp
• Searched for existing issues and documentation (try <C-k> on https://cmp.saghen.dev)

Bug Description

EDIT: I managed to fix my issue by setting completion.accept.resolve_timeout_ms to much higher value, but now I am getting error when I leave insert mode before the completion finishes.

blink.cmp/lua/blink/cmp/completion/accept/init.lua:69: Cursor position outside buffer

EDIT2:
This error disappeared when I set completion.accept.dot_repeat to false. But now I am getting random character (the character that my cursor was on when I initiated the menu) added after the completion, if I exit insert mode before the completion finishes.

Original issue:
My LSP is providing auto-import functionality on selecting completion. But with blink.cmp this often does not work very well. It seems to work better when I select the completion, then wait for some time, and then confirm the completion. But when I do it quickly, the auto-import does not happen. This may be caused by some behavior of the LSP, because with nvim-cmp when I do the same thing, the autoimport happens some hundreds of ms after I select the completion (sometimes after I've already left insert mode). So it seems there is some async LSP behavior which blink.cmp does not wait for / does not handle correctly. I really like blink.cmp, but this is the one thing that is making my experience very poor. The LSP in question is vtsls (typescript)

Relevant configuration

neovim version

0.10.4

blink.cmp version

0.14.1

[geril07]

I also face with this problem regularly, the problem with dot repeat comes from vim.fn.complete which can only be used in Insert Mode and it throws an error when called from any other mode.

https://github.com/neovim/neovim/blob/b2684d9f6658544d75e2431a06bcf21fe80673f8/runtime/doc/vimfn.txt#L1110

Maybe wrap vim.fn.complete call into pcall as a temporary workaround. Dot repeat will be lost in this cases, but at least there would be no error and cursor switching to tmp buffer. Entering Insert mode also can be an option, but i don't know if that's possible to do in a sync way, as i know feed_keys is only way to enter i mode and it's "async".
@Saghen

[geril07]

And about random character at the end, i tested a bit and find out that vim.lsp.util.apply_text_edits is called with slightly different end character.
No random character at the end:

apply_text_edits { {
    newText = ",",
    range = {
      ["end"] = {
        character = 14,
        line = 14
      },
      start = {
        character = 14,
        line = 14
      }
    }
  }, {
    newText = "\n  ApiBatchUpdateAuthority",
    range = {
      ["end"] = {
        character = 14,
        line = 14
      },
      start = {
        character = 14,
        line = 14
      }
    }
  }, {
    newText = "ApiBatchUpdateAuthority",
    range = {
      ["end"] = {
        character = 51,
        line = 68
      },
      start = {
        character = 47,
        line = 68
      }
    }
  } }

Random character at the end:

apply_text_edits { {
    newText = ",",
    range = {
      ["end"] = {
        character = 14,
        line = 14
      },
      start = {
        character = 14,
        line = 14
      }
    }
  }, {
    newText = "\n  ApiBatchUpdateAuthority",
    range = {
      ["end"] = {
        character = 14,
        line = 14
      },
      start = {
        character = 14,
        line = 14
      }
    }
  }, {
    newText = "ApiBatchUpdateAuthority",
    range = {
      ["end"] = {
        character = 50,
        line = 68
      },
      start = {
        character = 47,
        line = 68
      }
    }
  } }

I always triggered completion from ApiB and "random character" always was B, it just wasn't cleared because 47-50 is "Api" in my case. First example has 47-51 which is ApiB and that's correct.

And indeed ctx.get_cursor() inside text_edits.compensate_for_cursor_movement returns 50.

[geril07]

diff --git a/lua/blink/cmp/completion/accept/init.lua b/lua/blink/cmp/completion/accept/init.lua
index 1562734..b88691b 100644
--- a/lua/blink/cmp/completion/accept/init.lua
+++ b/lua/blink/cmp/completion/accept/init.lua
@@ -86,29 +86,32 @@ local function apply_item(ctx, item)
   end
 end

 --- Applies a completion item to the current buffer
 --- @param ctx blink.cmp.Context
 --- @param item blink.cmp.CompletionItem
 --- @param callback fun()
 local function accept(ctx, item, callback)
+  print('accept/init.lua', ctx.get_cursor()[2])
   local sources = require('blink.cmp.sources.lib')
   require('blink.cmp.completion.trigger').hide()
+  print('accept/init.lua 2', ctx.get_cursor()[2])

   -- Start the resolve immediately since text changes can invalidate the item
   -- with some LSPs (i.e. rust-analyzer) causing them to return the item as-is
   -- without i.e. auto-imports
   sources
     .resolve(ctx, item)
     -- Some LSPs may take a long time to resolve the item, so we timeout
     :timeout(config.resolve_timeout_ms)
     -- and use the item as-is
     :catch(function() return item end)
     :map(function(resolved_item)
+      print('accept/init.lua 3', ctx.get_cursor()[2])
       -- Updates the text edit based on the cursor position and converts it to utf-8
       resolved_item = vim.deepcopy(resolved_item)
       resolved_item.textEdit = text_edits_lib.get_from_item(resolved_item)

       return sources.execute(
         ctx,
         resolved_item,
         function(alternate_ctx, alternate_item) apply_item(alternate_ctx or ctx, alternate_item or resolved_item) end

accept/init.lua 51
accept/init.lua 2 51
accept/init.lua 3 50

A debugger is needed 😄

UPD: I just realized that it's because of exiting to Normal Mode 😄 , idk, maybe save cursor position when an action was triggered and use it instad of get_cursor()