`unused_assignments` when writing to variable and then reading from its raw pointer

[Giftzwerg02]

Code

let mut a = 0;
let a_ptr = &mut a as *mut _;

a = 3; // <-- produces warning for this assignment

println!("a: {}", unsafe { *a_ptr });

Current output

warning: value assigned to `a` is never read
  --> src/main.rs:43:5
   |
43 |     a = 3;
   |     ^^^^^
   |
   = help: maybe it is overwritten before being read?
   = note: `#[warn(unused_assignments)]` (part of `#[warn(unused)]`) on by default

warning: 1 warning emitted

Desired output

Ideally no error at all (?)

Rationale and extra context

I first got this warning when using the libc-crate, which requires passing raw pointers, e.g.:

fn main() {
    use libc;
    use std::time::Duration;

    let timeout = Duration::from_secs(1);
    let mut ts = libc::timespec {
        tv_sec: 0,
        tv_nsec: 0,
    };

    let ts_ptr = &mut ts as *mut _;

    unsafe { libc::clock_gettime(libc::CLOCK_REALTIME, ts_ptr) };

    // these writes cause a "value assigned is never read" warning
    ts.tv_sec += timeout.as_secs() as i64;
    ts.tv_nsec += timeout.subsec_nanos() as i64;

    let mut rc = 0;
    while /* exit-condition && */ rc == 0 {
        // ts_ptr used again here
        rc = unsafe { libc::pthread_cond_timedwait(todo!("cond"), todo!("lock"), ts_ptr) }
    }
}

Other cases

Rust Version

$ rustc --version --verbose
rustc 1.92.0 (ded5c06cf 2025-12-08)
binary: rustc
commit-hash: ded5c06cf21d2b93bffd5d884aa6e96934ee4234
commit-date: 2025-12-08
host: x86_64-unknown-linux-gnu
release: 1.92.0
LLVM version: 21.1.3

Anything else?

No response

[zachs18]

IIUC, it is not decided whether code like this is allowed or not (i.e. it is not fully decided whether it is allowed to use a_ptr after writing directly to a). Miri reports UB in the first snippet under Stacked Borrows, but not under Tree Borrows (playground: click "Tools > Miri" to run under Miri, use "[...] > Aliasing Model" to switch between stacked and tree borrows in Miri).

CC rust-lang/unsafe-code-guidelines#591 (though that example uses &raw mut local, not &mut local as *mut _)

Miri error

Code:

fn main() {
    let mut a = 0;
    let a_ptr = &raw mut a;
    
    a = 3; // <-- produces warning for this assignment
    
    println!("a: {}", unsafe { *a_ptr });
}

Error:

error: Undefined Behavior: attempting a read access using <422> at alloc212[0x0], but that tag does not exist in the borrow stack for this location
 --> src/main.rs:7:32
  |
7 |     println!("a: {}", unsafe { *a_ptr });
  |                                ^^^^^^ this error occurs as part of an access at alloc212[0x0..0x4]
  |
  = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
  = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
help: <422> was created by a SharedReadWrite retag at offsets [0x0..0x4]
 --> src/main.rs:3:17
  |
3 |     let a_ptr = &raw mut a;
  |                 ^^^^^^^^^^
help: <422> was later invalidated at offsets [0x0..0x4] by a write access
 --> src/main.rs:5:5
  |
5 |     a = 3; // <-- produces warning for this assignment
  |     ^^^^^

note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace

error: aborting due to 1 previous error; 1 warning emitted

[RalfJung]

The variant in the OP, with let a_ptr = &mut a as *mut _;, is UB even under Tree Borrows. It fairly clearly violates the idea that mutable references must be unique. So that code definitely should be fixed.

That said, the warning also kicks in for the variant that only uses raw pointers, and I do think that variant should be allowed -- but it is correct that this is in a grey zone currently.