Интеграция терминального редактора Neovim с LSP‑сервером, автокомплитом и отладкой для Rust и Go в Termux

Termux позволяет собрать полноценное рабочее окружение «в кармане». В этой статье я покажу, как интегрировать Neovim с LSP‑сервером, добавить автокомплит, форматирование и отладку для Rust и Go в среде Termux. Все шаги рассчитаны на практическое использование в Linux‑подобной среде Android.

Фокус — на стабильной интеграции через Neovim‑плагины, LSP‑клиент (через nvim-lspconfig), автокомплит (через nvim-cmp) и отладку (через nvim-dap). При этом учитываем особенности Termux: доступ к инструментам Rust/Go, необходимость корреткных путей и выпусков бинарников.

Что понадобится

• Android‑устройство и установленный Termux
• Собранный набор системных пакетов: компиляторы, утилиты и зависимости для Neovim
• Neovim (предпочтительно 0.7+ или 0.8+)
• LSP‑серверы: для Rust (например, rust-analyzer) и для Go (gopls)
• Среда для отладки: vscode-js-debug не требуется; в нашем случае — отладка через DAP для native Rust/Go (через адаптеры/дебаггеры, доступные в Termux)

Подготовка Termux

Сначала обновим пакеты и поставим базовые зависимости. Выполните команды в Termux:

pkg update -y && pkg upgrade -y

pkg install -y git curl wget tar proot openssl-tool proot-distro clang make cmake pkg-config unzip xz-utils ncurses-utils python

Далее установим Neovim. В Termux обычно удобнее поставить через пакетный менеджер:

pkg install -y neovim

Проверьте версию:

nvim --version | head

Установка Rust и Go

Нам понадобятся инструментальные цепочки для сборки и запуска проектов.

Rust:

pkg install -y rust

Если у вас в репозиториях нет актуальной сборки, обычно используют установку rustup. Но в рамках Termux-стабильности проще начать с пакета rust.

Go:

pkg install -y golang

Проверьте:

rustc --version

cargo --version

go version

Базовая структура конфигурации Neovim

Создадим директорию конфигурации и поставим менеджер пакетов. Самый практичный путь — использовать lazy.nvim (Lua) или packer. Ниже приведу вариант с lazy.nvim, который хорошо подходит для современных конфигураций.

mkdir -p ~/.config/nvim

mkdir -p ~/.local/share/nvim/site/pack/lazy/start

Установим lazy.nvim через git в пакетную директорию:

git clone https://github.com/folke/lazy.nvim.git ~/.local/share/nvim/site/pack/lazy/start/lazy.nvim

Теперь создадим базовый init.lua:

cat > ~/.config/nvim/init.lua <<'EOF'
vim.o.number = true
vim.o.relativenumber = true
vim.o.termguicolors = true
vim.o.signcolumn = "yes"
vim.o.updatetime = 200
vim.o.timeoutlen = 400

require("lazy").setup({
  -- LSP
  { "neovim/nvim-lspconfig" },

  -- LSP status and capabilities
  { "williamboman/mason.nvim", config = function() require("mason").setup() end },
  { "williamboman/mason-lspconfig.nvim" },

  -- Autocomplete
  { "hrsh7th/nvim-cmp" },
  { "hrsh7th/cmp-nvim-lsp" },
  { "L3MON4D3/LuaSnip" },
  { "saadparwaiz1/cmp_luasnip" },

  -- Snippets (опционально; можно убрать, если не нужны)
  { "rafamadriz/friendly-snippets" },

  -- Formatting
  { "jose-elias-alvarez/null-ls.nvim" },

  -- Debugging
  { "mfussenegger/nvim-dap" },
  { "rcarriga/nvim-dap-ui" },
  { "theHamsta/nvim-dap-virtual-text" },

  -- UI extras
  { "nvim-tree/nvim-web-devicons", lazy = true },
})
EOF

Установка и настройка LSP-серверов

Для Rust и Go нужно, чтобы LSP‑серверы были доступны в системе (доступны как исполняемые файлы через PATH).

Rust: rust-analyzer

Варианты установки зависят от того, что проще в вашей среде. Часто работает установка через cargo (как компонент):

cargo install rust-analyzer

Проверьте:

rust-analyzer --version

Go: gopls

Установите gopls:

go install golang.org/x/tools/gopls@latest

Убедитесь, что директория с бинарниками доступна в PATH. В большинстве случаев это:

echo $GOPATH

И путь вида $GOPATH/bin. Для Termux часто используют:

export PATH="$PATH:$(go env GOPATH)/bin"

Проверьте:

gopls version

Конфигурация LSP в Neovim

Добавим отдельный модуль для LSP. Создадим файл:

mkdir -p ~/.config/nvim/lua

mkdir -p ~/.config/nvim/lua/plugins

cat > ~/.config/nvim/lua/plugins/lsp.lua <<'EOF'
local lspconfig = require("lspconfig")

local function on_attach(client, bufnr)
  local opts = { noremap=true, silent=true, buffer=bufnr }
  -- Базовые действия
  vim.keymap.set("n", "gd", function() vim.lsp.buf.definition() end, opts)
  vim.keymap.set("n", "gD", function() vim.lsp.buf.declaration() end, opts)
  vim.keymap.set("n", "gi", function() vim.lsp.buf.implementation() end, opts)
  vim.keymap.set("n", "gr", function() vim.lsp.buf.references() end, opts)
  vim.keymap.set("n", "K", function() vim.lsp.buf.hover() end, opts)
end

local capabilities = vim.lsp.protocol.make_client_capabilities()

-- Rust
lspconfig.rust_analyzer.setup({
  on_attach = on_attach,
  capabilities = capabilities,
  settings = {
    ["rust-analyzer"] = {
      cargo = { allFeatures = true },
      checkOnSave = { command = "clippy" },
    }
  }
})

-- Go
lspconfig.gopls.setup({
  on_attach = on_attach,
  capabilities = capabilities,
  settings = {
    gopls = {
      analyses = { unusedparams = true, nilness = true },
      staticcheck = true,
    }
  }
})
EOF

Подключим модуль в init.lua. Добавьте строку require("plugins.lsp") после setup lazy или включите как конфигурацию плагинов. Простой вариант — в конец init.lua:

echo 'require("plugins.lsp")' >> ~/.config/nvim/init.lua

Автокомплит: nvim-cmp

Добавим конфигурацию автокомплита. Создадим файл:

cat > ~/.config/nvim/lua/plugins/cmp.lua <<'EOF'
local cmp = require("cmp")
local luasnip = require("luasnip")

require("luasnip.loaders.from_vscode").lazy_load()

cmp.setup({
  snippet = {
    expand = function(args)
      luasnip.lsp_expand(args.body)
    end,
  },
  mapping = {
    ["<C-Space>"] = cmp.mapping.complete(),
    ["<CR>"] = cmp.mapping.confirm({ select = true }),
    ["<Tab>"] = cmp.mapping(function(fallback)
      if cmp.visible() then
        cmp.select_next_item()
      elseif luasnip.expand_or_jumpable() then
        luasnip.expand_or_jump()
      else
        fallback()
      end
    end, { "i", "s" }),
    ["<S-Tab>"] = cmp.mapping(function(fallback)
      if cmp.visible() then
        cmp.select_prev_item()
      elseif luasnip.jumpable(-1) then
        luasnip.jump(-1)
      else
        fallback()
      end
    end, { "i", "s" }),
  },
  sources = {
    { name = "nvim_lsp" },
    { name = "luasnip" },
  },
})
EOF

Подключим в init.lua:

echo 'require("plugins.cmp")' >> ~/.config/nvim/init.lua

Перезапустите Neovim. Откройте файл .rs или .go и проверьте всплытие подсказок после ввода.

Форматирование: null-ls (опционально) и внешние tools

Для Rust обычно используют rustfmt, для Go — gofmt. В Termux это чаще всего уже присутствует через toolchain.

Простейший рабочий подход: вызывать форматтеры руками или через автокоманду. Если хотите автоматизацию, можно использовать null-ls.nvim (через LSP-обертки) или автокоманды Neovim.

Минимальный вариант без сложной обвязки — настроить горячую клавишу на форматирование. Например, вызвать:

:lua vim.lsp.buf.format({async=true})

Однако фактическая поддержка зависит от того, как LSP-источник реализует formatting.

Отладка: nvim-dap для Rust и Go

Отладка в Termux — самая чувствительная часть: DAP работает с дебаггерами, а под Android/Termux доступны не все варианты так же, как на desktop Linux. Тем не менее часто удаётся собрать рабочий сценарий.

Общий принцип:

• у Neovim есть клиент DAP (nvim-dap)
• нужен адаптер, который умеет подключаться к соответствующему дебаггеру
• для Rust обычно применяют LLDB или GDB (в зависимости от доступности)
• для Go — стандартно Delve (но его сборка/работа в Termux может потребовать настройки)

Установка nvim-dap конфигураций

Создадим конфигурационный файл для DAP:

cat > ~/.config/nvim/lua/plugins/dap.lua <<'EOF'
local dap = require("dap")

-- Пример-скелет: реальные параметры зависят от доступного дебаггера/адаптера в вашем Termux.
-- Rust (пример с lldb/gdb) — проверьте наличие нужного бинарника.
dap.configurations.rust = {
  {
    name = "Debug Rust (Termux)",
    type = "lldb",
    request = "launch",
    program = function()
      return vim.fn.input("Path to executable: ", vim.fn.getcwd() .. "/", "file")
    end,
    cwd = "${workspaceFolder}",
    stopOnEntry = false,
  },
}

-- Go: часто используют delve (адаптер типа "delve"). Точная связка зависит от установленного инструмента.
dap.configurations.go = {
  {
    name = "Debug Go (Termux)",
    type = "delve",
    request = "launch",
    program = function()
      return vim.fn.input("Path to executable: ", vim.fn.getcwd() .. "/", "file")
    end,
    cwd = "${workspaceFolder}",
  },
}
EOF

Подключим:

echo 'require("plugins.dap")' >> ~/.config/nvim/init.lua

Важно: приведённая конфигурация является каркасом. Для реальной отладки нужно, чтобы в Termux существовали и соответствующие DAP‑адаптеры, и дебаггеры. Поэтому следующий шаг — проверить доступность:

which lldb

which gdb

which dlv

Сборка проектов под отладку

Для корректной отладки включайте отладочную сборку:

Rust:

cargo build

Это обычно даёт отладочные символы для dev-профиля. Если нужен релиз с отладкой:

cargo build --release

При необходимости добавляйте параметры профиля в Cargo.toml.

Go:

go build -gcflags="all=-N -l" -o ./bin/app ./cmd/app

Дальше в DAP указываете путь к скомпилированному бинарнику.

Проверка интеграции: быстрый чек‑лист

• Neovim запускается в Termux без ошибок Lua
• LSP подключается: для Rust — rust-analyzer, для Go — gopls
• Автокомплит появляется после ввода (источник nvim_lsp)
• Клавиши gd, K, gr работают на символах
• Отладка: DAP не падает, дебаггер найден в системе, программа корректно загружается

Типовые проблемы и решения

1) LSP не стартует

• Проверьте, что сервер доступен через PATH: which rust-analyzer, which gopls
• Для Go часто забывают добавить $(go env GOPATH)/bin в PATH

2) Нет автокомплита

• Убедитесь, что источники nvim_lsp и luasnip подключены
• Проверьте, что LSP реально поднят (иначе nvim-cmp не сможет брать подсказки от LSP)

3) Отладка не работает

• Проверьте наличие дебаггера (lldb/gdb) и адаптера DAP (если требуется отдельный пакет)
• Уточните тип конфигурации (type) в dap.configurations под ваш адаптер

Практическая рекомендация по рабочему профилю

Для комфортной работы в Termux старайтесь держать:

• короткие команды для сборки и форматирования
• одинаковую структуру проектов (например, cmd/ для Go)
• сборку отладочных бинарников в предсказуемую папку (например, ./bin)

Тогда при запуске DAP вам проще выбирать файл.

Заключение

Мы собрали рабочий контур для разработки в Termux: Neovim с LSP (Rust и Go), автокомплитом через nvim-cmp, возможностью форматирования и подготовкой к отладке через nvim-dap. Учитывайте, что отладка в Termux зависит от доступных дебаггеров и DAP‑адаптеров, поэтому конфигурация может потребовать подгонки под вашу конкретную среду.

Если хотите, чтобы настройка была сделана «под ключ» (включая подбор работающих DAP‑адаптеров под Rust/Go именно для вашего Termux‑окружения), обращайтесь в РыбинскЛАБ — поможем с интеграцией и стабилизацией разработки.