allow constants to refer to mutable/external memory, but reject such constants as patterns

src/items/constant-items.md

@@ -49,7 +49,26 @@ const BITS_N_STRINGS: BitsNStrings<'static> = BitsNStrings {
 ```
 
 r[items.const.final-value-immutable]
-The final value of a `const` item cannot contain references to anything mutable.
+The final value of a `const` item cannot contain a mutable reference.
+
+```rust
+# use core::sync::atomic::AtomicU8;
+static mut S_M: u8 = 0;
+static S_IM: AtomicU8 = AtomicU8::new(0);
+const C_M: &u8 = unsafe { &mut S_M }; // OK
+const C_IM: &AtomicU8 = &S_IM; // OK
+const C_MR: &mut u8 = unsafe { &mut S_M }; // ERROR not allowed
+```
+
+> [!NOTE]
+> We also disallow, in the final value, shared references to mutable statics created in the initializer for a separate reason. Consider:
+>
+> ```rust
+> # use core::sync::atomic::AtomicU8;
+> const C: &AtomicU8 = &AtomicU8:new(0); // ERROR
+> ```
+>
+> Here, the `AtomicU8` is a temporary that is lifetime extended to `'static` (see [destructors.scope.lifetime-extension.static]), and references to lifetime-extended temporaries with interior mutability are not allowed in the final value of a constant expression (see [const-eval.const-expr.borrows]).
 
 r[items.const.expr-omission]
 The constant expression may only be omitted in a [trait definition].

src/patterns.md

@@ -975,6 +975,9 @@ r[patterns.const.generic]
 In particular, the value of `C` must be known at pattern-building time (which is pre-monomorphization).
 This means that associated consts that involve generic parameters cannot be used as patterns.
 
+r[patterns.const.immutable]
+The value of `C` must not contain any references to mutable statics (`static mut` or interior mutable) or `extern` statics.
+
 r[patterns.const.translation]
 After ensuring all conditions are met, the constant value is translated into a pattern, and now behaves exactly as-if that pattern had been written directly.
 In particular, it fully participates in exhaustiveness checking.