La version du langage de programmation système Rust 1.53, fondé par le projet Mozilla, mais désormais développé sous les auspices de l'organisation indépendante à but non lucratif Rust Foundation, a été publiée. Le langage se concentre sur la sécurité de la mémoire, assure une gestion automatique de la mémoire et fournit les moyens d'atteindre un parallélisme élevé des tâches sans utiliser de garbage collector ou d'exécution (le temps d'exécution est réduit à l'initialisation et à la maintenance de base de la bibliothèque standard).
La gestion automatique de la mémoire de Rust élimine les erreurs lors de la manipulation des pointeurs et protège contre les problèmes résultant de la manipulation de la mémoire de bas niveau, tels que l'accès à une région mémoire après sa libération, les déréférences de pointeurs nuls, les dépassements de tampon, etc. Pour distribuer les bibliothèques, assurer l'assemblage et gérer les dépendances, le projet développe le gestionnaire de packages Cargo. Le référentiel crates.io est pris en charge pour l'hébergement de bibliothèques.
Principales nouveautés :
- Pour les tableaux, le trait IntoIterator a été implémenté, qui permet d'organiser l'itération des éléments du tableau par valeurs : for i in [1, 2, 3] { .. }
Il est également possible de passer des tableaux à des méthodes qui acceptent les itérateurs, par exemple : let set = BTreeSet::from_iter([1, 2, 3]); pour (a, b) dans some_iterator.chain([1]).zip([1, 2, 3]) { .. }
Auparavant, IntoIterator n'était implémenté que pour les références à des tableaux, c'est-à-dire pour parcourir les valeurs, il fallait utiliser des références (« &[1, 2, 3] ») ou « [1, 2, 3].iter() ». L'implémentation d'IntoIterator pour les tableaux a été entravée par des problèmes de compatibilité causés par une conversion antérieure du compilateur de array.into_iter() en (&array).into_iter(). Ces problèmes ont été résolus avec une solution de contournement : le compilateur continuera à convertir array.into_iter() en (&array).into_iter() comme s'il n'y avait pas d'implémentation du trait IntoIterator, mais uniquement lors de l'appel de la méthode à l'aide de ".into_iter( )" et sans toucher aux appels sous la forme "in [1, 2, 3]", "iter.zip([1, 2, 3])", "IntoIterator::into_iter([1, 2, 3] )".
- Il est possible de spécifier des expressions « | » (opération OU logique) dans n’importe quelle partie du modèle, par exemple, au lieu de « Some(1) | Some(2)", vous pouvez maintenant écrire "Some(1 | 2)" : résultat du match { Ok(Some(1 | 2)) => { .. } Err(MyError { kind: FileNotFound | PermissionDenied, .. }) => { .. } _ => { .. } }
- L'utilisation de caractères non-ASCII dans les identifiants est autorisée, y compris tous les caractères nationaux définis dans la spécification Unicode UAX 31, mais à l'exclusion des caractères emoji. Si vous utilisez des caractères différents mais similaires, le compilateur émettra un avertissement. const BLÅHAJ : &str = "🦈"; struct 人 { 名字: String, } let α = 1; letｓos = 2; avertissement : paire d'identifiants considérée comme pouvant être confondue entre 'ｓ' et 's'
- Une nouvelle partie des API a été transférée dans la catégorie stable, dont les stabilisées suivantes :
- tableau ::from_ref
- tableau ::from_mut
- AtomicBool :: fetch_update
- AtomicPtr :: fetch_update
- BTreeSet :: conserver
- BTreeMap :: conserver
- BufReader ::seek_relative
- cmp::min_by
- cmp :: min_by_key
- cmp::max_by
- cmp :: max_by_key
- DebugStruct :: finish_non_exhaustive
- Durée : ZÉRO
- Durée : MAX
- Durée ::is_zero
- Durée : saturating_add
- Durée ::saturating_sub
- Durée : saturating_mul
- f32 ::is_subnormal
- f64 ::is_subnormal
- IntoIterator pour les tableaux
- {entier} ::BITS
- io :: Erreur :: Non pris en charge
- NonZero*::leading_zeros
- NonZéro* ::trailing_zeros
- Option ::insérer
- Commande ::is_eq
- Commande ::is_ne
- Commande ::is_lt
- Commande ::is_gt
- Commande ::is_le
- Commande ::is_ge
- OsStr :: make_ascii_lowercase
- OsStr :: make_ascii_uppercase
- OsStr :: to_ascii_lowercase
- OsStr :: to_ascii_uppercase
- OsStr::is_ascii
- OsStr :: eq_ignore_ascii_case
- Peekable ::peek_mut
- Rc::increment_strong_count
- Rc::decrement_strong_count
- slice :: IterMut :: as_slice
- AsRef<[T]> pour slice :: IterMut
- impl SliceIndex pour (Lié , Lié )
- Vec :: extend_from_within
- Le troisième niveau de support pour la plateforme wasm64-unknown-unknown a été implémenté. Le troisième niveau implique un support de base, mais sans tests automatisés, sans publication de versions officielles ni vérification si le code peut être construit.
- Le gestionnaire de packages Cargo a été déplacé pour utiliser par défaut le nom « main » pour la branche principale du référentiel Git (HEAD). Les dépendances hébergées dans des référentiels qui utilisent le nom main au lieu de master ne nécessitent plus de configuration branch = "main".
- Dans le compilateur, les exigences pour la version minimale de LLVM sont élevées à LLVM 10.
Par ailleurs, on peut noter l'apport de financements pour le développement de l'intégration dans le noyau Linux d'outils de développement de composants en langage Rust. Les travaux seront réalisés dans le cadre du projet Prossimo sous les auspices de l'organisation ISRG (Internet Security Research Group), qui est le fondateur du projet Let's Encrypt et promeut HTTPS et le développement de technologies pour augmenter la sécurité du L'Internet. Les fonds seront fournis par Google, qui financera le travail de Miguel Ojeda, l'auteur du projet Rust-for-Linux. Auparavant, ISRG et Google ont déjà financé la création d'un backend HTTP alternatif pour l'utilitaire curl et le développement d'un nouveau module TLS pour le serveur http Apache.
Selon Microsoft et Google, environ 70 % des vulnérabilités sont causées par une gestion non sécurisée de la mémoire. On s'attend à ce que l'utilisation du langage Rust pour développer des composants du noyau tels que des pilotes de périphériques réduise le risque de vulnérabilités causées par une gestion dangereuse de la mémoire et élimine les erreurs telles que l'accès à une région de mémoire après qu'elle a été libérée et le dépassement des limites de la mémoire tampon.
Une gestion sécurisée de la mémoire est assurée dans Rust au moment de la compilation grâce à la vérification des références, au suivi de la propriété des objets et de leur durée de vie (portée), ainsi qu'à l'évaluation de l'exactitude de l'accès à la mémoire pendant l'exécution du code. Rust offre également une protection contre les débordements d'entiers, nécessite l'initialisation obligatoire des valeurs des variables avant utilisation, gère mieux les erreurs dans la bibliothèque standard, applique le concept de références et de variables immuables par défaut, propose un typage statique fort pour minimiser les erreurs logiques.
Source: opennet.ru