---
title: "Cargo: Could Not Compile — Como Resolver"
url: "https://rustlang.com.br/erros/cargo-could-not-compile/"
markdown_url: "https://rustlang.com.br/erros/cargo-could-not-compile.MD"
description: "Como resolver o erro 'could not compile' do Cargo no Rust. Aprenda a ler a saída de erros, identificar causas comuns e usar ferramentas de diagnóstico do compilador."
date: "2026-02-23"
author: "Equipe Rust Brasil"
---

# Cargo: Could Not Compile — Como Resolver

Como resolver o erro 'could not compile' do Cargo no Rust. Aprenda a ler a saída de erros, identificar causas comuns e usar ferramentas de diagnóstico do compilador.


# Cargo: Could Not Compile

A mensagem **"could not compile"** é o aviso final do Cargo de que a compilação falhou. Não é um erro em si, mas o resumo de que existem um ou mais erros no seu código que precisam ser resolvidos. A chave está em ler as mensagens **acima** desta linha.

## A Mensagem de Erro

```
error: could not compile `meu-projeto` (bin "meu-projeto") due to 3 previous errors
```

Ou com warnings:

```
error: could not compile `meu-projeto` (bin "meu-projeto") due to 2 previous errors; 5 warnings emitted
```

## O Que Significa

Esta mensagem é apenas o **resumo** do processo de compilação. O Cargo tentou compilar seu projeto e encontrou erros que impedem a geração do binário. Os erros reais estão nas mensagens anteriores na saída do terminal.

O número de erros indicado ("due to 3 previous errors") nem sempre é exato — um único problema pode causar erros em cascata. É recomendado **resolver o primeiro erro** e recompilar, pois frequentemente os erros subsequentes desaparecem.

## Como Ler os Erros do Compilador

O Rust tem uma das melhores saídas de erro de todas as linguagens. Vamos dissecar a anatomia:

```
error[E0382]: borrow of moved value: `nome`
 --> src/main.rs:4:20
  |
2 |     let nome = String::from("Rust");
  |         ---- move occurs because `nome` has type `String`
3 |     let outro = nome;
  |                 ---- value moved here
4 |     println!("{}", nome);
  |                    ^^^^ value borrowed here after move
  |
help: consider cloning the value if the performance cost is acceptable
  |
3 |     let outro = nome.clone();
  |                     ++++++++

error: could not compile `meu-projeto` (bin "meu-projeto") due to 1 previous error
```

Cada parte da mensagem:

1. **`error[E0382]`** — Nível (error/warning) e código do erro
2. **`borrow of moved value`** — Descrição curta do problema
3. **`--> src/main.rs:4:20`** — Arquivo, linha e coluna
4. **Linhas com `|`** — Contexto do código com anotações
5. **`help:`** — Sugestão de correção do compilador

## Causas Comuns e Soluções

### Causa 1: Erros de Sintaxe

```
error: expected `;`, found `}`
 --> src/main.rs:3:5
  |
2 |     let x = 5
  |              - expected `;` here
3 | }
  | ^ unexpected token
```

**Solução:** Adicione o ponto e vírgula faltando.

### Causa 2: Dependência Não Compilando

```
error[E0433]: failed to resolve: use of undeclared crate or module `serde`
```

**Solução:** Verifique o `Cargo.toml`:

```bash
cargo add serde
```

### Causa 3: Versão do Rust Incompatível

```
error: `let...else` statements are not yet stable
```

**Solução:** Atualize o Rust:

```bash
rustup update stable
```

### Causa 4: Erros em Cascata

Um único erro pode causar dezenas de erros subsequentes. Sempre **resolva o primeiro erro** antes de se preocupar com os demais.

## Ferramentas de Diagnóstico

### `cargo check` — Verificação Rápida

Mais rápido que `cargo build` pois não gera o binário final:

```bash
cargo check
```

### `rustc --explain EXXXX` — Explicação Detalhada

Cada erro numerado tem uma explicação completa:

```bash
rustc --explain E0382
```

### `RUST_BACKTRACE=1` — Backtrace Completo

Para erros de runtime (panics):

```bash
RUST_BACKTRACE=1 cargo run
```

### `cargo clippy` — Análise Estática

Encontra problemas além dos erros de compilação:

```bash
cargo clippy
```

### `cargo build --message-format=json` — Saída em JSON

Útil para integração com editores e ferramentas:

```bash
cargo build --message-format=json 2>&1 | head -20
```

## Estratégia para Resolver Erros

1. **Leia o primeiro erro** — Ignore temporariamente os demais
2. **Olhe o código indicado** — A seta `-->` mostra exatamente onde
3. **Leia a sugestão `help:`** — O compilador frequentemente dá a resposta
4. **Use `rustc --explain`** — Para entender melhor o erro
5. **Resolva e recompile** — Muitos erros subsequentes desaparecerão
6. **Repita** até compilar

## Dicas Importantes

### Compile Frequentemente

Não espere escrever centenas de linhas para compilar. Compile a cada mudança significativa:

```bash
# Instale cargo-watch para compilação automática
cargo install cargo-watch
cargo watch -x check
```

### Use um Editor com rust-analyzer

O **rust-analyzer** mostra erros em tempo real no editor, antes mesmo de salvar o arquivo. Funciona com VS Code, Neovim, Emacs e outros.

### Leia as Warnings Também

Warnings não impedem a compilação, mas indicam problemas potenciais:

```bash
# Tratar warnings como erros
RUSTFLAGS="-D warnings" cargo build
```

## Veja Também

- [Cargo: Unresolved Import](/erros/cargo-unresolved-import/)
- [Cargo: Feature Not Found](/erros/cargo-feature-not-found/)
- [E0382: Uso de Valor Após Move](/erros/e0382-uso-apos-move/)
- [E0308: Tipos Incompatíveis](/erros/e0308-tipos-incompativeis/)
- [Cheatsheet Rust](/cheatsheet/)