La version 1.86 du langage de programmation généraliste Rust, initialement développé par Mozilla, est désormais maintenue par la Rust Foundation, une organisation à but non lucratif indépendante. Ce langage met l'accent sur la gestion sécurisée de la mémoire et offre des outils pour atteindre un haut niveau de parallélisme d'exécution, le tout sans recourir à un ramasse-miettes (garbage collector) ni à un runtime élaboré (celui-ci se limite à une initialisation de base et à la maintenance de la bibliothèque standard).
Les méthodes de gestion de la mémoire en Rust éliminent les erreurs lors de la manipulation des pointeurs et protègent contre les problèmes liés à la gestion bas niveau de la mémoire, tels que l'accès à une zone mémoire après sa libération, la déréférence de pointeurs nuls, le dépassement de tampon, etc. Pour faciliter la diffusion des bibliothèques, assurer la compilation et gérer les dépendances, un gestionnaire de paquets nommé Cargo est en développement. Un dépôt pour le déploiement des bibliothèques, crates.io, est également supporté.
La sécurité de la mémoire dans Rust est assurée au moment de la compilation grâce à la vérification des références, au suivi de la propriété des objets, à la prise en compte de la durée de vie des objets (portée) et à l'évaluation de l'accès mémoire pendant l'exécution du code. Rust offre également des outils pour se protéger contre les débordements d'entiers, exige l'initialisation obligatoire des valeurs des variables avant leur utilisation, gère mieux les erreurs dans la bibliothèque standard, applique le concept d'immuabilité (immutable) pour les références et les variables par défaut, et propose une forte typage statique pour minimiser les erreurs logiques.
Les principales nouveautés :
- Le support de la conversion (upcast) des traits vers le supertrait de base a été ajouté, permettant ainsi la conversion directe d'une référence d'objet trait en référence d'objet supertrait sans avoir besoin de créer une méthode spéciale dans le trait pour retourner cette référence. Une opération similaire peut être réalisée avec d'autres types de pointeurs intelligents, comme « Arc<dyn Trait> -> Arc<dyn Supertrait> » et « *const dyn Trait -> *const dyn Supertrait ». trait Trait: Supertrait {} trait Supertrait {} fn upcast(x: &dyn Trait) -> &dyn Supertrait { x }
- Dans HashMap et les slices, la méthode get_disjoint_mut() a été ajoutée pour obtenir simultanément plusieurs références mutables sur les éléments. Auparavant, le borrow checker n'autorisait pas l'utilisation simultanée des références obtenues par la méthode get_mut(). let v = &mut [1, 2, 3]; if let Ok([a, b]) = v.get_disjoint_mut([0, 2]) { *a = 413; *b = 612; } assert_eq!(v, &[413, 2, 612]); if let Ok([a, b]) = v.get_disjoint_mut([0..1, 1..3]) { a[0] = 8; b[0] = 88; b[1] = 888; } assert_eq!(v, &[8, 88, 888]);
- Il est maintenant possible de marquer des fonctions safe avec l'attribut « #[target_feature] », indiquant que la fonction utilise les capacités CPU spécifiées. Une fonction safe marquée avec l'attribut « #[target_feature] » peut être appelée en toute sécurité par une autre fonction safe seulement si cette dernière est elle aussi marquée « #[target_feature] » (sans quoi ces fonctions doivent être appelées dans un bloc unsafe). En outre, elles ne peuvent pas être transmises à des fonctions prenant des paramètres génériques restreints par des traits Fn*. Auparavant, l'attribut « #[target_feature] » ne pouvait être appliqué qu'aux fonctions marquées comme « unsafe ». #[target_feature(enable = «avx2»)] fn requires_avx2() { // … } #[target_feature(enable = «avx2»)] fn safe_callsite() { requires_avx2(); } fn unsafe_callsite() { if is_x86_feature_detected!(«avx2») { unsafe { requires_avx2() }; } }
- Dans le compilateur Rust, une vérification de débogage est activée (debug-assert) pour s'assurer qu'un pointeur ne contient pas la valeur NULL lors de la lecture et de l'écriture de tailles non nulles, ainsi que lors d'un réemprunt (reborrow) d'un pointeur dans une référence. Par exemple, avec les vérifications de débogage activées, le code ci-dessous entraînera maintenant un état de « panic » : let _x = *std::ptr::null::(); let _x = &*std::ptr::null::();
- Par défaut, la vérification lint « missing_abi » est activée, ce qui génère un avertissement si l'ABI n'est pas spécifié après le mot clé extern. Auparavant, si l'ABI n'était pas spécifié après extern, on supposait que l'ABI « C » était utilisé. Il est désormais recommandé de spécifier explicitement l'ABI « C », par exemple, ‘extern «C» {}’ et ‘extern «C» fn’
- Une nouvelle série d'API a été stabilisée dans la catégorie des API stables, notamment des méthodes et des implémentations de traits stabilisées :
- {float}::next_down
- {float}::next_up
- ::get_disjoint_mut
- ::get_disjoint_unchecked_mut
- slice::GetDisjointMutError
- HashMap::get_disjoint_mut
- HashMap::get_disjoint_unchecked_mut
- NonZero::count_ones
- Vec::pop_if
- sync::Once::wait
- sync::Once::wait_force
- sync::OnceLock::wait
- L'attribut «const» est appliqué dans les fonctions :
- hint::black_box
- io::Cursor::get_mut
- io::Cursor::set_position
- str::is_char_boundary
- str::split_at
- str::split_at_checked
- str::split_at_mut
- str::split_at_mut_checked
- Le troisième niveau de support a été implémenté pour les plateformes {aarch64-unknown,x86_64-pc}-nto-qnx710_iosock, {aarch64-unknown,x86_64-pc}-nto-qnx800, {x86_64,i686}-win7-windows-gnu, amdgcn-amd-amdhsa, x86_64-pc-cygwin, {mips,mipsel}-mti-none-elf, m68k-unknown-none-elf, armv7a-nuttx-{eabi,eabihf}, aarch64-unknown-nuttx et thumbv7a-nuttx-{eabi,eabihf}. Le troisième niveau implique un soutien de base, mais sans tests automatisés, publication de versions officielles et vérification de la possibilité de compilation du code.
- Un avertissement a été ajouté concernant l'abandon du second niveau de support pour la plateforme cible i586-pc-windows-msvc dans le prochain version (1.87). Il est recommandé d'utiliser la plateforme i686-pc-windows-msvc, qui prend en charge les instructions SSE2. La plateforme i586-pc-windows-msvc est devenue obsolète, car Windows 10 nécessite le support de SSE2, et les versions antérieures de Windows ne sont plus prises en charge dans Rust.
Il convient également de noter que la société Ferrocene a transmis à la communauté la spécification du langage Rust (FLS — Ferrocene Language Specification), créée lors du développement de son compilateur Rust pour des systèmes critiques et synchronisée périodiquement avec l'état actuel du compilateur Rust principal. La spécification FLS comprend un guide structuré et détaillé sur la syntaxe, la sémantique et le comportement de Rust, adapté à la vérification, à l'évaluation de la compatibilité et à la normalisation.
Les matériaux fournis seront utilisés pour créer une spécification de référence pour le langage Rust, qui pourra être utilisée lors du développement de compilateurs alternatifs et pour vérifier le compilateur dans des domaines critiques en termes de sécurité.
Source : opennet.ru
