Heiker's Blog

Se puede usar el cliente LSP de neovim sin plugins?

Heiker's photo
Heiker
·

6 min read

Sí se puede. La complejidad de la configuración dependerá del flujo de trabajo que queremos utilizar. Pero si lua les resulta fácil de leer podrán entender la "estructura" necesaria para obtener una configuración decente.

La base

Resulta que sólo necesitamos conocer dos funciones. Una para inicializar el servidor LSP. Una para notificar cada cambio en el texto un archivo.

  • vim.lsp.start_client(): Crea una instancia de un "cliente" que es la que se encarga de comunicarse con el servidor LSP.

  • vim.lsp.buf_attach_client(): Envía notificaciones al servidor LSP con cada cambio en el texto.

Este es un ejemplo simple e ineficiente usando un servidor LSP para typescript.

local launch_tsserver = function()
  local config = {
    cmd = {'typescript-language-server', '--stdio'},
    name = 'tsserver',
    root_dir = vim.fn.getcwd(),
  }

  local client_id = vim.lsp.start_client(config)

  if client_id then
    vim.lsp.buf_attach_client(0, client_id)
  end
end

vim.api.nvim_create_user_command(
  'LaunchTsserver',
  launch_tsserver,
  {desc = 'Inicializar tsserver'}
)

Con esto creamos el comando LaunchTsserver, al ejecutarlo podremos usar el servidor typescript-language-server y obtener diagnósticos en el archivo actual.

¿Por qué es ineficiente? Bueno, porque sólo funciona con un solo archivo. Y cada vez que lo ejecutamos estamos creando un nuevo proceso de typescript-language-server. Lo ideal sería poder compartir el mismo servidor en todo el proyecto.

Uso en proyectos

¿Qué nos falta para poder utilizar el servidor LSP de manera eficiente? Necesitamos crear un "autocomando". Debemos indicarle a neovim que queremos vincular una extensión o tipo de archivo con un servidor LSP.

local filetypes = {
  'typescript',
  'javascript',
  'typescriptreact',
  'javascriptreact',
  'typescript.tsx',
  'javascript.jsx'
}

local buf_attach = function()
  vim.lsp.buf_attach_client(0, client_id)
end

autocmd_id = vim.api.nvim_create_autocmd('FileType', {
  desc = string.format('Vincular servidor: %s', client_name),
  pattern = filetypes,
  callback = buf_attach
})

Bien, ahora nvim_create_autocmd nos devolverá un id que podremos usar para eliminar el autocomando cuando sea necesario.

Para eliminar el autocomando necesitaremos la función nvim_del_autocmd.

vim.api.nvim_del_autocmd(autocmd_id)

¿Pero en qué momento debemos crear este autocomando? Cuando el servidor termine su proceso de inicialización. Podemos usar la función on_init para crearlo y después usamos on_exit para borrarlo.

Si aplicamos todo este conocimiento a nuestro ejemplo, la función launch_tsserver quedaría de la siguiente manera.

local launch_tsserver = function()
  local autocmd
  local filetypes = {
    'typescript',
    'javascript',
    'typescriptreact',
    'javascriptreact',
    'typescript.tsx',
    'javascript.jsx'
  }

  local config = {
    cmd = {'typescript-language-server', '--stdio'},
    name = 'tsserver',
    root_dir = vim.fn.getcwd(),
  }

  config.on_init = function(client, results)
    local buf_attach = function()
      vim.lsp.buf_attach_client(0, client.id)
    end

    autocmd = vim.api.nvim_create_autocmd('FileType', {
      desc = string.format('Vincular servidor: %s', client.name),
      pattern = filetypes,
      callback = buf_attach
    })

    if vim.v.vim_did_enter == 1 and
      vim.tbl_contains(filetypes, vim.bo.filetype)
    then
      buf_attach()
    end
  end

  config.on_exit = vim.schedule_wrap(function(code, signal, client_id)
    vim.api.nvim_del_autocmd(autocmd)
  end)

  vim.lsp.start_client(config)
end

Configuraciones de servidor

Nuestro ejemplo aún no está completo. La mayoría de los servidores LSP tienen una serie de opciones únicas, para habilitar funcionalidades o modificar algún comportamiento. Justo ahora no le estamos enviando esa información al servidor.

Después de que el servidor esté listo podemos enviarle una "notificación" con los datos que queremos. Entonces, en la función on_init agregamos esto.

if results.offsetEncoding then
  client.offset_encoding = results.offsetEncoding
end

if client.config.settings then
  client.notify('workspace/didChangeConfiguration', {
    settings = client.config.settings
  })
end

La documentación de neovim sugiere que debemos configurar la codificación del cliente antes de enviar cualquier petición o notificación. Entonces si el servidor nos devuelve esta información en results lo usamos en el cliente.

Si la instancia del cliente tiene la propiedad settings nos aseguramos de enviarla al servidor. Vale la pena mencionar que client.config es una copia del argumento que le pasamos a la función vim.lsp.start_client().

¿Cuándo definimos los atajos?

No podemos olvidarnos de los atajos. ¿Cómo debemos proceder? La documentación nos sugiere que usemos la función on_attach para definir los atajos y cualquier otro comando. Pero yo tengo otra sugerencia, yo digo que usemos un "evento de usuario" así podemos definir los atajos en cualquier lugar de nuestra configuración.

config.on_attach = function(client, bufnr)
  vim.api.nvim_exec_autocmds('User', {pattern = 'LspAttached'})
end

Ahora podemos definir nuestros atajos en otro lugar.

vim.api.nvim_create_autocmd('User', {
  pattern = 'LspAttached',
  desc = 'Acciones LSP',
  callback = function()
    local bufmap = function(mode, lhs, rhs)
      local opts = {buffer = true}
      vim.keymap.set(mode, lhs, rhs, opts)
    end

    -- Configura sugerencias del servidor
    -- se activan presionando Ctrl-x + Ctrl-o en modo de inserción
    vim.bo.omnifunc = 'v:lua.vim.lsp.omnifunc'

    -- Muestra información sobre símbolo debajo del cursor
    bufmap('n', 'K', '<cmd>lua vim.lsp.buf.hover()<cr>')

    -- Saltar a definición
    bufmap('n', 'gd', '<cmd>lua vim.lsp.buf.definition()<cr>')

    -- Saltar a declaración
    bufmap('n', 'gD', '<cmd>lua vim.lsp.buf.declaration()<cr>')

    -- Mostrar implementaciones
    bufmap('n', 'gi', '<cmd>lua vim.lsp.buf.implementation()<cr>')

    -- Saltar a definición de tipo
    bufmap('n', 'go', '<cmd>lua vim.lsp.buf.type_definition()<cr>')

    -- Listar referencias
    bufmap('n', 'gr', '<cmd>lua vim.lsp.buf.references()<cr>')

    -- Mostrar argumentos de función
    bufmap('n', '<C-k>', '<cmd>lua vim.lsp.buf.signature_help()<cr>')

    -- Renombrar símbolo
    bufmap('n', '<F2>', '<cmd>lua vim.lsp.buf.rename()<cr>')

    -- Listar "code actions" disponibles en la posición del cursor
    bufmap('n', '<F4>', '<cmd>lua vim.lsp.buf.code_action()<cr>')
    bufmap('x', '<F4>', '<cmd>lua vim.lsp.buf.range_code_action()<cr>')

    -- Mostrar diagnósticos de la línea actual
    bufmap('n', 'gl', '<cmd>lua vim.diagnostic.open_float()<cr>')

    -- Saltar al diagnóstico anterior
    bufmap('n', '[d', '<cmd>lua vim.diagnostic.goto_prev()<cr>')

    -- Saltar al siguiente diagnóstico
    bufmap('n', ']d', '<cmd>lua vim.diagnostic.goto_next()<cr>')
  end
})

Código completo

Si aplicamos todos estos cambios a nuestro ejemplo obtendremos esto.

local launch_tsserver = function()
  local autocmd
  local filetypes = {
    'typescript',
    'javascript',
    'typescriptreact',
    'javascriptreact',
    'typescript.tsx',
    'javascript.jsx'
  }

  local config = {
    cmd = {'typescript-language-server', '--stdio'},
    name = 'tsserver',
    root_dir = vim.fn.getcwd(),
    capabilities = vim.lsp.protocol.make_client_capabilities(),
  }

  config.on_attach = function(client, bufnr)
    vim.api.nvim_exec_autocmds('User', {pattern = 'LspAttached'})
  end

  config.on_init = function(client, results)
    if results.offsetEncoding then
      client.offset_encoding = results.offsetEncoding
    end

    if client.config.settings then
      client.notify('workspace/didChangeConfiguration', {
        settings = client.config.settings
      })
    end

    local buf_attach = function()
      vim.lsp.buf_attach_client(0, client.id)
    end

    autocmd = vim.api.nvim_create_autocmd('FileType', {
      desc = string.format('Vincular servidor: %s', client.name),
      pattern = filetypes,
      callback = buf_attach
    })

    if vim.v.vim_did_enter == 1 and
      vim.tbl_contains(filetypes, vim.bo.filetype)
    then
      buf_attach()
    end
  end

  config.on_exit = vim.schedule_wrap(function(code, signal, client_id)
    vim.api.nvim_del_autocmd(autocmd)
  end)

  vim.lsp.start_client(config)
end

vim.api.nvim_create_user_command(
  'LaunchTsserver',
  launch_tsserver,
  {desc = 'Inicializar tsserver'}
)

¿Podemos mejorarlo?

Claro. Casi todo el código puede moverse a una función auxiliar, con eso podremos eliminar todo el ruido.

Sólo imaginen algo como esto.

local launch_tsserver = function()
  local config = make_config({
    cmd = {'typescript-language-server', '--stdio'},
    name = 'tsserver',
    filetypes = {
      'typescript',
      'javascript',
      'typescriptreact',
      'javascriptreact',
      'typescript.tsx',
      'javascript.jsx'
    }
  })

  vim.lsp.start_client(config)
end

vim.api.nvim_create_user_command(
  'LaunchTsserver',
  launch_tsserver,
  {desc = 'Inicializar tsserver'}
)

¿Y qué tiene make_config? Bueno... se los dejo de tarea. Tendrán que implementarla ustedes mismos. Ya les mostré todo el código necesario confío en que pueden hacerlo solos.

Si de verdad quieren saber qué haría yo pueden encontrar la respuesta en este repositorio: VonHeikemen/nvim-lsp-sans-plugins

Conclusión

Aprendimos suficiente sobre el cliente LSP que viene incluido en neovim para crear una pequeña configuración. Sabemos cómo reutilizar una instancia de servidor LSP en múltiples archivos. Y en el proceso aprendimos un poco sobre los autocomandos. Ya podemos decir que podemos manejar el cliente LSP de neovim.

Fuentes

Gracias por su tiempo. Si este artículo les pareció útil y quieren apoyar mis esfuerzos para crear más contenido, pueden dejar una propina en buy me a coffee ☕.

vimneovimshellspanish