Utgivning av Rust 1.86. Förberedelse av den officiella specifikationen för språket Rust

Det har publicerats en ny version av det allmänna programmeringsspråket Rust 1.86, som ursprungligen utvecklades av Mozilla men nu vidareutvecklas under den oberoende, ideella organisationen Rust Foundation. Språket fokuserar på säker minneshantering och erbjuder verktyg för att uppnå hög parallellism i uppgiftsutförande, utan att behöva använda en skräpare och runtime (runtime begränsas till grundläggande initialisering och stöd för 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öd för uppcasting av trait-typer till grundläggande supertrait har lagts till, vilket innebär att det nu är möjligt att omvandla en referens till ett trait-objekt direkt till en referens till ett supertrait-objekt utan att behöva skapa en specifik metod i traitet som returnerar en referens till supertraitet. En liknande operation kan också utföras med andra typer av smarta pekare, till exempel "Arc<dyn Trait> -> Arc<dyn Supertrait>" och "*const dyn Trait -> *const dyn Supertrait". trait Trait: Supertrait {} trait Supertrait {} fn upcast(x: &dyn Trait) -> &dyn Supertrait { x }
• En ny metod, get_disjoint_mut(), har lagts till i HashMap och skivor (slice) för att simultant få flera ändringsbara referenser till element. Tidigare tillät inte låne-checkern samtidiga användningar av referenser som erhölls via metoden get_mut(). let v = &mut [1, 2, 3]; if let Ok([a, b]) = v.get_disjoint_mut([0, 2]) { *a = 413; *b = 612; } assert_eq!(v, &[413, 2, 612]); if let Ok([a, b]) = v.get_disjoint_mut([0..1, 1..3]) { a[0] = 8; b[0] = 88; b[1] = 888; } assert_eq!(v, &[8, 88, 888]);
• Det har blivit tillåtet att märkta safe-funktioner med attributet "#[target_feature]", som anger att funktionen använder angivna CPU-funktioner. En safe-funktion, som är märkt med attributet "#[target_feature]", kan endast säkert anropas av en annan safe-funktion om den också är märkt med "#[target_feature]" (annars måste sådana funktioner anropas i en unsafe-block). De kan inte överföras till funktioner som accepterar generiska parametrar som begränsas av trait Fn*. Tidigare kunde attributet "#[target_feature]" endast tillämpas på funktioner märkta som "unsafe". #[target_feature(enable = "avx2")] fn requires_avx2() { // … } #[target_feature(enable = "avx2")] fn safe_callsite() { requires_avx2(); } fn unsafe_callsite() { if is_x86_feature_detected!("avx2") { unsafe { requires_avx2() }; } }
• I Rust-kompilatorn är debug-assertions aktiverade, vilket innebär att pekaren inte får vara null vid läsning och skrivning av icke-noll storlekar, samt vid återlån (reborrow) av pekaren till en referens. Till exempel, när debug-assertions är aktiverade kommer nedanstående kod nu att leda till ett "panic": let _x = *std::ptr::null::(); let _x = &*std::ptr::null::();
• Som standard är lint-checken "missing_abi" aktiverad, vilket resulterar i en varning om ABI inte anges efter nyckelordet extern. Tidigare antogs det att ABI "C" användes om none ABI angavs efter extern. Det rekommenderas nu att tydligt ange ABI "C", till exempel ‘extern "C" {}’ och ‘extern "C" fn’
• En ny uppsättning API har blivit stabiliserad, inklusive stabilisering av metoder och implementeringar av traits:
  • {float}::next_down
  • {float}::next_up
  • ::get_disjoint_mut
  • ::get_disjoint_unchecked_mut
  • slice::GetDisjointMutError
  • HashMap::get_disjoint_mut
  • HashMap::get_disjoint_unchecked_mut
  • NonZero::count_ones
  • Vec::pop_if
  • sync::Once::wait
  • sync::Once::wait_force
  • sync::OnceLock::wait
• Indikatorn "const" har tillämpats i funktioner:
  • hint::black_box
  • io::Cursor::get_mut
  • io::Cursor::set_position
  • str::is_char_boundary
  • str::split_at
  • str::split_at_checked
  • str::split_at_mut
  • str::split_at_mut_checked
• Det har lagts till ett tredje nivå av stöd för plattformar {aarch64-unknown,x86_64-pc}-nto-qnx710_iosock, {aarch64-unknown,x86_64-pc}-nto-qnx800, {x86_64,i686}-win7-windows-gnu, amdgcn-amd-amdhsa, x86_64-pc-cygwin, {mips,mipsel}-mti-none-elf, m68k-unknown-none-elf, armv7a-nuttx-{eabi,eabihf}, aarch64-unknown-nuttx och thumbv7a-nuttx-{eabi,eabihf}. Den tredje nivån innebär grundläggande stöd, men utan automatiserade tester, publicering av officiella byggen och verifiering av byggbarhet av koden.
• En varning har lagts till om att det andra nivån av stöd för målplattformen i586-pc-windows-msvc kommer att upphöra i nästa version (1.87). Det rekommenderas att använda plattformen i686-pc-windows-msvc, som erbjuder stöd för SSE2-instruktioner. Plattformen i586-pc-windows-msvc har förlorat sin relevans, eftersom stöd för SSE2 krävs för Windows 10, och äldre versioner av Windows stöds inte längre i Rust.

Det bör även nämnas att företaget Ferrocene har överlämnat språkets specifikation för Rust (FLS — Ferrocene Language Specification) till samhället, vilken skapades under utvecklingen av sitt Rust-kompilator för kritiska system och som periodiskt uppdateras med aktuell status av den primära Rust-kompilatorn. FLS-specifikationen innehåller en strukturerad och detaljerad vägledning om syntax, semantik och beteende för Rust, vilket är lämpligt för verifiering, bedömning av kompatibilitet och standardisering.

De överlämnade material kommer att användas för att skapa en referensspecifikation för programmeringsspråket Rust, vilket kan användas vid utveckling av alternativa kompilatorer och för att verifiera kompilatorn inom områden som är kritiska ur säkerhetssynpunkt.

Källa: opennet.ru