Il n’y a pas longtemps, j’ai voulu me mettre sérieusement à Rust, un langage de programmation moderne et sûr. Et j’ai donc commencé ma quête d’un environnement de développement stable, efficace et agréable à l’utilisation. Quête dont je souhaite faire le récit pour ceux qui un jour rencontreraient les mêmes difficultés.
Le choix des outils
Une première question s’est vite posée : quel éditeur utiliser ? Tout d’abord je ne souhaitais pas un IDE lourd et poussif, et je cherchais aussi une solution un minimum portable dans l’éventualité où j’aurais besoin de la déployer sur Linux. Grâce à cette ressource, j’ai rapidement restreint mon choix à Atom ou VSCode. Le premier présente l’avantage d’avoir déjà une solide communauté et une base d’addons assez impressionnante, qui le rendent apte à programmer dans quasiment tous les langages. Cependant, il reste plus adapté à des langages interprétés (web, python, …) qu’à des langages compilés comme Rust, car il ne propose pas de débugger, ni de mécanisme permettant de facilement compiler du code, sans passer par des addons assez lourds d’utilisation. VSCode quant à lui m’avait rebuté au premier abord (peut être parce qu’il était signé microsoft, allez savoir …) mais il présente l’avantage d’être plus orienté programmation : avec les outils comme intellisense, un débugger natif qui peut s’interfacer avec LLDB, de bons plugins Rust, et une ergonomie franchement pas mauvaise.
De plus, il faut savoir que Rust propose des outils comme Cargo qui permettent d’utiliser facilement et efficacement des commandes de compilation, test, run, et autres bien pratiques. Je cherchais donc une solution dans laquelle je puisse efficacement interfacer ces commandes pour ne pas avoir à retourner dans mon terminal à chaque fois que je voulais build et run mon projet.
J’ai donc finalement opté pour VSCode pour toutes ces raisons.
Installation et paramétrage
On arrive au coeur du sujet. Nous allons avoir besoin de plusieurs outils :
- évidemment, VScode
- une installation Rust
- des addons pour VSCode
- Un debugger, un formatter de code, un utilitaire d’autocomplétion, …
Commençons donc par installer VSCode, en choisissant la version qui vous correspond sur cette page.
Après le téléchargement, lancez VSCode et faites cmd+shift+p (rappelez vous de ce raccourci, il sert à ouvrir la palette de commande de VSCode, on va beaucoup l’utiliser). Dans la palette qui s’ouvre tapez Shell command et sélectionner la tâche
1 | Install 'code' command in PATH |
Maintenant, vous pouvez ouvrir un projet ou un document avec VSCode depuis le terminal en utilisant la commande
1 | code <filename> |
Maintenant, il faut installer Rust. Pour cela on va utiliser Rustup, l’outil officiel pour gérer les installations des différentes versions de Rust (Rust Stable ou nightly par exemple) pour cela, ouvrez un terminal et tapez :
1 | curl https://sh.rustup.rs -sSf | sh
|
Puis pour être sur que tout est à jour (au cas où vous possédiez déjà rustup)
1 | rustup self update |
Nous allons maintenant installer la nightly release de Rustup (les outils dont nous avons besoin nécessitent la nightly et pas la stable). Pour cela, il suffit de taper dans le terminal :
1 | rustup install nightly |
Maintenant nous allons installer RLS, Rust Language Server, un utilitaire qui s’interface avec VSCode et qui va gérer tout ce qui a trait au codecompletion, symboles, définitions, et formatage. Pour cela, effectuez les commandes suivantes:
1 2 3 | rustup component add rls --toolchain nightly rustup component add rust-analysis --toolchain nightly rustup component add rust-src --toolchain nightly |
Il faut ensuite exporter dans le chemin des sources rust :
1 | export RUST_SRC_PATH=~/.multirust/toolchains/[your-toolchain]/lib/rustlib/src/rust/src |
(où [your-toolchain] est le nom du dossier contenant la toolchain utilisée, suivant que vous préfériez stable ou nightly)
Vous pouvez maintenant vérifier que tout fonctionne en tapant dans le terminale :
1 | racer complete std::io::B
|
Si tout se passe bien, racer, l’outil de complétion, devrait vous proposer des match pour cette expression
Il ne nous reste plus qu’à paramétrer VSCode. Pour cela nous allons avoir besoin de plusieurs extensions, et il faudra en build une nous même. Tout d’abord dans le catalogue d’extensions de VScode, cherchez et installez l’extension Rust. Faites de même pour l’extension LLDB Debugger. Ensuite, il va nous falloir créer l’extension qui va gérer RLS. Pour cela, il faut tout d’abord que Node.js soit installé sur votre ordinateur : c’est par ici. Une fois cela fait, mettez vous dans un répertoire de travail et exécutez les commandes suivantes.
1 2 3 4 | git clone https://github.com/rust-lang-nursery/rls-vscode
cd rls-vscode
npm install
code .
|
Cela aura pour effet de créer un projet et de l’ouvrir avec VSCode, et ce projet contiendra tout ce qu’il faut pour construire l’extension. Vous pouvez déjà allez dans l’onglet debugging et cliquer sur la flèche verte en haut à gauche, ce qui ouvrira une autre instance de VSCode interfacée avec RLS. Si tout s’est bien passé, vous devriez voir en bas dans la barre d’exécution RLS analysis: working / puis RLS analysis: done
Vous avez alors accès à "aller à la def", "trouver toutes les références", "renommer", "aller au type", etc. L’autocomplétion sera aussi disponible grâce à Racer. Le code sera aussi analysé statiquement au fur et à mesure que vous tapez et les erreurs seront reportées.
Cependant, il reste encore a construire une bonne fois pour toute cette extension et à l’installer sur VSCode pour ne pas avoir à relancer ce projet à chaque fois. Pour cela, tapez dans le terminal :
1 2 | npm install -g vsce vsce package |
ce qui créera une archive .vsix dans le répertoire de travail. Ensuite, dans VSCode, dans le menu des extensions, cliquez sur les … en haut à gauche et choisissez Installer depuis un VSIX. Choisissez alors l’archive juste créée.
Il ne nous reste plus qu’à installer le débugger. Si vous avez installé les command line tools avec Xcode, LLDB est déjà installé, sinon vous devez le faire manuellement. Ensuite créez un projet rust et ouvrez le main avec VSCode, puis dans l’onglet Debugging, cliquez sur la flèche verte. Le programme va alors vous demander quelle configuration de débugger utiliser : choisissez LLDB. Cela va créer et ouvrir un fichier launch.json du style :
1 2 3 4 5 6 7 8 9 10 11 12 13 | {
"version": "0.2.0",
"configurations": [
{
"type": "lldb",
"request": "launch",
"name": "Debug",
"program": "${workspaceRoot}/<program>,
"args": [],
"cwd": "${workspaceRoot}"
}
]
}
|
Il vous suffira de remplacer /<program> par le chemin relatif de l’exécutable produit par rust dans le répertoire du projet (typiquement "${workspaceRoot}/target/debug/nom-executable") Vous pouvez aussi ajouter des configurations pour par exemple débugger en release.
Voilà, on a fait le tour pour ce qui est de l’installation.
Usage
Vous pouvez maintenant créer un projet Rust et l’ouvrir en lançant la commande suivante depuis votre terminal.
1 2 | cargo new projet-test --bin cd projet-test && code . |
Maintenant, en utilisant la palette de commande, vous avez accès à plusieurs tâches du style :
- cargo build
- cargo run
- cargo test
directement depuis VSCode, ce qui permet aussi de paramétrer un raccourci clavier pour ces tâches. Par exemple, j’utilise cmd+r pour lancer la tâche cargo run
Pensez à sauvegarder votre fichier avant de lancer un cargo run ou build. J’ai cherché comment lancer une sauvegarde à chaque fois que la tâche est effectuée mais je n’ai pas trouvé de façon pratique de le faire si ce n’est en modifiant l’extension rust…
Vous pouvez aussi lancer la tâche format pour formater votre document suivant les guidelines rust (raccourci par défaut : alt+shift+f)
Enfin, RLS s’occupe de l’analyse en temps réel de votre code et de la complétion.
Si jamais vous souhaitez de plus un Linter, je vous conseille scrapy, qui peut aussi s’intercaler avec rust et RLS. Cependant je ne décrirai pas la procédure d’installation ici.