feat: smarter caching, misc fixes

Author: Saghen

lua/blink/cmp/sources/lib/context.lua

@@ -12,6 +12,7 @@ function sources_context.new(context, sources_groups, on_completions_callback)
   self.active_request = nil
   self.queued_request_context = nil
   self.last_successful_completions = nil
+  self.last_sources_group_idx = nil
   --- @type fun(context: blink.cmp.Context, items: blink.cmp.CompletionItem[])
   self.on_completions_callback = on_completions_callback
 
@@ -32,21 +33,25 @@ function sources_context:get_completions(context)
 
   -- Create a task to get the completions for the first sources group,
   -- falling back to the next sources group iteratively if there are no items
-  local request = self:get_completions_for_group(self.sources_groups[1], context)
+  local request = self:get_completions_for_group(1, self.sources_groups[1], context)
   for idx, sources_group in ipairs(self.sources_groups) do
     if idx > 1 then
-      request = request:map(function(items)
-        if #items > 0 then return items end
-        return self:get_completions_for_group(sources_group, context)
+      request = request:map(function(res)
+        if #res.items > 0 then return res end
+        return self:get_completions_for_group(idx, sources_group, context)
       end)
     end
   end
 
   -- Send response upstream and run the queued request, if it exists
-  self.active_request = request:map(function(items)
+  self.active_request = request:map(function(response)
     self.active_request = nil
-    self.last_successful_completions = items
-    self.on_completions_callback(context, items)
+    self.last_successful_completions = response.items
+    -- only send upstream if the response contains something new
+    if not response.is_cached or response.sources_group_idx ~= self.last_sources_group_idx then
+      self.on_completions_callback(context, response.items)
+    end
+    self.last_sources_group_idx = response.sources_group_idx
 
     -- todo: when the queued request results in 100% cached content, we end up
     -- calling the on_completions_callback with the same data, which triggers
@@ -59,10 +64,11 @@ function sources_context:get_completions(context)
   end)
 end
 
+--- @param sources_group_idx number
 --- @param sources_group blink.cmp.Source[]
 --- @param context blink.cmp.Context
 --- @return blink.cmp.Task
-function sources_context:get_completions_for_group(sources_group, context)
+function sources_context:get_completions_for_group(sources_group_idx, sources_group, context)
   -- get completions for each source in the group
   local tasks = vim.tbl_map(function(source)
     -- the source indicates we should refetch when this character is typed
@@ -85,23 +91,25 @@ function sources_context:get_completions_for_group(sources_group, context)
   return async.task
     .await_all(tasks)
     :map(function(tasks_results)
+      local is_cached = true
       local items = {}
       -- for each task, filter the items and add them to the list
       -- if the source should show the completions
       for idx, task_result in ipairs(tasks_results) do
         if task_result.status == async.STATUS.COMPLETED then
+          is_cached = is_cached and (task_result.result.is_cached or false)
           local source = sources_group[idx]
           --- @type blink.cmp.CompletionResponse
           local response = task_result.result
           response.items = source:filter_completions(response)
           if source:should_show_completions(response) then vim.list_extend(items, response.items) end
         end
       end
-      return items
+      return { sources_group_idx = sources_group_idx, is_cached = is_cached, items = items }
     end)
     :catch(function(err)
       vim.print('failed to get completions for group with error: ' .. err)
-      return { is_incomplete_forward = false, is_incomplete_backward = false, items = {} }
+      return { sources_group_idx = sources_group_idx, is_cached = false, items = {} }
     end)
 end
 

lua/blink/cmp/sources/lib/init.lua

@@ -38,7 +38,7 @@ end
 
 function sources.listen_on_completions(callback) sources.on_completions_callback = callback end
 
---- @param context blink.cmp.ShowContext
+--- @param context blink.cmp.Context
 function sources.request_completions(context)
   -- a new context means we should refetch everything
   local is_new_context = sources.current_context == nil or context.id ~= sources.current_context.id
@@ -79,10 +79,10 @@ function sources.resolve(item, callback)
     callback(nil)
     return function() end
   end
-  return item_source
-    :resolve(item)
-    :map(function(resolved_item) callback(resolved_item) end)
-    :catch(function() callback(nil) end)
+  return item_source:resolve(item):map(function(resolved_item) callback(resolved_item) end):catch(function(err)
+    vim.print('failed to resolve item with error: ' .. err)
+    callback(nil)
+  end)
 end
 
 return sources

lua/blink/cmp/sources/lib/source.lua

@@ -28,7 +28,7 @@ function source:get_completions(context)
   -- and the data doesn't need to be updated
   if self.last_response ~= nil and self.last_response.context.id == context.id then
     if utils.should_run_request(context, self.last_response) == false then
-      return async.task.new(function(resolve) resolve(self.last_response) end)
+      return async.task.new(function(resolve) resolve(require('blink.cmp.utils').shallow_copy(self.last_response)) end)
     end
   end
 
@@ -37,15 +37,16 @@ function source:get_completions(context)
     :map(function(response)
       if response == nil then response = { is_incomplete_forward = true, is_incomplete_backward = true, items = {} } end
       response.context = context
-      self.last_response = response
 
       -- add score offset if configured
       for _, item in ipairs(response.items) do
         item.score_offset = (item.score_offset or 0) + (self.config.score_offset or 0)
-        item.cursor_column = context.bounds.end_col -- todo: is this correct?
+        item.cursor_column = context.cursor[2]
         item.source = self.config[1]
       end
 
+      self.last_response = require('blink.cmp.utils').shallow_copy(response)
+      self.last_response.is_cached = true
       return response
     end)
 end
@@ -69,7 +70,9 @@ end
 function source:resolve(item)
   return async.task.new(function(resolve)
     if self.module.resolve == nil then return resolve(nil) end
-    return self.module:resolve(item, resolve)
+    return self.module:resolve(item, function(resolved_item)
+      vim.schedule(function() resolve(resolved_item) end)
+    end)
   end)
 end
 

lua/blink/cmp/sources/lib/types.lua

@@ -5,7 +5,7 @@
 --- @class blink.cmp.CompletionResponse
 --- @field is_incomplete_forward boolean
 --- @field is_incomplete_backward boolean
---- @field context blink.cmp.CompletionContext
+--- @field context blink.cmp.Context
 --- @field items blink.cmp.CompletionItem[]
 ---
 --- @class blink.cmp.Source

lua/blink/cmp/sources/lib/utils.lua

@@ -3,20 +3,19 @@ local utils = {}
 --- Checks if a request should be made, based on the previous response/context
 --- and the new context
 ---
---- @param context blink.cmp.ShowContext | blink.cmp.TriggerContext
---- @param new_context blink.cmp.ShowContext | blink.cmp.TriggerContext
+--- @param new_context blink.cmp.Context
 --- @param response blink.cmp.CompletionResponse
 ---
 --- @return false | 'forward' | 'backward' | 'unknown'
 function utils.should_run_request(new_context, response)
   local old_context = response.context
   -- get the text for the current and queued context
-  local context_query = old_context.line:sub(old_context.bounds.start_col, old_context.bounds.end_col)
-  local queued_context_query = new_context.line:sub(new_context.bounds.start_col, new_context.bounds.end_col)
+  local old_context_query = old_context.line:sub(old_context.bounds.start_col, old_context.cursor[2])
+  local new_context_query = new_context.line:sub(new_context.bounds.start_col, new_context.cursor[2])
 
   -- check if the texts are overlapping
-  local is_before = vim.startswith(context_query, queued_context_query)
-  local is_after = vim.startswith(queued_context_query, context_query)
+  local is_before = vim.startswith(old_context_query, new_context_query)
+  local is_after = vim.startswith(new_context_query, old_context_query)
 
   if is_before and response.is_incomplete_backward then return 'forward' end
   if is_after and response.is_incomplete_forward then return 'backward' end

lua/blink/cmp/sources/lsp.lua

@@ -70,18 +70,19 @@ function lsp:get_completions(context, callback)
   -- for these special cases
   -- i.e. hello.wor| would be sent as hello.|wor
   -- todo: should we still make two calls to the LSP server and merge?
-  local trigger_characters = self:get_trigger_characters()
-  local trigger_character_block_list = { ' ', '\n', '\t' }
-  local bounds = context.bounds
-  local trigger_character_before_context = context.line:sub(bounds.start_col - 1, bounds.start_col - 1)
-  if
-    vim.tbl_contains(trigger_characters, trigger_character_before_context)
-    and not vim.tbl_contains(trigger_character_block_list, trigger_character_before_context)
-  then
-    local offset_encoding = vim.lsp.get_clients({ bufnr = 0 })[1].offset_encoding
-    params.position.character =
-      vim.lsp.util.character_offset(0, params.position.line, bounds.start_col - 1, offset_encoding)
-  end
+  -- todo: breaks the textEdit resolver since it assumes the request was made from the cursor
+  -- local trigger_characters = self:get_trigger_characters()
+  -- local trigger_character_block_list = { ' ', '\n', '\t' }
+  -- local bounds = context.bounds
+  -- local trigger_character_before_context = context.line:sub(bounds.start_col - 1, bounds.start_col - 1)
+  -- if
+  --   vim.tbl_contains(trigger_characters, trigger_character_before_context)
+  --   and not vim.tbl_contains(trigger_character_block_list, trigger_character_before_context)
+  -- then
+  --   local offset_encoding = vim.lsp.get_clients({ bufnr = 0 })[1].offset_encoding
+  --   params.position.character =
+  --     vim.lsp.util.character_offset(0, params.position.line, bounds.start_col - 1, offset_encoding)
+  -- end
 
   -- request from each of the clients
   -- todo: refactor
@@ -118,9 +119,8 @@ function lsp:get_completions(context, callback)
         item.kind = item.kind or vim.lsp.protocol.CompletionItemKind.Text
         item.client_id = client_id
 
-        if item.deprecated or (item.tags and vim.tbl_contains(item.tags, 1)) then
-          item.score_offset = (item.score_for_deprecated or -2)
-        end
+        -- todo: make configurable
+        if item.deprecated or (item.tags and vim.tbl_contains(item.tags, 1)) then item.score_offset = -2 end
       end
     end
 

lua/blink/cmp/sources/path/fs.lua

@@ -55,4 +55,20 @@ function fs.fs_stat_all(cwd, entries)
   end)
 end
 
+--- @param path string
+--- @param byte_limit number
+--- @return blink.cmp.Task
+function fs.read_file(path, byte_limit)
+  return async.task.new(function(resolve, reject)
+    uv.fs_open(path, 'r', 438, function(open_err, fd)
+      if open_err or fd == nil then return reject(open_err) end
+      uv.fs_read(fd, byte_limit, 0, function(read_err, data)
+        uv.fs_close(fd, function() end)
+        if read_err or data == nil then return reject(read_err) end
+        resolve(data)
+      end)
+    end)
+  end)
+end
+
 return fs

lua/blink/cmp/sources/path/init.lua

@@ -32,18 +32,45 @@ function path:get_completions(context, callback)
   local lib = require('blink.cmp.sources.path.lib')
 
   local dirname = lib.dirname(PATH_REGEX, self.opts.get_cwd, context)
-  if not dirname then return callback() end
+  if not dirname then return callback({ is_incomplete_forward = false, is_incomplete_backward = false, items = {} }) end
 
   local include_hidden = self.opts.show_hidden_files_by_default
     or string.sub(context.line, context.bounds.start_col - 1, context.bounds.start_col - 1) == '.'
   lib
     .candidates(dirname, include_hidden, self.opts)
     :map(
       function(candidates)
-        callback({ is_incomplete_forward = false, is_incomplete_backward = true, items = candidates })
+        callback({ is_incomplete_forward = false, is_incomplete_backward = false, items = candidates })
       end
     )
     :catch(function() callback() end)
 end
 
+function path:resolve(item, callback)
+  require('blink.cmp.sources.path.fs')
+    .read_file(item.data.full_path, 1024)
+    :map(function(content)
+      local is_binary = content:find('\0')
+
+      -- binary file
+      if is_binary then
+        item.documentation = {
+          kind = 'plaintext',
+          value = 'Binary file',
+        }
+      -- highlight with markdown
+      else
+        local ext = vim.fn.fnamemodify(item.data.path, ':e')
+        item.documentation = {
+          kind = 'markdown',
+          value = '```' .. ext .. '\n' .. content .. '```',
+        }
+      end
+
+      return item
+    end)
+    :map(function(resolved_item) callback(resolved_item) end)
+    :catch(function() callback(item) end)
+end
+
 return path

lua/blink/cmp/sources/path/lib.lua

@@ -51,7 +51,7 @@ function lib.candidates(dirname, include_hidden, opts)
       return vim.tbl_filter(function(entry) return include_hidden or entry.name ~= '.' end, entries)
     end)
     :map(function(entries)
-      return vim.tbl_map(function(entry) return lib.entry_to_completion_item(entry, opts) end, entries)
+      return vim.tbl_map(function(entry) return lib.entry_to_completion_item(entry, dirname, opts) end, entries)
     end)
 end
 
@@ -65,16 +65,17 @@ function lib.is_slash_comment(_)
 end
 
 --- @param entry { name: string, type: string, stat: table }
+--- @param dirname string
 --- @param opts table
 --- @return blink.cmp.CompletionItem[]
-function lib.entry_to_completion_item(entry, opts)
+function lib.entry_to_completion_item(entry, dirname, opts)
   local is_dir = entry.type == 'directory'
   return {
     label = (opts.label_trailing_slash and is_dir) and entry.name .. '/' or entry.name,
     kind = is_dir and vim.lsp.protocol.CompletionItemKind.Folder or vim.lsp.protocol.CompletionItemKind.File,
     insertText = is_dir and entry.name .. '/' or entry.name,
     word = opts.trailing_slash and entry.name or nil,
-    data = { path = entry.name, type = entry.type, stat = entry.stat },
+    data = { path = entry.name, full_path = dirname .. '/' .. entry.name, type = entry.type, stat = entry.stat },
   }
 end
 

lua/blink/cmp/trigger.lua

@@ -10,9 +10,10 @@
 ---
 --- @class blink.cmp.Context
 --- @field id number
---- @field bounds blink.cmp.TriggerBounds
 --- @field bufnr number
---- @field treesitter_node table | nil
+--- @field cursor number[]
+--- @field line string
+--- @field bounds blink.cmp.TriggerBounds
 --- @field trigger { kind: number, character: string | nil }
 ---
 --- @class blink.cmp.TriggerEventTargets
@@ -138,7 +139,7 @@ end
 
 function trigger.listen_on_hide(callback) trigger.event_targets.on_hide = callback end
 
---- @param context blink.cmp.ShowContext | nil
+--- @param context blink.cmp.Context | nil
 --- @param cursor number[]
 --- @return boolean
 function trigger.within_query_bounds(cursor)
@@ -184,15 +185,4 @@ function helpers.get_context_bounds(regex)
   return { line_number = cursor_line, start_col = start_col, end_col = end_col }
 end
 
---- @return TSNode | nil
-function helpers.get_treesitter_node_at_cursor()
-  local ts = vim.treesitter
-  local parser = ts.get_parser(0) -- Adjust language as needed
-  if not parser then return end
-  parser:parse()
-
-  local cursor = vim.api.nvim_win_get_cursor(0)
-  return ts.get_node({ bufnr = 0, pos = { cursor[1] - 1, math.max(0, cursor[2] - 1) } })
-end
-
 return trigger

lua/blink/cmp/util.lua renamed to lua/blink/cmp/utils.lua

@@ -17,14 +17,18 @@ function utils.keymap(mode, key, callback)
 end
 
 --- Gets the text under the cursor to be used for fuzzy matching
-function utils.get_query()
+--- @param regex string | nil
+--- @return string
+function utils.get_query(regex)
+  if regex == nil then regex = '[%w_\\-]+$' end
+
   local bufnr = vim.api.nvim_get_current_buf()
 
   local current_line = vim.api.nvim_win_get_cursor(0)[1] - 1
   local current_col = vim.api.nvim_win_get_cursor(0)[2] - 1
   local line = vim.api.nvim_buf_get_lines(bufnr, current_line, current_line + 1, false)[1]
 
-  return string.sub(line, 1, current_col + 1):match('[%w_\\-]+$') or ''
+  return string.sub(line, 1, current_col + 1):match(regex) or ''
 end
 
 --- Debounces a function on the trailing edge. Automatically
@@ -47,4 +51,16 @@ function utils.debounce(fn, timeout)
   return wrapped_fn, timer
 end
 
+--- Shallow copy table
+--- @generic T
+--- @param t T
+--- @return T
+function utils.shallow_copy(t)
+  local t2 = {}
+  for k, v in pairs(t) do
+    t2[k] = v
+  end
+  return t2
+end
+
 return utils