---
title: "Rust-analyzer: LSP do Rust no VS Code e Neovim | Rust Brasil"
url: "https://rustlang.com.br/ecossistema/rust-analyzer/"
markdown_url: "https://rustlang.com.br/ecossistema/rust-analyzer.MD"
description: "Guia de rust-analyzer, o language server oficial do Rust: instalação no VS Code, Neovim, config com rust-analyzer.toml, recursos e correção de problemas."
date: "2026-10-08"
author: ""
---

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

Guia de rust-analyzer, o language server oficial do Rust: instalação no VS Code, Neovim, config com rust-analyzer.toml, recursos e correção de problemas.


**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

| Sua tarefa | Como fazer | Atenção |
|---|---|---|
| Configurar VS Code para Rust | Extensão `rust-lang.rust-analyzer` | Instale também o conjunto de *Snippets* de teste só se quiser |
| Fixar o servidor via rustup | `rustup component add rust-analyzer` | No settings.json, aponte `rust-analyzer.server.path` para o binário |
| Configurar projeto (features, targets, lints) | Arquivo `rust-analyzer.toml` na raiz | Complementa, não substitui o `Cargo.toml` |
| Ver logs do servidor | Painel *Output* → *rust-analyzer* (VS Code) | `:LspLog` no Neovim |
| Reiniciar a análise | *Command Palette* → "rust-analyzer: Restart server" | Resolve a maioria dos diagnósticos travados |
| Desativar salvamento automático de *cargo check* | `checkOnSave: false` no `rust-analyzer.toml` | Economiza CPU em máquinas fracas |

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](#rust-analyzer-vs-code-passo-a-passo) e [Neovim](#rust-analyzer-no-neovim). Ele complementa os guias de [Cargo](/ecossistema/cargo/), [Clippy](/ecossistema/clippy/) e [Rustfmt](/ecossistema/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):

```bash
# 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:

```json
{
  "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](/instalacao/windows/), no [WSL](/instalacao/wsl/) e no [macOS](/instalacao/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](/instalacao/neovim/) traz a configuração passo a passo com autocompletion, `nvim-dap` e Telescope; o essencial é:

```lua
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:

```toml
# 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:

| Problema | Configuração | Efeito |
|---|---|---|
| CPU alta em notebooks | `checkOnSave = false` | Roda check só sob demanda |
| Projeto gigante lento para indexar | `cargo.buildScripts.enable = true` + manter `check` só no pacote aberto | Reduz re-análises |
| Hints poluindo a tela | `inlayHints.parameterHints.enable = false` | Menos texto fantasma |
| Warnings do Clippy no editor | `check.command = "clippy"` | Mesma regra do CI (`cargo clippy -- -D warnings`) |

Se o time já usa Clippy no CI — como recomendado no [guia do Clippy](/ecossistema/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.

| Editor | Custo | Pontos fortes | Para quem |
|---|---|---|---|
| VS Code + rust-analyzer | Gratuito | Padrão do ecossistema, setup em 2 minutos, extensões | Maioria dos desenvolvedores |
| RustRover (JetBrains) | Gratuito (não comercial) / pago | Debugger integrado, refatorações pesadas, suporte a `Cargo.toml` e Docker | Quem vem de IntelliJ/PyCharm |
| Neovim + rust-analyzer | Gratuito | Terminal, leve, `nvim-dap` para debug | Usuários avançados de terminal |
| Zed / Helix | Gratuito | Performance, rust-analyzer embutido | Quem prioriza velocidade de editor |
| Emacs + eglot | Gratuito | Integração total ao fluxo Emacs | Usuários de longa data |

Para quem está começando, o caminho mais curto é [instalar o Rust](/instalacao/) e usar VS Code com a extensão oficial; os [primeiros passos com a linguagem](/tutoriais/primeiros-passos/) 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:

```toml
# 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](/carreira/transicao-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](/carreira/entrevistas-tecnicas/): ninguém perde mais tempo compilando para descobrir um erro de tipo.

Para continuar, veja o guia de [como aprender Rust em 2026](/blog/como-aprender-rust-2026/), os [projetos práticos](/projetos/) para exercitar o que o editor sugere e as [vagas Rust](/vagas/) abertas no Brasil.