È stato pubblicato il rilascio del linguaggio di programmazione di uso generale Rust 1.86, originariamente sviluppato da Mozilla, ora mantenuto sotto l'egida dell'organizzazione no-profit indipendente Rust Foundation. Il linguaggio è focalizzato sulla sicurezza della gestione della memoria e fornisce strumenti per raggiungere un alto parallelismo nell'esecuzione dei compiti, evitando l'uso di garbage collector e runtime (il runtime si riduce all'inizializzazione di base e all'accompagnamento della libreria standard).
I metodi di gestione della memoria in Rust liberano gli sviluppatori dagli errori di manipolazione dei puntatori e li proteggono da problemi derivanti da operazioni a basso livello con la memoria, come l'accesso a aree di memoria dopo il loro rilascio, la dereferenziazione di puntatori nulli, l'uscita dai limiti del buffer, ecc. Per la distribuzione delle librerie, l'assicurazione della compilazione e la gestione delle dipendenze, il progetto promuove il gestore di pacchetti Cargo. È supportato un repository per l'hosting delle librerie su crates.io.
La gestione sicura della memoria in Rust è garantita durante la compilazione attraverso il controllo dei riferimenti, il tracciamento della proprietà degli oggetti, la considerazione del tempo di vita degli oggetti (ambiti di visibilità) e la valutazione della correttezza dell'accesso alla memoria durante l'esecuzione del codice. Rust fornisce anche strumenti per proteggere da overflow interi, richiede l'inizializzazione obbligatoria 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 minimizzare gli errori logici.
Novità principali:
- È stata aggiunta la supporto per l'upcast delle trait al supertrait di base, ovvero è ora possibile convertire direttamente un riferimento a un oggetto di trait in un riferimento a un oggetto di supertrait senza la necessità di creare un metodo speciale nel trait che restituisca un riferimento al supertrait. Un'operazione simile può essere effettuata anche con altri tipi di puntatori intelligenti, ad esempio, «Arc -> Arc» e «*const dyn Trait -> *const dyn Supertrait». trait Trait: Supertrait {} trait Supertrait {} fn upcast(x: &dyn Trait) -> &dyn Supertrait { x }
- In HashMap e negli slice è stato aggiunto il metodo get_disjoint_mut() per ottenere simultaneamente più riferimenti mutabili agli elementi. In precedenza, il borrow checker non consentiva l'uso simultaneo di riferimenti ottenuti tramite il metodo 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]);
- È consentito contrassegnare le funzioni safe attraverso l'attributo «#[target_feature]», che indica che la funzione utilizza determinate funzionalità della CPU. Una funzione safe contrassegnata con l'attributo «#[target_feature]» può essere chiamata in modo sicuro da un'altra funzione safe solo se anch'essa è contrassegnata da «#[target_feature]» (in caso contrario, tali funzioni devono essere chiamate in un blocco unsafe). Inoltre, non possono essere passate a funzioni che accettano parametri generici vincolati da trait Fn*. In precedenza, l'attributo «#[target_feature]» poteva essere applicato solo a funzioni contrassegnate come «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 è abilitato il controllo di debug (debug-assert), che verifica che il puntatore non contenga un valore NULL durante la lettura e la scrittura di dimensioni non nulle, così come durante il riutilizzo (reborrow) del puntatore in un riferimento. Ad esempio, con il controllo di debug attivato, il codice qui sotto porterà ora a uno stato di «panic»: let _x = *std::ptr::null::(); let _x = &*std::ptr::null::();
- Per impostazione predefinita, è abilitato il controllo lint «missing_abi», che genera un avviso se dopo la parola chiave extern non è specificato l'ABI. In precedenza, se dopo extern non era specificato l'ABI, si presumeva che si stesse utilizzando 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 trasformata in versioni stabili, inclusi i metodi stabilizzati e le implementazioni delle trait:
- {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 segnale «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 il 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 supporto di base, ma senza test automatizzati, pubblicazione di versioni ufficiali e verifica della possibilità di compilazione del codice.
- È stato aggiunto un avviso riguardante la 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 offre supporto per le istruzioni SSE2. La piattaforma i586-pc-windows-msvc non ha più senso, poiché per Windows 10 è necessario il supporto SSE2, e le versioni precedenti di Windows non sono supportate in Rust.
Inoltre, si può notare che l'azienda Ferrocene ha trasmesso alla comunità la specifica del linguaggio Rust (FLS — Ferrocene Language Specification), creata nel processo di sviluppo del proprio compilatore Rust per sistemi critici e sincronizzata periodicamente con lo stato attuale del compilatore Rust principale. La specifica FLS include una guida strutturata e dettagliata sulla sintassi, semantica e comportamento del Rust, adatta per la verifica, valutazione della compatibilità e standardizzazione.
I materiali forniti verranno utilizzati per creare una specifica di riferimento per il linguaggio Rust, che potrà essere utilizzata nello sviluppo di compilatori alternativi e per il collaudo del compilatore in aree critiche per la sicurezza.
Fonte: opennet.ru
