Version History and Testing

Which Rust release changed what the borrow checker accepts, which APIs remove the need for workarounds, and how to lock fixes in with tests and CI.

#Contents

• Stabilisations that matter for borrow errors
• Edition 2021 changes
• Edition 2024 changes
• Checking your MSRV before suggesting an API
• Testing that code does not compile
• Testing runtime borrow failures
• CI with the scripts

#Stabilisations that matter for borrow errors

#Edition 2021 changes

• Disjoint closure captures: closures capture the exact paths they use (self.a.b), not whole variables. Fixes many E0502/E0499 errors with closures inside methods. Side effect: drop order of captured values can change; cargo fix --edition inserts let _ = &x; where it matters.
• array.into_iter() yields values, not references (method syntax), which can move arrays you expected to borrow.
• Panics: panic!("{}") requires a format string; not borrow related.

#Edition 2024 changes

Edition 2024 (Rust 1.85) changes several rules that affect borrows:

Migrate with cargo fix --edition on 2021, check, then set edition = "2024" and re-run cargo check; run parse_diagnostics on the output to triage new borrow errors.

// Edition 2024 RPIT capture and its precise-capturing fix (1.82+ syntax, works on 2021 too).
fn evens<'a>(v: &'a [u32], _scratch: &mut Vec<u32>) -> impl Iterator<Item = u32> + use<'a> {
    v.iter().copied().filter(|x| x % 2 == 0)   // captures 'a only, not the `_scratch` borrow
}

#Checking your MSRV before suggesting an API

• Read rust-version in Cargo.toml (or the toolchain in rust-toolchain.toml).
• Below 1.86: suggest split_at_mut, not get_disjoint_mut. Below 1.87: retain (+ clone) instead of extract_if. Below 1.80: once_cell crate instead of LazyLock. Below 1.65: no let ... else.
• The explain_code fix lists name the minimum version next to each newer API.
• cargo +1.70 check (with that toolchain installed) or cargo msrv verify confirm a fix builds on the MSRV.

#Testing that code does not compile

Keep a regression test for "this misuse must stay a compile error", for example a type that must not be Send, or an API whose returned reference must not outlive its owner.

compile_fail doctests (stable, no extra crates):

/// The guard cannot outlive the pool:
///
/// ```compile_fail,E0597
/// let conn;
/// {
///     let pool = mycrate::Pool::new();
///     conn = pool.get();
/// }
/// conn.query("select 1");
/// ```
pub struct Pool;

The error code after compile_fail, makes rustdoc check that the failure is the expected one (the code check is enforced on nightly; stable only checks that it fails). Prefer tests that fail for exactly one reason.

trybuild (dev-dependency) compares full compiler output with .stderr snapshots:

#[test]
fn ui() {
    let t = trybuild::TestCases::new();
    t.compile_fail("tests/ui/*.rs");   // each file must fail; output compared to tests/ui/*.stderr
    t.pass("tests/ui-pass/*.rs");
}

Run TRYBUILD=overwrite cargo test to accept new snapshots after a compiler upgrade changes wording.

#Testing runtime borrow failures

use std::cell::RefCell;

struct Bus { listeners: RefCell<Vec<String>> }

impl Bus {
    fn emit(&self) -> usize {
        let snapshot = self.listeners.borrow().clone(); // guard dropped before calling out
        for _l in &snapshot {
            self.listeners.borrow_mut().push("re-subscribed".into());
        }
        snapshot.len()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn emit_can_resubscribe() {
        let bus = Bus { listeners: RefCell::new(vec!["a".into()]) };
        assert_eq!(bus.emit(), 1);
        assert_eq!(bus.listeners.borrow().len(), 2);
    }

    #[test]
    #[should_panic(expected = "already borrowed")]
    fn holding_a_guard_while_mutating_panics() {
        let cell = RefCell::new(vec![1]);
        let _r = cell.borrow();
        cell.borrow_mut().push(2);
    }
}

For mutexes, test the recovery path: spawn a thread that panics while holding the lock, join() it (it returns Err), then assert that lock() returns Err and that your recovery (into_inner/clear_poison) works.

#CI with the scripts

The scripts are single-file, std-only Rust programs: build with rustc, no Cargo project needed.

SKILL=path/to/rust-borrow-checker-error-explainer
for t in parse_diagnostics runtime_panic; do
  rustc -O --edition 2021 "$SKILL/scripts/$t.rs" -o "/tmp/$t"
done

# Fail fast with an explanation when a PR introduces borrow errors:
cargo check --all-targets --message-format=json > check.jsonl || /tmp/parse_diagnostics check.jsonl

# Explain RefCell / Mutex panics in test failures:
cargo test 2>&1 | tee test.txt || /tmp/runtime_panic test.txt

--strict makes either tool exit 1 when the output contains errors or panics that are not borrow-related, so a pipeline step can tell "borrow problem, see explanation" from "something else broke".