Installation et configuration de l'environnement de développement

Préparer le terrain : les étapes clés pour démarrer avec Rust

Avant de pouvoir écrire votre première ligne de code Rust, il est indispensable de mettre en place un environnement de développement fonctionnel et agréable. Heureusement, l'équipe Rust a fourni des outils qui rendent ce processus remarquablement simple et cohérent sur différentes plateformes. Ce chapitre vous guidera à travers les étapes essentielles : l'installation de Rust lui-même à l'aide de `rustup`, la configuration de votre éditeur de code (avec un accent sur Visual Studio Code et l'extension `rust-analyzer` pour une expérience optimale), et enfin, la création et l'exécution de votre tout premier programme Rust, le traditionnel "Hello, world!", en utilisant Cargo.

L'objectif est de vous rendre opérationnel le plus rapidement possible, avec un environnement qui non seulement vous permet de compiler du code Rust, mais aussi de bénéficier d'une aide précieuse pendant que vous codez, comme l'autocomplétion, la détection d'erreurs en temps réel et la navigation aisée dans le code. Un bon environnement est un facteur clé de productivité et de plaisir dans l'apprentissage d'un nouveau langage. Suivez attentivement ces instructions, et vous serez prêt à explorer les merveilles de Rust en un rien de temps.

Installer Rust avec `rustup` : la méthode officielle et recommandée

L'outil officiel pour installer et gérer les versions de Rust est `rustup`. C'est un installateur de toolchains Rust qui vous permet d'installer facilement les compilateurs Rust (`rustc`), le gestionnaire de paquets et de build (`cargo`), la documentation standard (`rust-doc`), et d'autres outils utiles. `rustup` facilite également la mise à jour de votre installation Rust et le passage entre différentes versions de Rust (stable, beta, nightly) si nécessaire.

Sur Linux et macOS :

Ouvrez votre terminal et exécutez la commande suivante. Elle télécharge et exécute un script qui installe `rustup` et la dernière version stable de Rust :

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Le script vous posera quelques questions. Pour la plupart des utilisateurs, les options par défaut sont suffisantes. Une fois l'installation terminée, le script vous indiquera généralement de configurer votre shell actuel en exécutant une commande comme `source $HOME/.cargo/env` ou `source ~/.cargo/env`. Vous devrez peut-être aussi ouvrir une nouvelle fenêtre de terminal ou redémarrer votre session pour que les modifications du `PATH` prennent effet.

Sur Windows :

La méthode recommandée est de télécharger et d'exécuter `rustup-init.exe` depuis le site officiel de Rust. Cet installateur vous guidera à travers les étapes. Il est important de noter que Rust sur Windows nécessite les outils de build C++ de Microsoft Visual Studio. Si vous ne les avez pas, l'installateur de `rustup` tentera de les installer pour vous ou vous donnera des instructions. Suivez attentivement les messages affichés par l'installateur.

Après l'installation, `rustup` ajoutera le répertoire `~/.cargo/bin` (ou `%USERPROFILE%\.cargo\bin` sur Windows) à votre variable d'environnement `PATH`. Cela vous permettra d'exécuter les commandes `rustc`, `cargo`, et `rustup` depuis n'importe quel terminal.

Pour vérifier que l'installation s'est bien déroulée, ouvrez un nouveau terminal et tapez :

rustc --version
cargo --version

Vous devriez voir s'afficher les versions du compilateur Rust et de Cargo. Pour mettre à jour votre installation Rust à l'avenir, vous utiliserez simplement la commande :

rustup update

Configuration de l'éditeur de code : VS Code et `rust-analyzer` à la rescousse

Bien que vous puissiez écrire du code Rust dans n'importe quel éditeur de texte, utiliser un éditeur avec un bon support pour Rust améliorera considérablement votre productivité et votre expérience d'apprentissage. L'un des choix les plus populaires et recommandés par la communauté Rust est Visual Studio Code (VS Code) combiné à l'extension `rust-analyzer`.

`rust-analyzer` est un serveur de langage (Language Server Protocol) pour Rust. Il fournit des fonctionnalités avancées directement dans votre éditeur, telles que :

• Autocomplétion intelligente : Suggestions de code contextuelles pendant que vous tapez.
• Diagnostics en temps réel : Affichage des erreurs et des avertissements du compilateur directement dans l'éditeur, souvent avant même que vous ne sauvegardiez le fichier.
• Navigation dans le code : "Aller à la définition", "Trouver toutes les références", etc.
• Refactoring : Aides pour renommer des symboles, extraire du code dans des fonctions, etc.
• Affichage des types et de la documentation : Informations sur les types des variables et des fonctions au survol de la souris.
• Intégration avec Cargo pour lancer des builds, des tests, etc., directement depuis l'éditeur.

Pour configurer VS Code avec `rust-analyzer` :

1. Si vous ne l'avez pas déjà, téléchargez et installez Visual Studio Code depuis son site officiel.
2. Ouvrez VS Code, allez dans la vue des Extensions (l'icône des carrés sur la barre latérale gauche, ou Ctrl+Shift+X / Cmd+Shift+X).
3. Recherchez "rust-analyzer" (assurez-vous de choisir celui publié par `rust-lang.org`).
4. Cliquez sur "Installer".

Une fois installé, `rust-analyzer` devrait commencer à fonctionner automatiquement lorsque vous ouvrez un projet Rust (un répertoire contenant un fichier `Cargo.toml`). Il peut prendre quelques instants pour indexer votre projet la première fois. D'autres éditeurs populaires comme IntelliJ IDEA (avec le plugin Rust), Neovim, ou Sublime Text offrent également un excellent support pour Rust, souvent via `rust-analyzer` ou des plugins équivalents.

Votre premier "Hello, world!" avec `cargo new`

Maintenant que Rust est installé et votre éditeur configuré, il est temps de créer et d'exécuter votre premier programme Rust. Nous allons utiliser Cargo pour cela.

Ouvrez votre terminal, naviguez vers le répertoire où vous souhaitez créer vos projets (par exemple, `~/projets` ou `C:\Users\VotreNom\Projects`), puis exécutez la commande suivante :

cargo new hello_rust

Cette commande crée un nouveau répertoire nommé `hello_rust` avec la structure de base d'un projet Rust binaire :

hello_rust/
├── Cargo.toml
└── src/
    └── main.rs

• `Cargo.toml` : Le fichier manifeste de votre package, décrivant votre projet et ses dépendances (pour l'instant, il sera très simple).
• `src/main.rs` : Le fichier source principal de votre application.

Ouvrez le fichier `src/main.rs` dans VS Code (ou votre éditeur configuré). Il devrait contenir le code suivant, généré automatiquement par Cargo :

fn main() {
    println!("Hello, world!");
}

Ce code définit une fonction nommée `main`, qui est le point d'entrée de tout programme Rust exécutable. A l'intérieur, `println!` est une macro Rust qui affiche du texte à la console.

Pour compiler et exécuter ce programme, retournez dans votre terminal, assurez-vous d'être dans le répertoire `hello_rust` (utilisez `cd hello_rust`), puis tapez :

cargo run

Cargo va d'abord compiler votre projet (si ce n'est pas déjà fait ou si des modifications ont eu lieu), puis exécuter le binaire résultant. Vous devriez voir s'afficher :

Hello, world!

Félicitations ! Vous venez de créer, compiler et exécuter votre premier programme Rust. Vous avez maintenant un environnement de développement fonctionnel, prêt pour explorer plus en profondeur les fonctionnalités de ce langage passionnant. Les fichiers compilés se trouvent dans le sous-répertoire `target/debug/` (pour les builds de développement) ou `target/release/` (pour les builds de production optimisés, créés avec `cargo build --release`).