---
title: "E0412: Tipo Não Encontrado no Rust"
url: "https://rustlang.com.br/erros/e0412-tipo-nao-encontrado/"
markdown_url: "https://rustlang.com.br/erros/e0412-tipo-nao-encontrado.MD"
description: "Como resolver o erro E0412 do Rust: tipo não encontrado no escopo atual. Veja as causas comuns como imports faltando, typos, dependências ausentes e soluções."
date: "2026-02-23"
author: "Equipe Rust Brasil"
---

# E0412: Tipo Não Encontrado no Rust

Como resolver o erro E0412 do Rust: tipo não encontrado no escopo atual. Veja as causas comuns como imports faltando, typos, dependências ausentes e soluções.


# E0412: Tipo Não Encontrado

O erro **E0412** ocorre quando você usa um nome de tipo que o compilador não consegue encontrar no escopo atual. As causas mais comuns são: import (`use`) faltando, erro de digitação, dependência não adicionada ao `Cargo.toml`, ou o tipo está definido em outro módulo.

## A Mensagem de Erro

```
error[E0412]: cannot find type `HashMap` in this scope
 --> src/main.rs:2:16
  |
2 |     let mapa: HashMap<String, i32> = HashMap::new();
  |               ^^^^^^^ not found in this scope
  |
help: consider importing this struct
  |
1 + use std::collections::HashMap;
  |
```

Variação com tipo de crate externo:

```
error[E0412]: cannot find type `Regex` in this scope
 --> src/main.rs:3:16
  |
3 |     let re: Regex = Regex::new(r"\d+").unwrap();
  |             ^^^^^ not found in this scope
```

## O Que Significa

O Rust usa um sistema de módulos explícito. Diferente de algumas linguagens onde tudo está disponível globalmente, no Rust você precisa **importar** tipos antes de usá-los. O compilador não encontrou o tipo porque:

1. **Falta o `use`** — Você esqueceu de importar o tipo
2. **Typo** — Erro de digitação no nome do tipo
3. **Dependência ausente** — O crate não está no `Cargo.toml`
4. **Módulo não declarado** — O módulo onde o tipo está definido não foi declarado
5. **Feature flag** — O tipo requer uma feature que não está ativada
6. **Visibilidade** — O tipo é privado (`pub` não declarado)

## Código com Erro

```rust
fn main() {
    // ERRO: HashMap não está no escopo
    let mut mapa: HashMap<String, i32> = HashMap::new();
    mapa.insert("chave".to_string(), 42);
}
```

```rust
// ERRO: typo — "Stirng" em vez de "String"
fn processar(texto: Stirng) {
    println!("{}", texto);
}
```

```rust
// ERRO: Regex não está disponível sem o crate `regex`
fn validar(email: &str) -> bool {
    let re = Regex::new(r"^[\w.-]+@[\w.-]+\.\w+$").unwrap();
    re.is_match(email)
}
```

## Como Resolver

### Solução 1: Adicionar o Import (`use`)

A solução mais comum — importe o tipo necessário:

```rust
use std::collections::HashMap;

fn main() {
    let mut mapa: HashMap<String, i32> = HashMap::new();
    mapa.insert("chave".to_string(), 42);
    println!("{:?}", mapa);
}
```

Imports comuns da biblioteca padrão:

```rust
use std::collections::{HashMap, HashSet, BTreeMap, VecDeque};
use std::io::{self, Read, Write, BufReader, BufWriter};
use std::fs::{self, File};
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex, RwLock};
use std::cell::{Cell, RefCell};
use std::fmt::{self, Display, Formatter};
```

### Solução 2: Corrigir Erros de Digitação

O compilador frequentemente sugere o tipo correto:

```
error[E0412]: cannot find type `Stirng` in this scope
 --> src/main.rs:1:20
  |
1 | fn processar(texto: Stirng) {
  |                     ^^^^^^ help: a struct with a similar name exists: `String`
```

```rust
// Corrigido: String com grafia correta
fn processar(texto: String) {
    println!("{}", texto);
}
```

### Solução 3: Adicionar Dependência ao Cargo.toml

Para tipos de crates externos, adicione a dependência:

```bash
cargo add regex
```

Ou edite `Cargo.toml` manualmente:

```toml
[dependencies]
regex = "1"
serde = { version = "1", features = ["derive"] }
tokio = { version = "1", features = ["full"] }
```

Depois importe:

```rust
use regex::Regex;

fn validar(email: &str) -> bool {
    let re = Regex::new(r"^[\w.-]+@[\w.-]+\.\w+$").unwrap();
    re.is_match(email)
}
```

### Solução 4: Declarar Módulos Corretamente

Se o tipo está em outro arquivo do seu projeto:

```
src/
├── main.rs
├── modelos/
│   ├── mod.rs
│   └── usuario.rs
```

```rust
// src/modelos/usuario.rs
pub struct Usuario {
    pub nome: String,
    pub email: String,
}

// src/modelos/mod.rs
pub mod usuario;

// src/main.rs
mod modelos;
use modelos::usuario::Usuario;

fn main() {
    let u = Usuario {
        nome: "Alice".to_string(),
        email: "alice@email.com".to_string(),
    };
}
```

### Solução 5: Ativar Feature Flags

Alguns tipos só estão disponíveis com features específicas:

```toml
# Cargo.toml
[dependencies]
serde = { version = "1", features = ["derive"] }
tokio = { version = "1", features = ["rt-multi-thread", "macros"] }
```

```rust
// Só disponível com feature "derive"
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct Config {
    porta: u16,
    host: String,
}
```

### Solução 6: Usar Caminho Completo sem Import

Você pode usar o caminho completo (fully qualified path) em vez de `use`:

```rust
fn main() {
    let mut mapa = std::collections::HashMap::new();
    mapa.insert("chave", 42);
}
```

Útil quando há conflito de nomes ou para uso esporádico.

## Dica: rust-analyzer

Se você usa um editor com **rust-analyzer** (VS Code, Neovim, etc.), ele pode adicionar imports automaticamente. Ao digitar o nome de um tipo, o autocompletar sugere e insere o `use` necessário.

## Veja Também

- [Cargo: Unresolved Import](/erros/cargo-unresolved-import/)
- [Cargo: Feature Not Found](/erros/cargo-feature-not-found/)
- [E0308: Tipos Incompatíveis](/erros/e0308-tipos-incompativeis/)
- [Cheatsheet Rust](/cheatsheet/)
- [Documentação oficial: E0412](https://doc.rust-lang.org/error_codes/E0412.html)