Auto merge of #67000 - spastorino:remove-promoted-from-place, r=<try>

Promote references to constants instead of statics

This sits on top of @oli-obk's #67192. When that's merged I can rebase and make it a final PR.

r? @oli-obk

Author: bors

src/librustc/mir/interpret/allocation.rs

@@ -127,6 +127,10 @@ impl<Tag> Allocation<Tag> {
             extra: (),
         }
     }
+
+    pub fn zst(align: Align) -> Self {
+        Self::undef(Size::ZERO, align)
+    }
 }
 
 impl Allocation<(), ()> {

src/librustc/mir/interpret/error.rs

@@ -468,6 +468,7 @@ pub enum UnsupportedOpInfo<'tcx> {
     HeapAllocNonPowerOfTwoAlignment(u64),
     ReadFromReturnPointer,
     PathNotFound(Vec<String>),
+    TransmuteSizeDiff(Ty<'tcx>, Ty<'tcx>),
 }
 
 impl fmt::Debug for UnsupportedOpInfo<'tcx> {
@@ -490,6 +491,9 @@ impl fmt::Debug for UnsupportedOpInfo<'tcx> {
                 write!(f, "tried to call a function with argument of type {:?} \
                            passing data of type {:?}",
                     callee_ty, caller_ty),
+            TransmuteSizeDiff(from_ty, to_ty) =>
+                write!(f, "tried to transmute from {:?} to {:?}, but their sizes differed",
+                    from_ty, to_ty),
             FunctionRetMismatch(caller_ty, callee_ty) =>
                 write!(f, "tried to call a function with return type {:?} \
                            passing return place of type {:?}",

src/librustc/mir/interpret/value.rs

@@ -339,8 +339,9 @@ impl<'tcx, Tag> Scalar<Tag> {
     }
 
     /// Do not call this method!  Use either `assert_ptr` or `force_ptr`.
+    /// This method is intentionally private, do not make it public.
     #[inline]
-    pub fn to_ptr(self) -> InterpResult<'tcx, Pointer<Tag>> {
+    fn to_ptr(self) -> InterpResult<'tcx, Pointer<Tag>> {
         match self {
             Scalar::Raw { data: 0, .. } => throw_unsup!(InvalidNullPointerUsage),
             Scalar::Raw { .. } => throw_unsup!(ReadBytesAsPointer),
@@ -517,12 +518,6 @@ impl<'tcx, Tag> ScalarMaybeUndef<Tag> {
         }
     }
 
-    /// Do not call this method!  Use either `assert_ptr` or `force_ptr`.
-    #[inline(always)]
-    pub fn to_ptr(self) -> InterpResult<'tcx, Pointer<Tag>> {
-        self.not_undef()?.to_ptr()
-    }
-
     /// Do not call this method!  Use either `assert_bits` or `force_bits`.
     #[inline(always)]
     pub fn to_bits(self, target_size: Size) -> InterpResult<'tcx, u128> {

src/librustc/mir/mod.rs

@@ -154,6 +154,16 @@ pub struct Body<'tcx> {
 
     /// A span representing this MIR, for error reporting.
     pub span: Span,
+
+    /// The user may be writing e.g. &[(SOME_CELL, 42)][i].1 and this would get promoted, because
+    /// we'd statically know that no thing with interior mutability will ever be available to the
+    /// user without some serious unsafe code.  Now this means that our promoted is actually
+    /// &[(SOME_CELL, 42)] and the MIR using it will do the &promoted[i].1 projection because the
+    /// index may be a runtime value. Such a promoted value is illegal because it has reachable
+    /// interior mutability. This flag just makes this situation very obvious where the previous
+    /// implementation without the flag hid this situation silently.
+    /// FIXME(oli-obk): rewrite the promoted during promotion to eliminate the cell components.
+    pub ignore_interior_mut_in_const_validation: bool,
 }
 
 impl<'tcx> Body<'tcx> {
@@ -190,6 +200,7 @@ impl<'tcx> Body<'tcx> {
             spread_arg: None,
             var_debug_info,
             span,
+            ignore_interior_mut_in_const_validation: false,
             control_flow_destroyed,
         }
     }
@@ -1649,52 +1660,17 @@ impl Debug for Statement<'_> {
 /// A path to a value; something that can be evaluated without
 /// changing or disturbing program state.
 #[derive(
-    Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, HashStable,
+    Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, HashStable,
 )]
 pub struct Place<'tcx> {
-    pub base: PlaceBase<'tcx>,
+    pub local: Local,
 
     /// projection out of a place (access a field, deref a pointer, etc)
     pub projection: &'tcx List<PlaceElem<'tcx>>,
 }
 
 impl<'tcx> rustc_serialize::UseSpecializedDecodable for Place<'tcx> {}
 
-#[derive(
-    Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable, HashStable,
-)]
-pub enum PlaceBase<'tcx> {
-    /// local variable
-    Local(Local),
-
-    /// static or static mut variable
-    Static(Box<Static<'tcx>>),
-}
-
-/// We store the normalized type to avoid requiring normalization when reading MIR
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash,
-         RustcEncodable, RustcDecodable, HashStable)]
-pub struct Static<'tcx> {
-    pub ty: Ty<'tcx>,
-    pub kind: StaticKind<'tcx>,
-    /// The `DefId` of the item this static was declared in. For promoted values, usually, this is
-    /// the same as the `DefId` of the `mir::Body` containing the `Place` this promoted appears in.
-    /// However, after inlining, that might no longer be the case as inlined `Place`s are copied
-    /// into the calling frame.
-    pub def_id: DefId,
-}
-
-#[derive(
-    Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, HashStable, RustcEncodable, RustcDecodable,
-)]
-pub enum StaticKind<'tcx> {
-    /// Promoted references consist of an id (`Promoted`) and the substs necessary to monomorphize
-    /// it. Usually, these substs are just the identity substs for the item. However, the inliner
-    /// will adjust these substs when it inlines a function based on the substs at the callsite.
-    Promoted(Promoted, SubstsRef<'tcx>),
-    Static,
-}
-
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[derive(RustcEncodable, RustcDecodable, HashStable)]
 pub enum ProjectionElem<V, T> {
@@ -1783,15 +1759,15 @@ rustc_index::newtype_index! {
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct PlaceRef<'a, 'tcx> {
-    pub base: &'a PlaceBase<'tcx>,
+    pub local: &'a Local,
     pub projection: &'a [PlaceElem<'tcx>],
 }
 
 impl<'tcx> Place<'tcx> {
     // FIXME change this to a const fn by also making List::empty a const fn.
     pub fn return_place() -> Place<'tcx> {
         Place {
-            base: PlaceBase::Local(RETURN_PLACE),
+            local: RETURN_PLACE,
             projection: List::empty(),
         }
     }
@@ -1811,13 +1787,13 @@ impl<'tcx> Place<'tcx> {
     pub fn local_or_deref_local(&self) -> Option<Local> {
         match self.as_ref() {
             PlaceRef {
-                base: &PlaceBase::Local(local),
+                local,
                 projection: &[],
             } |
             PlaceRef {
-                base: &PlaceBase::Local(local),
+                local,
                 projection: &[ProjectionElem::Deref],
-            } => Some(local),
+            } => Some(*local),
             _ => None,
         }
     }
@@ -1830,7 +1806,7 @@ impl<'tcx> Place<'tcx> {
 
     pub fn as_ref(&self) -> PlaceRef<'_, 'tcx> {
         PlaceRef {
-            base: &self.base,
+            local: &self.local,
             projection: &self.projection,
         }
     }
@@ -1839,18 +1815,12 @@ impl<'tcx> Place<'tcx> {
 impl From<Local> for Place<'_> {
     fn from(local: Local) -> Self {
         Place {
-            base: local.into(),
+            local,
             projection: List::empty(),
         }
     }
 }
 
-impl From<Local> for PlaceBase<'_> {
-    fn from(local: Local) -> Self {
-        PlaceBase::Local(local)
-    }
-}
-
 impl<'a, 'tcx> PlaceRef<'a, 'tcx> {
     /// Finds the innermost `Local` from this `Place`, *if* it is either a local itself or
     /// a single deref of a local.
@@ -1859,13 +1829,13 @@ impl<'a, 'tcx> PlaceRef<'a, 'tcx> {
     pub fn local_or_deref_local(&self) -> Option<Local> {
         match self {
             PlaceRef {
-                base: PlaceBase::Local(local),
+                local,
                 projection: [],
             } |
             PlaceRef {
-                base: PlaceBase::Local(local),
+                local,
                 projection: [ProjectionElem::Deref],
-            } => Some(*local),
+            } => Some(**local),
             _ => None,
         }
     }
@@ -1874,7 +1844,7 @@ impl<'a, 'tcx> PlaceRef<'a, 'tcx> {
     /// projections, return `Some(_X)`.
     pub fn as_local(&self) -> Option<Local> {
         match self {
-            PlaceRef { base: PlaceBase::Local(l), projection: [] } => Some(*l),
+            PlaceRef { local, projection: [] } => Some(**local),
             _ => None,
         }
     }
@@ -1896,7 +1866,7 @@ impl Debug for Place<'_> {
             }
         }
 
-        write!(fmt, "{:?}", self.base)?;
+        write!(fmt, "{:?}", self.local)?;
 
         for elem in self.projection.iter() {
             match elem {
@@ -1940,22 +1910,6 @@ impl Debug for Place<'_> {
     }
 }
 
-impl Debug for PlaceBase<'_> {
-    fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
-        match *self {
-            PlaceBase::Local(id) => write!(fmt, "{:?}", id),
-            PlaceBase::Static(box self::Static { ty, kind: StaticKind::Static, def_id }) => {
-                write!(fmt, "({}: {:?})", ty::tls::with(|tcx| tcx.def_path_str(def_id)), ty)
-            }
-            PlaceBase::Static(box self::Static {
-                ty, kind: StaticKind::Promoted(promoted, _), def_id: _
-            }) => {
-                write!(fmt, "({:?}: {:?})", promoted, ty)
-            }
-        }
-    }
-}
-
 ///////////////////////////////////////////////////////////////////////////
 // Scopes
 
@@ -3019,29 +2973,13 @@ impl<'tcx> TypeFoldable<'tcx> for GeneratorKind {
 impl<'tcx> TypeFoldable<'tcx> for Place<'tcx> {
     fn super_fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
         Place {
-            base: self.base.fold_with(folder),
+            local: self.local.fold_with(folder),
             projection: self.projection.fold_with(folder),
         }
     }
 
     fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
-        self.base.visit_with(visitor) || self.projection.visit_with(visitor)
-    }
-}
-
-impl<'tcx> TypeFoldable<'tcx> for PlaceBase<'tcx> {
-    fn super_fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
-        match self {
-            PlaceBase::Local(local) => PlaceBase::Local(local.fold_with(folder)),
-            PlaceBase::Static(static_) => PlaceBase::Static(static_.fold_with(folder)),
-        }
-    }
-
-    fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
-        match self {
-            PlaceBase::Local(local) => local.visit_with(visitor),
-            PlaceBase::Static(static_) => (**static_).visit_with(visitor),
-        }
+        self.local.visit_with(visitor) || self.projection.visit_with(visitor)
     }
 }
 
@@ -3056,40 +2994,6 @@ impl<'tcx> TypeFoldable<'tcx> for &'tcx ty::List<PlaceElem<'tcx>> {
     }
 }
 
-impl<'tcx> TypeFoldable<'tcx> for Static<'tcx> {
-    fn super_fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
-        Static {
-            ty: self.ty.fold_with(folder),
-            kind: self.kind.fold_with(folder),
-            def_id: self.def_id,
-        }
-    }
-
-    fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
-        let Static { ty, kind, def_id: _ } = self;
-
-        ty.visit_with(visitor) || kind.visit_with(visitor)
-    }
-}
-
-impl<'tcx> TypeFoldable<'tcx> for StaticKind<'tcx> {
-    fn super_fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
-        match self {
-            StaticKind::Promoted(promoted, substs) =>
-                StaticKind::Promoted(promoted.fold_with(folder), substs.fold_with(folder)),
-            StaticKind::Static => StaticKind::Static
-        }
-    }
-
-    fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
-        match self {
-            StaticKind::Promoted(promoted, substs) =>
-                promoted.visit_with(visitor) || substs.visit_with(visitor),
-            StaticKind::Static => { false }
-        }
-    }
-}
-
 impl<'tcx> TypeFoldable<'tcx> for Rvalue<'tcx> {
     fn super_fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
         use crate::mir::Rvalue::*;

src/librustc/mir/tcx.rs

@@ -116,15 +116,15 @@ impl<'tcx> PlaceTy<'tcx> {
 
 impl<'tcx> Place<'tcx> {
     pub fn ty_from<D>(
-        base: &PlaceBase<'tcx>,
+        local: &Local,
         projection: &[PlaceElem<'tcx>],
         local_decls: &D,
         tcx: TyCtxt<'tcx>
     ) -> PlaceTy<'tcx>
         where D: HasLocalDecls<'tcx>
     {
         projection.iter().fold(
-            base.ty(local_decls),
+            PlaceTy::from_ty(local_decls.local_decls()[*local].ty),
             |place_ty, elem| place_ty.projection_ty(tcx, elem)
         )
     }
@@ -133,18 +133,7 @@ impl<'tcx> Place<'tcx> {
     where
         D: HasLocalDecls<'tcx>,
     {
-        Place::ty_from(&self.base, &self.projection, local_decls, tcx)
-    }
-}
-
-impl<'tcx> PlaceBase<'tcx> {
-    pub fn ty<D>(&self, local_decls: &D) -> PlaceTy<'tcx>
-        where D: HasLocalDecls<'tcx>
-    {
-        match self {
-            PlaceBase::Local(index) => PlaceTy::from_ty(local_decls.local_decls()[*index].ty),
-            PlaceBase::Static(data) => PlaceTy::from_ty(data.ty),
-        }
+        Place::ty_from(&self.local, &self.projection, local_decls, tcx)
     }
 }