Rust-analyzer: LSP do Rust no VS Code e Neovim | Rust Brasil

rust-analyzer é o language server oficial do Rust: ele fornece autocomplete, navegação, diagnósticos, refatorações e documentação no hover para VS Code, Neovim, Zed, Helix, Emacs e qualquer editor compatível com LSP. No VS Code, basta instalar a extensão oficial rust-lang.rust-analyzer — o binário do servidor é baixado automaticamente. Em servidores ou para fixar versão, use rustup component add rust-analyzer. A configuração fica em rust-analyzer.toml na raiz do projeto.

rust-analyzer: o que usar em cada situação

Quem pesquisa rust-analyzer normalmente quer resolver um problema imediato: configurar o editor, entender por que o autocomplete não aparece ou ajustar o comportamento em um workspace grande. Este guia cobre instalação em cada editor, configuração recomendada, recursos que valem a pena dominar e os problemas mais comuns — com foco em VS Code e Neovim. Ele complementa os guias de Cargo, Clippy e Rustfmt, que cuidam de build, lints e formatação.

O que o rust-analyzer faz

O rust-analyzer implementa o Language Server Protocol (LSP) para Rust. O editor conversa com o servidor por mensagens; o servidor mantém uma análise incremental do projeto inteiro e responde com:

• Autocomplete com tipos: sugere métodos, campos e funções respeitando o borrow checker e os traits em escopo, mostrando o tipo de cada expressão.
• Navegação: go to definition, find all references, rename seguro em todo o workspace.
• Diagnósticos: erros e warnings enquanto você digita (cargo check rodando em background), com correções rápidas via CodeLens — inclusive clippy::pedantic quando ativado.
• Hints inline: tipos inferidos, nomes de parâmetros e mutabilidade exibidos como texto fantasma no editor.
• Assistências (snippets): adicionar derive, gerar impl, importar item, converter if let em match, gerar funções a partir de chamadas.
• Execução de testes: CodeLens “Run” e “Debug” sobre cada #[test].

Por ser o servidor usado por praticamente todos os editores, dominar a configuração do rust-analyzer transfere de VS Code para Neovim, Zed, Helix e Emacs sem retrabalho.

Instalação

rust-analyzer VS Code: passo a passo

1. Abra a aba de extensões do VS Code (Ctrl+Shift+X).
2. Pesquise rust-analyzer e instale a extensão oficial rust-lang.rust-analyzer.
3. Abra a pasta do projeto — a que contém o Cargo.toml — e aguarde a primeira indexação. Um pêndulo com “rust-analyzer” aparece na barra de status.

A extensão baixa o binário do servidor automaticamente na primeira execução e o atualiza junto com as releases. Para usar o binário do rustup (útil em ambientes sem acesso ao GitHub ou para casar servidor e toolchain):

# Instalar o componente na toolchain em uso
rustup component add rust-analyzer

# Confirmar onde o binário está
rustup which rust-analyzer

No settings.json do VS Code:

{
  "rust-analyzer.server.path": "~/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/bin/rust-analyzer"
}

Confira também o guia de instalação do Rust no Windows, no WSL e no macOS — a extensão do VS Code funciona nas três plataformas, e no WSL ela deve ser instalada dentro da sessão Remote - WSL.

rust-analyzer no Neovim

O Neovim consome o rust-analyzer via LSP nativo (vim.lsp.start) ou com nvim-lspconfig. O guia completo de Neovim para Rust traz a configuração passo a passo com autocompletion, nvim-dap e Telescope; o essencial é:

require'lspconfig'.rust_analyzer.setup{
  settings = {
    ['rust-analyzer'] = {
      check = { command = 'clippy' },
    },
  },
}

Zed e Helix já vêm com rust-analyzer embutido para arquivos Rust — nenhuma configuração extra é necessária. No Emacs, o eglot detecta o binário rust-analyzer no PATH.

Configuração recomendada com rust-analyzer.toml

Desde a versão 0.4.170+ do rust-analyzer, a configuração por projeto vive no arquivo rust-analyzer.toml na raiz do repositório (antes ficava em .vscode/settings.json). Um ponto de partida pragmático para projetos brasileiros típicos — backend com workspace e features:

# rust-analyzer.toml — na raiz do projeto
check.command = "clippy"        # diagnósticos usam clippy em vez de cargo check
cargo.features = "all"          # analisa todas as features (cuidado em libs com features incompatíveis)
cargo.allTargets = true         # inclui testes, exemplos e benches na análise
procMacro.enable = true         # macros procedurais (serde, tokio, sqlx)
hover.actions.enable = true
inlayHints.parameterHints.enable = true
inlayHints.typeHints.enable = true

Configurações que mais rendem em máquinas modestas:

Se o time já usa Clippy no CI — como recomendado no guia do Clippy — alinhar check.command = "clippy" faz o editor mostrar exatamente o que o pipeline reprova.

rust-analyzer, RustRover, Zed: qual IDE usar com Rust?

A pergunta “qual IDE para Rust” aparece em toda transição de carreira, e a resposta curta é: o editor que você já domina + rust-analyzer. A diferença real está no editor, não na análise — Zed, Neovim e VS Code usam o mesmo servidor.

Para quem está começando, o caminho mais curto é instalar o Rust e usar VS Code com a extensão oficial; os primeiros passos com a linguagem entram no próximo passo, com autocomplete e diagnósticos já funcionando.

Problemas comuns e correções

“rust-analyzer failed to load workspace” — quase sempre a pasta aberta no editor não é a que contém o Cargo.toml raiz, ou existe um Cargo.toml de exemplo dentro do workspace que não compila. Abra a pasta correta e, se necessário, exclua membros problemáticos:

# rust-analyzer.toml
workspace.discoverConfig = false # e liste os membros manualmente, se preciso

Autocomplete não aparece — confira rustup component add rust-analyzer, rustup show active-toolchain e se um rust-toolchain.toml no projeto não está apontando para uma toolchain sem o componente. Reinicie o servidor no Command Palette.

Erros falsos em macros (serde, sqlx) — ative procMacro.enable e buildScripts.enable; o servidor precisa executar as macros procedurais para entendê-las.

Alto consumo de memória em monorepos — reduza o escopo da análise com cargo.targetDir compartilhado, mantenha check.targets só no alvo principal e evite cargo.features = "all" em bibliotecas com features mutuamente exclusivas.

Servidor não atualiza após rustup update — a extensão do VS Code gerencia o binário próprio; use Command Palette → “rust-analyzer: Restart server” e, se persistir, atualize a extensão.

rust-analyzer e carreira

A configuração do editor é a primeira vitória de produtividade de quem está de transição para Rust: diagnósticos instantâneos e hints de tipo encurtam a curva com o borrow checker, porque o servidor explica o problema enquanto você escreve — não minutos depois, no cargo build. No trabalho do dia a dia, o mesmo conhecimento de LSP acompanha você entre VS Code, Neovim e Zed, e aparece como expectativa básica nas entrevistas técnicas de Rust: ninguém perde mais tempo compilando para descobrir um erro de tipo.

Para continuar, veja o guia de como aprender Rust em 2026, os projetos práticos para exercitar o que o editor sugere e as vagas Rust abertas no Brasil.