
et autorise la création de binaires dépouillés
L'équipe Rust a publié une nouvelle version de Rust, 1.59.0.
Rust est un langage de programmation compilé multi-paradigme conçu et développé par Mozilla Research depuis 2010. Il a été conçu pour être « un langage fiable, concurrent, pratique », supportant les styles de programmation purement fonctionnel, modèle d'acteur (il s'agit d'un modèle de programmation concurrente, dans lequel la charge de travail est répartie entre des entités s'exécutant en parallèle, les acteurs. C'est un modèle dans lequel il n'y a pas d'état partagé, les acteurs sont isolés et l'information ne peut circuler que sous forme de messages), procédural, ainsi qu'orienté objet sous certains aspects.
En 2020, ses domaines de prédilection sont la programmation système, les applications en ligne de commande, les applications Web via WebAssembly, les services réseaux et les systèmes embarqués.
Du fait de la politique de Mozilla, Rust est entièrement développé de façon ouverte (les ingénieurs de Mozilla Research publient leurs idées et les décisions prises lors des réunions) et sollicite les remarques et contributions de la communauté.
L'équipe n'a pas manqué d'adressé son soutien au peuple Ukrainien :
« La publication d'aujourd'hui tombe le jour où l'attention du monde est captée par la soudaine invasion de l'Ukraine par les forces de Poutine. Avant d'entrer dans les détails de la nouvelle version de Rust, nous aimerions déclarer que nous sommes solidaires du peuple ukrainien et exprimons notre soutien à toutes les personnes touchées par ce conflit ».
Alors quoi de neuf (ou d'amélioré) dans Rust ?
Assemblage en ligne
Le langage Rust prend désormais en charge l'assemblage en ligne. Cela peut être utile pour de nombreuses applications qui ont besoin d'un contrôle de très bas niveau sur leur exécution ou d'accéder à des instructions machine spécialisées.
Lors de la compilation pour des cibles x86-64, par exemple, vous pouvez désormais écrire :
Code Rust : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | use std::arch::asm; // Multiply x by 6 using shifts and adds let mut x: u64 = 4; unsafe { asm!( "mov {tmp}, {x}", "shl {tmp}, 1", "shl {x}, 2", "add {x}, {tmp}", x = inout(reg) x, tmp = out(reg) _, ); } assert_eq!(x, 4 * 6); |
La syntaxe de la chaîne de format utilisée pour nommer les registres dans asm! et global_asm!, les macros sont les mêmes que celles utilisées dans les chaînes de format Rust, elles devraient donc sembler assez familières aux développeurs Rust.
Le langage d'assemblage et les instructions disponibles avec l'assemblage en ligne varient en fonction de l'architecture cible. Aujourd'hui, le compilateur stable Rust prend en charge l'assemblage en ligne sur les architectures suivantes :
- x86 and x86-64
- ARM
- AArch64
- RISC-V
Déstructuration d'une affectation
Vous pouvez désormais utiliser des modèles de tuple, de tranche et de structure comme côté gauche d'une affectation.
Code Rust : | Sélectionner tout |
1 2 3 4 5 6 7 | let (a, b, c, d, e); (a, b) = (1, 2); [c, .., d, _] = [1, 2, 3, 4, 5]; Struct { e, .. } = Struct { e: 5, f: 3 }; assert_eq!([1, 2, 1, 4, 5], [a, b, c, d, e]); |
Cela rend l'affectation plus cohérente avec les liaisons let, qui supportent depuis longtemps la même chose. Notez que les affectations de déstructuration avec des opérateurs tels que += ne sont pas autorisées.
Génériques const par défaut et entrelacement
Les types génériques peuvent désormais spécifier des valeurs par défaut pour leurs génériques const. Par exemple, vous pouvez maintenant écrire ce qui suit*:
Code Rust : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 | struct ArrayStorage<T, const N: usize = 2> { arr: [T; N], } impl<T> ArrayStorage<T> { fn new(a: T, b: T) -> ArrayStorage<T> { ArrayStorage { arr: [a, b], } } } |
Auparavant, les paramètres de type devaient précéder tous les paramètres const. Cette restriction a été assouplie et vous pouvez maintenant les entrelacer.
Code Rust : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 | fn cartesian_product< T, const N: usize, U, const M: usize, V, F >(a: [T; N], b: [U; M], f: F) -> [[V; N]; M] where F: FnMut(&T, &U) -> V { // ... } |
Futurs avertissements d'incompatibilité
Parfois, des bogues dans le compilateur Rust le font accepter du code qui n'aurait pas dû être accepté. Un exemple de ceci était les emprunts de champs de structure compressés autorisés dans le code sécurisé.
Bien que cela se produise très rarement, cela peut être assez perturbant lorsqu'une crate (une crate est un binaire ou une bibliothèque) utilisée par votre projet contient du code qui ne sera plus autorisé. En fait, vous ne le remarquerez peut-être pas tant que votre projet ne s'arrêtera pas inexplicablement pendant les phases de build.
Cargo vous affiche désormais des avertissements lorsqu'une dépendance sera rejetée par une future version de Rust. Après avoir exécuté cargo build ou cargo check, vous pouvez voir :

Création de binaires dépouillés
Il est souvent utile de supprimer les informations inutiles telles que les informations de débogage des fichiers binaires que vous distribuez, en les rendant plus petits.
Bien qu'il ait toujours été possible de le faire manuellement après la création du binaire, cargo et rustc prennent désormais en charge la suppression lorsque le binaire est lié. Pour activer cela, ajoutez ce qui suit à votre Cargo.toml :
Code Rust : | Sélectionner tout |
1 2 | [profile.release] strip = "debuginfo" |
Cela entraîne la suppression de debuginfo des fichiers binaires de version. Vous pouvez également fournir des "symbols" ou simplement true pour supprimer toutes les informations de symbole lorsqu'elles sont prises en charge.
La bibliothèque standard est généralement livrée avec des symboles de débogage et des informations de débogage au niveau de la ligne, de sorte que les binaires Rust construits sans symboles de débogage activés incluent toujours les informations de débogage de la bibliothèque standard par défaut. L'utilisation de l'option strip vous permet de supprimer ces informations supplémentaires, produisant des fichiers binaires Rust plus petits.
Compilation incrémentielle désactivée par défaut
La version 1.59.0 désactive l'incrémentation par défaut (sauf demande explicite via une variable d'environnement : RUSTC_FORCE_INCREMENTAL=1). Cela atténue les effets d'un bogue connu, #94124, qui peut provoquer des erreurs de désérialisation (et des paniques) lors de la compilation avec la compilation incrémentielle activée.
Le correctif spécifique pour #94124 est disponible et est actuellement dans la version bêta 1.60, qui sera livrée dans six semaines. L'équipe indique ne pas être actuellement au courant d'autres problèmes qui encourageraient une décision de désactiver la compilation incrémentielle dans la version 1.60 stable, et si aucun ne se pose, il est probable que la version 1.60 stable réactive la compilation incrémentielle. La compilation incrémentielle reste activée par défaut dans les chaînes bêta et nightly.
API stabilisées
Les méthodes et implémentations de traits suivantes sont désormais stabilisées :
- std::thread::available_parallelism
- Result::copied
- Result::cloned
- arch::asm!
- arch::global_asm!
- ops::ControlFlow::is_break
- ops::ControlFlow::is_continue
- TryFrom<char> for u8
- char::TryFromCharError implementing Clone, Debug, Display, PartialEq, Copy, Eq, Error
- iter::zip
- NonZeroU8::is_power_of_two
- NonZeroU16::is_power_of_two
- NonZeroU32::is_power_of_two
- NonZeroU64::is_power_of_two
- NonZeroU128::is_power_of_two
- DoubleEndedIterator for ToLowercase
- DoubleEndedIterator for ToUppercase
- TryFrom<&mut [T]> for [T; N]
- UnwindSafe for Once
- RefUnwindSafe for Once
- armv8 neon intrinsics for aarch64
Rust, un langage apprécié par les développeurs
Plus tôt ce mois-ci, l'équipe Rust a publié les résultats de l'édition 2021 de l'enquête sur l'écosystème Rust (Rust Survey).
L'enquête, menée en décembre et qui a interrogé 9354 personnes dans 113 pays et territoires différents, a révélé que l'utilisation de Rust en production a progressé, mais de nombreux défis restent à relever pour améliorer le langage. Parmi les personnes interrogées, elles sont 81% à l’utiliser...
La fin de cet article est réservée aux abonnés. Soutenez le Club Developpez.com en prenant un abonnement pour que nous puissions continuer à vous proposer des publications.