Annexe D : outils de développement utiles
Dans cette annexe, nous allons découvrir quelques outils de développement utiles que propose le projet Rust. Nous verrons le formatage automatique, des moyens rapides pour corriger les avertissements, un analyseur statique (linter) et l’intégration avec des environnements de développement intégrés (IDEs).
Formatage automatique avec rustfmt
L’outil rustfmt reformate votre code selon le style de codage de la communauté. Beaucoup de projets collaboratifs utilisent rustfmt afin d’éviter des discussions quant à savoir quel style doit être utilisé pour écrire du Rust : tout le monde formate son code en utilisant l’outil.
Les installations de Rust incluent rustfmt par défaut, vous devriez donc déjà avoir sur votre système les programmes rustfmt et cargo-fmt. Ces deux commandes sont semblables à rustc et cargo, avec rustfmt qui permet d’avoir un contrôle plus fin et cargo-fmt qui comprend les conventions d’un projet qui utilise Cargo. Pour formater un projet Cargo quelconque, entrez la commande suivante :
$ cargo fmt
L’exécution de cette commande reformate tout le code Rust de la crate courante. Ceci ne devrait changer que le style du code, et non pas sa sémantique. Pour en savoir plus sur rustfmt, voyez sa documentation.
Correction de votre code avec rustfix
L’outil rustfix est inclus avec les installations de Rust et peut automatiquement corriger des avertissements du compilateur pour lesquels existe une solution aisée de correction, solution qui sera probablement ce que vous souhaitez. Vous avez plus que certainement vu des avertissements du compilateur précédemment. Par exemple, voyez ce code :
Fichier : src/main.rs
fn main() {
let mut x = 42;
println!("{x}");
}Ici, nous définissons une variable x comme modifiable, mais nous de la modifions en réalité jamais. Rust nous en avertit :
$ cargo build
Compiling myprogram v0.1.0 (file:///projects/myprogram)
warning: variable does not need to be mutable
--> src/main.rs:2:9
|
2 | let mut x = 0;
| ----^
| |
| help: remove this `mut`
|
= note: `#[warn(unused_mut)]` on by default
L’avertissement suggère de supprimer le mot-clé mut. Nous pouvons automatiquement appliquer cette suggestion à l’aide de l’outil rustfix en entrant la commande cargo fix :
$ cargo fix
Checking myprogram v0.1.0 (file:///projects/myprogram)
Fixing src/main.rs (1 fix)
Finished dev [unoptimized + debuginfo] target(s) in 0.59s
Si nous regardons à nouveau src/main.rs, nous pourrons constater que cargo fix a changé le code :
Fichier : src/main.rs
fn main() {
let x = 42;
println!("{x}");
}La variable x est désormais immuable, et l’avertissement n’apparaît plus.
Vous pouvez aussi utiliser la commande cargo fix pour migrer votre code entre différentes éditions de Rust. Les éditions sont traitées dans l’annexe E.
Analyse statique plus complète avec Clippy
L’outil Clippy est une collection de correcteurs de code / analyses statiques (lints) pour analyser votre code de manière à ce que vous puissiez débusquer certaines erreurs courantes et ainsi améliorer votre code Rust. Clippy est inclus avec les installations standard de Rust.
Pour lancer l’analyse statique et la correction de code de Clippy sur un projet Cargo, entrez la commande suivante :
$ cargo clippy
Par exemple, imaginons que vous écriviez un programme utilisant une approximation d’une constante mathématique comme pi, ainsi que le fait ce programme :
fn main() {
let x = 3.1415;
let r = 8.0;
println!("l'aire du cercle est {}", x * r * r);
}L’exécution de cargo clippy sur ce projet aboutit à cette erreur :
error: approximate value of `f{32, 64}::consts::PI` found
--> src/main.rs:2:13
|
2 | let x = 3.1415;
| ^^^^^^
|
= note: `#[deny(clippy::approx_constant)]` on by default
= help: consider using the constant directly
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#approx_constant
Cette erreur vous indique que Rust déjà a la constante PI qui est définie plus précisément, et que votre programme serait plus pertinent si vous utilisiez à la place cette constante. Vous changeriez alors votre code pour utiliser la constante PI.
Le code suivant n’amène à aucune erreur ni avertissement de la part de Clippy :
fn main() {
let x = std::f64::consts::PI;
let r = 8.0;
println!("l'aire du cercle est {}", x * r * r);
}Pour en savoir plus sur Clippy, voyez sa documentation.
Intégration à un environnement de développement intégré (IDE) avec rust-analyzer
Pour ce qui est de l’intégration avec les environnements de développement intégrés (IDEs), la communauté Rust recommande l’utilisation de rust-analyzer. Cet outil est un ensemble d’utilitaires organisés autour du compilateur, qui utilisent le protocole de serveur de langage - Language Server Protocol, lequel est une spécification pour les IDEs et d’autres langages de programmation pour communiquer les uns avec les autres. Différents clients peuvent utiliser rust-analyzer, comme par exemple le greffon Rust analyzer pour Visual Studio Code.
Consultez la page d’accueil du projet rust-analyzer pour la procédure d’installation, puis installez la prise en charge du serveur de langage dans votre IDE. Votre IDE bénéficiera alors de fonctionnalités comme l’autocomplétion, la possibilité de sauter directement aux définitions, et l’affichage en ligne des erreurs.