Rust: rustaceanvim al máximo

Rust en Neovim no se configura con el LSP genérico: se usa rustaceanvim, que envuelve rust-analyzer y le añade todo lo que hace especial a Rust — ejecutar tests inline, expandir macros, explicar un error del compilador, depurar con un comando.

rustaceanvim, no rust_analyzer

En la lección 2.5 viste el camino normal para cualquier servidor: una ficha en lsp/, un vim.lsp.enable y listo. Rust es la excepción deliberada del track, porque rust-analyzer ofrece un montón de peticiones fuera del protocolo estándar (runnables, expansión de macros, explicación de errores, árbol sintáctico) que un cliente LSP genérico no sabe pedir. rustaceanvim las implementa todas.

rustaceanvim pide Neovim 0.12 o superior, no lleva setup() y hace su propia carga perezosa por tipo de archivo, así que no debes envolverlo en la del gestor de plugins. Se configura poniendo una tabla en vim.g.rustaceanvim antes de que el plugin se inicialice.

return {
  "mrcjkb/rustaceanvim",
  version = "^9",
  lazy = false,
  init = function()
    require("config.rust")  -- define vim.g.rustaceanvim antes de arrancar
  end,
}

require("config.rust")  -- primero la config global, luego el plugin

vim.pack.add({
  {
    src = "https://github.com/mrcjkb/rustaceanvim",
    version = vim.version.range("^9"),
  },
})

Las opciones del servidor viven en su propio módulo:

vim.g.rustaceanvim = {
  server = {
    default_settings = {
      ["rust-analyzer"] = {
        cargo = { features = "all" },   -- equivale a --all-features
        check = { command = "clippy" }, -- clippy en lugar de cargo check
        procMacro = { enable = true },
      },
    },
  },
}

Las teclas, en el ftplugin

rustaceanvim expone sus funciones por el comando :RustLsp. Como solo tienen sentido en archivos Rust, el sitio correcto para los atajos es un ftplugin, que Neovim ejecuta al abrir cada buffer del tipo:

local buf = vim.api.nvim_get_current_buf()
local function map(k, fn, desc)
  vim.keymap.set("n", k, fn, { buffer = buf, desc = desc })
end

map("<leader>rr", function() vim.cmd.RustLsp("runnables") end,            "Rust: runnables")
map("<leader>rt", function() vim.cmd.RustLsp("testables") end,            "Rust: testables")
map("<leader>rd", function() vim.cmd.RustLsp("debuggables") end,          "Rust: debuggables")
map("<leader>rm", function() vim.cmd.RustLsp("expandMacro") end,          "Rust: expandir macro")
map("<leader>re", function() vim.cmd.RustLsp("explainError") end,         "Rust: explicar error")
map("<leader>rD", function() vim.cmd.RustLsp("renderDiagnostic") end,     "Rust: diagnóstico completo")
map("<leader>rc", function() vim.cmd.RustLsp("openCargo") end,            "Rust: abrir Cargo.toml")
map("<leader>ro", function() vim.cmd.RustLsp("openDocs") end,             "Rust: docs.rs del símbolo")
map("K",          function() vim.cmd.RustLsp({ "hover", "actions" }) end, "Rust: hover con acciones")

Runnables, testables y debuggables

Dos comandos más que casi nadie conoce y que valen la lección entera: <leader>re (explainError) busca el diagnóstico con código de error y te muestra la explicación del índice oficial de errores de Rust, y <leader>rD (renderDiagnostic) te enseña el diagnóstico tal y como lo imprimiría cargo, con el contexto de varios archivos junto. Para pelearte con el borrow checker o con genéricos, esa vista es la que de verdad ayuda.

El parser de Rust no es opcional

require("nvim-treesitter").install({ "rust", "toml" })

-- Sin foldlevelstart = 99, cada archivo se abre ENTERO PLEGADO.
-- Ponlo una vez en tus opciones (leccion 2.3).
vim.o.foldlevelstart = 99

vim.api.nvim_create_autocmd("FileType", {
  pattern = { "rust" },
  callback = function()
    vim.treesitter.start()
    vim.wo[0][0].foldexpr = "v:lua.vim.treesitter.foldexpr()"
    vim.wo[0][0].foldmethod = "expr"
  end,
})

Aquí el parser no es solo cosmético: el comando :Rustc unpretty, que te enseña la representación intermedia de la función bajo el cursor (necesita además una toolchain nightly), requiere el parser de Rust instalado.

crates.nvim: dependencias en Cargo.toml

return {
  "saecki/crates.nvim",
  tag = "stable",
  event = { "BufRead Cargo.toml" },
  config = function()
    require("crates").setup()
  end,
}

vim.pack.add({
  { src = "https://github.com/saecki/crates.nvim" },
})

require("crates").setup()

Con él, Cargo.toml deja de ser un archivo ciego: ves qué versión de cada crate es la última publicada y gestionas las dependencias sin salir del buffer.

Formateo y depuración

rustfmt viene con la toolchain, y ya declaraste rust = { "rustfmt" } en conform (lección 2.4), así que se formatea al guardar respetando tu rustfmt.toml.

Para depurar necesitas nvim-dap (lección 2.4) y un adaptador: codelldb da mejor experiencia que lldb en Rust y rustaceanvim lo detecta solo si está instalado. Ojo al matiz: <leader>rd solo carga las configuraciones que genera rust-analyzer, mientras que require("dap").continue() carga todas las de Rust, incluidas las que tengas en un .vscode/launch.json.