do not premote non-ZST mutable references ever

Author: RalfJung

compiler/rustc_mir/src/transform/promote_consts.rs

@@ -364,15 +364,7 @@ impl<'tcx> Validator<'_, 'tcx> {
                             // In theory, any zero-sized value could be borrowed
                             // mutably without consequences. However, only &mut []
                             // is allowed right now, and only in functions.
-                            if self.const_kind
-                                == Some(hir::ConstContext::Static(hir::Mutability::Mut))
-                            {
-                                // Inside a `static mut`, &mut [...] is also allowed.
-                                match ty.kind() {
-                                    ty::Array(..) | ty::Slice(_) => {}
-                                    _ => return Err(Unpromotable),
-                                }
-                            } else if let ty::Array(_, len) = ty.kind() {
+                            if let ty::Array(_, len) = ty.kind() {
                                 // FIXME(eddyb) the `self.is_non_const_fn` condition
                                 // seems unnecessary, given that this is merely a ZST.
                                 match len.try_eval_usize(self.tcx, self.param_env) {
@@ -673,13 +665,7 @@ impl<'tcx> Validator<'_, 'tcx> {
                     // In theory, any zero-sized value could be borrowed
                     // mutably without consequences. However, only &mut []
                     // is allowed right now, and only in functions.
-                    if self.const_kind == Some(hir::ConstContext::Static(hir::Mutability::Mut)) {
-                        // Inside a `static mut`, &mut [...] is also allowed.
-                        match ty.kind() {
-                            ty::Array(..) | ty::Slice(_) => {}
-                            _ => return Err(Unpromotable),
-                        }
-                    } else if let ty::Array(_, len) = ty.kind() {
+                    if let ty::Array(_, len) = ty.kind() {
                         // FIXME(eddyb): We only return `Unpromotable` for `&mut []` inside a
                         // const context which seems unnecessary given that this is merely a ZST.
                         match len.try_eval_usize(self.tcx, self.param_env) {

src/test/ui/consts/promotion-mutable-ref.rs

@@ -0,0 +1,17 @@
+// run-pass
+#![feature(const_mut_refs)]
+
+static mut TEST: i32 = {
+    // We cannot promote this, as CTFE needs to be able to mutate it later.
+    let x = &mut [1,2,3];
+    x[0] += 1;
+    x[0]
+};
+
+// This still works -- it's not done via promotion.
+#[allow(unused)]
+static mut TEST2: &'static mut [i32] = &mut [0,1,2];
+
+fn main() {
+    assert_eq!(unsafe { TEST }, 2);
+}