El tooling diario: rustfmt, clippy y rust-analyzer

El compilador de Rust es exigente, pero no está solo. A su alrededor hay tres herramientas oficiales que convierten el ciclo de escritura en un diálogo constante: rustfmt decide el formato, clippy te enseña a escribir Rust idiomático, y rust-analyzer te da inteligencia semántica en vivo. No son adornos: son parte del lenguaje tal y como se usa de verdad.

rustfmt: se acabaron los debates de estilo

rustfmt es el formateador oficial. Aplica un estilo canónico y no negociable, de modo que ningún equipo vuelve a discutir dónde van las llaves:

cargo fmt            # formatea todo el paquete in situ
cargo fmt --check    # no toca nada; falla si algo está sin formatear (ideal para CI)

Se puede afinar con un rustfmt.toml en la raíz, aunque la recomendación es tocar lo mínimo:

max_width = 100
edition = "2024"

El valor real no es la estética: es que el formato deja de ser una decisión. El diff de un commit muestra solo cambios de lógica, nunca de espaciado.

clippy: un profesor de Rust idiomático

clippy es el linter oficial, con más de 700 lints organizados por categorías: correctness (errores reales), style, complexity, perf, y el grupo pedantic que se activa aparte. Su verdadero valor no es cazar bugs, sino enseñarte a escribir como un rustáceo:

// Lo que escribe quien viene de otro lenguaje:
let mut cuadrados = Vec::new();
for x in &numeros {
    cuadrados.push(x * x);
}

// Lo que clippy te sugiere: expresa la intención, no el bucle.
let cuadrados: Vec<_> = numeros.iter().map(|x| x * x).collect();

cargo clippy                 # analiza y sugiere
cargo clippy --fix           # aplica las correcciones automáticas
cargo clippy -- -D warnings  # en CI: cualquier lint es un error

Puedes silenciar un lint concreto con #[allow(clippy::nombre_del_lint)] cuando de verdad sabes lo que haces, pero la actitud sana es leer cada sugerencia como una lección.

Los grupos de lints se controlan a nivel de crate. Muchos proyectos suben el listón encendiendo pedantic y prohibiendo patrones peligrosos:

#![warn(clippy::pedantic)]      // lints más estrictos, opcionales
#![deny(clippy::unwrap_used)]   // prohíbe unwrap fuera de tests

rust-analyzer: el cerebro en tu editor

rust-analyzer es el servidor LSP oficial. Corre en segundo plano y le da a cualquier editor —VS Code, Neovim, Helix, Emacs— inteligencia semántica de Rust en tiempo real:

Un ajuste que todo el mundo activa: que rust-analyzer use clippy al guardar, para tener sus lints en vivo dentro del editor.

{
  "rust-analyzer.check.command": "clippy"
}

rust-analyzer no es un editor ni un plugin: es un proceso aparte que habla el protocolo LSP, así que el mismo cerebro sirve a VS Code, Neovim o Helix sin cambiar de motor. Comparte además el modelo de cargo, por lo que sus tipos y errores coinciden con los del compilador en vez de ser una aproximación.

El bucle completo

Las tres herramientas, junto al compilador, forman un ciclo cerrado que gira mientras escribes:

flowchart LR
W[escribes codigo] --> A[rust-analyzer avisa en vivo]
A --> F[cargo fmt formatea]
F --> C[cargo clippy ensena idioms]
C --> W

Ese bucle se automatiza. Puedes definir un alias de cargo que encadene formato, lints y tests en una sola orden, y ejecutar exactamente lo mismo en tu máquina y en CI:

[alias]
lint = "clippy --all-targets --all-features -- -D warnings"
verifica = "!cargo fmt --check && cargo lint && cargo test"

cargo verifica   # formato + clippy estricto + tests, de un golpe

La regla de oro de un proyecto serio es que la CI corra cargo fmt --check y cargo clippy -- -D warnings: así ningún commit con formato torcido o con un lint sin resolver llega a la rama principal. Lo que en local es una ayuda, en CI es una garantía.