Rilascio del linguaggio di programmazione Rust 1.59 con supporto per inserimenti in assembler

È stato pubblicato il rilascio del linguaggio di programmazione generale Rust 1.59, originariamente sviluppato da Mozilla e attualmente gestito dalla Rust Foundation, un'organizzazione indipendente e no-profit. Il linguaggio si concentra sulla gestione sicura della memoria e offre strumenti per raggiungere un elevato parallelismo nell'esecuzione dei compiti, senza fare uso di garbage collector e runtime (il runtime è limitato all'inizializzazione di base e al supporto 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:

• Предоставлена возможность использования ассемблерных вставок, востребованных в приложениях, которым необходимо управлять выполнением на низком уровне или иметь возможность использования специализированных машинных инструкций. Ассемблерные вставки добавляются при помощи макросов «asm!» и «global_asm!» с использованием для именования регистров синтаксиса форматирования строк, аналогичного тому, что используется в строковых подстановках в Rust. Компилятором поддерживаются ассемблерные инструкции для архитектур x86, x86-64, ARM, AArch64 и RISC-V. Пример вставки: use std::arch::asm; // Multiply x by 6 using shifts and adds let mut x: u64 = 4; unsafe { asm!( «mov {tmp}, {x}», «shl {tmp}, 1», «shl {x}, 2», «add {x}, {tmp}», x = inout(reg) x, tmp = out(reg) _, ); } assert_eq!(x, 4 * 6);
• Добавлена поддержка деструктурированных (параллельных) присвоений, в которых в левой части выражения указывается несколько типажей, слайсов или структур. Например: let (a, b, c, d, e); (a, b) = (1, 2); [c, .., d, _] = [1, 2, 3, 4, 5]; Struct { e, .. } = Struct { e: 5, f: 3 }; assert_eq!([1, 2, 1, 4, 5], [a, b, c, d, e]);
• È stata fornita la possibilità di specificare valori predefiniti per i generici costanti («const generics»): struct ArrayStorage { arr: [T; N], } impl ArrayStorage { fn new(a: T, b: T) -> ArrayStorage { ArrayStorage { arr: [a, b], } } }
• Nel gestore di pacchetti Cargo è stato implementato un avviso riguardante l'uso di costrutti non validi nelle dipendenze, gestiti a causa di errori del compilatore (ad esempio, a causa di un errore, era permessa l'acquisizione di campi di strutture incapsulate in blocchi safe). Il supporto per tali costrutti verrà interrotto in una futura versione di Rust.
• In cargo e rustc è stata incorporata la possibilità di generare file eseguibili privi di dati di debug (strip = «debuginfo») e simboli (strip = «symbols»), senza la necessità di chiamare un'utilità separata. La configurazione della pulizia è implementata tramite il parametro «strip» in Cargo.toml: [profile.release] strip = «debuginfo», «symbols»
• Per impostazione predefinita, la compilazione incrementale è disabilitata. La causa è un bypass temporaneo di un errore nel compilatore che provoca arresti anomali e errori di deserializzazione. La correzione dell'errore è già pronta e sarà inclusa nella prossima versione. Per riattivare la compilazione incrementale, è possibile utilizzare la variabile di ambiente RUSTC_FORCE_INCREMENTAL=1.
• Una nuova serie di API è stata traslata nella categoria stabile, stabilizzando i metodi e le implementazioni dei tipi:
  • std::thread::available_parallelism
  • Result::copied
  • Result::cloned
  • arch::asm!
  • arch::global_asm!
  • ops::ControlFlow::is_break
  • ops::ControlFlow::is_continue
  • TryFrom for u8
  • char::TryFromCharError (Clone, Debug, Display, PartialEq, Copy, Eq, Error)
  • iter::zip
  • NonZeroU8::is_power_of_two
  • NonZeroU16::is_power_of_two
  • NonZeroU32::is_power_of_two
  • NonZeroU64::is_power_of_two
  • NonZeroU128::is_power_of_two
  • DoubleEndedIterator per la struttura ToLowercase
  • DoubleEndedIterator per la struttura ToUppercase
  • TryFrom<&mut [T]> per [T; N]
  • UnwindSafe per la struttura Once
  • RefUnwindSafe per Once
  • funzioni di supporto armv8 neon integrate nel compilatore per aarch64
• L'indicatore «const», che determina la possibilità di utilizzo in qualsiasi contesto al posto delle costanti, è stato applicato nelle funzioni:
  • mem::MaybeUninit::as_ptr
  • mem::MaybeUninit::assume_init
  • mem::MaybeUninit::assume_init_ref
  • ffi::CStr::from_bytes_with_nul_unchecked

Fonte: opennet.ru