Écosystème et outils Rust¶

L'écosystème outillage de Rust est l'un des plus complets de l'industrie pour un langage système. Le gestionnaire de toolchains rustup, le linter Clippy, le formateur rustfmt et l'analyseur statique cargo-audit sont installes avec la toolchain standard et couvrent la majorité des besoins d'un projet en production.

Gestion des toolchains avec rustup¶

rustup est le gestionnaire de versions de Rust. Il permet d'installer et de basculer entre différentes toolchains (stable, beta, nightly) et de gérer les cibles de compilation.

# Installation de rustup (Linux / macOS)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Composants installes par defaut
# rustc     — le compilateur
# cargo     — le gestionnaire de paquets et de build
# rustup    — le gestionnaire de toolchains
# rustfmt   — le formateur
# clippy    — le linter

# Gestion des toolchains
rustup show                        # Toolchain active et installee
rustup update                      # Mettre a jour toutes les toolchains
rustup toolchain install nightly   # Installer nightly
rustup default stable              # Definir la toolchain par defaut

# Surcharge par projet — fichier rust-toolchain.toml
# Rustup lira ce fichier et utilisera la version specifiee

# rust-toolchain.toml — fixe la toolchain pour le projet
[toolchain]
channel    = "stable"
date       = "2025-01-01"   # Optionnel : fixe la date exacte
components = ["rustfmt", "clippy", "rust-analyzer"]
targets    = [
    "x86_64-unknown-linux-musl",
    "aarch64-unknown-linux-gnu",
    "wasm32-unknown-unknown",
]

# Gestion des cibles
rustup target add wasm32-unknown-unknown
rustup target add aarch64-unknown-linux-gnu
rustup target list --installed

# Composants optionnels
rustup component add rust-src          # Sources de la stdlib (pour rust-analyzer)
rustup component add rust-docs         # Documentation locale
rustup component add llvm-tools        # Pour cargo-llvm-cov

IDEs et éditeurs¶

VS Code + rust-analyzer¶

rust-analyzer est le serveur LSP officiel de Rust. Il fournit la completion, les diagnostics en temps réel, le refactoring et l'inlay hints.

// .vscode/settings.json — configuration recommandee pour un projet Rust
{
    "rust-analyzer.cargo.features": "all",
    "rust-analyzer.checkOnSave": true,
    "rust-analyzer.checkOnSave.command": "clippy",  // Clippy au lieu de check
    "rust-analyzer.inlayHints.typeHints.enable": true,
    "rust-analyzer.inlayHints.parameterHints.enable": true,
    "rust-analyzer.lens.enable": true,  // Boutons Run/Debug au-dessus des tests
    "editor.formatOnSave": true,
    "[rust]": {
        "editor.defaultFormatter": "rust-lang.rust-analyzer"
    }
}

Extensions VS Code recommandees :

Extension	Rôle
rust-lang.rust-analyzer	LSP officiel — completion, diagnostics, refactoring
vadimcn.vscode-lldb	Debugger LLDB (CodeLLDB) — breakpoints, step
tamasfe.even-better-toml	Syntax highlighting et validation de Cargo.toml
serayuzgur.crates	Versions des dépendances dans Cargo.toml

RustRover¶

RustRover est l'IDE JetBrains dédié a Rust. Il intégré nativement rust-analyzer, un debugger LLDB et des outils de profiling.

# Installation via JetBrains Toolbox (recommande)
# https://www.jetbrains.com/toolbox-app/

# Fonctionnalites notables :
# - Debug visuel avec breakpoints et inspection de l'ownership
# - Profiling integre (flamegraph, allocation sampling)
# - Support cargo workspace natif
# - Refactoring avance (rename, extract function, inline)

Formatage et linting¶

rustfmt¶

# Formater tout le projet
cargo fmt

# Verifier sans modifier (CI)
cargo fmt -- --check

# Formater un fichier specifique
rustfmt src/main.rs

# rustfmt.toml — configuration avancee
edition                  = "2024"
max_width                = 100
tab_spaces               = 4
newline_style            = "Unix"
imports_granularity      = "Crate"
group_imports            = "StdExternalCrate"
use_field_init_shorthand = true
use_try_shorthand        = true   # foo? plutot que try!(foo)

Clippy — lint groups¶

// src/lib.rs ou src/main.rs — activation des groupes de lints

// Niveau minimal recommande pour tout projet
#![warn(clippy::all)]

// Niveau pedantique — idiomes avances
#![warn(clippy::pedantic)]

// Lints de performance — allocations evitables
#![warn(clippy::perf)]

// Desactiver un lint specifique quand c'est justifie
#[allow(clippy::too_many_arguments)]  // Justification requise en commentaire
pub fn fonction_avec_beaucoup_de_params(/* ... */) {}

# Lancer Clippy sur tout le workspace
cargo clippy --workspace --all-targets --all-features

# Clippy avec tous les lints pedantiques
cargo clippy -- -W clippy::pedantic

# Afficher les lints disponibles
cargo clippy -- -W clippy::all -W clippy::pedantic 2>&1 | grep "warning\["

Groupes de lints Clippy :

Groupe	Description	Recommandation
`correctness`	Bugs probables — active par défaut, erreurs compilation	Toujours actif
`style`	Style et lisibilite	Toujours actif
`perf`	Optimisations d'allocation et de performance	Recommande
`pedantic`	Idiomes avances, parfois strict	Projets serieux
`nursery`	Lints experimentaux, peuvent changer	Optionnel
`restriction`	Lints opiniones (p.ex. interdire `unwrap`)	Sur besoin

Analyse statique et sécurité¶

cargo-audit¶

# Installer cargo-audit
cargo install cargo-audit

# Verifier les vulnerabilites connues dans les dependances
cargo audit

# Rapport au format JSON
cargo audit --json

# Integrer dans CI — echoue si CVE detectee
cargo audit --deny warnings

cargo-deny¶

cargo install cargo-deny
cargo deny init     # Cree deny.toml
cargo deny check    # Verifie licences, CVE, doublons de dependances

# deny.toml — configuration
[licenses]
allow = ["MIT", "Apache-2.0", "BSD-2-Clause", "BSD-3-Clause", "ISC", "Unicode-DFS-2016"]
deny  = ["GPL-3.0"]  # Rejeter les licences copyleft

[advisories]
db-path    = "~/.cargo/advisory-db"
db-urls    = ["https://github.com/rustsec/advisory-db"]
vulnerability = "deny"
unmaintained  = "warn"

[bans]
multiple-versions = "warn"   # Avertir si une dependance est presente en plusieurs versions

Miri — détection de comportement indefini¶

Miri est un interpréteur pour le MIR (Mid-level Intermediate Représentation) de Rust. Il détecté les comportements indefinis dans le code unsafe.

# Installation via rustup (necessite nightly)
rustup +nightly component add miri

# Lancer les tests sous Miri
cargo +nightly miri test

# Verifier un binaire
cargo +nightly miri run

Miri et le code unsafe

Miri détecté les use-after-free, les alignements incorrects, les lectures de mémoire non initialisee et les violations de l'aliasing model de Rust (Stacked Borrows). Il est indispensable pour tout crate qui expose du code unsafe. La couverture n'est pas totale : Miri ne peut pas simuler les syscalls système ni les interactions avec des bibliotheques C natives.

Debuggers¶

VS Code + CodeLLDB¶

// .vscode/launch.json — configuration de debug
{
    "version": "0.2.0",
    "configurations": [
        {
            "type": "lldb",
            "request": "launch",
            "name": "Debug mon-service",
            "cargo": {
                "args": ["build", "--bin=mon-service"],
                "filter": { "name": "mon-service", "kind": "bin" }
            },
            "args": [],
            "cwd": "${workspaceFolder}",
            "env": {
                "RUST_LOG": "debug",
                "DATABASE_URL": "sqlite::memory:"
            }
        },
        {
            "type": "lldb",
            "request": "launch",
            "name": "Debug tests",
            "cargo": {
                "args": ["test", "--no-run", "--lib"],
                "filter": { "name": "mon-service-lib", "kind": "lib" }
            },
            "args": []
        }
    ]
}

rust-gdb et rust-lldb¶

# rust-gdb — GDB avec pretty-printers pour les types Rust
rust-gdb target/debug/mon-service

# Commandes GDB utiles dans le contexte Rust
# b src/main.rs:42     — breakpoint sur la ligne 42
# p variable           — afficher une variable (avec pretty-print Rust)
# bt                   — backtrace
# n                    — next (pas a pas)
# c                    — continue

# rust-lldb — LLDB avec pretty-printers
rust-lldb target/debug/mon-service

Profilers¶

perf + flamegraph¶

# Installation flamegraph
cargo install flamegraph

# Generer un flamegraph (necessite perf sur Linux)
cargo flamegraph --bin mon-service

# Ouvrir flamegraph.svg dans le navigateur
# Les frames les plus larges = fonctions les plus couteuses en CPU

cargo-instruments (macOS uniquement)¶

# Installation
cargo install cargo-instruments

# Profiling CPU (Time Profiler)
cargo instruments --template "Time Profiler" --bin mon-service

# Profiling allocations
cargo instruments --template Allocations --bin mon-service

# Ouvre automatiquement Instruments.app

Dhat — profiling des allocations heap¶

# Cargo.toml — [dev-dependencies]
# dhat = "0.3"

# src/main.rs (uniquement en mode profiling)
#[cfg(feature = "profiling")]
#[global_allocator]
static ALLOC: dhat::Alloc = dhat::Alloc;

fn main() {
    #[cfg(feature = "profiling")]
    let _profiler = dhat::Profiler::new_heap();

    // ... code de l'application ...
}

# Lancer avec profiling heap
cargo run --features profiling

# Generer le rapport
# dhat-heap.json est genere a la sortie du programme
# Visualiser avec https://nnethercote.github.io/dh_view/dh_view.html

Outils cargo essentiels¶

Outil	Installation	Usage
cargo-watch	`cargo install cargo-watch`	Relance cargo à chaque modification de fichier
cargo-expand	`cargo install cargo-expand`	Développé les macros pour inspection
cargo-tree	Intégré dans cargo	Affiche le graphe de dépendances
cargo-outdated	`cargo install cargo-outdated`	Dépendances avec mises à jour disponibles
cargo-machete	`cargo install cargo-machete`	Détecté les dépendances inutilisees
cargo-bloat	`cargo install cargo-bloat`	Identifie les fonctions qui gonflent le binaire
cargo-udeps	`cargo install cargo-udeps`	Dépendances non utilisées (nightly requis)

# cargo-watch — developpement avec rechargement automatique
cargo watch -x "test -- --nocapture"
cargo watch -x "run"
cargo watch -x "clippy"

# cargo-expand — inspecter ce que les macros generate
cargo expand item  # Developpe le module item
cargo expand       # Developpe tout le crate

# cargo-bloat — identifier les gros contributeurs a la taille du binaire
cargo bloat --release --crates   # Par crate
cargo bloat --release -n 20      # Top 20 fonctions les plus lourdes

cargo-watch en développement

La combinaison cargo watch -x "clippy --all-targets" donne un feedback immédiat à chaque sauvegarde. Clippy intégré les diagnostics de cargo check — il n'est donc pas nécessaire de lancer les deux séparément. Sur un SSD moderne, le cycle edit-clippy prend moins d'une seconde pour les modifications locales grâce à la compilation incrementale.