Die Veröffentlichung von Rust 1.64, einer allgemein einsetzbaren Programmiersprache, die ursprünglich von Mozilla entwickelt wurde und nun von der unabhängigen Non-Profit-Organisation Rust Foundation unterstützt wird, wurde bekannt gegeben. Die Sprache konzentriert sich auf einen sicheren Umgang mit Speicher und bietet Mittel zur Erreichung hohen Parallelismus bei der Ausführung von Aufgaben, ohne einen Garbage Collector oder umfangreiche Runtime zu benötigen; die Runtime beschränkt sich auf die grundlegende Initialisierung und die Bereitstellung der Standardbibliothek.
Die Speicherverwaltungsmethoden in Rust befreien Entwickler von Fehlern beim Umgang mit Zeigern und schützen vor Problemen, die durch die Programmierung auf niedriger Ebene entstehen, wie z.B. den Zugriff auf freigegebenen Speicher, Dereferenzierung von Nullzeigern, Pufferüberläufe usw. Zur Verteilung von Bibliotheken, zur Gewährleistung des Builds und zum Management von Abhängigkeiten wird der Paketmanager Cargo entwickelt. Für die Bereitstellung von Bibliotheken wird das Repository crates.io unterstützt.
Die sichere Handhabung von Speicher in Rust wird während der Kompilierung durch die Überprüfung von Referenzen, das Verfolgen des Besitztums von Objekten, das Management der Lebensdauer von Objekten (Sichtbarkeitsbereiche) und die Bewertung der Korrektheit des Zugriffs auf den Speicher zur Laufzeit sichergestellt. Rust bietet außerdem Mechanismen zum Schutz vor ganzzahligen Überläufen, erfordert die verpflichtende Initialisierung von Variablenwerten vor der Verwendung, behandelt Fehler in der Standardbibliothek effektiver, implementiert das Konzept der Unveränderlichkeit (immutable) von Referenzen und Variablen standardmäßig und bietet eine starke statische Typisierung zur Minimierung logischer Fehler.
Hauptneuheiten:
- Die Anforderungen an die Linux-Umgebung im Compiler, im Paketmanager Cargo und in der Standardbibliothek libstd wurden erhöht – die minimalen Anforderungen an Glibc wurden von Version 2.11 auf 2.17 angehoben, und die Linux-Kernel-Anforderungen von Version 2.6.32 auf 3.2. Die Einschränkungen gelten auch für ausführbare Dateien von Rust-Anwendungen, die mit libstd erstellt wurden. Entsprechende Distributionen sind RHEL 7, SLES 12-SP5, Debian 8 und Ubuntu 14.04. Die Unterstützung für RHEL 6, SLES 11-SP4, Debian 7 und Ubuntu 12.04 wird eingestellt. Nutzer, die mit dem Rust-Toolchain erstellte ausführbare Dateien in Umgebungen mit älteren Linux-Kernel verwenden, wird geraten, ihre Systeme zu aktualisieren, bei den älteren Compiler-Versionen zu verbleiben oder ihr eigenes libstd-Branch mit Kompatibilitätsschichten zu pflegen.
Unter den Gründen für die Einstellung der Unterstützung älterer Linux-Systeme werden begrenzte Ressourcen für die weitere Pflege der Kompatibilität mit alten Umgebungen genannt. Die Unterstützung des alten Glibc erfordert die Verwendung alter Werkzeuge bei der Überprüfung im Continuous-Integration-System, insbesondere angesichts der steigenden Anforderungen an die Versionen in LLVM und den Cross-Compilation-Tools. Die erhöhten Kernelversion-Anforderungen hängen mit der Möglichkeit zusammen, in libstd neue Systemaufrufe zu verwenden, ohne dass Schichten zur Sicherstellung der Kompatibilität mit alten Kernels gepflegt werden müssen.
- Der Typ IntoFuture wurde stabilisiert, der dem IntoIterator ähnelt, sich jedoch dadurch unterscheidet, dass er "await" anstelle von "for ... in ..."-Schleifen verwendet. In Kombination mit IntoFuture kann das Schlüsselwort "await" nicht nur den Typ Future abwarten, sondern auch alle anderen Typen, die in Future umgewandelt werden können.
- Das Tool rust-analyzer ist Teil der Sammlung von Tools, die mit den Rust-Releases geliefert werden. Das Tool kann auch über rustup installiert werden (rustup component add rust-analyzer).
- Im Paketmanager Cargo wurde die Möglichkeit implementiert, Arbeitsbereiche zu erben, um duplizierte Werte für typische Felder wie Rust-Versionen und Repository-URLs zu vermeiden. Außerdem wurde die Unterstützung für den gleichzeitigen Bau für mehrere Zielplattformen hinzugefügt (im Parameter „—target“ können jetzt mehrere Parameter angegeben werden).
- Eine neue Reihe von APIs wurde stabilisiert und in die stabile Version überführt, einschließlich stabilisierter Methoden und Implementierungen von Traits:
- future::IntoFuture
- num::NonZero*::checked_mul
- num::NonZero*::checked_pow
- num::NonZero*::saturating_mul
- num::NonZero*::saturating_pow
- num::NonZeroI*::abs
- num::NonZeroI*::checked_abs
- num::NonZeroI*::overflowing_abs
- num::NonZeroI*::saturating_abs
- num::NonZeroI*::unsigned_abs
- num::NonZeroI*::wrapping_abs
- num::NonZeroU*::checked_add
- num::NonZeroU*::checked_next_power_of_two
- num::NonZeroU*::saturating_add
- os::unix::process::CommandExt::process_group
- os::windows::fs::FileTypeExt::is_symlink_dir
- os::windows::fs::FileTypeExt::is_symlink_file
- In den Kernbereich (core) und die Alloc-Bibliothek wurden zuvor im Modul std::ffi stabilisierte C-compatibles Typen hinzugefügt:
- core::ffi::CStr
- core::ffi::FromBytesWithNulError
- alloc::ffi::CString
- alloc::ffi::FromVecWithNulError
- alloc::ffi::IntoStringError
- alloc::ffi::NulError
- In die Module core::ffi und std::ffi wurden C-Typen, die zuvor im Modul std::os::raw stabilisiert wurden, hinzugefügt (zum Beispiel wurden für die C-Typen uint und ulong die Typen c_uint und c_ulong vorgeschlagen):
- ffi::c_char
- ffi::c_double
- ffi::c_float
- ffi::c_int
- ffi::c_long
- ffi::c_longlong
- ffi::c_schar
- ffi::c_short
- ffi::c_uchar
- ffi::c_uint
- ffi::c_ulong
- ffi::c_ulonglong
- ffi::c_ushort
- Niedrigstufige Handler wurden für die Verwendung mit dem Poll-Mechanismus stabilisiert (zukunftsorientiert ist ein vereinfachte API geplant, die keine niedrigstufigen Strukturen wie Pull und Pin erfordert):
- future::poll_fn
- task::ready!
- Das "const"-Merkmal, das die Verwendung in jedem Kontext anstelle von Konstanten definiert, wurde in der Funktion slice::from_raw_parts angewendet.
- Um die Datenspeicherung zu optimieren, wurde das Speichermapping der Strukturen Ipv4Addr, Ipv6Addr, SocketAddrV4 und SocketAddrV6 geändert. Dies kann zu Inkompatibilitäten mit Einzel- crate-Paketen führen, die std::mem::transmute für niedrigstufige Manipulationen von Strukturen verwenden.
- Im Rust-Compiler für die Windows-Plattform wurden PGO-Optimierungen (profilgesteuerte Optimierung) implementiert, die die Kompilierungsleistung um 10-20 % steigern konnten.
- Der Compiler implementiert eine neue Warnung für ungenutzte Felder in bestimmten Strukturen.
Zusätzlich kann der Statusbericht über die Entwicklung einer alternativen Implementierung des Rust-Compilers erwähnt werden, die vom gccrs-Projekt (GCC Rust) vorbereitet und für die Integration in GCC genehmigt wurde. Nach der Integration des Frontends wird das standardmäßige GCC-Werkzeugset zur Kompilierung von Programmen in Rust verwendet werden können, ohne dass der rustc-Compiler, der auf LLVM-Technologien basiert, installiert werden muss. Der Fortschritt verläuft planmäßig, und sofern keine unerwarteten Probleme auftreten, wird das Rust-Frontend in die kommende GCC-Version 13 integriert, die für Mai nächsten Jahres geplant ist. Die Rust-Implementierung in GCC 13 wird vorerst den Status einer Beta-Version haben und nicht standardmäßig aktiviert sein.
Quelle: opennet.ru
