Squashed 'mut/neovim/pack/plugins/start/blink.cmp/' content from commit 1cc3b1a

git-subtree-dir: mut/neovim/pack/plugins/start/blink.cmp
git-subtree-split: 1cc3b1a908fbcfd15451c4772759549724f38524

4 files changed, 370 insertions, 0 deletions

diff --git a/lua/blink/cmp/sources/lib/provider/config.lua b/lua/blink/cmp/sources/lib/provider/config.lua
new file mode 100644
index 0000000..cda6a52
--- /dev/null
+++ b/lua/blink/cmp/sources/lib/provider/config.lua
@@ -0,0 +1,46 @@
+--- @class blink.cmp.SourceProviderConfigWrapper
+--- @field new fun(config: blink.cmp.SourceProviderConfig): blink.cmp.SourceProviderConfigWrapper
+---
+--- @field name string
+--- @field module string
+--- @field enabled fun(): boolean
+--- @field async fun(ctx: blink.cmp.Context): boolean
+--- @field timeout_ms fun(ctx: blink.cmp.Context): number
+--- @field transform_items fun(ctx: blink.cmp.Context, items: blink.cmp.CompletionItem[]): blink.cmp.CompletionItem[]
+--- @field should_show_items fun(ctx: blink.cmp.Context, items: blink.cmp.CompletionItem[]): boolean
+--- @field max_items? fun(ctx: blink.cmp.Context, items: blink.cmp.CompletionItem[]): number
+--- @field min_keyword_length fun(ctx: blink.cmp.Context): number
+--- @field fallbacks fun(ctx: blink.cmp.Context): string[]
+--- @field score_offset fun(ctx: blink.cmp.Context): number
+
+--- @class blink.cmp.SourceProviderConfigWrapper
+--- @diagnostic disable-next-line: missing-fields
+local wrapper = {}
+
+function wrapper.new(config)
+  local function call_or_get(fn_or_val, default)
+    if fn_or_val == nil then
+      return function() return default end
+    end
+    return function(...)
+      if type(fn_or_val) == 'function' then return fn_or_val(...) end
+      return fn_or_val
+    end
+  end
+
+  local self = setmetatable({}, { __index = config })
+  self.name = config.name
+  self.module = config.module
+  self.enabled = call_or_get(config.enabled, true)
+  self.async = call_or_get(config.async, false)
+  self.timeout_ms = call_or_get(config.timeout_ms, 2000)
+  self.transform_items = config.transform_items or function(_, items) return items end
+  self.should_show_items = call_or_get(config.should_show_items, true)
+  self.max_items = call_or_get(config.max_items, nil)
+  self.min_keyword_length = call_or_get(config.min_keyword_length, 0)
+  self.fallbacks = call_or_get(config.fallbacks, {})
+  self.score_offset = call_or_get(config.score_offset, 0)
+  return self
+end
+
+return wrapper
diff --git a/lua/blink/cmp/sources/lib/provider/init.lua b/lua/blink/cmp/sources/lib/provider/init.lua
new file mode 100644
index 0000000..0494dcc
--- /dev/null
+++ b/lua/blink/cmp/sources/lib/provider/init.lua
@@ -0,0 +1,179 @@
+--- Wraps the sources to respect the configuration options and provide a unified interface
+--- @class blink.cmp.SourceProvider
+--- @field id string
+--- @field name string
+--- @field config blink.cmp.SourceProviderConfigWrapper
+--- @field module blink.cmp.Source
+--- @field list blink.cmp.SourceProviderList | nil
+--- @field resolve_tasks table<blink.cmp.CompletionItem, blink.cmp.Task>
+---
+--- @field new fun(id: string, config: blink.cmp.SourceProviderConfig): blink.cmp.SourceProvider
+--- @field enabled fun(self: blink.cmp.SourceProvider): boolean
+--- @field get_trigger_characters fun(self: blink.cmp.SourceProvider): string[]
+--- @field get_completions fun(self: blink.cmp.SourceProvider, context: blink.cmp.Context, on_items: fun(items: blink.cmp.CompletionItem[], is_cached: boolean))
+--- @field should_show_items fun(self: blink.cmp.SourceProvider, context: blink.cmp.Context, items: blink.cmp.CompletionItem[]): boolean
+--- @field transform_items fun(self: blink.cmp.SourceProvider, context: blink.cmp.Context, items: blink.cmp.CompletionItem[]): blink.cmp.CompletionItem[]
+--- @field resolve fun(self: blink.cmp.SourceProvider, context: blink.cmp.Context, item: blink.cmp.CompletionItem): blink.cmp.Task
+--- @field execute fun(self: blink.cmp.SourceProvider, context: blink.cmp.Context, item: blink.cmp.CompletionItem, callback: fun()): blink.cmp.Task
+--- @field get_signature_help_trigger_characters fun(self: blink.cmp.SourceProvider): { trigger_characters: string[], retrigger_characters: string[] }
+--- @field get_signature_help fun(self: blink.cmp.SourceProvider, context: blink.cmp.SignatureHelpContext): blink.cmp.Task
+--- @field reload (fun(self: blink.cmp.SourceProvider): nil) | nil
+
+--- @type blink.cmp.SourceProvider
+--- @diagnostic disable-next-line: missing-fields
+local source = {}
+
+local async = require('blink.cmp.lib.async')
+
+function source.new(id, config)
+  assert(type(config.name) == 'string', 'Each source in config.sources.providers must have a "name" of type string')
+  assert(type(config.module) == 'string', 'Each source in config.sources.providers must have a "module" of type string')
+
+  local self = setmetatable({}, { __index = source })
+  self.id = id
+  self.name = config.name
+  self.module = require('blink.cmp.sources.lib.provider.override').new(
+    require(config.module).new(config.opts or {}, config),
+    config.override
+  )
+  self.config = require('blink.cmp.sources.lib.provider.config').new(config)
+  self.list = nil
+  self.resolve_tasks = {}
+
+  return self
+end
+
+function source:enabled()
+  -- user defined
+  if not self.config.enabled() then return false end
+
+  -- source defined
+  if self.module.enabled == nil then return true end
+  return self.module:enabled()
+end
+
+--- Completion ---
+
+function source:get_trigger_characters()
+  if self.module.get_trigger_characters == nil then return {} end
+  return self.module:get_trigger_characters()
+end
+
+function source:get_completions(context, on_items)
+  -- return the previous successful completions if the context is the same
+  -- and the data doesn't need to be updated
+  -- or if the list is async, since we don't want to cause a flash of no items
+  if self.list ~= nil and self.list:is_valid_for_context(context) then
+    self.list:set_on_items(on_items)
+    self.list:emit(true)
+    return
+  end
+
+  -- the source indicates we should refetch when this character is typed
+  local trigger_character = context.trigger.character
+    and vim.tbl_contains(self:get_trigger_characters(), context.trigger.character)
+
+  -- The TriggerForIncompleteCompletions kind is handled by the source provider itself
+  local source_context = require('blink.cmp.lib.utils').shallow_copy(context)
+  source_context.trigger = trigger_character
+      and { kind = vim.lsp.protocol.CompletionTriggerKind.TriggerCharacter, character = context.trigger.character }
+    or { kind = vim.lsp.protocol.CompletionTriggerKind.Invoked }
+
+  local async_initial_items = self.list ~= nil and self.list.context.id == context.id and self.list.items or {}
+  if self.list ~= nil then self.list:destroy() end
+
+  self.list = require('blink.cmp.sources.lib.provider.list').new(
+    self,
+    context,
+    on_items,
+    -- HACK: if the source is async, we're not reusing the previous list and the response was marked as incomplete,
+    -- the user will see a flash of no items from the provider, since the list emits immediately. So we hack around
+    -- this for now
+    { async_initial_items = async_initial_items }
+  )
+end
+
+function source:should_show_items(context, items)
+  -- if keyword length is configured, check if the context is long enough
+  local provider_min_keyword_length = self.config.min_keyword_length(context)
+
+  -- for manual trigger, we ignore the min_keyword_length set globally, but still respect per-provider
+  local global_min_keyword_length = 0
+  if context.trigger.initial_kind ~= 'manual' then
+    local global_min_keyword_length_func_or_num = require('blink.cmp.config').sources.min_keyword_length
+    if type(global_min_keyword_length_func_or_num) == 'function' then
+      global_min_keyword_length = global_min_keyword_length_func_or_num(context)
+    else
+      global_min_keyword_length = global_min_keyword_length_func_or_num
+    end
+  end
+
+  local min_keyword_length = math.max(provider_min_keyword_length, global_min_keyword_length)
+  local current_keyword_length = context.bounds.length
+  if current_keyword_length < min_keyword_length then return false end
+
+  if self.config.should_show_items == nil then return true end
+  return self.config.should_show_items(context, items)
+end
+
+function source:transform_items(context, items)
+  if self.config.transform_items ~= nil then items = self.config.transform_items(context, items) end
+  items = require('blink.cmp.config').sources.transform_items(context, items)
+  return items
+end
+
+--- Resolve ---
+
+function source:resolve(context, item)
+  local tasks = self.resolve_tasks
+  if tasks[item] == nil or tasks[item].status == async.STATUS.CANCELLED then
+    tasks[item] = async.task.new(function(resolve)
+      if self.module.resolve == nil then return resolve(item) end
+
+      return self.module:resolve(item, function(resolved_item)
+        -- HACK: it's out of spec to update keys not in resolveSupport.properties but some LSPs do it anyway
+        local merged_item = vim.tbl_deep_extend('force', item, resolved_item or {})
+        local transformed_item = self:transform_items(context, { merged_item })[1] or merged_item
+        vim.schedule(function() resolve(transformed_item) end)
+      end)
+    end)
+  end
+  return tasks[item]
+end
+
+--- Execute ---
+
+function source:execute(context, item)
+  if self.module.execute == nil then
+    return async.task.new(function(resolve) resolve() end)
+  end
+  return async.task.new(function(resolve) self.module:execute(context, item, resolve) end)
+end
+
+--- Signature help ---
+
+function source:get_signature_help_trigger_characters()
+  if self.module.get_signature_help_trigger_characters == nil then
+    return { trigger_characters = {}, retrigger_characters = {} }
+  end
+  return self.module:get_signature_help_trigger_characters()
+end
+
+function source:get_signature_help(context)
+  return async.task.new(function(resolve)
+    if self.module.get_signature_help == nil then return resolve(nil) end
+    return self.module:get_signature_help(context, function(signature_help)
+      vim.schedule(function() resolve(signature_help) end)
+    end)
+  end)
+end
+
+--- Misc ---
+
+--- For external integrations to force reloading the source
+function source:reload()
+  if self.module.reload == nil then return end
+  self.module:reload()
+end
+
+return source
diff --git a/lua/blink/cmp/sources/lib/provider/list.lua b/lua/blink/cmp/sources/lib/provider/list.lua
new file mode 100644
index 0000000..17d4bdf
--- /dev/null
+++ b/lua/blink/cmp/sources/lib/provider/list.lua
@@ -0,0 +1,128 @@
+--- @class blink.cmp.SourceProviderList
+--- @field provider blink.cmp.SourceProvider
+--- @field context blink.cmp.Context
+--- @field items blink.cmp.CompletionItem[]
+--- @field on_items fun(items: blink.cmp.CompletionItem[], is_cached: boolean)
+--- @field has_completed boolean
+--- @field is_incomplete_backward boolean
+--- @field is_incomplete_forward boolean
+--- @field cancel_completions? fun(): nil
+---
+--- @field new fun(provider: blink.cmp.SourceProvider,context: blink.cmp.Context, on_items: fun(items: blink.cmp.CompletionItem[], is_cached: boolean), opts: blink.cmp.SourceProviderListOpts): blink.cmp.SourceProviderList
+--- @field append fun(self: blink.cmp.SourceProviderList, response: blink.cmp.CompletionResponse)
+--- @field emit fun(self: blink.cmp.SourceProviderList, is_cached?: boolean)
+--- @field destroy fun(self: blink.cmp.SourceProviderList): nil
+--- @field set_on_items fun(self: blink.cmp.SourceProviderList, on_items: fun(items: blink.cmp.CompletionItem[], is_cached: boolean))
+--- @field is_valid_for_context fun(self: blink.cmp.SourceProviderList, context: blink.cmp.Context): boolean
+---
+--- @class blink.cmp.SourceProviderListOpts
+--- @field async_initial_items blink.cmp.CompletionItem[]
+
+--- @type blink.cmp.SourceProviderList
+--- @diagnostic disable-next-line: missing-fields
+local list = {}
+
+function list.new(provider, context, on_items, opts)
+  --- @type blink.cmp.SourceProviderList
+  local self = setmetatable({
+    provider = provider,
+    context = context,
+    items = opts.async_initial_items,
+    on_items = on_items,
+
+    has_completed = false,
+    is_incomplete_backward = true,
+    is_incomplete_forward = true,
+  }, { __index = list })
+
+  -- Immediately fetch completions
+  local default_response = {
+    is_incomplete_forward = true,
+    is_incomplete_backward = true,
+    items = {},
+  }
+  if self.provider.module.get_completions == nil then
+    self:append(default_response)
+  else
+    self.cancel_completions = self.provider.module:get_completions(
+      self.context,
+      function(response) self:append(response or default_response) end
+    )
+  end
+
+  -- if async, immediately send the default response/initial items
+  local is_async = self.provider.config.async(self.context)
+  if is_async and not self.has_completed then self:emit() end
+
+  -- if not async and timeout is set, send the default response after the timeout
+  local timeout_ms = self.provider.config.timeout_ms(self.context)
+  if not is_async and timeout_ms > 0 then
+    vim.defer_fn(function()
+      if not self.has_completed then self:append(default_response) end
+    end, timeout_ms)
+  end
+
+  return self
+end
+
+function list:append(response)
+  if self.has_completed and #response.items == 0 then return end
+
+  if not self.has_completed then
+    self.has_completed = true
+    self.is_incomplete_backward = response.is_incomplete_backward
+    self.is_incomplete_forward = response.is_incomplete_forward
+    self.items = {}
+  end
+
+  -- add metadata and default kind
+  local source_score_offset = self.provider.config.score_offset(self.context) or 0
+  for _, item in ipairs(response.items) do
+    item.score_offset = (item.score_offset or 0) + source_score_offset
+    item.cursor_column = self.context.cursor[2]
+    item.source_id = self.provider.id
+    item.source_name = self.provider.name
+    item.kind = item.kind or require('blink.cmp.types').CompletionItemKind.Property
+  end
+
+  -- combine with existing items
+  local new_items = {}
+  vim.list_extend(new_items, self.items)
+  vim.list_extend(new_items, response.items)
+  self.items = new_items
+
+  -- run provider-local and global transform_items functions
+  self.items = self.provider:transform_items(self.context, self.items)
+
+  self:emit()
+end
+
+function list:emit(is_cached)
+  if is_cached == nil then is_cached = false end
+  self.on_items(self.items, is_cached)
+end
+
+function list:destroy()
+  if self.cancel_completions ~= nil then self.cancel_completions() end
+  self.on_items = function() end
+end
+
+function list:set_on_items(on_items) self.on_items = on_items end
+
+function list:is_valid_for_context(new_context)
+  if self.context.id ~= new_context.id then return false end
+
+  -- get the text for the current and queued context
+  local old_context_query = self.context.line:sub(self.context.bounds.start_col, self.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(old_context_query, new_context_query)
+  local is_after = vim.startswith(new_context_query, old_context_query)
+
+  return (is_before and not self.is_incomplete_backward)
+    or (is_after and not self.is_incomplete_forward)
+    or (is_after == is_before and not (self.is_incomplete_backward or self.is_incomplete_forward))
+end
+
+return list
diff --git a/lua/blink/cmp/sources/lib/provider/override.lua b/lua/blink/cmp/sources/lib/provider/override.lua
new file mode 100644
index 0000000..96e8edd
--- /dev/null
+++ b/lua/blink/cmp/sources/lib/provider/override.lua
@@ -0,0 +1,17 @@
+--- @class blink.cmp.Override : blink.cmp.Source
+--- @field new fun(module: blink.cmp.Source, override_config: blink.cmp.SourceOverride): blink.cmp.Override
+
+local override = {}
+
+function override.new(module, override_config)
+  override_config = override_config or {}
+
+  return setmetatable({}, {
+    __index = function(_, key)
+      if override_config[key] ~= nil then return function(_, ...) return override_config[key](module, ...) end end
+      return module[key]
+    end,
+  })
+end
+
+return override