Treesitter y edición avanzada

En el Nivel 0 aprendiste objetos de texto genéricos (iw, i", i(). Treesitter los lleva a otro nivel: ahora puedes decir “dentro de la función”, “este argumento”, “esta clase” — objetos que entienden la estructura real de tu código. Eso sí: en Neovim 0.12 el mundo de Treesitter cambió de raíz, y casi todo lo que encuentres escrito antes de 2026 ya no compila.

Para qué sirve el plugin si Neovim ya trae Treesitter

Aquí hay que pararse, porque en 0.12 la pregunta legítima es por qué instalar este plugin si Neovim ya hace todo eso. La respuesta es que no hace todo eso.

Neovim trae la librería de tree-sitter y las funciones que la usan: vim.treesitter.start() para resaltar, vim.treesitter.foldexpr() para plegar, la selección incremental que verás más abajo. Pero una librería de parseo sin un parser del lenguaje concreto no puede hacer nada. Y de parsers, Neovim trae exactamente seis:

Para Rust, Python, TypeScript, Go, HTML, CSS, JSON, YAML, Swift o Kotlin no viene nada: ni el parser ni las queries que le dicen a Neovim qué nodo es un comentario y cuál una función. Abre un .rs con la configuración pelada y vim.treesitter.start() falla, porque no hay parser de Rust que arrancar.

Así que el plugin sirve para tres cosas concretas, y ninguna la cubre Neovim:

Instalar los parsers

vim.pack.add({
  { src = "https://github.com/nvim-treesitter/nvim-treesitter", version = "main" },
})

require("nvim-treesitter").install({
  "lua", "vim", "vimdoc", "c", "rust", "swift",
  "javascript", "typescript", "tsx", "html", "css",
  "json", "yaml", "toml", "markdown", "bash",
})

El resaltado y el plegado son de Neovim, no del plugin. Se activan por tipo de archivo:

-- IMPRESCINDIBLE si activas el plegado: sin esto, cada archivo se abre
-- ENTERO PLEGADO y parece que has roto el editor. Ver más abajo.
vim.o.foldlevelstart = 99

vim.api.nvim_create_autocmd("FileType", {
  callback = function(args)
    -- Sin lista de lenguajes: pregunta si hay parser y actúa.
    local lang = vim.treesitter.language.get_lang(vim.bo[args.buf].filetype)
    if not lang or not vim.treesitter.language.add(lang) then return end

    vim.treesitter.start(args.buf, lang)                       -- resaltado
    vim.wo[0][0].foldexpr = "v:lua.vim.treesitter.foldexpr()"  -- plegado
    vim.wo[0][0].foldmethod = "expr"
    vim.bo[args.buf].indentexpr = "v:lua.require'nvim-treesitter'.indentexpr()"
  end,
})

Instala un parser nuevo y funciona solo: no hay ninguna lista que mantener sincronizada a mano.

Qué acabas de activar: el plegado

Un fold es un trozo de código colapsado en una sola línea. No borra nada ni toca el archivo: solo lo oculta de la vista. Antes de Treesitter tenías que decirle a Vim dónde estaban los pliegues con reglas de indentación o marcas en comentarios; ahora los deduce del árbol de sintaxis, así que una función se pliega por ser una función, no porque esté indentada de cierta manera.

Estas son las teclas, todas con prefijo z porque en Vim z es el mundo de la pantalla y los pliegues:

Con esto tienes lo suficiente para usarlo a diario: za sobre una función para quitarla de en medio, zR cuando quieras verlo todo. El plegado da bastante más de sí —persistirlo entre sesiones, plegar por diagnósticos del LSP, un foldtext que diga cuántas líneas oculta cada pliegue— y eso es la lección 4.2, dedicada entera al tema.

Objetos de texto por sintaxis

El plugin de objetos de texto también se reescribió: ya no mapea nada por ti. Tú declaras las teclas, y eso es bueno — es la única forma de no chocar con lo que ya tienes.

return {
  "nvim-treesitter/nvim-treesitter-textobjects",
  branch = "main",
  lazy = false,
  init = function()
    vim.g.no_plugin_maps = true
  end,
  config = function()
    require("nvim-treesitter-textobjects").setup({
      select = { lookahead = true },
      move = { set_jumps = true },
    })
    require("config.textobjects")  -- las teclas, aparte
  end,
}

vim.g.no_plugin_maps = true

vim.pack.add({
  { src = "https://github.com/nvim-treesitter/nvim-treesitter-textobjects", version = "main" },
})

require("nvim-treesitter-textobjects").setup({
  select = { lookahead = true },
  move = { set_jumps = true },
})
require("config.textobjects")

Las teclas van en un módulo propio, porque ahora son responsabilidad tuya:

local sel = require("nvim-treesitter-textobjects.select")
local mov = require("nvim-treesitter-textobjects.move")
local swp = require("nvim-treesitter-textobjects.swap")

local function objeto(captura)
  return function() sel.select_textobject(captura, "textobjects") end
end

for tecla, captura in pairs({
  af = "@function.outer",  ["if"] = "@function.inner",
  ac = "@class.outer",     ic    = "@class.inner",
  aa = "@parameter.outer", ia    = "@parameter.inner",
  al = "@loop.outer",      il    = "@loop.inner",
}) do
  vim.keymap.set({ "x", "o" }, tecla, objeto(captura), { desc = "objeto " .. captura })
end

-- Navegación: usa los prefijos ] y [ que Vim reserva justo para esto.
vim.keymap.set({ "n", "x", "o" }, "]f", function() mov.goto_next_start("@function.outer", "textobjects") end)
vim.keymap.set({ "n", "x", "o" }, "[f", function() mov.goto_previous_start("@function.outer", "textobjects") end)
vim.keymap.set({ "n", "x", "o" }, "]a", function() mov.goto_next_start("@parameter.inner", "textobjects") end)
vim.keymap.set({ "n", "x", "o" }, "[a", function() mov.goto_previous_start("@parameter.inner", "textobjects") end)

-- Intercambiar argumentos sin tocar el ratón.
-- OJO: NO uses <leader>ca — esa es la code action del LSP (lección 2.1).
vim.keymap.set("n", "<leader>cp", function() swp.swap_next("@parameter.inner") end,     { desc = "mover parametro adelante" })
vim.keymap.set("n", "<leader>cP", function() swp.swap_previous("@parameter.inner") end, { desc = "mover parametro atras" })

Ahora tienes objetos nuevos que combinan con los verbos del Nivel 0:

local rep = require("nvim-treesitter-textobjects.repeatable_move")
vim.keymap.set({ "n", "x", "o" }, ";", rep.repeat_last_move_next)
vim.keymap.set({ "n", "x", "o" }, ",", rep.repeat_last_move_previous)
vim.keymap.set({ "n", "x", "o" }, "f", rep.builtin_f_expr, { expr = true })
vim.keymap.set({ "n", "x", "o" }, "F", rep.builtin_F_expr, { expr = true })

Selección incremental: ya no se configura

Aquí está la sorpresa agradable de 0.12. El módulo incremental_selection desapareció con la rama master, pero no hace falta sustituirlo: Neovim trae la selección incremental de serie, como mapeos por defecto del modo Visual. No instalas nada, no configuras nada.

Entras en Visual con v y pulsas an repetidamente: la selección sube por el árbol nodo a nodo (identificador → expresión → argumento → llamada → sentencia → bloque). in baja. Y hay un detalle bien pensado: si el buffer no tiene parser de Treesitter, an e in caen automáticamente en vim.lsp.buf.selection_range(), la capacidad selectionRange que 0.12 añadió al cliente LSP. Es decir, funciona igual en un lenguaje sin parser mientras haya un servidor conectado.

Por debajo todo esto es vim.treesitter.select(), por si quieres construir algo encima:

-- target: 'parent' | 'child' | 'next' | 'prev' | 'extend_next' | 'extend_prev'
vim.treesitter.select("parent", 2)  -- sube dos niveles de golpe

flash.nvim: saltar a cualquier parte

f/t saltan dentro de la línea. flash.nvim salta a cualquier punto visible con dos o tres teclas: invocas el salto, escribes un par de caracteres del destino y aparecen etiquetas.

return {
  "folke/flash.nvim",
  event = "VeryLazy",
  opts = {},
  keys = {
    { "s", mode = { "n", "x", "o" }, function() require("flash").jump() end,       desc = "Flash: saltar" },
    { "S", mode = { "n", "x", "o" }, function() require("flash").treesitter() end, desc = "Flash: nodo" },
  },
}

vim.pack.add({ { src = "https://github.com/folke/flash.nvim" } })

require("flash").setup({})
vim.keymap.set({ "n", "x", "o" }, "s", function() require("flash").jump() end,       { desc = "Flash: saltar" })
vim.keymap.set({ "n", "x", "o" }, "S", function() require("flash").treesitter() end, { desc = "Flash: nodo" })

mini.nvim: surround, pairs, comentarios

mini.nvim es una colección de módulos pequeños y sólidos. Tres son imprescindibles:

return {
  { "nvim-mini/mini.surround", version = false, event = "VeryLazy", opts = {} },
  { "nvim-mini/mini.pairs",    version = false, event = "InsertEnter", opts = {} },
  { "nvim-mini/mini.ai",       version = false, event = "VeryLazy", opts = {} },
}

vim.pack.add({
  { src = "https://github.com/nvim-mini/mini.surround" },
  { src = "https://github.com/nvim-mini/mini.pairs" },
  { src = "https://github.com/nvim-mini/mini.ai" },
})

require("mini.surround").setup({
  -- Prefijo gs: nativamente "dormir N segundos", o sea libre.
  -- Deja s y S para flash.nvim (leccion 2.3).
  mappings = {
    add = "gsa", delete = "gsd", replace = "gsr",
    find = "gsf", find_left = "gsF", highlight = "gsh",
  },
})
require("mini.pairs").setup({})
require("mini.ai").setup({})

Para comentar, Neovim ya trae gc nativo desde 0.10: gcc comenta la línea, gcap un párrafo, gc en Visual la selección. No necesitas plugin.

Autotag para JSX/HTML

Al escribir frontend, cerrar y renombrar etiquetas a mano es tedioso. nvim-ts-autotag lo automatiza con Treesitter:

return {
  "windwp/nvim-ts-autotag",
  ft = { "html", "javascriptreact", "typescriptreact", "tsx", "vue", "svelte", "xml" },
  opts = {},
}

vim.pack.add({ { src = "https://github.com/windwp/nvim-ts-autotag" } })
require("nvim-ts-autotag").setup({})

Escribe una etiqueta de apertura y se cierra sola; renombra la de apertura y la de cierre se actualiza.