La sortie du langage de programmation polyvalent Rust 1.59, fondé par le projet Mozilla, mais maintenant 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 et fournit les moyens d'atteindre un parallélisme élevé des tâches tout en évitant l'utilisation d'un ramasse-miettes et d'un temps d'exécution (le temps d'exécution est réduit à l'initialisation et à la maintenance de base de la bibliothèque standard).
Les méthodes de gestion de la mémoire de Rust évitent au développeur les erreurs lors de la manipulation des pointeurs et protègent contre les problèmes qui surviennent en raison de la gestion de la mémoire de bas niveau, comme l'accès à une zone mémoire après qu'elle a été libérée, le déréférencement des pointeurs nuls, les dépassements de mémoire tampon, etc. Pour distribuer les bibliothèques, fournir des builds 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.
La sécurité de la mémoire est fournie dans Rust au moment de la compilation grâce à la vérification des références, au suivi de la propriété des objets, au suivi des durées de vie des objets (portées) et à l'évaluation de l'exactitude de l'accès à la mémoire pendant l'exécution du code. Rust fournit également une protection contre les débordements d'entiers, nécessite une initialisation obligatoire des valeurs de 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.
Principales nouveautés :
- Il est possible d'utiliser des inserts en langage assembleur, qui sont très demandés dans les applications qui doivent contrôler l'exécution à un niveau bas ou être capables d'utiliser des instructions machine spécialisées. Les inserts d'assemblage sont ajoutés à l'aide des macros "asm!" et "global_asm!" en utilisant une syntaxe de formatage de chaîne pour nommer les registres similaire à celle utilisée pour les substitutions de chaînes dans Rust. Le compilateur prend en charge les instructions d'assemblage pour les architectures x86, x86-64, ARM, AArch64 et RISC-V. Exemple d'insertion : utilisez std::arch::asm; // Multipliez x par 6 en utilisant les décalages et ajoute 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);
- Ajout de la prise en charge des affectations déstructurées (parallèles), dans lesquelles plusieurs traits, tranches ou structures sont spécifiés sur le côté gauche de l'expression. Par exemple : soit (a, b, c, d, e) ; (une, 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]);
- La possibilité de spécifier des valeurs par défaut pour les génériques const a été fournie : struct ArrayStorage {arr: [T; N], } impl. ArrayStorage { fn nouveau (a : T, b : T) -> ArrayStorage { ArrayStorage { arr : [a, b], } } }
- Le gestionnaire de packages Cargo fournit des avertissements concernant l'utilisation de structures non valides dans les dépendances traitées en raison d'erreurs dans le compilateur (par exemple, en raison d'une erreur, les champs des structures compressées ont été autorisés à être empruntés dans des blocs sécurisés). De telles constructions ne seront plus prises en charge dans une future version de Rust.
- Cargo et rustc ont une capacité intégrée pour générer des fichiers exécutables dépourvus de données de débogage (strip = "debuginfo") et de symboles (strip = "symbols"), sans avoir besoin d'appeler un utilitaire distinct. Le paramètre de nettoyage est implémenté via le paramètre « strip » dans Cargo.toml : [profile.release] strip = « debuginfo », « symbols »
- La compilation incrémentielle est désactivée par défaut. La raison serait une solution temporaire à un bogue dans le compilateur qui entraîne des plantages et des erreurs de désérialisation. Un correctif de bug a déjà été préparé et sera inclus dans la prochaine version. Pour renvoyer une compilation incrémentielle, vous pouvez utiliser la variable d'environnement RUSTC_FORCE_INCREMENTAL=1.
- Une nouvelle partie de l'API a été déplacée vers la catégorie stable, dont les méthodes et les implémentations des traits ont été stabilisées :
- std :: thread :: available_parallelism
- Résultat ::copié
- Résultat : cloné
- arch::asm!
- arch::global_asm!
- ops :: ControlFlow :: is_break
- ops :: ControlFlow :: is_continue
- TryFrom pour u8
- char::TryFromCharError (Clone, Débogage, Affichage, PartialEq, Copie, Eq, Erreur)
- 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 pour la structure ToLowercase
- DoubleEndedIterator pour la structure ToUppercase
- TryFrom<&mut [T]> pour [T; N]
- UnwindSafe pour la structure Once
- RefUnwindSafe pour une fois
- Fonctions de support armv8 neon intégrées au compilateur pour aarch64
- L'attribut « const », qui détermine la possibilité de l'utiliser dans n'importe quel contexte à la place de constantes, est utilisé dans les fonctions :
- mem :: Peut-êtreUninit :: as_ptr
- mem::Peut-êtreUninit::assume_init
- mem::Peut-êtreUninit::assume_init_ref
- ffi::CStr::from_bytes_with_nul_unchecked
Source: opennet.ru