fix(completion): keep isIncomplete=true info until not needed

Details:
- This enables "not forgetting" about previously incomplete result
  during fast typing. I.e.:
    - Press `<C-Space>`. Wait for response which is incomplete.
    - Fast type `a` and `b` (so that the LSP request after `a` is
      cancelled). There should still be a force updated due to
      incomplete initial list. Previously it was forgotten after the
      first key press due to autocompletion stop.

Author: echasnovski

lua/mini/completion.lua

@@ -433,7 +433,7 @@ MiniCompletion.completefunc_lsp = function(findstart, base)
     local process_items, is_incomplete = H.get_config().lsp_completion.process_items, false
     process_items = process_items or MiniCompletion.default_process_items
     local words = H.process_lsp_response(H.completion.lsp.result, function(response, client_id)
-      is_incomplete = is_incomplete or response.isIncomplete
+      is_incomplete = is_incomplete or (response.isIncomplete == true)
       -- Response can be `CompletionList` with 'items' field plus their
       -- defaults or `CompletionItem[]`
       local items = H.table_get(response, { 'items' }) or response
@@ -443,7 +443,8 @@ MiniCompletion.completefunc_lsp = function(findstart, base)
       return H.lsp_completion_response_items_to_complete_items(items, client_id)
     end)
 
-    H.completion.lsp.status = is_incomplete and 'done-isincomplete' or 'done'
+    H.completion.lsp.status = 'done'
+    H.completion.lsp.is_incomplete = is_incomplete
 
     -- Maybe trigger fallback action
     if vim.tbl_isempty(words) and H.completion.fallback then return H.trigger_fallback() end
@@ -544,7 +545,8 @@ H.keys = {
 -- Field `lsp` is a table describing state of all used LSP requests. It has the
 -- following structure:
 -- - id: identifier (consecutive numbers).
--- - status: one of 'sent', 'received', 'done', 'done-isincomplete', 'canceled'
+-- - status: one of 'sent', 'received', 'done', 'canceled'
+-- - is_incomplete: whether request was incomplete and require recomputing
 -- - result: result of request.
 -- - cancel_fun: function which cancels current request.
 
@@ -555,7 +557,7 @@ H.completion = {
   source = nil,
   text_changed_id = 0,
   timer = vim.loop.new_timer(),
-  lsp = { id = 0, status = nil, result = nil, cancel_fun = nil },
+  lsp = { id = 0, status = nil, is_incomplete = false, result = nil, cancel_fun = nil },
   start_pos = {},
 }
 
@@ -693,13 +695,15 @@ H.auto_completion = function()
 
   H.completion.timer:stop()
 
-  local is_incomplete = H.completion.lsp.status == 'done-isincomplete'
+  local is_incomplete = H.completion.lsp.is_incomplete
   local force = H.is_lsp_trigger(vim.v.char, 'completion') or is_incomplete
   if force then
-    -- If character is LSP trigger, force fresh LSP completion later
-    -- Check LSP trigger before checking for pumvisible because it should be
-    -- forced even if there are visible candidates
-    H.stop_completion(false)
+    -- Force fresh LSP completion if needed. Check before checking pumvisible
+    -- because it should be forced even if there are visible candidates.
+    -- Keep positive `is_incomplete` to allow fast typing and not "forget" that
+    -- list was incomplete after the second fast key press. This will force LSP
+    -- completion until `isIncomplete=false` response or general `stop()`.
+    H.stop_completion(false, is_incomplete)
   elseif H.pumvisible() then
     -- Do nothing if popup is visible. `H.pumvisible()` might be `true` even if
     -- there is no popup. It is common when manually typing candidate followed
@@ -874,11 +878,11 @@ end
 H.default_fallback_action = function() vim.api.nvim_feedkeys(H.keys.ctrl_n, 'n', false) end
 
 -- Stop actions ---------------------------------------------------------------
-H.stop_completion = function(keep_source)
+H.stop_completion = function(keep_source, keep_lsp_is_incomplete)
   H.completion.timer:stop()
   H.cancel_lsp({ H.completion })
   H.completion.fallback, H.completion.force = true, false
-  if H.completion.lsp.status == 'done-isincomplete' then H.completion.lsp.status = 'done' end
+  if not keep_lsp_is_incomplete then H.completion.lsp.is_incomplete = false end
   if not keep_source then H.completion.source = nil end
 end
 

tests/dir-completion/mock-months-lsp.lua

@@ -196,12 +196,17 @@ Months.requests = {
 }
 
 -- Replace builtin functions with custom testable ones ========================
-vim.lsp.buf_request_all = function(bufnr, method, params, callback)
+local make_request = function(bufnr, method, params, callback)
   local requests = Months.requests[method]
   if requests == nil then return end
   callback(requests(params))
 end
 
+vim.lsp.buf_request_all = function(bufnr, method, params, callback)
+  if _G.mock_request_delay == nil then return make_request(bufnr, method, params, callback) end
+  vim.defer_fn(function() make_request(bufnr, method, params, callback) end, _G.mock_request_delay)
+end
+
 local get_lsp_clients = function() return { Months.client } end
 
 if vim.fn.has('nvim-0.10') == 0 then vim.lsp.buf_get_clients = get_lsp_clients end

tests/screenshots/tests-test_completion.lua---Autocompletion---forces-new-LSP-completion-for-`isIncomplete`-even-if-canceled

@@ -0,0 +1,23 @@
+--|---------|---------|
+01|Jul                 
+02|July Function       
+03|~                   
+04|~                   
+05|~                   
+06|~                   
+07|~                   
+08|~                   
+09|<ame] [+] 1,4    All
+10|-- INSERT --        
+
+--|---------|---------|
+01|00000000000000000000
+02|11111111111111122222
+03|22222222222222222222
+04|22222222222222222222
+05|22222222222222222222
+06|22222222222222222222
+07|22222222222222222222
+08|22222222222222222222
+09|33333333333333333333
+10|44444444444455555555

tests/test_completion.lua

@@ -526,6 +526,35 @@ T['Autocompletion']['forces new LSP completion in case of `isIncomplete`'] = fun
   eq(child.lua_get('_G.lines_at_request'), { 'J', 'Ju', 'J' })
 end
 
+T['Autocompletion']['forces new LSP completion for `isIncomplete` even if canceled'] = function()
+  child.lua([[
+    _G.lines_at_request = {}
+    local buf_request_all_orig = vim.lsp.buf_request_all
+    vim.lsp.buf_request_all = function(bufnr, method, params, callback)
+      table.insert(_G.lines_at_request, vim.api.nvim_get_current_line())
+      return buf_request_all_orig(bufnr, method, params, callback)
+    end
+  ]])
+  child.set_size(10, 20)
+  child.api.nvim_set_current_buf(child.api.nvim_create_buf(true, false))
+
+  child.lua('_G.mock_request_delay = ' .. small_time)
+
+  -- Mock incomplete completion list which contains only months 1-6
+  child.lua('_G.mock_isincomplete = true')
+  type_keys('i', 'J', '<C-Space>')
+  sleep(small_time + small_time)
+  eq(child.lua_get('_G.lines_at_request'), { 'J' })
+
+  -- Should force two requests even though the first one was canceled due to
+  -- fast typing
+  child.lua('_G.mock_isincomplete = false')
+  type_keys('u', 'l')
+  sleep(small_time + small_time)
+  child.expect_screenshot()
+  eq(child.lua_get('_G.lines_at_request'), { 'J', 'Ju', 'Jul' })
+end
+
 T['Autocompletion']['respects `config.delay.completion`'] = function()
   child.lua('MiniCompletion.config.delay.completion = ' .. (2 * default_completion_delay))