Disallow use of static mut inside unsafe block

```rust
static mut X: i32 = 23;
unsafe {
  let y = &X;
}
```

This is the idea for the 2024 edition.
Add `E0796` error code.

Author: obeis

Cargo.lock

@@ -3936,6 +3936,7 @@ dependencies = [
  "rustc_feature",
  "rustc_fluent_macro",
  "rustc_hir",
+ "rustc_hir_pretty",
  "rustc_index",
  "rustc_infer",
  "rustc_lint_defs",

compiler/rustc_error_codes/src/error_codes.rs

@@ -515,6 +515,7 @@ E0792: include_str!("./error_codes/E0792.md"),
 E0793: include_str!("./error_codes/E0793.md"),
 E0794: include_str!("./error_codes/E0794.md"),
 E0795: include_str!("./error_codes/E0795.md"),
+E0796: include_str!("./error_codes/E0796.md"),
 }
 
 // Undocumented removed error codes. Note that many removed error codes are kept in the list above

compiler/rustc_error_codes/src/error_codes/E0796.md

@@ -0,0 +1,20 @@
+Use of mutable static.
+
+Erroneous code example:
+
+```compile_fail,edition2024,E0796
+static mut X: i32 = 23;
+unsafe {
+  let y = &X;
+}
+
+unsafe fn foo() {
+    static mut X: i32 = 1;
+    let y = &X;
+}
+```
+
+Mutable statics can be written to by multiple threads: aliasing violations or
+data races will cause undefined behavior.
+
+Use of mutable static is a hard error from 2024 edition.

compiler/rustc_hir_analysis/Cargo.toml

@@ -17,6 +17,7 @@ rustc_errors = { path = "../rustc_errors" }
 rustc_feature = { path = "../rustc_feature" }
 rustc_fluent_macro = { path = "../rustc_fluent_macro" }
 rustc_hir = { path = "../rustc_hir" }
+rustc_hir_pretty = { path = "../rustc_hir_pretty" }
 rustc_index = { path = "../rustc_index" }
 rustc_infer = { path = "../rustc_infer" }
 rustc_lint_defs = { path = "../rustc_lint_defs" }

compiler/rustc_hir_analysis/messages.ftl

@@ -333,6 +333,11 @@ hir_analysis_start_not_target_feature = `#[start]` function is not allowed to ha
 hir_analysis_start_not_track_caller = `#[start]` function is not allowed to be `#[track_caller]`
     .label = `#[start]` function is not allowed to be `#[track_caller]`
 
+hir_analysis_static_mut_ref = use of mutable static is disallowed
+    .label = use of mutable static
+    .note = mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
+    .suggestion = use `addr_of_mut!` macro
+
 hir_analysis_static_specialize = cannot specialize on `'static` lifetime
 
 hir_analysis_substs_on_overridden_impl = could not resolve substs on overridden impl

compiler/rustc_hir_analysis/src/check/region.rs

@@ -6,20 +6,24 @@
 //!
 //! [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/borrow_check.html
 
-use rustc_ast::walk_list;
+use rustc_ast::{walk_list, BorrowKind};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::{Arm, Block, Expr, Local, Pat, PatKind, Stmt};
+use rustc_hir_pretty::qpath_to_string;
 use rustc_index::Idx;
 use rustc_middle::middle::region::*;
 use rustc_middle::ty::TyCtxt;
 use rustc_span::source_map;
 use rustc_span::Span;
+use rustc_type_ir::Mutability;
 
 use std::mem;
 
+use crate::errors;
+
 #[derive(Debug, Copy, Clone)]
 pub struct Context {
     /// The scope that contains any new variables declared, plus its depth in
@@ -90,6 +94,12 @@ fn resolve_block<'tcx>(visitor: &mut RegionResolutionVisitor<'tcx>, blk: &'tcx h
 
     let prev_cx = visitor.cx;
 
+    if let hir::BlockCheckMode::UnsafeBlock(src) = blk.rules
+        && matches!(src, hir::UnsafeSource::UserProvided)
+    {
+        static_mut_ref(visitor.tcx, blk.stmts);
+    }
+
     // We treat the tail expression in the block (if any) somewhat
     // differently from the statements. The issue has to do with
     // temporary lifetimes. Consider the following:
@@ -887,3 +897,24 @@ pub fn region_scope_tree(tcx: TyCtxt<'_>, def_id: DefId) -> &ScopeTree {
 
     tcx.arena.alloc(scope_tree)
 }
+
+/// Check for use of mutable static
+pub fn static_mut_ref(tcx: TyCtxt<'_>, stmts: &[Stmt<'_>]) {
+    for stmt in stmts {
+        if let hir::StmtKind::Local(loc) = stmt.kind
+            && let Some(init) = loc.init
+            && let hir::ExprKind::AddrOf(borrow_kind, _, expr) = init.kind
+            && matches!(borrow_kind, BorrowKind::Ref)
+            && let hir::ExprKind::Path(qpath) = expr.kind
+            && let hir::QPath::Resolved(_, path) = qpath
+            && let hir::def::Res::Def(def_kind, _) = path.res
+            && let hir::def::DefKind::Static(mt) = def_kind
+            && matches!(mt, Mutability::Mut)
+            && loc.span.edition().at_least_rust_2024()
+        {
+            let span = init.span;
+            let var = qpath_to_string(&qpath);
+            tcx.sess.emit_err(errors::StaticMutRef { span, var });
+        }
+    }
+}

compiler/rustc_hir_analysis/src/errors.rs

@@ -1329,3 +1329,18 @@ pub struct OnlyCurrentTraitsPointerSugg<'a> {
     pub mut_key: &'a str,
     pub ptr_ty: Ty<'a>,
 }
+
+#[derive(Diagnostic)]
+#[diag(hir_analysis_static_mut_ref, code = "E0796")]
+#[note]
+pub struct StaticMutRef {
+    #[primary_span]
+    #[label]
+    #[suggestion(
+        style = "verbose",
+        code = "addr_of_mut!({var})",
+        applicability = "maybe-incorrect"
+    )]
+    pub span: Span,
+    pub var: String,
+}