Announcing Rust 1.52.0

Rust 1.52.0’s most significant change fixes Cargo’s handling of Clippy so that cargo clippy runs as expected even after cargo check. The release also stabilizes string-splitting, slice-partitioning, formatting, and character APIs, while making several character and byte operations usable in const contexts.

Breaking News

Changes that may make code or platforms move

Compatibility notes

Upgrade to Rust 1.52.1, which disables incremental compilation by default, or disable it with CARGO_INCREMENTAL=0 or build.incremental = false in config.toml. Deleting the incremental cache with cargo clean is another workaround. Downgrading is not a fix because the underlying bugs exist in earlier versions; users remaining on a toolchain older than 1.52.0 are advised to disable incremental compilation.

If an unstable-fingerprint ICE occurs, report it if possible. Users willing to handle verification ICEs may opt in with RUSTC_FORCE_INCREMENTAL=1, but incremental compilation must also be enabled separately.

Cargo now distinguishes Clippy from ordinary checks

Previously, running cargo check followed by cargo clippy would not actually run Clippy because Cargo’s build cache did not distinguish between the two commands. Rust 1.52.0 fixes that caching behavior, so users get the expected result regardless of the order in which they run cargo check and cargo clippy.

New library APIs cover splitting, partitioning, formatting, and characters

This release stabilizes Arguments::as_str; the character constants char::MAX, char::REPLACEMENT_CHARACTER, and char::UNICODE_VERSION; the character functions char::decode_utf16, char::from_digit, char::from_u32_unchecked, and char::from_u32; slice::partition_point; and str::rsplit_once and str::split_once.

The previously stable APIs char::len_utf8, char::len_utf16, char::to_ascii_uppercase, char::to_ascii_lowercase, char::eq_ignore_ascii_case, u8::to_ascii_uppercase, u8::to_ascii_lowercase, and u8::eq_ignore_ascii_case are now usable in const contexts.

Errata · Point releases

Rust 1.52.1

10 May 2021 blog post

Rust 1.52.1 temporarily disables incremental compilation by default to avoid both newly exposed build failures and the underlying risk of incremental-compilation miscompilation. Users should upgrade or disable incremental compilation rather than downgrade; those who knowingly opt back in receive improved diagnostics when fingerprint verification finds an inconsistency.

Fingerprint verification exposed pre-existing incremental-compilation bugs

Incremental compilation breaks source input into pieces, tracks how those pieces influence the final build product, and reuses artifacts from earlier builds so that work is concentrated on parts affected by a change. Fingerprints help detect those changes: together with contextual state, a fingerprint is a 128-bit value intended to uniquely identify an internal compiler value. Some compiler results are cached on disk, and fingerprints validate that a newly computed result is unchanged from the cached result.

The fingerprint stability check asserts internal consistency when the compiler reruns a query whose output is expected to match a previous incremental-compilation session. Instead of assuming the values match, the verification checks them. Compiler bugs sometimes violated that expectation.

The checks were initially added in 2017 behind an unstable -Z flag for nightly and development builds. After a miscompilation was encountered in March, verify-ich was enabled by default so compilation would abort on fingerprint problems instead of allowing potential miscompilations into binaries. Nightly and beta users subsequently reported a steady stream of issues, and several fixes landed. Work had also begun on clearer guidance in the diagnostic under the mistaken assumption that verification would ship in 1.53; it instead shipped in 1.52.0.

The resulting ICE contains the key phrase found unstable fingerprints:

thread 'rustc' panicked at 'assertion failed: `(left == right)`
  left: `Some(Fingerprint(4565771098143344972, 7869445775526300234))`,
  right: `Some(Fingerprint(14934403843752251060, 623484215826468126))`: found unstable fingerprints for <massive text describing rustc internals elided>

error: internal compiler error: unexpected panic

note: the compiler unexpectedly panicked. this is a bug.

For some crates, particular edit-and-compile sequences expose an inconsistency between the incremental cache on disk and values computed by the current rustc invocation. Another observed form is:

thread 'rustc' panicked at 'found unstable fingerprints for predicates_of(<massive text describing rustc internals elided>)', /rustc/.../compiler/rustc_query_system/src/query/plumbing.rs:593:5

In these cases the ICE reveals an incremental-compilation bug that predates Rust 1.52.0 and could otherwise cause a miscompilation.

Rust 1.52.1 disables incremental compilation unless users opt in

Rust 1.52.1 temporarily changes the compiler defaults to disable incremental compilation unless the user knowingly opts in with RUSTC_FORCE_INCREMENTAL=1. It also improves the verification diagnostic, telling users to purge incremental state or disable incremental compilation.

RUSTC_FORCE_INCREMENTAL=1 makes the compiler respect the -Cincremental option passed by Cargo, restoring the 1.52.0 behavior with verification still active. The variable does not itself enable incremental compilation; Cargo or another mechanism must enable it separately.

Incremental compilation can otherwise be enabled by the dev or test profiles, which enable it by default; CARGO_INCREMENTAL=1; the build.incremental Cargo configuration setting; or the incremental setting for a profile in Cargo.toml. With unmodified defaults, the release profile, including cargo build --release, has had incremental compilation disabled since it was first enabled in Rust 1.24, so few production builds should be affected unless users opted in.

The incremental bugs can generate incorrect final artifacts—essentially malformed binaries—so in theory any behavior is possible. At the time of the release, the project knew of one particular miscompilation. Such bugs can be difficult to track down because rebuilding after light editing may trigger enough recompilation to make the problem disappear.

Fixes continue before incremental compilation is re-enabled

The project expected to continue fixing the bugs and, depending on confidence in those fixes, might issue Rust 1.52.2 with backports to stable. Incremental compilation was not then planned to be disabled on beta, although that decision was not firmly committed to; Rust 1.53 beta already contained several fixes, while nightly had the latest fixes.

At publication there were 32 issues identified through verify-ich, many of them duplicates, and several bugs had already been identified and fixed. Depending on the state of the fixes, stable releases from 1.53 onward would likely re-enable incremental compilation. The Rust teams also planned better tracking of bugs as they propagate across release channels.