Utgåvan av Rust 1.53. Google finansierar tillägg av stöd för Rust i Linux-kärnan.

Utgåvan av programmeringsspråket Rust 1.53, som grundades av Mozilla men numera utvecklas under ledning av den oberoende, ideella organisationen Rust Foundation. Språket fokuserar på säker minneshantering, erbjuder automatisk minneshantering och tillhandahåller verktyg för att uppnå hög parallellism i uppgiftens utförande, utan att använda en garbage collector eller runtime (runtime är begränsad till grundläggande initialisering och stöd för standardbiblioteket).

Den automatiska minneshanteringen i Rust befriar utvecklaren från fel vid hantering av pekare och skyddar mot problem som uppstår vid låg nivå minneshantering, såsom att referera till minnesområden efter att de har frigjorts, dereferera nullpekare, buffer overflow, och liknande. För distribution av bibliotek, byggnation och hantering av projektberoenden utvecklas paketadministratören Cargo. För att lagra bibliotek stöds förvaringsplatsen crates.io.

Huvudsakliga nyheter:

• För arrayer har en trait IntoIterator implementerats, vilket gör det möjligt att iterera över en array elementvärden: for i in [1, 2, 3] { .. }

  Det har också blivit möjligt att skicka arrayer till metoder som accepterar iterators, till exempel: let set = BTreeSet::from_iter([1, 2, 3]); for (a, b) in some_iterator.chain([1]).zip([1, 2, 3]) { .. }

  Tidigare var IntoIterator endast implementerad för referenser till arrayer, vilket innebar att man behövde använda referenser (‘&[1, 2, 3]’) eller ‘[1, 2, 3].iter()’ för att iterera över värden. Implementeringen av IntoIterator för arrayer stötte på problem med kompatibilitet, orsakade av en tidigare tillagd omvandling i kompilatorn som omvandlade metoden array.into_iter() till (&array).into_iter(). Dessa problem löstes på ett sidospår — kompilatorn kommer att fortsätta omvandla array.into_iter() till (&array).into_iter() som om ingen implementering av IntoIterator fanns, men endast när metoden anropas med syntaxen ‘.into_iter()’ och utan att beröra anrop i formen ‘in [1, 2, 3]’, ‘iter.zip([1, 2, 3])’, ‘IntoIterator::into_iter([1, 2, 3])’.

• Möjlighet att ange uttryck «|» (logisk operation OR) i vilken del av mallen som helst, till exempel, istället för «Some(1) | Some(2)» kan man nu skriva «Some(1 | 2)»: match result { Ok(Some(1 | 2)) => { .. } Err(MyError { kind: FileNotFound | PermissionDenied, .. }) => { .. } _ => { .. } }
• Användning av icke-ASCII-tecken i identifierare tillåts, inklusive alla nationella tecken som definieras i Unicode-specifikationen UAX 31, men inte emoji-tecken. Vid användning av olika, men liknande tecken, ger kompileraren en varning. const BLÅHAJ: &str = «🦈»; struct 人 { 名字: String, } let α = 1; let ｓos = 2; warning: identifier pair considered confusable between ‘ｓ’ and ‘s’
• En ny batch av API:er har blivit stabiliserade, inklusive:
  • 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 för arrayer
  • {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 för slice::IterMut
  • impl SliceIndex för (Bound, Bound)
  • Vec::extend_from_within
• Tredje nivå av stöd har implementerats för plattformen wasm64-unknown-unknown. Tredje nivå innebär basstöd, men utan automatiserad testning, offentliggörande av officiella versioner och verifiering av möjligheten att bygga kod.
• Paketmanagern Cargo har som standard blivit översatt för att använda namnet «main» för den primära grenen av Git-repo (HEAD). För beroenden som finns i repositorier som använder namnet main istället för master, krävs det inte längre att ange branch = «main» i inställningarna.
• Krav på minimal version av LLVM har höjts till LLVM 10.

Ytterligare kan nämnas att finansiering för arbetet med att utveckla integrationen i Linux-kärnan för komponenter som utvecklas i programmeringsspråket Rust kommer att tillhandahållas. Arbetet kommer att pågå inom ramen för projektet Prossimo under aegis av organisationen ISRG (Internet Security Research Group), som är grundare av projektet Let’s Encrypt och bidrar till främjandet av HTTPS och utvecklingen av teknologier för att öka säkerheten på internet. Finansieringen kommer att tillhandahållas av Google, som kommer att betala för Miguel Ojeda, upphovsmannen till projektet Rust-for-Linux. Tidigare har ISRG och Google redan finansierat skapandet av en alternativ HTTP-backend för verktyget curl och utvecklingen av en ny TLS-modul för http-servern Apache.

Enligt uppgifter från företagen Microsoft och Google orsakas cirka 70 % av sårbarheterna av osäker hantering av minnet. Det antas att användningen av programmeringsspråket Rust för att utveckla kärnkomponenter, såsom enhetsdrivrutiner, kommer att minska risken för sårbarheter orsakade av osäker minneshantering och utesluta sådana fel som åtkomst till minnesområden efter att de har frigjorts och buffertöverskridningar.

Säker minneshantering säkerställs i Rust vid kompilering genom kontroll av referenser, spårning av ägande av objekt och beaktande av objektens livstid (synlighet), samt genom utvärdering av korrekt tillgång till minnet under kodens körning. Rust tillhandahåller också verktyg för skydd mot heltalsöverflöden, kräver obligatorisk initialisering av variabelvärden innan användning, hanterar fel bättre i standardbiblioteket, tillämpar konceptet av oföränderliga (immutable) referenser och variabler som standard och erbjuder stark statisk typning för att minimera logiska fel.

Källa: opennet.ru