Lansare Rust 1.86. Pregătirea specificației oficiale a limbajului Rust

A fost publicată versiunea 1.86 a limbajului de programare de generație generală Rust, inițial dezvoltat de Mozilla, dar în prezent continuat sub tutela unei organizații independente non-profit, Rust Foundation. Limbajul se concentrează pe gestionarea sigură a memoriei și oferă instrumente pentru a atinge un înalt grad de paralelism în execuția sarcinilor, fără a necesita un colector de gunoi sau runtime (runtime-ul se limitează la inițializarea de bază și însoțirea bibliotecii standard).

Metodele de gestionare a memoriei în Rust scutesc dezvoltatorul de erori în manipularea pointerilor și protejează împotriva problemelor care apar din lucrul de nivel scăzut cu memoria, cum ar fi accesarea unui spațiu de memorie după ce acesta a fost eliberat, dereferința pointerilor nuli, depășirea limitelor buffer-ului etc. Pentru distribuirea bibliotecilor, asigurarea construirii și gestionarea dependențelor, se dezvoltă managerul de pachete Cargo. Pentru găzduirea bibliotecilor, suportul este oferit prin intermediul repository-ului crates.io.

Lucrul sigur cu memoria este asigurat în Rust în timpul compilării prin verificarea referințelor, urmărirea proprietății obiectelor, luarea în considerare a timpului de viață al obiectelor (domeniul de vizibilitate) și evaluarea corectitudinii accesului la memorie în timpul execuției codului. Rust oferă, de asemenea, instrumente pentru protejarea împotriva suprasaturării numerice, impune inițializarea obligatorie a valorilor variabilelor înainte de utilizare, gestionează mai bine erorile în biblioteca standard, aplică conceptul de referințe și variabile imutabile (immutable) din oficiu și oferă o tipizare statică puternică pentru a minimiza erorile logice.

Noutăți principale:

• A fost adăugată suportul pentru upcasting-ul trăsăturilor către supertrăsăturile de bază (supertrait), adică a apărut posibilitatea de a transforma direct o referință la un obiect al unei trăsături într-o referință la un obiect al supertrăsăturii, fără a fi necesară crearea unui metodă specială în trăsătură, care să returneze o referință la supertrăsătură. Aceleași operațiuni pot fi efectuate și cu alte tipuri de pointeri inteligenți, de exemplu, "Arc -> Arc" și "*const dyn Trait -> *const dyn Supertrait". trait Trait: Supertrait {} trait Supertrait {} fn upcast(x: &dyn Trait) -> &dyn Supertrait { x }
• În HashMap și pe slice-uri a fost adăugat metoda get_disjoint_mut() pentru obținerea simultană a mai multor referințe mutabile la elemente. Precedent, borrow checker-ul nu permitea utilizarea simultană a referințelor obținute prin metoda 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]);
• A fost permisă marcarea funcțiilor sigure (safe) cu ajutorul atributului "#[target_feature]", care indică faptul că funcția utilizează anumite funcționalități ale CPU-ului. O funcție sigură, marcată cu atributul "#[target_feature]", poate fi apelată în siguranță de o altă funcție sigură doar cu condiția ca aceasta să fie de asemenea marcată cu "#[target_feature]" (în caz contrar, aceste funcții trebuie apelate în interiorul unui bloc unsafe). De asemenea, acestea nu pot fi transmise funcțiilor care acceptă parametri generici restricționați de trăsături Fn*. Anterior, atributul "#[target_feature]" putea fi aplicat doar funcțiilor marcate ca "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() }; } }
• În compilatorul Rust este inclusă verificarea debug-assert, care asigură că un pointer nu conține valoarea NULL atunci când este citit și scris cu dimensiuni nenule, precum și atunci când este împrumutat din nou (reborrow) ca o referință. De exemplu, cu această verificare activată, codul de mai jos va duce acum la o stare de panică: let _x = *std::ptr::null::(); let _x = &*std::ptr::null::();
• În mod implicit, este activată verificarea lint "missing_abi", care generează o avertizare dacă ABI nu este specificat după cuvântul cheie extern. Anterior, dacă ABI nu era menționat după extern, se presupunea că se folosește ABI „C”. Acum se recomandă specificarea explicită a ABI „C”, de exemplu, ‘extern “C” {}’ și ‘extern “C” fn’.
• O nouă porțiune de API a fost transformată în stabilitate, inclusiv metode și implementări ale tiparelor stabilize.
  • {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
• Semnul „const” aplicat în funcții:
  • 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
• A fost implementat un al treilea nivel de suport pentru platformele {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 și thumbv7a-nuttx-{eabi,eabihf}. Al treilea nivel implică suport de bază, dar fără testare automatizată, publicarea de build-uri oficiale și verificarea posibilității de a compila codul.
• A fost adăugată o avertizare privind încetarea suportului de nivel doi pentru platforma țintă i586-pc-windows-msvc în următoarea versiune (1.87). Se recomandă utilizarea platformei i686-pc-windows-msvc, care are suport pentru instrucțiunile SSE2. Platforma i586-pc-windows-msvc a devenit obsoletă, deoarece Windows 10 necesită suport pentru SSE2, iar versiunile anterioare de Windows în Rust nu sunt acceptate.

De asemenea, se poate menționa că compania Ferrocene a transmis comunității specificația pentru limbajul Rust (FLS — Ferrocene Language Specification), creată în procesul de dezvoltare a propriului compilator Rust pentru sisteme critice și sincronizată periodic cu starea actuală a compilatorului principal Rust. Specificația FLS include un ghid structurat și detaliat despre sintaxa, semantica și comportamentul Rust, util pentru verificare, evaluarea compatibilității și standardizare.

Materialele transmise vor fi utilizate pentru a crea o specificație de referință pentru limbajul Rust, care va putea fi folosită în dezvoltarea de compilatoare alternative și pentru verificarea compilatorului în domenii cruciale din punct de vedere al securității.

Sursa: opennet.ro