Rust 1.64 programmeringsspråkutgivelse

Utgivelsen av Rust 1.64 generell programmeringsspråk, grunnlagt av Mozilla-prosjektet, men nå utviklet i regi av den uavhengige ideelle organisasjonen Rust Foundation, har blitt publisert. Språket fokuserer på minnesikkerhet og gir midler til å oppnå høy jobbparallellisme samtidig som man unngår bruk av en søppeloppsamler og kjøretid (kjøretiden reduseres til grunnleggende initialisering og vedlikehold av standardbiblioteket).

Rusts minnehåndteringsmetoder sparer utvikleren fra feil ved manipulering av pekere og beskytter mot problemer som oppstår på grunn av minnehåndtering på lavt nivå, for eksempel tilgang til et minneområde etter at det har blitt frigjort, avreferering av null-pekere, bufferoverskridelser, etc. For å distribuere biblioteker, tilby bygg og administrere avhengigheter, utvikler prosjektet Cargo-pakkeansvarlig. Crates.io-depotet støttes for hosting av biblioteker.

Minnesikkerhet er gitt i Rust på kompileringstidspunktet gjennom referansesjekking, holde styr på objekteierskap, holde styr på objektlevetider (scopes), og vurdere riktigheten av minnetilgang under kjøring av kode. Rust gir også beskyttelse mot heltallsoverløp, krever obligatorisk initialisering av variabelverdier før bruk, håndterer feil bedre i standardbiblioteket, bruker konseptet med uforanderlige referanser og variabler som standard, tilbyr sterk statisk skriving for å minimere logiske feil.

Hovedinnovasjoner:

• Kravene til Linux-miljøet i kompilatoren, Cargo-pakkebehandlingen og libstd-standardbiblioteket er økt - minimumskravene for Glibc er hevet fra versjon 2.11 til 2.17, og Linux-kjernen fra versjon 2.6.32 til 3.2. Restriksjonene gjelder også for kjørbare Rust-applikasjoner bygget med libstd. Distribusjonssettene RHEL 7, SLES 12-SP5, Debian 8 og Ubuntu 14.04 oppfyller de nye kravene. Støtte for RHEL 6, SLES 11-SP4, Debian 7 og Ubuntu 12.04 vil bli avviklet. Brukere som bruker Rust-bygde kjørbare filer i miljøer med en eldre Linux-kjerne oppfordres til å oppgradere systemene sine, holde seg på eldre utgaver av kompilatoren, eller vedlikeholde sin egen libstd-gaffel med lag for å opprettholde kompatibiliteten.

  Blant årsakene til å avslutte støtte for eldre Linux-systemer er begrensede ressurser for å fortsette å opprettholde kompatibilitet med eldre miljøer. Støtte for eldre Glibc krever bruk av eldre verktøy når du sjekker inn et kontinuerlig integreringssystem, i møte med økende versjonskrav i LLVM og krysskompileringsverktøy. Økningen i krav til kjerneversjon skyldes muligheten til å bruke nye systemanrop i libstd uten behov for å vedlikeholde lag for å sikre kompatibilitet med eldre kjerner.

• IntoFuture-trekket er stabilisert, som ligner IntoIterator, men skiller seg fra sistnevnte ved å bruke ".await" i stedet for "for ... in ..."-løkker. Når det kombineres med IntoFuture, kan søkeordet ".await" forvente ikke bare en fremtidig egenskap, men også alle andre typer som kan konverteres til en fremtid.
• Rust-analyseverktøyet er inkludert i samlingen av verktøy som følger med Rust-utgivelser. Verktøyet er også tilgjengelig for installasjon ved bruk av rustup (rustup-komponent legg til rust-analysator).
• Cargo-pakkebehandleren inkluderer arbeidsområdearv for å eliminere duplisering av vanlige feltverdier mellom pakker, for eksempel Rust-versjoner og depot-URLer. Støtte for å bygge for flere målplattformer samtidig er også lagt til (du kan nå spesifisere mer enn én parameter i "--target"-alternativet).
• En ny del av API har blitt flyttet til kategorien stabil, inkludert metodene og implementeringene av egenskaper er stabilisert:
  • 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::prosess::CommandExt::prosessgruppe
  • os::windows::fs::FileTypeExt::is_symlink_dir
  • os::windows::fs::FileTypeExt::is_symlink_file
• C-kompatible typer, tidligere stabilisert i std::ffi-modulen, er lagt til kjernen og alloc-biblioteket:
  • kjerne::ffi::CSr
  • kjerne::ffi::FromBytesWithNulError
  • alloc::ffi::CSstring
  • alloc::ffi::FromVecWithNulError
  • alloc::ffi::IntoStringError
  • alloc::ffi::NulError
• C-typer som tidligere var stabilisert i std::os::raw-modulen er lagt til kjernemodulene::ffi og std::ffi (for eksempel er c_uint- og c_ulong-typene foreslått for uint- og ulong C-typene):
  • ffi::c_char
  • ffi::c_dobbel
  • ffi::c_float
  • ffi::c_int
  • ffi::c_lang
  • ffi::c_longlong
  • ffi::c_schar
  • ffi::c_short
  • ffi::c_uchar
  • ffi::c_uint
  • ffi::c_ulong
  • ffi::c_ulonglong
  • ffi::c_short
• Håndtere på lavt nivå har blitt stabilisert for bruk med Poll-mekanismen (i fremtiden er det planlagt å tilby et forenklet API som ikke krever bruk av lavnivåstrukturer som Pull and Pin):
  • fremtid::poll_fn
  • oppgave::klar!
• «const»-attributtet, som bestemmer muligheten for å bruke det i en hvilken som helst kontekst i stedet for konstanter, brukes i slice::from_raw_parts-funksjonen.
• For å lagre data mer kompakt er minneoppsettet til strukturene Ipv4Addr, Ipv6Addr, SocketAddrV4 og SocketAddrV6 endret. Det kan være et kompatibilitetsproblem med enkeltkassepakker som bruker std::mem::transmute for lavnivåmanipulering av strukturer.
• Byggingen av rustkompilatoren for Windows-plattformen bruker PGO-optimaliseringer (profilveiledet optimalisering), som gjorde det mulig å øke kodekompileringsytelsen med 10-20 %.
• Kompilatoren har implementert en ny advarsel om ubrukte felt i visse strukturer.

I tillegg kan du legge merke til statusrapporten om utviklingen av en alternativ implementering av Rust-språkkompilatoren, utarbeidet av gccrs-prosjektet (GCC Rust) og godkjent for inkludering i GCC. Etter integrering av frontend, kan standard GCC-verktøyene brukes til å kompilere programmer i Rust-språket uten å måtte installere rustc-kompilatoren, bygget ved hjelp av LLVM-utviklinger. Så lenge utviklingen er i rute, og med unntak av uforutsette problemer, vil Rust-frontenden bli integrert i GCC 13-utgivelsen som er planlagt til mai neste år. GCC 13-implementeringen av Rust vil være i betastatus, ennå ikke aktivert som standard.

Kilde: opennet.ru