rust-knowledge-patch

Rust Knowledge Patch

Covers Rust 1.84–1.94 (2025-01-09 through 2026-03-05). Claude Opus 4.6 knows Rust through 1.83 and the 2021 Edition. It is unaware of the Rust 2024 Edition and any of the features below.

Index

Topic	Reference	Key features
Rust 2024 Edition	references/rust-2024-edition.md	Edition migration, breaking changes, let chains
Language features	references/language-features.md	Async closures, trait upcasting, naked functions, cfg booleans
Collections & iterators	references/collections.md	extract_if, as_chunks, array_windows, slice splits
Numeric methods	references/numerics.md	isqrt, midpoint, strict_*, sub_signed, const floats
Memory & unsafe	references/memory.md	Provenance APIs, NonNull, MaybeUninit, smart ptr alloc
Std library additions	references/std-additions.md	Pipes, file locking, sync, paths, Duration, fmt::from_fn
Cargo & toolchain	references/cargo.md	Resolver v3, publish --workspace, LLD linker, TOML 1.1
Lints & diagnostics	references/lints.md	New default warnings, never-type lints, diagnostic hints

---

Rust 2024 Edition — Breaking Changes (inline)

Enable with edition = "2024" in Cargo.toml. Migrate with cargo fix --edition.

Change	Before (2021)	After (2024)
extern blocks	extern "C" { fn foo(); }	unsafe extern "C" { fn foo(); }
Link attributes	#[no_mangle]	#[unsafe(no_mangle)]
unsafe fn bodies	implicit unsafe inside	require explicit unsafe { }
static mut refs	warned	hard error → use &raw const/&raw mut
set_var/remove_var	safe	now unsafe
gen keyword	valid identifier	reserved
impl Trait lifetime capture	opt-in	captures all in-scope lifetimes by default
Future/IntoFuture in prelude	not in prelude	added (may cause name conflicts)

// 2021 → 2024 migration examples

// extern blocks
unsafe extern "C" {
    fn foo();
    safe fn bar();  // opt-in safe: callable without unsafe
}

// attributes on linked items
#[unsafe(no_mangle)]
pub extern "C" fn my_fn() {}

// unsafe fn bodies
unsafe fn helper() {
    unsafe { some_unsafe_op(); }  // now required
}

// static mut: use raw refs instead
static mut GLOBAL: u32 = 0;
let r = &raw const GLOBAL;  // safe in 2024, was safe since 1.84

// impl Trait lifetime restriction
fn foo<'a>(x: &'a str) -> impl Display + use<'a> { x }  // restrict captures

---

Let Chains — 1.88 (Rust 2024 Edition only)

Chain let bindings with && in if/while. Earlier bindings are available in later conditions.

if let Channel::Stable(v) = release_info()
    && let Semver { major, minor, .. } = v
    && major == 1
    && minor == 88
{
    println!("let chains stabilized here");
}

while let Some(x) = iter.next() && x < 10 {
    process(x);
}

---

Async Closures — 1.85

async || {} can borrow captures across .await. Unlike || async {}, the inner future holds a borrow into the closure's environment. New traits: AsyncFn, AsyncFnMut, AsyncFnOnce.

let mut vec: Vec<String> = vec![];
let closure = async || {
    vec.push(ready(String::from("")).await);  // borrows vec across await point
};

// Higher-ranked async bounds — not expressible with Fn + Future:
async fn call_it(_: impl for<'a> AsyncFn(&'a u8)) {}

---

Trait Upcasting — 1.86

Coerce &dyn Trait to &dyn Supertrait (or any pointer wrapper). Previously required manual as_supertrait() workarounds.

trait Trait: Supertrait {}
trait Supertrait {}

fn upcast(x: &dyn Trait) -> &dyn Supertrait { x }
// Also: Arc<dyn Trait> -> Arc<dyn Supertrait>

// Downcasting without external crates:
use std::any::Any;
trait MyAny: Any {}
impl dyn MyAny {
    fn downcast_ref<T: 'static>(&self) -> Option<&T> {
        (self as &dyn Any).downcast_ref()
    }
}

---

Quick Method Reference

New in 1.84

Method	Description
n.isqrt() / n.checked_isqrt()	Integer square root (floor); checked returns None for negative
ptr::dangling::<T>()	Non-null, well-aligned dangling pointer
ptr.addr() / .with_addr(a) / .map_addr(f)	Pointer provenance-preserving address ops
ptr.expose_provenance() / ptr::with_exposed_provenance(a)	Round-trip through integer with provenance
ptr::without_provenance(a)	Pointer with no provenance (sentinel values)
&raw const *p	Now safe (was unsafe)

New in 1.85–1.86

Method	Description
a.midpoint(b)	Overflow-safe (a+b)/2 for floats and unsigned ints
v.pop_if(|x| ...)	Pop last element if predicate holds
v.get_disjoint_mut([i, j])	Multiple &mut into slice/HashMap simultaneously
lock.wait()	Block until OnceLock/Once is initialized

New in 1.87–1.88

Method	Description
std::io::pipe()	Returns (PipeReader, PipeWriter)
v.extract_if(.., |x| ...)	Drain matching elements (lazy iterator)
s.split_off(n) / split_off_first() / split_off_last()	Split slice, return tuple
os_str.display()	Lossily display OsStr / OsString
n.unbounded_shl(k) / unbounded_shr(k)	Shift returning 0 instead of panic when k ≥ bits
s.as_chunks::<N>() / as_rchunks::<N>()	Fixed-size array chunks with remainder
map.extract_if(|k,v| ...)	HashMap/HashSet drain by predicate
cell.update(|x| ...)	Update Cell<T> in place, return new value

New in 1.89–1.91

Method	Description
f.lock() / f.try_lock() / f.unlock()	Advisory file locking (no fs2 needed)
r.flatten()	Result<Result<T,E>,E> → Result<T,E>
NonNull::from_ref(&x) / from_mut(&mut x)	Safe NonNull from references
x.checked_sub_signed(n) etc.	Subtract signed from unsigned (checked_, wrapping_, saturating_, overflowing_)
n.strict_add(m) etc.	Panic on overflow in debug AND release
s.ceil_char_boundary(i) / floor_char_boundary(i)	Nearest valid UTF-8 boundary
Path::file_prefix()	Stem with ALL extensions stripped
p.add_extension("gz")	Append extension (unlike set_extension which replaces)
Duration::from_mins(n) / from_hours(n)	Convenience constructors
Path == "/some/str"	PartialEq<str> / PartialEq<String> now implemented

New in 1.92–1.94

Method	Description
RwLockWriteGuard::downgrade(guard)	Atomically write→read lock downgrade
Box::new_zeroed() / new_zeroed_slice(n)	Zero-initialized allocation (also Rc, Arc)
s.into_raw_parts() / v.into_raw_parts()	Decompose String/Vec to (ptr, len, cap)
Duration::from_nanos_u128(n)	Like from_nanos but accepts u128
s.as_chunks::<N>()	(also as_array::<N>() in 1.93: slice → fixed-size array ref)
fmt::from_fn(|f| ...)	Display value from closure, no new type needed
dq.pop_front_if(|x| ...) / pop_back_if(...)	Conditional pop from VecDeque
cell.get() on LazyCell/LazyLock	Option<&T> without forcing init
LazyCell::force_mut(&mut cell)	Force init, return &mut T
iter.next_if_map(|x| ...)	Peek + transform; advance only if Some
v.element_offset(&v[i])	Index of element by reference
f64::consts::EULER_GAMMA / GOLDEN_RATIO	New float constants