Rust 1.64 programspråk release

Utgivningen av Rust 1.64 allmänt programmeringsspråk, grundat av Mozilla-projektet, men nu utvecklat under överinseende av den oberoende ideella organisationen Rust Foundation, har publicerats. Språket fokuserar på minnessäkerhet och ger möjlighet att uppnå hög jobbparallellism samtidigt som man undviker användningen av en skräpsamlare och körtid (körtiden reduceras till grundläggande initiering och underhåll av standardbiblioteket).

Rusts minneshanteringsmetoder räddar utvecklaren från fel vid manipulering av pekare och skyddar mot problem som uppstår på grund av minneshantering på låg nivå, som att komma åt ett minnesområde efter att det har frigjorts, avläsning av nollpekare, buffertöverskridningar, etc. För att distribuera bibliotek, tillhandahålla builds och hantera beroenden utvecklar projektet Cargo package manager. Crates.io-förvaret stöds för värdbibliotek.

Minnessäkerhet tillhandahålls i Rust vid kompilering genom referenskontroll, hålla reda på objektägande, hålla reda på objektlivslängder (scopes) och bedöma riktigheten av minnesåtkomst under kodexekvering. Rust ger också skydd mot heltalsspill, kräver obligatorisk initiering av variabelvärden innan användning, hanterar fel bättre i standardbiblioteket, tillämpar konceptet med oföränderliga referenser och variabler som standard, erbjuder stark statisk typning för att minimera logiska fel.

Huvudsakliga innovationer:

• Ökade krav på miljön Linux I kompilatorn, pakethanteraren Cargo och standardbiblioteket libstd har minimikraven för Glibc höjts från version 2.11 till 2.17, och kärnorna Linux Från version 2.6.32 till 3.2. Restriktionerna gäller även för Rust-programkörbara filer byggda med libstd. RHEL 7, SLES 12-SP5 och andra distributioner uppfyller de nya kraven. Debian 8 och Ubuntu 14.04. Stöd för RHEL 6, SLES 11-SP4 kommer att upphöra. Debian 7 och Ubuntu 12.04. För användare som använder Rust-verktygskedjans körbara filer i miljöer med en äldre kärna Linux, rekommenderas det att uppgradera sina system, behålla äldre kompilatorutgåvor eller oberoende underhålla sin egen libstd-gren med mellanlager för att upprätthålla kompatibilitet.

  Bland anledningarna till att stödet för gamla upphör Linux-system nämner begränsade resurser för att fortsätta upprätthålla kompatibilitet med äldre miljöer. Stöd för äldre Glibc kräver användning av äldre verktyg vid incheckning i det kontinuerliga integrationssystemet, med tanke på de ökade versionskraven för LLVM och korskompileringsverktyg. De ökade kraven på kärnversioner beror på möjligheten att använda nya systemanrop i libstd utan behov av mellanhänder för att säkerställa kompatibilitet med äldre kärnor.

• IntoFuture-egenskapen har stabiliserats, som liknar IntoIterator men skiljer sig från den senare genom att använda ".await" istället för "for ... in ..." loopar. När det kombineras med IntoFuture kan nyckelordet ".await" inte bara vänta på Future-typen utan även andra typer som kan konverteras till Future.
• Rostanalysverktyget ingår i samlingen av verktyg som levereras med Rust-releaser. Verktyget är också tillgängligt för installation med hjälp av rustup (rustup-komponent lägg till rostanalysator).
• Pakethanteraren Cargo stöder nu arv av arbetsytor för att undvika duplicering av vanliga fältvärden, såsom Rust-versioner och URL:er för arkiv, mellan paket. Den lägger också till stöd för att bygga för flera målplattformar samtidigt (alternativet "--target" tillåter nu mer än en parameter).
• En ny del av API:t har flyttats till kategorin stabil, inklusive metoder och implementeringar av egenskaper har stabiliserats:
  • future::IntoFuture
  • num::NonZero*::checked_mul
  • num::NonZero*::checked_pow
  • num::NonZero*::saturating_mul
  • num::NonZero*::saturating_pow
  • num::NonZeroI*::abs
  • num::NonZeroI*::checked_abs
  • num::NonZeroI*::overflowing_abs
  • num::NonZeroI*::saturating_abs
  • num::NonZeroI*::unsigned_abs
  • num::NonZeroI*::wrapping_abs
  • num::NonZeroU*::checked_add
  • num::NonZeroU*::checked_next_power_of_two
  • num::NonZeroU*::saturating_add
  • os::unix::process::CommandExt::process_group
  • os::windows::fs::FileTypeExt::is_symlink_dir
  • os::windows::fs::FileTypeExt::is_symlink_file
• C-kompatibla typer som tidigare stabiliserats i std::ffi-modulen har lagts till i kärn- och alloc-biblioteket:
  • kärna::ffi::CSr
  • kärna::ffi::FromBytesWithNulError
  • alloc::ffi::CString
  • alloc::ffi::FromVecWithNulError
  • alloc::ffi::IntoStringError
  • alloc::ffi::NulError
• Modulerna core::ffi och std::ffi har uppdaterats med C-typer som tidigare stabiliserats i modulen std::os::raw (till exempel har typerna c_uint och c_ulong föreslagits för C-typerna uint och ulong):
  • ffi::c_char
  • ffi::c_dubbel
  • ffi::c_float
  • ffi::c_int
  • ffi::c_long
  • ffi::c_longlong
  • ffi::c_schar
  • ffi::c_short
  • ffi::c_uchar
  • ffi::c_uint
  • ffi::c_ulong
  • ffi::c_ulonglong
  • ffi::c_short
• Lågnivåhanterare för användning med Poll-mekanismen har stabiliserats (i framtiden planeras ett förenklat API som inte kräver användning av lågnivåstrukturer som Pull och Pin):
  • framtid::poll_fn
  • uppgift::klar!
• Flaggan "const", som bestämmer möjligheten att använda i alla sammanhang istället för konstanter, används i funktionen slice::from_raw_parts.
• För att lagra data mer kompakt har minneslayouten för strukturerna Ipv4Addr, Ipv6Addr, SocketAddrV4 och SocketAddrV6 ändrats. Det kan finnas kompatibilitetsbrott med enstaka paket som använder std::mem::transmute för manipulering av struktur på låg nivå.
• I rust-kompilatorversionen för plattformen Windows PGO-optimeringar (profilstyrd optimering) användes, vilket möjliggjorde en ökning av kodkompileringsprestandan med 10–20 %.
• Kompilatorn har en ny varning om oanvända fält i vissa strukturer.

Dessutom kan vi notera statusrapporten om utvecklingen av en alternativ implementering av Rust-språkkompilatorn, utarbetad av gccrs-projektet (GCC Rust) och godkänd för inkludering i GCC. Efter att ha integrerat gränssnittet kan standardverktyget GCC användas för att kompilera Rust-program utan att behöva installera rustc-kompilatorn, byggd med hjälp av LLVM-utvecklingar. Så länge utvecklingen går enligt plan, och med undantag för oförutsedda problem, kommer Rust-fronten att integreras i GCC 13-utgåvan som är planerad till maj nästa år. Rust-implementeringen i GCC 13 kommer att vara i betastatus och inte aktiverad som standard ännu.

Källa: opennet.ru