Rilascio di Rust 1.86. Preparazione della specifica ufficiale del linguaggio Rust

È stato pubblicato il rilascio del linguaggio di programmazione generico Rust 1.86, originariamente sviluppato da Mozilla, ma attualmente gestito sotto l'egida dell'organizzazione no-profit indipendente Rust Foundation. Questo linguaggio è focalizzato sulla gestione sicura della memoria e offre strumenti per ottenere un elevato parallelismo nell'esecuzione delle operazioni, senza utilizzare un garbage collector né un runtime (il runtime si limita all'inizializzazione di base e alla gestione della libreria standard).

I metodi di gestione della memoria in Rust liberano gli sviluppatori dagli errori nella manipolazione dei puntatori e li proteggono da problematiche derivanti dal lavoro a basso livello con la memoria, come l'accesso a zone di memoria dopo la loro liberazione, la dereferenziazione di puntatori nulli, il superamento dei limiti del buffer, e così via. Per la distribuzione delle librerie, la gestione della compilazione e delle dipendenze, si è sviluppato un gestore di pacchetti chiamato Cargo. Le librerie sono ospitate nel repository crates.io.

La gestione sicura della memoria in Rust è garantita durante la compilazione tramite il controllo dei riferimenti, il tracciamento della proprietà degli oggetti, la gestione della durata degli oggetti (scope) e la valutazione della correttezza dell'accesso alla memoria durante l'esecuzione del codice. Rust offre anche strumenti per proteggere da overflow interi, richiede l'inizializzazione obbligatoria dei valori delle variabili prima dell'uso, gestisce meglio gli errori nella libreria standard, applica il concetto di riferimenti e variabili immutabili per impostazione predefinita e offre una forte tipizzazione statica per ridurre al minimo gli errori logici.

Novità principali:

• È stato aggiunto il supporto per il casting (upcast) dei trait al supertrait di base, ovvero è ora possibile convertire direttamente un riferimento a un oggetto di un trait in un riferimento a un oggetto del supertrait senza dover creare un metodo speciale nel trait che restituisca un riferimento al supertrait. È possibile eseguire operazioni simili anche con altri tipi di smart pointer, ad esempio, «Arc<dyn Trait> -> Arc<dyn Supertrait>» e «*const dyn Trait -> *const dyn Supertrait». trait Trait: Supertrait {} trait Supertrait {} fn upcast(x: &dyn Trait) -> &dyn Supertrait { x }
• In HashMap and slices, a new method get_disjoint_mut() has been added for simultaneously obtaining multiple mutable references to elements. Previously, the borrow checker did not allow simultaneous use of references obtained using the get_mut() method. 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]);
• It is now permitted to mark safe functions with the attribute "#[target_feature]", indicating that the function uses specified CPU capabilities. A safe function marked with the "#[target_feature]" attribute can be safely called by another safe function only if it is also marked with "#[target_feature]" (otherwise, such functions must be called within an unsafe block). They cannot be passed to functions that accept generic arguments constrained by the Fn* traits. Previously, the "#[target_feature]" attribute could only be applied to functions marked as "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() }; } }
• Nel compilatore Rust è attivata l'assegnazione di controlli di debug (debug-assert), per garantire che il puntatore non contenga un valore NULL durante la lettura e la scrittura di dimensioni non nulle, e anche durante la riempiego (reborrow) del puntatore in un riferimento. Ad esempio, attivando i controlli di debug, il seguente codice ora provocherà uno stato di «panic»: let _x = *std::ptr::null::(); let _x = &*std::ptr::null::();
• Per impostazione predefinita, è attivata la lint-check «missing_abi», che genera un avviso se dopo la parola chiave extern non viene specificato ABI. In precedenza, se non veniva specificato ABI dopo extern, si presumeva che si utilizzasse l'ABI «C». Ora si raccomanda di specificare esplicitamente l'ABI «C», ad esempio, ‘extern «C» {}’ e ‘extern «C» fn’
• Una nuova serie di API è stata traslata nella categoria stabile, stabilizzando i metodi e le implementazioni dei tipi:
  • {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
• Il flag «const» è stato applicato nelle funzioni:
  • 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
• È stato implementato un terzo livello di supporto per le piattaforme {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 e thumbv7a-nuttx-{eabi,eabihf}. Il terzo livello implica un supporto di base, ma senza test automatizzati, pubblicazione di build ufficiali e verifica della possibilità di compilare il codice.
• È stato aggiunto un avviso di cessazione del secondo livello di supporto per la piattaforma target i586-pc-windows-msvc nella prossima versione (1.87). Si consiglia di utilizzare la piattaforma i686-pc-windows-msvc, che supporta le istruzioni SSE2. La piattaforma i586-pc-windows-msvc ha perso significato, poiché per Windows 10 è necessaria la compatibilità con SSE2, e le versioni precedenti di Windows non sono supportate in Rust.

Inoltre, si può notare che l'azienda Ferrocene ha condiviso con la comunità la specifica del linguaggio Rust (FLS — Ferrocene Language Specification), creata durante lo sviluppo del proprio compilatore Rust per sistemi critici e periodicamente sincronizzata con lo stato attuale del compilatore Rust principale. La specifica FLS include una guida strutturata e dettagliata sulla sintassi, semantica e comportamento di Rust, adatta per la verifica, la valutazione della compatibilità e la standardizzazione.

I materiali forniti saranno utilizzati per creare una specifica di riferimento per il linguaggio Rust, che potrà essere impiegata nello sviluppo di compilatori alternativi e per la verifica dei compilatori in aree critiche dal punto di vista della sicurezza.

Fonte: opennet.ru