Utgåvan av Rust 1.79. Ett konsortium har bildats för att utveckla högpålitliga system med Rust

Tillkännagivandet av versionssläppet av programmeringsspråket Rust 1.79, som ursprungligen utvecklades av Mozilla men numera underhålls av den oberoende icke-vinstdrivande organisationen Rust Foundation. Språket fokuserar på säker minneshantering och erbjuder verktyg för att uppnå hög parallellism i exekveringen av uppgifter, utan att använda skräpsamling eller runtime (runtime begränsar sig till grundläggande initialisering och underhåll av standardbiblioteket).

Minneshanteringsmetoderna i Rust skyddar utvecklare från att göra fel vid manipulering av pekare och skyddar mot problem som uppstår vid låg nivå minnesarbete, såsom att komma åt minnesområden efter att de har frigjorts, dereferera nullpekare, buffer overflow, etc. För distribution av bibliotek, byggande och hantering av projektberoenden utvecklas paketförvaltaren Cargo. För lagring av bibliotek stöds ett repository på crates.io.

Säker minneshantering säkerställs i Rust under kompilering genom att kontrollera referenser, spåra ägandeskap över objekt, ta hänsyn till livslängden av objekt (synlighet) och utvärdera korrekt minnesåtkomst under körning av koden. Rust erbjuder också verktyg för att skydda mot heltalsöverflöden, kräver obligatorisk initialisering av variabelvärden innan de används, hanterar fel bättre i standardbiblioteket, tillämpar konceptet av oföränderliga (immutable) referenser och variabler som standard och erbjuder stark statisk typning för att minimera logiska fel.

Huvudsakliga nyheter:

• Stödet för inline-konstanter har lagts till, vilket gör att man kan ange dem direkt i koden med hjälp av blocken «const { … }», som bearbetas i kontexten av konstanter och gör det möjligt att undvika separata konstansdefinitioner. Koden som anges i blocket «const { … }» beräknas vid kompilering och används som konstant, utan att utföras under programmets körning. Till skillnad från att definiera konstanter genom uttrycket «const ITEM: … = …», kan man i blocken «const { … }» utelämna typen, eftersom automatisk typutvinning stöds där. Till exempel, koden med en separat konstandefinition.

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

  kan ersättas med användning på plats:

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

• Syntaxen «T: Trait» för att ange begränsningar i positionen för ett associerat typ har stabiliserats, vilket förenklar definitionen av uttryck med inbäddade typbegränsningar som tidigare krävde angivande av inbäddad impl Trait eller flera villkor «where».
• Automatiskt livslängdsförlängning för temporära värden som används i konstruktionerna «match» och «if» har säkerställts.

  let a = if true {
  ..;
  &temp() // livslängden kommer att förlängas
  } else {
  ..;
  &temp() // livslängden kommer att förlängas
  };

• Möjligheten att importera funktionen main från andra moduler och crate-paket har stabiliserats.
• Vid sammansättning av standardbiblioteket används flaggan «-Cforce-frame-pointers=yes» i kompilatorn, vilket lägger till data för stackåterställning under programprofilering.
• En ny uppsättning API har blivit stabiliserad, inklusive stabilisering av metoder och implementeringar av traits:
  • {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
• Beteckningen «const», som definierar möjligheten att använda det i vilken kontext som helst istället för konstanter, används i funktioner:
  • 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
• Stabiliserad
  en del av funktionerna som kan användas vid kompilering till det intermediära representationsformatet Webassembly (WASM).
• Den tredje nivån av stöd för plattformarna aarch64-apple-visionos, aarch64-apple-visionos-sim och riscv32ima-unknown-none-elf har implementerats. Tredje nivån innebär grundläggande stöd, men utan automatiserad testning, publicering av officiella byggen och verifiering av byggbarheten av koden.
• Den andra nivån av stöd för målplattformarna aarch64-pc-windows-gnullvm, i686-pc-windows-gnullvm och x86_64-pc-windows-gnullvm har implementerats. Den andra nivån av stöd garanterar byggbarhet.

Dessutom har organisationen Rust Foundation, som övervakar ekosystemet kring programmeringsspråket Rust, tillkännagett skapandet av konsortiet "Safety-Critical Rust Consortium", som syftar till att använda Rust i lösningar som kräver högre tillförlitlighet (Safety-Critical Software), vars fel kan hota människors liv, orsaka skada på miljön eller leda till allvarliga skador på utrustning. Företagen ARM, AdaCore, Ferrous Systems, OxidOS, Synopsys, HighTec EDV-Systeme GmbH, TrustInSoft, Veecle och Woven by Toyota har gått med i konsortiet. Några av de uppgifter som konsortiet kommer att hantera inkluderar att skriva riktlinjer och utveckla bibliotek, linters och statiska analyzatorer, samt tillämpa metoder för formell verifiering av tillförlitlighet och utveckla delmängder av språket för hög-tillförlitliga system.

Bland projekten kopplade till hög-tillförlitliga system kan nämnas Verus — ett verktyg för att verifiera korrektheten av kod som skrivits med Rust. Verifieringen sker genom att definiera en specifikation som beskriver det tillåtna beteendet hos koden. Under körningen av den exekverbara koden kontrollerar Verus att specifikationen följs för att bekräfta att funktionen fungerar korrekt.

Källa: opennet.ru