---
title: "Configurar VS Code para Rust"
url: "https://rustlang.com.br/instalacao/vscode/"
markdown_url: "https://rustlang.com.br/instalacao/vscode.MD"
description: "Guia completo para configurar VS Code para Rust com rust-analyzer, extensões essenciais, debugging, settings.json e tasks.json otimizados."
date: "2026-02-23"
author: "Equipe Rust Brasil"
---

# Configurar VS Code para Rust

Guia completo para configurar VS Code para Rust com rust-analyzer, extensões essenciais, debugging, settings.json e tasks.json otimizados.


O **Visual Studio Code** é o editor mais popular para desenvolvimento Rust, graças à extensão **rust-analyzer** que oferece autocompletar, verificação de tipos em tempo real, refatoração e debugging. Neste guia, vamos configurar o VS Code para uma experiência de desenvolvimento Rust de primeira classe.

## Pré-requisitos

Antes de configurar o VS Code, certifique-se de ter o Rust instalado. Veja o guia para seu sistema operacional:

- [Ubuntu](/instalacao/ubuntu/) | [Fedora](/instalacao/fedora/) | [Arch Linux](/instalacao/arch-linux/) | [Debian](/instalacao/debian/)
- [macOS](/instalacao/macos/) | [Windows](/instalacao/windows/) | [WSL](/instalacao/wsl/)

O [rustup](/instalacao/rustup/) deve estar instalado e funcionando:

```bash
rustc --version
cargo --version
```

## Instalar o VS Code

### Linux (Ubuntu/Debian)

```bash
sudo snap install code --classic
# ou via apt
wget -qO- https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > packages.microsoft.gpg
sudo install -o root -g root -m 644 packages.microsoft.gpg /usr/share/keyrings/
echo "deb [arch=amd64 signed-by=/usr/share/keyrings/packages.microsoft.gpg] https://packages.microsoft.com/repos/code stable main" | sudo tee /etc/apt/sources.list.d/vscode.list
sudo apt update && sudo apt install code
```

### macOS

```bash
brew install --cask visual-studio-code
```

### Windows

Baixe em [code.visualstudio.com](https://code.visualstudio.com/) ou via winget:

```powershell
winget install Microsoft.VisualStudioCode
```

## Extensões Essenciais

### rust-analyzer (Obrigatória)

A extensão mais importante para Rust:

```bash
code --install-extension rust-lang.rust-analyzer
```

O rust-analyzer fornece:

- **Autocompletar** inteligente com informações de tipo
- **Diagnósticos** em tempo real (erros e warnings)
- **Go to definition** e **Find references**
- **Inlay hints** (tipos inferidos exibidos inline)
- **Code actions** (refatoração automática)
- **Hover** com documentação

### CodeLLDB (Debugging)

Para debugging integrado:

```bash
code --install-extension vadimcn.vscode-lldb
```

### Extensões Recomendadas

```bash
# Melhor visualização de erros
code --install-extension usernamehw.errorlens

# Gerenciamento de crates no Cargo.toml
code --install-extension serayuzgur.crates

# TOML syntax highlighting
code --install-extension tamasfe.even-better-toml

# Git integrado (se não usa o built-in)
code --install-extension eamodio.gitlens
```

## Configurar settings.json

Abra as configurações do VS Code (`Ctrl+Shift+P` > "Open Settings JSON") e adicione:

```json
{
  // rust-analyzer
  "rust-analyzer.check.command": "clippy",
  "rust-analyzer.cargo.allFeatures": true,
  "rust-analyzer.inlayHints.typeHints.enable": true,
  "rust-analyzer.inlayHints.parameterHints.enable": true,
  "rust-analyzer.inlayHints.chainingHints.enable": true,
  "rust-analyzer.lens.enable": true,
  "rust-analyzer.lens.run.enable": true,
  "rust-analyzer.lens.debug.enable": true,
  "rust-analyzer.procMacro.enable": true,

  // Formatação automática ao salvar
  "[rust]": {
    "editor.defaultFormatter": "rust-lang.rust-analyzer",
    "editor.formatOnSave": true,
    "editor.rulers": [100]
  },

  // Terminal integrado
  "terminal.integrated.defaultProfile.linux": "bash",

  // Editor
  "editor.inlineSuggest.enabled": true,
  "editor.bracketPairColorization.enabled": true,
  "editor.guides.bracketPairs": "active"
}
```

### Usar Clippy em Vez de Check

A configuração `"rust-analyzer.check.command": "clippy"` faz o rust-analyzer executar `clippy` em vez de `cargo check`, mostrando sugestões de linting diretamente no editor.

## Configurar Debugging

### launch.json

Crie `.vscode/launch.json` no seu projeto:

```json
{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "lldb",
      "request": "launch",
      "name": "Debug executável",
      "cargo": {
        "args": ["build", "--bin=meu-app", "--package=meu-app"],
        "filter": {
          "name": "meu-app",
          "kind": "bin"
        }
      },
      "args": [],
      "cwd": "${workspaceFolder}"
    },
    {
      "type": "lldb",
      "request": "launch",
      "name": "Debug testes unitários",
      "cargo": {
        "args": ["test", "--no-run", "--bin=meu-app", "--package=meu-app"],
        "filter": {
          "name": "meu-app",
          "kind": "bin"
        }
      },
      "args": [],
      "cwd": "${workspaceFolder}"
    }
  ]
}
```

### Usar o Debugger

1. Coloque um **breakpoint** clicando na margem esquerda do editor
2. Pressione **F5** ou clique em **Run > Start Debugging**
3. Use a barra de debug para step over, step into, continue, etc.
4. Inspecione variáveis no painel **Variables**

## Configurar tasks.json

Crie `.vscode/tasks.json` para atalhos de build:

```json
{
  "version": "2.0.0",
  "tasks": [
    {
      "type": "cargo",
      "command": "build",
      "problemMatcher": ["$rustc"],
      "group": "build",
      "label": "cargo build"
    },
    {
      "type": "cargo",
      "command": "run",
      "problemMatcher": ["$rustc"],
      "label": "cargo run"
    },
    {
      "type": "cargo",
      "command": "test",
      "problemMatcher": ["$rustc"],
      "group": "test",
      "label": "cargo test"
    },
    {
      "type": "cargo",
      "command": "clippy",
      "problemMatcher": ["$rustc"],
      "label": "cargo clippy"
    },
    {
      "type": "shell",
      "command": "cargo watch -x run",
      "label": "cargo watch",
      "isBackground": true,
      "problemMatcher": []
    }
  ]
}
```

Use `Ctrl+Shift+B` para executar o build padrão ou `Ctrl+Shift+P` > "Run Task" para ver todas as tarefas.

## Atalhos Úteis

| Atalho | Ação |
|--------|------|
| `F12` | Ir para definição |
| `Ctrl+Click` | Ir para definição |
| `Shift+F12` | Encontrar referências |
| `F2` | Renomear símbolo |
| `Ctrl+.` | Code actions (quick fix) |
| `Ctrl+Space` | Autocompletar |
| `Ctrl+Shift+P` | Paleta de comandos |
| `F5` | Iniciar debugging |

## Workspace com Múltiplos Crates

Para projetos com workspaces do [Cargo](/instalacao/cargo/), o rust-analyzer já suporta nativamente. Adicione ao `settings.json`:

```json
{
  "rust-analyzer.linkedProjects": [
    "./Cargo.toml"
  ],
  "rust-analyzer.cargo.allTargets": true
}
```

## Solução de Problemas

### rust-analyzer não inicia ou mostra erros

Verifique se o Rust está instalado corretamente:

```bash
which rust-analyzer
rustup component add rust-analyzer
```

No VS Code, abra Output (`Ctrl+Shift+U`) e selecione "rust-analyzer" para ver logs de erro.

### Autocompletar lento em projetos grandes

Adicione ao `settings.json`:

```json
{
  "rust-analyzer.cargo.buildScripts.enable": true,
  "rust-analyzer.files.excludeDirs": ["target", "node_modules", ".git"]
}
```

### IntelliSense não funciona para macros procedurais

Habilite o suporte a proc macros:

```json
{
  "rust-analyzer.procMacro.enable": true,
  "rust-analyzer.procMacro.attributes.enable": true
}
```

## Próximos Passos

Com o VS Code configurado para Rust:

- Siga o tutorial de [Primeiros Passos com Rust](/tutoriais/primeiros-passos/)
- Consulte o [Cheatsheet Rust](/cheatsheet/) para referência rápida
- Configure [CI/CD com GitHub Actions](/instalacao/github-actions/)
- Aprenda sobre o [Guia Completo do Cargo](/instalacao/cargo/) para produtividade máxima
- Veja as [Perguntas Frequentes](/faq/) para dúvidas comuns

Se você também usa VS Code para Go, confira o [golang.com.br](https://golang.com.br) para dicas de configuração.

---

*Última atualização: 23 de fevereiro de 2026. Para uma alternativa ao VS Code, veja o [guia de Neovim para Rust](/instalacao/neovim/).*