Compiler, exécuter et vérifier son code

Le cycle de vie de base du développement Rust avec Cargo

Une fois que vous avez structuré votre projet Rust et commencé à écrire du code, le cycle itératif de compilation, d'exécution et de vérification devient central dans votre flux de travail. Cargo, l'outil de gestion de projet et de construction de Rust, simplifie grandement ces étapes grâce à une série de commandes intuitives. Comprendre comment et quand utiliser `cargo build`, `cargo run` et `cargo check` est essentiel pour développer efficacement en Rust, en tirant parti de la puissance du compilateur pour produire du code correct et performant.

Ces commandes sont vos principaux points d'interaction avec le compilateur Rust (`rustc`). Cargo agit comme une interface conviviale, orchestrant le processus de compilation, la gestion des dépendances, et l'exécution de votre programme. Maîtriser ce trio de commandes vous permettra de progresser rapidement, d'identifier les erreurs tôt et d'optimiser votre application pour différents environnements.

Ce chapitre explore en détail chacune de ces commandes, leurs options courantes et leur rôle dans le processus de développement, afin de vous rendre rapidement opérationnel et productif avec Rust.

Compiler avec `cargo build` : modes debug et release

La commande `cargo build` est votre principal outil pour transformer votre code source Rust en un programme exécutable ou une bibliothèque. Lorsque vous exécutez `cargo build` dans le répertoire racine de votre projet, Cargo invoque le compilateur Rust (`rustc`) avec les options appropriées, compile vos fichiers sources ainsi que toutes les dépendances nécessaires, et place les artéfacts résultants dans le répertoire `target/`.

Par défaut, `cargo build` compile votre projet en mode debug. Ce mode est optimisé pour la rapidité de compilation et l'expérience de débogage. Les binaires produits en mode debug contiennent des informations de débogage et ne sont pas soumis à des optimisations agressives. Cela signifie qu'ils se compilent plus vite, mais s'exécutent plus lentement et sont généralement plus volumineux. Les artéfacts de ce mode sont placés dans `target/debug/`.

# Compile le projet en mode debug (par défaut)
$ cargo build

Lorsque vous êtes prêt à distribuer votre application ou à mesurer ses performances réelles, vous devez compiler en mode release. Pour cela, utilisez l'option `--release` :

# Compile le projet en mode release avec optimisations
$ cargo build --release

Le mode release active des optimisations poussées du compilateur. Cela se traduit par un temps de compilation plus long, mais produit un exécutable beaucoup plus rapide et généralement plus petit, optimisé pour la performance. Les artéfacts du mode release sont placés dans `target/release/`. Il est crucial de toujours tester les performances et de distribuer les versions compilées en mode release.

Si votre projet contient plusieurs binaires (par exemple, définis dans `src/bin/`) ou des exemples, vous pouvez spécifier lequel compiler avec l'option `--bin ` ou `--example `.

# Compile uniquement le binaire 'mon_outil_cli'
$ cargo build --bin mon_outil_cli

# Compile l'exemple 'exemple_utilisation' en mode release
$ cargo build --example exemple_utilisation --release

La commande `cargo build` est idempotente : si vous n'avez pas modifié de fichiers sources depuis la dernière compilation, Cargo ne recompilera rien, économisant ainsi du temps. Il ne recompile que les parties modifiées de votre projet et de ses dépendances.

Exécuter avec `cargo run` : compiler et lancer en une seule étape

Pendant le développement actif, vous voudrez fréquemment compiler et exécuter votre programme pour tester ses fonctionnalités. La commande `cargo run` simplifie ce processus en combinant la compilation et l'exécution en une seule étape. Lorsque vous exécutez `cargo run`, Cargo vérifie d'abord si des modifications ont été apportées depuis la dernière compilation. Si c'est le cas, il compile votre projet (en mode debug par défaut), puis exécute le binaire principal résultant.

# Compile (si nécessaire) et exécute le binaire principal du projet en mode debug
$ cargo run

Tout comme `cargo build`, `cargo run` compile en mode debug par défaut. Pour compiler et exécuter en mode release, vous pouvez utiliser l'option `--release` :

# Compile (si nécessaire) et exécute le binaire principal en mode release
$ cargo run --release

Si votre projet contient plusieurs binaires (par exemple, un `src/main.rs` et des fichiers dans `src/bin/`), `cargo run` exécutera par défaut le binaire correspondant à `src/main.rs`. Pour exécuter un binaire spécifique défini dans `src/bin/`, ou un exemple, vous devez le spécifier avec `--bin ` ou `--example `:

# Exécute le binaire 'mon_autre_app' défini dans src/bin/
$ cargo run --bin mon_autre_app

# Exécute l'exemple 'demo_simple'
$ cargo run --example demo_simple

Un avantage notable de `cargo run` est la possibilité de passer des arguments à votre programme. Tous les arguments fournis après `--` sont transmis directement à l'exécutable de votre application, et non à Cargo lui-même :

# Exécute le programme et lui passe 'argument1' et '--option-programme' comme arguments
$ cargo run -- argument1 --option-programme valeur

Cette commande est extrêmement pratique pour des cycles de développement rapides, car elle vous permet de voir immédiatement l'impact de vos modifications sans avoir à taper deux commandes distinctes (`cargo build` puis `target/debug/mon_programme`).

Vérifier rapidement avec `cargo check` : l'analyse sans compilation complète

La compilation complète d'un projet Rust, surtout s'il est volumineux ou comporte de nombreuses dépendances, peut prendre un certain temps, même en mode debug. Pour obtenir un retour plus rapide sur la validité de votre code (erreurs de syntaxe, de type, de respect des règles de l'ownership, etc.), Cargo fournit la commande `cargo check`.

`cargo check` effectue une analyse de votre code et de ses dépendances, similaire à ce que fait `cargo build`, mais s'arrête avant la phase de génération du code machine (codegen). Cela le rend significativement plus rapide que `cargo build`, tout en effectuant la majorité des vérifications sémantiques et de type du compilateur.

# Vérifie rapidement le code sans générer d'exécutable
$ cargo check

Cette commande est particulièrement utile pendant que vous écrivez ou refactorisez activement du code. Vous pouvez l'exécuter fréquemment pour vous assurer que vos modifications n'introduisent pas d'erreurs de compilation, sans avoir à attendre une compilation complète. De nombreux développeurs intègrent `cargo check` dans leur éditeur de code pour obtenir des diagnostics en temps réel ou l'exécutent en arrière-plan via des outils de surveillance de fichiers.

Les messages d'erreur et les avertissements produits par `cargo check` sont les mêmes que ceux que vous obtiendriez avec `cargo build`. Cela signifie que si `cargo check` passe sans erreurs, il y a une très forte probabilité que `cargo build` réussisse également (sauf pour des erreurs très spécifiques liées à la génération de code ou à la liaison).

Comme les autres commandes Cargo, `cargo check` peut être ciblé sur des binaires ou des exemples spécifiques :

$ cargo check --bin mon_utilitaire
$ cargo check --example une_demonstration

En intégrant `cargo check` dans votre flux de travail habituel, vous pouvez considérablement accélérer votre boucle de feedback et identifier les problèmes plus tôt, ce qui conduit à un développement plus fluide et moins frustrant. C'est un outil indispensable pour maintenir une productivité élevée, en particulier sur des projets de taille conséquente.