Rust-Version 1.79. Ein Konsortium zur Entwicklung hochzuverlässiger Systeme in Rust wurde gegründet.

Die Version der universellen Programmiersprache Rust 1.79, die ursprünglich von Mozilla erstellt, aber inzwischen unter der Schirmherrschaft der unabhängigen gemeinnützigen Organisation Rust Foundation weiterentwickelt wird, wurde veröffentlicht. Die Sprache konzentriert sich auf die sichere Arbeit mit Speicher und bietet Werkzeuge zur Erreichung einer hohen Parallelität bei der Ausführung von Aufgaben, ohne einen Garbage Collector und Runtime (die Runtime beschränkt sich auf die grundlegende Initialisierung und Pflege der Standardbibliothek) verwenden zu müssen.

Die Methoden zur Speicherverwaltung in Rust befreien den Entwickler von Fehlern beim Umgang mit Zeigern und schützen vor Problemen, die durch niedrige Speicherverwaltung entstehen, wie z. B. den Zugriff auf Speicherbereiche nach deren Freigabe, Dereferenzierung von Nullzeigern, Pufferüberläufen usw. Zur Verbreitung von Bibliotheken, zur Gewährleistung des Builds und zur Verwaltung von Abhängigkeiten wird der Paketmanager Cargo entwickelt. Für das Hosting von Bibliotheken wird das Repository crates.io unterstützt.

Sichere Speicherverwaltung wird in Rust während der Kompilierung durch Überprüfung von Referenzen, Nachverfolgung des Eigentums an Objekten, Berücksichtigung der Lebensdauer von Objekten (Sichtbarkeitsbereiche) und Bewertung der Korrektheit des Zugriffs auf den Speicher während der Ausführung des Codes gewährleistet. Rust bietet ebenfalls Mittel zum Schutz vor Überläufen bei Ganzzahlen, fordert die zwingende Initialisierung von Variablenwerten vor deren Verwendung und behandelt Fehler in der Standardbibliothek besser. Außerdem wird das Konzept der Unveränderlichkeit (immutable) von Referenzen und Variablen standardmäßig angewendet, und es bietet eine starke statische Typisierung zur Minimierung logischer Fehler.

Hauptneuheiten:

• Die Unterstützung für Inline-Konstanten wurde hinzugefügt, die direkt im Code mithilfe von Blöcken «const { … }» angegeben werden können. Diese werden im Kontext von Konstanten verarbeitet und ermöglichen es, auf separate Definitionen von Konstanten zu verzichten. Der im Block «const { … }» angegebene Code wird zur Kompilierungszeit berechnet und als Konstante verwendet, ohne während der Programmausführung ausgeführt zu werden. Im Gegensatz zur Definition von Konstanten über den Ausdruck «const ITEM: … = …» muss im Block «const { … }» kein Typ angegeben werden, da hier die automatische Typableitung unterstützt wird. Zum Beispiel kann der Code mit einer separaten Konstantendefinition

  const EMPTY: Option<Vec> = None;
  let foo = [EMPTY; 100];

  durch die Verwendung vor Ort ersetzt werden:

  let foo = [const { None }; 100];

• Die Syntax «T: Trait» zur Angabe von Einschränkungen in der Position des assoziativen Typs wurde stabilisiert, was die Definition von Ausdrücken mit verschachtelten Typbeschränkungen verkürzt, die zuvor die Angabe einer verschachtelten impl Trait oder mehrerer «where»-Bedingungen erforderten.
• Es wurde sichergestellt, dass temporäre Werte, die in «match»- und «if»-Konstruktionen verwendet werden, automatisch eine Lebensdauerverlängerung erhalten.

  let a = if true {
  ..;
  &temp() // Die Lebensdauer wird verlängert
  } else {
  ..;
  &temp() // Die Lebensdauer wird verlängert
  };

• Die Möglichkeit, die Funktion main aus anderen Modulen und crate-Paketen zu importieren, wurde stabilisiert.
• Beim Bau der Standardbibliothek wird im Compiler das Flag «-Cforce-frame-pointers=yes» verwendet, das Daten zur Rekonstruktion des Stacks während der Profilerstellung von Programmen hinzufügt.
• Eine neue Charge von APIs wurde in den stabilen Bereich überführt, darunter wurden Methoden und Implementierungen von Traits stabilisiert:
  • {integer}::unchecked_add
  • {integer}::unchecked_mul
  • {integer}::unchecked_sub
  • ::split_at_unchecked
  • ::split_at_mut_unchecked
  • ::utf8_chunks
  • str::Utf8Chunks
  • str::Utf8Chunk
  • ::is_aligned
  • ::is_aligned
  • NonNull::is_aligned
  • ::len
  • ::len
  • ::is_empty
  • ::is_empty
  • NonNull::::is_empty
  • CStr::count_bytes
  • io::Error::downcast
  • num::NonZero
  • path::absolute
  • proc_macro::Literal::byte_character
  • proc_macro::Literal::c_string
• Das Zeichen „const“, das die Verwendung in jedem Kontext anstelle von Konstanten bestimmt, wird in Funktionen angewendet:
  • Atomic*::into_inner
  • io::Cursor::new
  • io::Cursor::get_ref
  • io::Cursor::position
  • io::empty
  • io::repeat
  • io::sink
  • panic::Location::caller
  • panic::Location::file
  • panic::Location::line
  • panic::Location::column
• Stabilisiert
  teilweise Möglichkeiten, die bei der Kompilierung in ein intermediäres Format von Webassembly (WASM) verwendet werden können.
• Die dritte Unterstützungsebene wurde für die Plattformen aarch64-apple-visionos, aarch64-apple-visionos-sim und riscv32ima-unknown-none-elf implementiert. Die dritte Ebene umfasst grundlegende Unterstützung, jedoch ohne automatisierte Tests, Veröffentlichung offizieller Builds und Überprüfung der Fähigkeit zur Kompilierung von Code.
• Die zweite Unterstützungsebene für die Zielplattformen aarch64-pc-windows-gnullvm, i686-pc-windows-gnullvm und x86_64-pc-windows-gnullvm wurde implementiert. Die zweite Unterstützungsebene gewährleistet die Kompilierung.

Darüber hinaus hat die Rust Foundation, die das mit der Programmiersprache Rust verbundene Ökosystem betreut, die Gründung des „Safety-Critical Rust Consortium“ angekündigt, das darauf abzielt, die Programmiersprache Rust in Lösungen zu verwenden, die eine hohe Zuverlässigkeit erfordern (Safety-Critical Software), deren Ausfall das Leben von Menschen gefährden, der Umwelt schaden oder zu schweren Schäden an der Ausrüstung führen kann. Zu den Mitgliedsunternehmen des Konsortiums gehören ARM, AdaCore, Ferrous Systems, OxidOS, Synopsys, HighTec EDV-Systeme GmbH, TrustInSoft, Veecle und Woven by Toyota. Zu den Aufgaben des Konsortiums zählen die Erstellung von Leitfäden und die Entwicklung von Bibliotheken, Linter und statischen Analysatoren sowie die Anwendung von Methoden zur formalen Verifikation der Zuverlässigkeit und die Entwicklung von Untergruppen der Sprache für hochzuverlässige Systeme.

Unter den Projekten, die mit hochzuverlässigen Systemen verbunden sind, kann Verus hervorgehoben werden – ein Werkzeug für die Überprüfung der Korrektheit von Code, der in der Programmiersprache Rust geschrieben ist. Die Überprüfung erfolgt durch die Definition einer Spezifikation, die das zulässige Verhalten des Codes beschreibt. Während der Ausführung des ausführbaren Codes prüft Verus die Einhaltung der Spezifikation zur Bestätigung der Korrektheit.

Quelle: opennet.ru