Rust 1.78.0 : Quelles sont les nouveautés ?

L'équipe Rust est heureuse d'annoncer une nouvelle version de Rust, 1.78.0. Rust est un langage de programmation permettant à chacun de construire des logiciels fiables et efficaces.

\ Si vous avez une version précédente de Rust installée via rustup, vous pouvez obtenir la version 1.78.0 avec :

$ rustup update stable

\ Si vous ne l'avez pas encore, vous pouvez obtenir rustup depuis la page appropriée sur notre site web, et consulter les notes de version détaillées pour 1.78.0.

\ Si vous souhaitez nous aider en testant les futures versions, vous pourriez envisager de mettre à jour localement pour utiliser le canal bêta (rustup default beta) ou le canal nightly (rustup default nightly). Veuillez signaler tout bug que vous pourriez rencontrer !

Nouveautés de la version stable 1.78.0

Attributs de diagnostic

Rust prend désormais en charge un espace de noms d'attribut #[diagnostic] pour influencer les messages d'erreur du compilateur. Ces attributs sont traités comme des indications que le compilateur n'est pas obligé d'utiliser, et ce n'est pas non plus une erreur de fournir un diagnostic que le compilateur ne reconnaît pas. Cette flexibilité permet au code source de fournir des diagnostics même lorsqu'ils ne sont pas pris en charge par tous les compilateurs, qu'il s'agisse de versions différentes ou d'implémentations entièrement différentes.

\ Avec cet espace de noms vient le premier attribut pris en charge, #[diagnostic::on_unimplemented], qui peut être placé sur un trait pour personnaliser le message lorsque ce trait est requis mais n'a pas été implémenté sur un type. Considérez l'exemple donné dans la pull request de stabilisation :

#[diagnostic::on_unimplemented( message = "My Message for `ImportantTrait<{A}>` is not implemented for `{Self}`", label = "My Label", note = "Note 1", note = "Note 2" )] trait ImportantTrait<A> {} fn use_my_trait(_: impl ImportantTrait<i32>) {} fn main() { use_my_trait(String::new()); }

\ Auparavant, le compilateur donnait une erreur intégrée comme celle-ci :

error[E0277]: the trait bound `String: ImportantTrait<i32>` is not satisfied --> src/main.rs:12:18 | 12 | use_my_trait(String::new()); | ------------ ^^^^^^^^^^^^^ the trait `ImportantTrait<i32>` is not implemented for `String` | | | required by a bound introduced by this call |

\ Avec #[diagnostic::on_unimplemented], son message personnalisé remplit la ligne d'erreur principale, et son étiquette personnalisée est placée sur la sortie source. L'étiquette originale est toujours écrite comme sortie d'aide, et toutes les notes personnalisées sont également écrites. (Ces détails exacts sont susceptibles de changer.)

error[E0277]: My Message for `ImportantTrait<i32>` is not implemented for `String` --> src/main.rs:12:18 | 12 | use_my_trait(String::new()); | ------------ ^^^^^^^^^^^^^ My Label | | | required by a bound introduced by this call | = help: the trait `ImportantTrait<i32>` is not implemented for `String` = note: Note 1 = note: Note 2

\ Pour les auteurs de traits, ce type de diagnostic est plus utile si vous pouvez fournir une meilleure indication que de simplement parler de l'implémentation manquante elle-même. Par exemple, voici un exemple abrégé de la bibliothèque standard :

#[diagnostic::on_unimplemented( message = "the size for values of type `{Self}` cannot be known at compilation time", label = "doesn't have a size known at compile-time" )] pub trait Sized {}

\ Pour plus d'informations, consultez la section de référence sur l'espace de noms d'attribut d'outil diagnostic.

Vérification des préconditions unsafe

La bibliothèque standard de Rust dispose d'un certain nombre d'assertions pour les préconditions des fonctions unsafe, mais historiquement, elles n'ont été activées que dans les builds #[cfg(debug_assertions)] de la bibliothèque standard pour éviter d'affecter les performances en production. Cependant, comme la bibliothèque standard est généralement compilée et distribuée en mode release, la plupart des développeurs Rust n'exécutaient jamais ces vérifications.

\ Maintenant, la condition pour ces assertions est retardée jusqu'à la génération de code, donc elles seront vérifiées en fonction du propre paramètre de l'utilisateur pour les assertions de débogage -- activées par défaut dans les builds de débogage et de test. Ce changement aide les utilisateurs à détecter les comportements indéfinis dans leur code, bien que les détails de ce qui est vérifié ne soient généralement pas stables.

\ Par exemple, slice::from_raw_parts nécessite un pointeur non-nul aligné. L'utilisation suivante d'un pointeur délibérément mal aligné a un comportement indéfini, et bien que si vous étiez malchanceux, cela aurait pu sembler "fonctionner" dans le passé, l'assertion de débogage peut maintenant le détecter :

fn main() { let slice: &[u8] = &[1, 2, 3, 4, 5]; let ptr = slice.as_ptr(); // Create an offset from `ptr` that will always be one off from `u16`'s correct alignment let i = usize::from(ptr as usize & 1 == 0); let slice16: &[u16] = unsafe { std::slice::from_raw_parts(ptr.add(i).cast::<u16>(), 2) }; dbg!(slice16); } thread 'main' panicked at library/core/src/panicking.rs:220:5: unsafe precondition(s) violated: slice::from_raw_parts requires the pointer to be aligned and non-null, and the total size of the slice not to exceed `isize::MAX` note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace thread caused non-unwinding panic. aborting.

Réalignement déterministe

La bibliothèque standard possède quelques fonctions qui modifient l'alignement des pointeurs et des tranches, mais elles avaient auparavant des mises en garde qui les rendaient difficiles à utiliser en pratique, si vous suiviez précisément leur documentation. Ces mises en garde existaient principalement comme protection contre l'évaluation const, mais elles ne sont de toute façon stables que pour une utilisation non-const. Il est maintenant promis qu'elles auront un comportement d'exécution cohérent en fonction de leurs entrées réelles.

• pointer::align_offset calcule le décalage nécessaire pour changer un pointeur à l'alignement donné. Il renvoie usize::MAX si ce n'est pas possible, mais il était auparavant autorisé à toujours renvoyer usize::MAX, et maintenant ce comportement est supprimé.
• slice::align_to et slice::align_to_mut transmutent tous deux des tranches en une tranche centrale alignée et les tranches de tête et de queue non alignées restantes. Ces méthodes promettent maintenant de renvoyer la plus grande partie centrale possible, plutôt que de permettre à l'implémentation de renvoyer quelque chose de moins optimal comme renvoyer tout en tant que tranche de tête.

APIs stabilisées

• impl Read for &Stdin
• Acceptation des durées de vie non 'static pour plusieurs implémentations liées à std::error::Error
• Faire en sorte que impl<Fd: AsFd> impl prenne ?Sized
• impl From<TryReserveError> for io::Error

\ Ces APIs sont maintenant stables dans les contextes const :

• Barrier::new()

Notes de compatibilité

• Comme annoncé précédemment, Rust 1.78 a augmenté son exigence minimale à Windows 10 pour les cibles suivantes :
• x86_64-pc-windows-msvc
• i686-pc-windows-msvc
• x86_64-pc-windows-gnu
• i686-pc-windows-gnu
• x86_64-pc-windows-gnullvm
• i686-pc-windows-gnullvm
• Rust 1.78 a mis à niveau son LLVM intégré vers la version 18, complétant le changement d'ABI u128/i128 annoncé pour les cibles x86-32 et x86-64. Les distributeurs qui utilisent leur propre LLVM antérieur à la version 18 peuvent toujours rencontrer les bugs de convention d'appel mentionnés dans ce post.

Autres changements

Découvrez tout ce qui a changé dans Rust, Cargo et Clippy.

Contributeurs à la version 1.78.0

De nombreuses personnes se sont réunies pour créer Rust 1.78.0. Nous n'aurions pas pu le faire sans vous tous. Merci !

L'équipe de publication de Rust

\ Également publié ici

\ Photo par Ubaid E. Alyafizi sur Unsplash