May 19, 2022

stickyriceles

Software Development

Rust 2024 roadmap focuses on developer ease of use

What’s new in the Rust programming language


The unique approach of the Rust programming language results in better code with fewer compromises than C, C++, Go, and the other languages you probably use. It also gets updated regularly, often every month.

Where to download the latest Rust version

If you already have a previous version of Rust installed via rustup, you can access the latest version via the following command:

$ rustup update stable

The new features in Rust 1.60.0

Rust 1.60, introduced April 7, 2022, stabilizes support for LLVM-based coverage instrumentation in rustc. This provides for source-based code coverage. Developers can try this out by rebuilding their code with -Cinstrument-coverage. Afterward, running the resulting binary will produce a default.profraw file in the current directory.

The llvm-tools-preview component includes llvm-profdata for processing and merging raw profile output, llvm-profdata for processing raw file output, and llvm-cov for report generation. Baseline functionality is stable and will exist in all future Rust releases, but the specific output format and LLVM tools that produce it are subject to change. Developers should use the same version for both llvm-tools-preview and the rustc binary used to compile code.

Rust 1.60 also re-enables incremental compilation. The Rust team continues to work on fixing bugs in incremental but no problems causing widespread breakage are known at this time.

 Also in Rust 1.60:

  • On all platforms, Instant will try to use an operating system API that guarantees monotonic behavior if available. In practice, such guarantees are, under rare circumstances, broken by hardware, virtualization, or operating system bugs. To work around these bugs, and to work with platforms that lack monotonic clocks, Instant::duration_since, Instant::elapsed, and Instant::sub now saturate to zero. In older versions of Rust, this led to a panic, instead.
  • Cargo has established support for collecting information on build with the --timings flag.
  • Namespaced dependencies and weak dependency features have been introduced to improve support for Cargo features and how they interact with optional dependencies. Cargo features provide a mechanism to express conditional compilation and optional dependencies.
  • A number of APIs have been stabilized such as Arc::new_cyclic, Rc::new_cyclic, and slice::EscapAscii.

The new features in Rust 1.59.0

Rust 1.59.0 was announced on February 24. A key feature is support for inline assembly, enabling many applications that need very low-level control over execution or access to specialized machine instructions. Assembly language and instructions available with inline assembly vary according to architecture. The capability currently is supported on architectures including x86 and x64, ARM, Risc-V, and AArch64. 

Other new features and improvements in Rust 1.59.0:

  • Developers now can use slice, tuple, and struct patterns as the left-hand side of an assignment, making assignment more consistent with let bindings, which already support these patterns.
  • Generic types now can specify default values for const generics.
  • The Cargo package manager now shows warnings when a dependency will be rejected by a future version of Rust.
  • For the creation of stripped binaries, cargo and rustc now support stripping when the binary is linked. Rust’s developers said it is often useful to strip unnecessary information like buginfo from binaries that are distributed, making them smaller.
  • Incremental compilation is off by default. This mitigates the effect of a known bug that causes deserialization errors. A fix for this bug will be available in the Rust 1.60 beta due in six weeks.
  • A number of APIs have been stabilized.

The new features in Rust 1.58.1

This point release arriving January 20, 2022, just days after Rust 1.58, fixes a race condition in the std::fs::remove_dir_all standard library function. This vulnerability is tracked at CVE-2022-21658 and there was an advisory published. An attacker could use this security issue to trick a privileged program into deleting files and directories that the attacker otherwise could not access or delete. Rust versions 1.0 through 1.58 are affected by this vulnerability. Users are advised to update their toolchains and build programs with the updated compiler.

Rust 1.58.1 also addresses several regressions in diagnostics and tools introduced in Rust 1.58:

  • The non_send_fields_in_send_ty Clippy lint was found to have too many false positives and has been moved to the experimental lints group called “nursery”.
  • The useless_format Clippy lint was updated to handle captured identifiers in format strings, introduced in Rust 1.58.
  • A regression in Rustfmt preventing generated files from being formatted when passed through the standard input has been fixed.
  • An incorrect error message displayed by rustc in some cases has been fixed.

The new features in Rust 1.58

Rust 1.58, announced January 13, features captured identifiers in format strings. With this capability, format strings now can capture arguments by writing ident in the string. Formats long have accepted positional arguments and named arguments, such as:

println!("Hello, !", get_person());     // implicit position
println!("Hello, 0!", get_person());     // explicit index
println!("Hello, person!", person = get_person());     // named

Now, named arguments also can be captured from the surrounding scope.

Also new in Rust 1.58: On Windows targets, std::process::Command will no longer search the current directory for executables, which was an effect of the historical behavior of the win32 CreateProcess API. This fixes a situation in which searches could lead to surprising behavior or malicious results when dealing with untrusted directories. 

Rust 1.58 also introduces more #[must_use] in the standard library. The #[must use] attribute can be applied to types or functions when failing to explicitly consider them or their output is almost certainly a bug. Rust 1.58 also has stabilized APIs such as Metadata::is_symlinkcode and Path::is_symlink.

The new features in Rust 1.57

Rust 1.57, unveiled December 2, brings panic! (for terminating a program in an unrecoverable state) to const contexts. Previously, the panic! macro was not usable in const fn and other compile-time contexts. This has now been stabilized. Together with the stabilization of panic!, several other standard libraries now are usable in const, such as assert!. But this stabilization does not yet include the full formatting infrastructure. The panic! macro must be called with either a static string or a single interpolated value to be used with . This support is expected to expand in the future.

Other new features and improvements in Rust 1.57:

  • Cargo adds support for arbitrarily named profiles.
  • try_reserve has been stabilized for Vec, String, HashMap, HashSet, and VecDeque. This API enables callers to fallibly allocate backing storage for these types.
  • Multiple other APIs have been stabilized including [T; N]::as_mut_slice and [T; N]::as_slice.
  • Macro attributes now may follow #derive and will see the original input.

The new features in Rust 1.56

Announced October 21, Rust 1.56 is the first version of the language that supports the Rust 2021 edition. The Rust 2021 edition lets Rust crate authors opt in to breaking language changes that make Rust easier to use and more consistent. Crates can opt in at any time and remain interoperable with crates in older editions. The Rust compiler supports all three editions of the language: 2015, 2018, and 2021.

Other new capabilities in Rust 1.56 include:

  • Disjoint capture in closures, to simplify the writing of closures.
  • Cargo.toml now supports a [package] [rust-version] field to specify the minimum supported Rust version for a crate, and Cargo will exit with an early error if that is not satisfied. While this currently does not influence the dependency resolver, the intent is catch compatibility problems before they turn into cryptic compiler errors.
  • New bindings in [email protected] are supported. Rust pattern matching can be written with a single identifier that binds the entire value, followed by @ and a more-refined structural pattern, but has not allowed additional bindings in that pattern until now. This functionality had been permitted prior to Rust 1.0, but was removed due to unsoundness. The compiler team now has determined that this pattern is safe and allowable in stable Rust.
  • Panic macros now always expect format strings, just like printlin!().
  • A number of APIs have been stabilized including std::os::unix::fs::chroot and UnsafeCell::raw_get.

The new features in Rust 1.55

Announced September 9, 2021, Rust 1.55 offers faster, more correct float parsing. The standard library implementation of float parsing has been updated to use the Eisel-Lemire algorithm, which brings improvements in speed and correctness. Previously, certain edge cases failed to parse, but these have now been fixed.

Also in Rust 1.55:

  • The use of open ranges in patterns has been stabilized.
  • A number of methods and trait implementations have been stabilized including Bound::cloned and Drain::as_str.
  • Cargo now deduplicates compiler errors and prints a report at the end of compilation. Previously, when running cargo test, cargo check ---all targets, or similar commands that built the same Rust crate in multiple configurations, errors and warnings might show up duplicated as the rustc executions were run in parallel and showed the same warning.

The new features in Rust 1.54

Published July 29, Rust 1.54 supports invoking function-like macros inside attributes. Function-like macros can be macros based on macro-rules! or they can be procedural macros, which are invoked like macro!(…). A notable use case is including documentation from other files into Rust doc comments.

Other new features in Rust 1.54:

  • A number of instrinsics for wasm32 platform have been stabilized. These give access to SIMD instructions in WebAssembly.
  • Incremental compilation is re-enabled by default. It had been disabled by default in Rust 1.52.1. With Rust 1.52, additional validation was added when loading incremental compilation from on-disk cache, resulting in pre-existing potential soundness issues being uncovered as validation changed these silent bugs into internal compiler errors (ICE). Since then, work has been done to resolve these issues, with some fixes landing in Rust 1.53 and the majority landing in Rust 1.54. Remaining issues that could result in ICE are considered rare in practice.
  • Multiple methods and trait implementations have been stabilized.
  • Compiler output has been improved for debugging enums on Windows MSVC platforms for C++.

Rust 1.54 follows the June 17 release of Rust 1.53, which contained language and library features including the IntoIterator implementation for arrays.

The new features in Rust 1.52

Introduced May 6, Rust 1.52 was led by an enhancement to tooling support for Clippy, which is a collection of lints to find mistakes and improve Rust code. Previously, running cargo check followed by cargo clippy would not actually run Clippy, with the build caching in Cargo not differentiating between the two. This has been fixed in Rust 1.52. Also in version 1.52, the following methods were stabilized:

Several previously stable APIs, including char::len_utf8 and u8LLeq_ignore_ascii_case, are now const. For the compiler, the default LLVM has been upgraded to LLVM 12. A subsequent point release of the language, Rust 1.52.1, published May 10, provides a workaround for a bug in incremental compilation that was made into a compiler error in Rust 1.52.0. Rust builders recommend either an upgrade to 1.52.1 or disabling incremental compilation.

The new features in Rust 1.51.0

Published March 25, 2021, the Rust 1.51.0 release is one of the largest additions to the language and Cargo package manager in quite some time, with the stabilization of an MVP (minimum viable product) implementation of const generics and a new feature resolver for Cargo among the highlights. Other highlights:



Source link