Rust 1.97: v0 Symbol Mangling Default and pin! Fix

Rust 1.97 drops tomorrow, July 9, and most of the coverage will focus on new stabilizations. Two changes deserve more attention: a default switch that will silently break debugger workflows on older Linux toolchains, and a soundness fix for a pin! regression lurking since 1.88.0. Run rustup update with eyes open.

v0 Symbol Mangling Is Now the Default

This is the one change in Rust 1.97 that can break your workflow without touching a single line of code. Starting with this release, rustc defaults to the v0 symbol mangling scheme (RFC 2603) instead of the legacy C++-derived format it has used since 1.0. The switch has been coming for a long time — v0 was opt-in since Rust 1.37 in 2019, giving the ecosystem seven years to catch up. Most of it has.

The problem is most. If you are running GDB below version 10.2 — including the system GDB shipped with Ubuntu 20.04 LTS — symbols in your debug sessions will either demangle incorrectly or not at all. Profilers, binary analysis tools, and CI pipelines that hardcode assumptions about legacy Rust symbol format are also in scope. The temporary fix: add -C symbol-mangling-version=legacy to your RUSTFLAGS until you can upgrade your toolchain.

If you are on modern distros with GDB 10.2+, VS Code with rust-analyzer, or recent CLion — you are fine. The v0 scheme is strictly better: generics, lifetimes, and const generics all encode cleanly, producing readable symbol names in panic backtraces and profiler output instead of the C++ template explosions you have been squinting at.

The pin! Soundness Fix You Probably Missed

Rust 1.88.0, released nine months ago, introduced a regression in the pin! macro. When the macro was updated to use super let internally, it inadvertently allowed deref coercions on its argument. If you called pin!(x) where x had type &mut T, the macro could silently produce Pin<&mut T> instead of the correct Pin<&mut &mut T>. That is not a type error — it is worse. A Drop impl could later access the &mut T through the coerced pin, breaking the Pin invariant in safe code. The original issue (#153438) lays out exactly how the unsoundness can manifest.

Rust 1.97 closes it. The macro now strictly produces Pin<&mut &mut T> when given an &mut T. If your code depended on the implicit coercion, you will get a compile error. The migration: use pin!(*x) to explicitly dereference if you need Pin<&mut T>. Audit async code that uses pin!() with mutable reference arguments — pinned futures with &mut state, custom async state machines, and libraries abstracting over pinned types are where this surfaces.

Cargo Gets Two Long-Overdue Config Flags

The RUSTFLAGS="-Dwarnings" pattern is everywhere in CI. It works, but it is a blunt instrument — it denies warnings across all crates including your dependencies, which produces noise and occasionally breaks builds when an upstream crate has not caught up. Rust 1.97 stabilizes build.warnings in Cargo config:

# .cargo/config.toml
[build]
warnings = "deny"

This applies only to your local packages. Dependencies are untouched. Values are "allow", "warn" (default), and "deny". Drop it in your project’s .cargo/config.toml and retire the RUSTFLAGS hack from your CI pipeline.

The second stabilization is resolver.lockfile-path, letting you specify where Cargo reads and writes the lockfile independently of the source directory:

[resolver]
lockfile-path = "/build/cache/Cargo.lock"

This matters for hermetic build systems, Nix builds, and monorepos where the source tree is read-only or shared. Previously you needed symlinks or build script workarounds. One more: -m is now shorthand for --manifest-path. Not a headline feature, but if you are running cargo build --manifest-path across a large workspace all day, it adds up.

Integer Bit Methods, Finally in std

Several bit manipulation methods are now stable for all integer primitives and their NonZero variants:

let n: u32 = 0b_0110_0100; // 100

n.isolate_highest_one()  // 0b_0100_0000 — only the highest set bit
n.isolate_lowest_one()   // 0b_0000_0100 — only the lowest set bit
n.highest_one()          // Some(6) — zero-indexed position of highest set bit
n.lowest_one()           // Some(2) — zero-indexed position of lowest set bit
n.bit_width()            // 7 — minimum bits to represent this value

These have lived in external crates and hand-rolled bit arithmetic for years. They are useful in allocators, bitmask schedulers, bit-packed data formats, and network protocol parsing. bit_width() is particularly clean — it replaces the common-but-verbose u32::BITS - n.leading_zeros() pattern, which also silently returns the wrong answer for zero.

What Else Changed

A few other notes: a new allow-by-default dead_code_pub_in_binary lint warns about unused pub items in binary crates — often a copy-paste artifact from library code. Empty #[export_name] attributes are now a hard error. On Windows, write attempts after socket shutdown now return BrokenPipe instead of the generic Other variant, which is more useful for error handling. And cargo clean now validates that --target-dir looks like a Cargo target directory before proceeding — a simple safety check that prevents accidentally wiping an unrelated directory.

How to Upgrade

Run rustup update stable. Before you do: check your GDB version (gdb --version), grep your codebase for pin!( with mutable reference arguments, and update CI scripts using RUSTFLAGS="-Dwarnings" to use build.warnings in config. The full changelog is on releases.rs, and the official announcement hits the Rust Blog tomorrow.