Release of Rust 1.53. Google will fund the addition of Rust support in the Linux kernel.

Megjelent a Mozilla által indított Rust 1.53 rendszernyelv, amelyet most egy független, nonprofit szervezet, a Rust Foundation fejleszt. A nyelv a memória biztonságos kezelésére összpontosít, automatikus memória kezelést biztosít, és lehetőséget ad a feladatok magas párhuzamosságának elérésére, mindezt a hulladékgyűjtő és futási idő (runtime) használata nélkül, amely csupán az alapvető inicializálásra és a standard könyvtár karbantartására korlátozódik.

A Rust automatikus memória kezelése megszünteti a fejlesztők által a mutatókkal végzett manipulációkból adódó hibákat, és védelmet nyújt a memória alacsony szintű működésével kapcsolatos problémák, például a felszabadított memória területére való hivatkozás, a null mutatók dereferálása, a pufferek túllépése stb. ellen. A könyvtárak terjesztésére, a fordítás biztosítására és a projekt függőségeinek kezelésére a Cargo csomagkezelő fejlesztés alatt áll.

Főbb újítások:

• A tömbök esetében megvalósításra került az IntoIterator tulajdonság, amely lehetővé teszi a tömb elemeinek értékenkénti iterálását: for i in [1, 2, 3] { .. }

  Emellett lehetőség nyílt tömbök átadására olyan metódusoknak, amelyek iterátorokat várnak, például: let set = BTreeSet::from_iter([1, 2, 3]); for (a, b) in some_iterator.chain([1]).zip([1, 2, 3]) { .. }

  Korábban az IntoIterator csupán a tömbokra való hivatkozásokra volt megvalósítva, azaz az elemek értékenkénti iterálásához hivatkozások („&[1, 2, 3]”) vagy „[1, 2, 3].iter()” használata volt szükséges. Az IntoIterator tömbökre való megvalósítása problémákba ütközött, amelyeket a fordítóhoz hozzáadott array.into_iter() metódus átírási problémái okoztak, amikor átalakítja azt (&array).into_iter(). E probléma megoldására egy kerülőút segítségével képes lesz a fordító az array.into_iter() -t az (&array).into_iter() -re alakítani, mintha az IntoIterator tulajdonság megvalósítása hiányozna, de csak akkor, amikor a metódust a „.into_iter()” szintaxissal hívják meg, anélkül, hogy a „in [1, 2, 3]”, „iter.zip([1, 2, 3])”, „IntoIterator::into_iter([1, 2, 3])” formájú hívásokra vonatkoznának.

• Lehetővé vált a "|" (logikai OR művelet) kifejezések feltüntetése a sablon bármely részén, például a "Some(1) | Some(2)" helyett most már írhatjuk, hogy "Some(1 | 2)": match result { Ok(Some(1 | 2)) => { .. } Err(MyError { kind: FileNotFound | PermissionDenied, .. }) => { .. } _ => { .. } }
• ASCII karakterek, beleértve a Unicode UAX 31 specifikációban meghatározott nemzeti karaktereket is, használata engedélyezett az azonosítókban, de az emoji karakterek kivételével. Ha eltérő, de hasonló formájú karaktereket használnak, a fordító figyelmeztetést ad. const BLÅHAJ: &str = «🦈»; struct 人 { 名字: String, } let α = 1; let ｓos = 2; warning: az ‘ｓ’ és ‘s’ közötti azonosító pár zavarosnak minősül.
• Új API-k stabilizált részletei kerültek át a stabil sorozatba, beleértve a következőket:
  • array::from_ref
  • array::from_mut
  • AtomicBool::fetch_update
  • AtomicPtr::fetch_update
  • BTreeSet::retain
  • BTreeMap::retain
  • BufReader::seek_relative
  • cmp::min_by
  • cmp::min_by_key
  • cmp::max_by
  • cmp::max_by_key
  • DebugStruct::finish_non_exhaustive
  • Duration::ZERO
  • Duration::MAX
  • Duration::is_zero
  • Duration::saturating_add
  • Duration::saturating_sub
  • Duration::saturating_mul
  • f32::is_subnormal
  • f64::is_subnormal
  • IntoIterator tömbökhöz
  • {integer}::BITS
  • io::Error::Unsupported
  • NonZero*::leading_zeros
  • NonZero*::trailing_zeros
  • Option::insert
  • Ordering::is_eq
  • Ordering::is_ne
  • Ordering::is_lt
  • Ordering::is_gt
  • Ordering::is_le
  • Ordering::is_ge
  • OsStr::make_ascii_lowercase
  • OsStr::make_ascii_uppercase
  • OsStr::to_ascii_lowercase
  • OsStr::to_ascii_uppercase
  • OsStr::is_ascii
  • OsStr::eq_ignore_ascii_case
  • Peekable::peek_mut
  • Rc::increment_strong_count
  • Rc::decrement_strong_count
  • slice::IterMut::as_slice
  • AsRef<[T]> a slice::IterMut számára
  • impl SliceIndex a (Bound<usize>, Bound<usize>)-ra
  • Vec::extend_from_within
• Harmadik szintű támogatás valósult meg a wasm64-unknown-unknown platformon. A harmadik szint alapvető támogatást jelent, de automatizált tesztelés, hivatalos kiadások közzététele és a kód összeállításának ellenőrzése nélkül.
• A Cargo csomagkezelő alapértelmezés szerint a «main» nevet használja a Git-repozitórium fő ágához (HEAD). A main névre átnevezett repókhoz tartozó függőségek esetén már nem szükséges a settings branch = «main» megadása.
• A fordító minimális LLVM verzió követelményei az LLVM 10-re emelkedtek.

Továbbá említést érdemel, hogy finanszírozást biztosítanak a Linux kernelhez való Rust komponensek fejlesztésének integrációjához. A munka a Prossimo projekt keretein belül valósul meg az ISRG (Internet Security Research Group) szervezésében, amely a Let’s Encrypt projekt alapítója és elősegíti a HTTPS elterjedését, valamint az internet védelmét szolgáló technológiák fejlesztését. A forrást a Google biztosítja, aki Miguel Ojeda (a Rust-for-Linux projekt szerzője) munkáját finanszírozza. Korábban az ISRG és a Google már támogatta egy alternatív HTTP backend kifejlesztését a curl segédprogramhoz és egy új TLS modul kidolgozását az Apache HTTP szerverhez.

A Microsoft és a Google által közzétett adatok szerint a sebezhetőségek körülbelül 70%-áért a memória nem biztonságos használata felelős. Feltehetően a Rust nyelv használata a kernel összetevőinek, például eszközmeghajtóknak a fejlesztésében csökkenti a memória nem biztonságos használatából fakadó sebezhetőségek kockázatát, és megszünteti az olyan hibák megjelenését, mint a memóriaterület hozzáférése annak felszabadítása után és a pufferméret túllépése.

A memória biztonságos kezelése a Rust nyelvben a fordítás során a hivatkozások ellenőrzésével, az objektumok tulajdonlásának nyomon követésével, valamint az objektumok élettartamának (láthatóságának) figyelembevételével történik, továbbá a memóriához való hozzáférés helyességének értékelésével a kód futtatása alatt. A Rust eszközöket is biztosít a egész számok túlfutásának védelmére, kötelezővé teszi a változók értékeinek inicializálását használat előtt, jobban kezeli a hibákat a standard könyvtárban, alkalmazza az immutable (változhatatlan) hivatkozások és változók fogalmát alapértelmezés szerint, valamint erős statikus típust kínál a logikai hibák minimalizálására.

Forrás: opennet.ru