Autocompletado: primero el nativo, luego blink.cmp

Durante años, montar un IDE en Neovim empezaba por instalar un plugin de completado. En 0.12 ya no hace falta: el menú automático en modo Insert es una opción del editor, y el LSP se enchufa a él con dos líneas. Esta lección empieza por lo que ya tienes gratis y solo después mira qué justifica añadir un plugin encima.

El completado ya está dentro

Neovim 0.12 trae la opción autocomplete: cuando está activa, el menú aparece solo mientras escribes, sin pulsar nada y sin plugins. Va acompañada de dos opciones que ya existían y ahora importan más: complete decide de dónde salen los candidatos y en qué orden, y completeopt decide cómo se comportan el menú y la inserción.

-- El menú aparece solo mientras escribes.
vim.o.autocomplete = true

-- Retardo antes de abrirlo (0 por defecto). Súbelo un poco si te molesta
-- que salte a media palabra.
vim.o.autocompletedelay = 50

-- Cómo se comporta el menú.
vim.opt.completeopt = {
  "menuone",  -- muestra el menú aunque solo haya un candidato
  "popup",    -- ventana flotante con la info del candidato seleccionado
  "fuzzy",    -- coincidencia difusa: perdona letras saltadas
}

-- De dónde salen los candidatos, en orden. El "^5" limita cada fuente
-- a 5 resultados para que el menú no se convierta en una lista infinita.
vim.opt.complete = { ".^5", "w^5", "b^5", "u^5" }

Las banderas de complete que vas a usar: . es el buffer actual, w los buffers de otras ventanas, b los buffers cargados de la lista, u los descargados, y o el omnifunc (aquí es donde entrará el LSP). Neovim reparte un presupuesto de tiempo decreciente entre ellas: las primeras de la lista tienen prioridad, pero todas llegan a responder.

Enchufar el LSP al menú nativo

Cuando un servidor se adjunta, Neovim ya pone omnifunc a vim.lsp.omnifunc, así que <C-x><C-o> funciona sin configurar nada. Para que los candidatos del LSP entren en el menú automático, hay dos piezas: activar vim.lsp.completion en el buffer y añadir la fuente o a complete.

vim.api.nvim_create_autocmd("LspAttach", {
  group = vim.api.nvim_create_augroup("completado_lsp", { clear = true }),
  callback = function(ev)
    -- autotrigger usa los triggerCharacters que declara el servidor
    -- (el punto, la flecha, los dos puntos dobles...).
    vim.lsp.completion.enable(true, ev.data.client_id, ev.buf, { autotrigger = true })

    -- La fuente "o" es el omnifunc, es decir, el LSP.
    vim.opt_local.complete:append("o")
  end,
})

Aceptar un candidato del LSP con <C-y> no solo inserta texto: aplica los efectos secundarios que trae el servidor —expandir el snippet, añadir el import que falta, ejecutar el comando asociado—. Eso funciona igual si el menú vino del autotrigger, del omnifunc o de una llamada manual.

Las teclas del completado

<C-y>, <C-e>, <C-n> y <C-p> los tienes ya. Las otras dos las pones tú, y son exactamente las que propone la documentación de Neovim:

-- Tab y Shift-Tab navegan el menú; si no hay menú, hacen lo de siempre.
vim.keymap.set("i", "<Tab>", function()
  return vim.fn.pumvisible() == 1 and "<C-n>" or "<Tab>"
end, { expr = true, desc = "Completado: siguiente" })

vim.keymap.set("i", "<S-Tab>", function()
  return vim.fn.pumvisible() == 1 and "<C-p>" or "<S-Tab>"
end, { expr = true, desc = "Completado: anterior" })

-- Ctrl-Espacio pide el completado del LSP sin esperar al autotrigger.
vim.keymap.set("i", "<C-Space>", function()
  vim.lsp.completion.get()
end, { desc = "Completado: invocar LSP" })

Regla de oro: Ctrl-Espacio y Tab no son tuyos

Quien de verdad se pelea hoy por estas teclas son los plugins de saltos y los de IA, casi siempre por <Tab>. Ese caso está tratado en la lección 3.4: el <Tab> de la IA se encadena dentro de la capa de completado en vez de robarlo.

Cuando algo “deja de funcionar”, el primer reflejo debe ser preguntar quién tiene la tecla:

:map <C-Space>
:imap <Tab>
:verbose imap <Tab>

:map te dice si alguien la ha tomado en Normal o Visual; :imap es la que importa aquí, porque el completado vive en Insert; y :verbose añade el archivo y la línea exactos donde se definió el mapeo. Tres comandos, quince segundos, en vez de una tarde.

inlineCompletion: la IA también habla LSP

Neovim 0.12 añadió al cliente el soporte de textDocument/inlineCompletion. Es la parte del protocolo pensada para sugerencias largas —una función entera, no una palabra— que se muestran como texto superpuesto en vez de como menú.

Importa aquí por una razón: el “ghost text” de las herramientas de IA ya no necesita un plugin propio si el proveedor publica un servidor de lenguaje. El módulo se maneja como cualquier otra función del cliente:

vim.lsp.inline_completion.enable()

-- Aceptar la sugerencia superpuesta. get() devuelve false si no hay
-- ninguna, así que el fallback a Tab es limpio.
vim.keymap.set("i", "<Tab>", function()
  if not vim.lsp.inline_completion.get() then
    return "<Tab>"
  end
end, { expr = true, desc = "Aceptar sugerencia inline" })

Fíjate en que esto vuelve a caer sobre <Tab>: es la misma tecla, encadenada. Eso es lo correcto — el completado y las sugerencias inline son la misma capa y comparten teclado. Lo que no puedes es tener dos plugins distintos reclamando <Tab> por su cuenta. La lección 3.4 monta esta parte a fondo.

Qué añade blink.cmp encima

Con lo anterior tienes un completado decente. blink.cmp no lo sustituye: lo mejora en cosas concretas y medibles.

La diferencia práctica no es la velocidad —el nativo es rápido—, es la gestión de fuentes. Si quieres que las rutas de archivo, los snippets, el buffer y el LSP convivan en un mismo menú con un orden que tú decides, y que buscar fuction encuentre function, eso el nativo no lo hace.

return {
  "saghen/blink.cmp",
  version = "1.*",  -- las etiquetas traen el binario Rust precompilado
  dependencies = { "rafamadriz/friendly-snippets" },
  event = "InsertEnter",
  opts = {
    -- default: <C-Space> abre, <C-y> acepta, <Tab> salta huecos de snippet.
    -- 'super-tab' acepta con <Tab>; 'enter' acepta con <CR>.
    keymap = { preset = "default" },

    appearance = { nerd_font_variant = "mono" },

    -- El orden importa: es el orden en que se agrupan en el menú.
    sources = {
      default = { "lsp", "path", "snippets", "buffer" },
    },

    completion = {
      documentation = { auto_show = true, auto_show_delay_ms = 200 },
      ghost_text = { enabled = true },
      menu = { border = "rounded" },
    },

    signature = { enabled = true, window = { border = "rounded" } },

    fuzzy = { implementation = "prefer_rust_with_warning" },
  },
  opts_extend = { "sources.default" },
}

vim.pack.add({
  { src = "https://github.com/rafamadriz/friendly-snippets" },
  {
    src = "https://github.com/saghen/blink.cmp",
    version = vim.version.range("1.x"),  -- última etiqueta de la serie 1
  },
})

require("blink.cmp").setup({
  keymap = { preset = "default" },
  appearance = { nerd_font_variant = "mono" },
  sources = { default = { "lsp", "path", "snippets", "buffer" } },
  completion = {
    documentation = { auto_show = true, auto_show_delay_ms = 200 },
    ghost_text = { enabled = true },
    menu = { border = "rounded" },
  },
  signature = { enabled = true, window = { border = "rounded" } },
  fuzzy = { implementation = "prefer_rust_with_warning" },
})

Si instalas blink.cmp, apaga el nativo: dos menús a la vez es exactamente el tipo de conflicto que esta lección intenta evitar.

vim.o.autocomplete = false

Cuándo NO instalar blink.cmp

Vale la pena decirlo claro, porque va contra la costumbre: