Rust: why multiple exclusive borrows are possible for static mut variables in unsafe blocks?

In Rust, ensuring mut borrows are exclusive is a strong invariant. Wanting to circumvent that with std::mem::transmute is considered undefined behaviour, because the compiler uses this invariant to apply some optimisations.

Even with unsafe, disabling the borrow checker is not possible. However, it seems it is still possible to disabling that for static mut variables.

For instance, this does not compile:

fn main() {
    let mut s = String::new();
    unsafe {
        let a = &mut s;
        let b = &mut s;
        println!("Result: {a} {b}");  
    }
}

Error is:

error[E0499]: cannot borrow `s` as mutable more than once at a time
  --> src/main.rs:18:17
   |
17 |         let a = &mut s;
   |                 ------ first mutable borrow occurs here
18 |         let b = &mut s;
   |                 ^^^^^^ second mutable borrow occurs here
19 |         println!("{a} {b}");  
   |                   --- first borrow later used here

But this code compiles and works fine:

static mut s: String = String::new();

fn main() {
    unsafe {
        let a = &mut s;
        let b = &mut s;
        println!("Result: {a} {b}");  
    }
}

Why this difference?

Is it a kind of legacy that should be removed? Or are there some specific needs or requirements for static variables due to their nature or for code interoperability with C or LLVM, and why?

This is one of the reasons accessing static mut is unsafe.

As for why the compiler cannot verify that, it is because the borrow checker uses lifetimes to validate the rules that mutable borrows are exclusive. Each variable is assigned a unique lifetime, and the compiler verifies that no-one borrows such lifetime twice. But a borrow of static variable always results in a 'static lifetime (this is necessary to be able to pass it around, there is no other sensible lifetime), and the compiler cannot determine what static variable it is sourced from. This becomes impossible in the general case, too, when the references are just &'static mut and we lost all information about where they came from.

This is also one of the reasons why using static mut correctly is so hard, and why you should avoid it at any price. Prefer static with UnsafeCell when you need an unsafely mutable static.

Currently, Rust compiler is incapable of tracing borrows of static mut VAR.
Maybe compiler will catch more such borrowing mistakes in the future,
BUT it seems to be impossible to implement FULL borrow checking for mutable statics.
That's the reason no one even bothered to do it even for trivial borrowing cases like yours.

Arguably, it would be possible to implement some case-specific borrow-checks for cases like yours.
Yet, it's unlikely for an average programmer to introduce this-specific bug.
So that's why no one bothered to implement such compile time error, though it would be posible for this trivial case.