`static_mut_refs` suggests invalid code in static context

[matthiaskrgr]

Using the following flags

--force-warn static_mut_refs

this code:

pub static mut ZERO: [u8; 1] = [0];
pub static ZERO_REF: &[u8; 1] = unsafe { &ZERO };
pub static mut OPT_ZERO: Option<u8> = Some(0);

caused the following diagnostics:

    Checking _static_cross_crate v0.1.0 (/tmp/icemaker_global_tempdir.0gE5D6KlClUx/icemaker_clippyfix_tempdir.zqEni6SMBF1V/_static_cross_crate)
warning: creating a shared reference to mutable static
 --> src/lib.rs:2:42
  |
2 | pub static ZERO_REF: &[u8; 1] = unsafe { &ZERO };
  |                                          ^^^^^ shared reference to mutable static
  |
  = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
  = note: shared references to mutable statics are dangerous; it's undefined behavior if the static is mutated or if a mutable reference is created for it while the shared reference lives
  = note: requested on the command line with `--force-warn static-mut-refs`
help: use `&raw const` instead to create a raw pointer
  |
2 | pub static ZERO_REF: &[u8; 1] = unsafe { &raw const ZERO };
  |                                           +++++++++

warning: `_static_cross_crate` (lib) generated 1 warning
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.46s

However after applying these diagnostics, the resulting code:

pub static mut ZERO: [u8; 1] = [0];
pub static ZERO_REF: &[u8; 1] = unsafe { &raw const ZERO };
pub static mut OPT_ZERO: Option<u8> = Some(0);

no longer compiled:

    Checking _static_cross_crate v0.1.0 (/tmp/icemaker_global_tempdir.0gE5D6KlClUx/icemaker_clippyfix_tempdir.zqEni6SMBF1V/_static_cross_crate)
error[E0308]: mismatched types
 --> src/lib.rs:2:42
  |
2 | pub static ZERO_REF: &[u8; 1] = unsafe { &raw const ZERO };
  |                                          ^^^^^^^^^^^^^^^ expected `&[u8; 1]`, found `*const [u8; 1]`
  |
  = note: expected reference `&'static [u8; 1]`
           found raw pointer `*const [u8; 1]`

For more information about this error, try `rustc --explain E0308`.
error: could not compile `_static_cross_crate` (lib test) due to 1 previous error
warning: build failed, waiting for other jobs to finish...
error: could not compile `_static_cross_crate` (lib) due to 1 previous error

Version:

rustc 1.90.0-nightly (f32b23204 2025-07-26)
binary: rustc
commit-hash: f32b23204a0efe2fe8383ed4be1a30b56c1bbf94
commit-date: 2025-07-26
host: x86_64-unknown-linux-gnu
release: 1.90.0-nightly
LLVM version: 20.1.8

[RalfJung]

This has nothing to do with "static contexts". The same happens with let x: &[u8; 1] = unsafe { &ZERO }; in a normal function.

And this is expected. Fixing the lint requires changing the code to use raw pointers instead of references. There is no local fix. The suggestion is merely the first step. (You could write &*&raw const ZERO but that has the exact same UB issues as the original code so it is a bad suggestion.)

[AviraL0013]

This lint fires anytime you try to make a shared &T from a static mut T, whether in a function or at the top level.

Rust can’t guarantee safety if you take a &ZERO when ZERO is mutable—there’s no safe way to do that without risking undefined behavior.

To fix it you have to change your design, for example:
Make it immutable

pub static ZERO: [u8; 1] = [0];
pub static ZERO_REF: &[u8; 1] = &ZERO;

Or use a raw pointer/UnsafeCell

use std::cell::UnsafeCell;
pub static ZERO: UnsafeCell<[u8; 1]> = UnsafeCell::new([0]);
pub static ZERO_PTR: *const [u8; 1] = ZERO.get();

Both ways make it clear: immutable data can safely be shared by &T, while mutable globals need raw pointers or UnsafeCell and unsafe to access.