Make mutability taken from Freezeness of the main static alloc explicit.

Before it was hard to see that in the other cases we just preserve the static's mutability

Author: oli-obk

compiler/rustc_const_eval/src/interpret/validity.rs

@@ -483,26 +483,25 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
                         }
                         // Return alloc mutability. For "root" statics we look at the type to account for interior
                         // mutability; for nested statics we have no type and directly use the annotated mutability.
-                        let DefKind::Static { mutability, nested } = self.ecx.tcx.def_kind(did)
+                        let DefKind::Static { mut mutability, nested } = self.ecx.tcx.def_kind(did)
                         else {
                             bug!()
                         };
-                        match (mutability, nested) {
-                            (Mutability::Mut, _) => Mutability::Mut,
-                            (Mutability::Not, true) => Mutability::Not,
-                            (Mutability::Not, false)
-                                if !self
-                                    .ecx
-                                    .tcx
-                                    .type_of(did)
-                                    .no_bound_vars()
-                                    .expect("statics should not have generic parameters")
-                                    .is_freeze(*self.ecx.tcx, ty::ParamEnv::reveal_all()) =>
+                        if let Mutability::Not = mutability
+                            && !nested
+                        {
+                            if !self
+                                .ecx
+                                .tcx
+                                .type_of(did)
+                                .no_bound_vars()
+                                .expect("statics should not have generic parameters")
+                                .is_freeze(*self.ecx.tcx, ty::ParamEnv::reveal_all())
                             {
-                                Mutability::Mut
+                                mutability = Mutability::Mut;
                             }
-                            (Mutability::Not, false) => Mutability::Not,
                         }
+                        mutability
                     }
                     Some(GlobalAlloc::Memory(alloc)) => alloc.inner().mutability,
                     Some(GlobalAlloc::Function(..) | GlobalAlloc::VTable(..)) => {