Remove Static from PlaceBase

Author: spastorino

src/librustc/mir/mod.rs

@@ -1663,7 +1663,7 @@ impl Debug for Statement<'_> {
     Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, HashStable,
 )]
 pub struct Place<'tcx> {
-    pub base: PlaceBase<'tcx>,
+    pub base: PlaceBase,
 
     /// projection out of a place (access a field, deref a pointer, etc)
     pub projection: &'tcx List<PlaceElem<'tcx>>,
@@ -1674,24 +1674,9 @@ impl<'tcx> rustc_serialize::UseSpecializedDecodable for Place<'tcx> {}
 #[derive(
     Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable, HashStable,
 )]
-pub enum PlaceBase<'tcx> {
+pub enum PlaceBase {
     /// 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>,
-    /// 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(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -1782,7 +1767,7 @@ rustc_index::newtype_index! {
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct PlaceRef<'a, 'tcx> {
-    pub base: &'a PlaceBase<'tcx>,
+    pub base: &'a PlaceBase,
     pub projection: &'a [PlaceElem<'tcx>],
 }
 
@@ -1844,7 +1829,7 @@ impl From<Local> for Place<'_> {
     }
 }
 
-impl From<Local> for PlaceBase<'_> {
+impl From<Local> for PlaceBase {
     fn from(local: Local) -> Self {
         PlaceBase::Local(local)
     }
@@ -1939,13 +1924,10 @@ impl Debug for Place<'_> {
     }
 }
 
-impl Debug for PlaceBase<'_> {
+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, def_id }) => {
-                write!(fmt, "({}: {:?})", ty::tls::with(|tcx| tcx.def_path_str(def_id)), ty)
-            }
         }
     }
 }
@@ -3023,18 +3005,16 @@ impl<'tcx> TypeFoldable<'tcx> for Place<'tcx> {
     }
 }
 
-impl<'tcx> TypeFoldable<'tcx> for PlaceBase<'tcx> {
+impl<'tcx> TypeFoldable<'tcx> for PlaceBase {
     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),
         }
     }
 }
@@ -3050,21 +3030,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),
-            def_id: self.def_id,
-        }
-    }
-
-    fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
-        let Static { ty, def_id: _ } = self;
-
-        ty.visit_with(visitor)
-    }
-}
-
 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,7 +116,7 @@ impl<'tcx> PlaceTy<'tcx> {
 
 impl<'tcx> Place<'tcx> {
     pub fn ty_from<D>(
-        base: &PlaceBase<'tcx>,
+        base: &PlaceBase,
         projection: &[PlaceElem<'tcx>],
         local_decls: &D,
         tcx: TyCtxt<'tcx>
@@ -137,13 +137,12 @@ impl<'tcx> Place<'tcx> {
     }
 }
 
-impl<'tcx> PlaceBase<'tcx> {
+impl<'tcx> PlaceBase {
     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),
         }
     }
 }

src/librustc/mir/visit.rs

@@ -164,7 +164,7 @@ macro_rules! make_mir_visitor {
             }
 
             fn visit_place_base(&mut self,
-                                base: & $($mutability)? PlaceBase<'tcx>,
+                                base: & $($mutability)? PlaceBase,
                                 context: PlaceContext,
                                 location: Location) {
                 self.super_place_base(base, context, location);
@@ -705,16 +705,13 @@ macro_rules! make_mir_visitor {
             }
 
             fn super_place_base(&mut self,
-                                place_base: & $($mutability)? PlaceBase<'tcx>,
+                                place_base: & $($mutability)? PlaceBase,
                                 context: PlaceContext,
                                 location: Location) {
                 match place_base {
                     PlaceBase::Local(local) => {
                         self.visit_local(local, context, location);
                     }
-                    PlaceBase::Static(box Static { ty, def_id: _ }) => {
-                        self.visit_ty(& $($mutability)? *ty, TyContext::Location(location));
-                    }
                 }
             }
 
@@ -889,7 +886,7 @@ macro_rules! visit_place_fns {
     () => (
         fn visit_projection(
             &mut self,
-            base: &PlaceBase<'tcx>,
+            base: &PlaceBase,
             projection: &[PlaceElem<'tcx>],
             context: PlaceContext,
             location: Location,
@@ -899,7 +896,7 @@ macro_rules! visit_place_fns {
 
         fn visit_projection_elem(
             &mut self,
-            base: &PlaceBase<'tcx>,
+            base: &PlaceBase,
             proj_base: &[PlaceElem<'tcx>],
             elem: &PlaceElem<'tcx>,
             context: PlaceContext,
@@ -934,7 +931,7 @@ macro_rules! visit_place_fns {
 
         fn super_projection(
             &mut self,
-            base: &PlaceBase<'tcx>,
+            base: &PlaceBase,
             projection: &[PlaceElem<'tcx>],
             context: PlaceContext,
             location: Location,
@@ -948,7 +945,7 @@ macro_rules! visit_place_fns {
 
         fn super_projection_elem(
             &mut self,
-            _base: &PlaceBase<'tcx>,
+            _base: &PlaceBase,
             _proj_base: &[PlaceElem<'tcx>],
             elem: &PlaceElem<'tcx>,
             _context: PlaceContext,

src/librustc/ty/codec.rs

@@ -223,7 +223,7 @@ pub fn decode_place<D>(decoder: &mut D) -> Result<mir::Place<'tcx>, D::Error>
 where
     D: TyDecoder<'tcx>,
 {
-    let base: mir::PlaceBase<'tcx> = Decodable::decode(decoder)?;
+    let base: mir::PlaceBase = Decodable::decode(decoder)?;
     let len = decoder.read_usize()?;
     let projection: &'tcx List<mir::PlaceElem<'tcx>> =
         decoder.tcx().mk_place_elems((0..len).map(|_| Decodable::decode(decoder)))?;

src/librustc_codegen_ssa/mir/analyze.rs

@@ -12,7 +12,6 @@ use rustc::mir::traversal;
 use rustc::session::config::DebugInfo;
 use rustc::ty;
 use rustc::ty::layout::{LayoutOf, HasTyCtxt};
-use syntax_pos::DUMMY_SP;
 use super::FunctionCx;
 use crate::traits::*;
 
@@ -139,10 +138,9 @@ impl<Bx: BuilderMethods<'a, 'tcx>> LocalAnalyzer<'mir, 'a, 'tcx, Bx> {
                     .projection_ty(cx.tcx(), elem)
                     .ty;
                 let elem_ty = self.fx.monomorphize(&elem_ty);
-                let span = if let mir::PlaceBase::Local(index) = place_ref.base {
-                    self.fx.mir.local_decls[*index].source_info.span
-                } else {
-                    DUMMY_SP
+                let span = match place_ref.base {
+                    mir::PlaceBase::Local(index) =>
+                        self.fx.mir.local_decls[*index].source_info.span,
                 };
                 if cx.spanned_layout_of(elem_ty, span).is_zst() {
                     return;
@@ -183,8 +181,8 @@ impl<Bx: BuilderMethods<'a, 'tcx>> LocalAnalyzer<'mir, 'a, 'tcx, Bx> {
                     // We use `NonUseContext::VarDebugInfo` for the base,
                     // which might not force the base local to memory,
                     // so we have to do it manually.
-                    if let mir::PlaceBase::Local(local) = place_ref.base {
-                        self.visit_local(&local, context, location);
+                    match place_ref.base {
+                        mir::PlaceBase::Local(local) => self.visit_local(&local, context, location),
                     }
                 }
             }

src/librustc_codegen_ssa/mir/debuginfo.rs

@@ -261,8 +261,8 @@ pub fn per_local_var_debug_info(
     if tcx.sess.opts.debuginfo == DebugInfo::Full || !tcx.sess.fewer_names() {
         let mut per_local = IndexVec::from_elem(vec![], &body.local_decls);
         for var in &body.var_debug_info {
-            if let mir::PlaceBase::Local(local) = var.place.base {
-                per_local[local].push(var);
+            match var.place.base {
+                mir::PlaceBase::Local(local) => per_local[local].push(var),
             }
         }
         Some(per_local)

src/librustc_codegen_ssa/mir/operand.rs

@@ -385,44 +385,44 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
     ) -> Option<OperandRef<'tcx, Bx::Value>> {
         debug!("maybe_codegen_consume_direct(place_ref={:?})", place_ref);
 
-        if let mir::PlaceBase::Local(index) = place_ref.base {
-            match self.locals[*index] {
-                LocalRef::Operand(Some(mut o)) => {
-                    // Moves out of scalar and scalar pair fields are trivial.
-                    for elem in place_ref.projection.iter() {
-                        match elem {
-                            mir::ProjectionElem::Field(ref f, _) => {
-                                o = o.extract_field(bx, f.index());
-                            }
-                            mir::ProjectionElem::Index(_) |
-                            mir::ProjectionElem::ConstantIndex { .. } => {
-                                // ZSTs don't require any actual memory access.
-                                // FIXME(eddyb) deduplicate this with the identical
-                                // checks in `codegen_consume` and `extract_field`.
-                                let elem = o.layout.field(bx.cx(), 0);
-                                if elem.is_zst() {
-                                    o = OperandRef::new_zst(bx, elem);
-                                } else {
-                                    return None;
+        match place_ref.base {
+            mir::PlaceBase::Local(index) => {
+                match self.locals[*index] {
+                    LocalRef::Operand(Some(mut o)) => {
+                        // Moves out of scalar and scalar pair fields are trivial.
+                        for elem in place_ref.projection.iter() {
+                            match elem {
+                                mir::ProjectionElem::Field(ref f, _) => {
+                                    o = o.extract_field(bx, f.index());
+                                }
+                                mir::ProjectionElem::Index(_) |
+                                mir::ProjectionElem::ConstantIndex { .. } => {
+                                    // ZSTs don't require any actual memory access.
+                                    // FIXME(eddyb) deduplicate this with the identical
+                                    // checks in `codegen_consume` and `extract_field`.
+                                    let elem = o.layout.field(bx.cx(), 0);
+                                    if elem.is_zst() {
+                                        o = OperandRef::new_zst(bx, elem);
+                                    } else {
+                                        return None;
+                                    }
                                 }
+                                _ => return None,
                             }
-                            _ => return None,
                         }
-                    }
 
-                    Some(o)
-                }
-                LocalRef::Operand(None) => {
-                    bug!("use of {:?} before def", place_ref);
-                }
-                LocalRef::Place(..) | LocalRef::UnsizedPlace(..) => {
-                    // watch out for locals that do not have an
-                    // alloca; they are handled somewhat differently
-                    None
+                        Some(o)
+                    }
+                    LocalRef::Operand(None) => {
+                        bug!("use of {:?} before def", place_ref);
+                    }
+                    LocalRef::Place(..) | LocalRef::UnsizedPlace(..) => {
+                        // watch out for locals that do not have an
+                        // alloca; they are handled somewhat differently
+                        None
+                    }
                 }
             }
-        } else {
-            None
         }
     }
 

src/librustc_codegen_ssa/mir/place.rs

@@ -54,20 +54,6 @@ impl<'a, 'tcx, V: CodegenObject> PlaceRef<'tcx, V> {
         }
     }
 
-    fn new_thin_place<Bx: BuilderMethods<'a, 'tcx, Value = V>>(
-        bx: &mut Bx,
-        llval: V,
-        layout: TyLayout<'tcx>,
-    ) -> PlaceRef<'tcx, V> {
-        assert!(!bx.cx().type_has_metadata(layout.ty));
-        PlaceRef {
-            llval,
-            llextra: None,
-            layout,
-            align: layout.align.abi
-        }
-    }
-
     // FIXME(eddyb) pass something else for the name so no work is done
     // unless LLVM IR names are turned on (e.g. for `--emit=llvm-ir`).
     pub fn alloca<Bx: BuilderMethods<'a, 'tcx, Value = V>>(
@@ -465,19 +451,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     }
                 }
             }
-            mir::PlaceRef {
-                base: mir::PlaceBase::Static(box mir::Static {
-                    ty,
-                    def_id,
-                }),
-                projection: [],
-            } => {
-                // NB: The layout of a static may be unsized as is the case when working
-                // with a static that is an extern_type.
-                let layout = cx.layout_of(self.monomorphize(&ty));
-                let static_ = bx.get_static(*def_id);
-                PlaceRef::new_thin_place(bx, static_, layout)
-            },
             mir::PlaceRef {
                 base,
                 projection: [proj_base @ .., mir::ProjectionElem::Deref],

src/librustc_mir/borrow_check/borrow_set.rs

@@ -210,8 +210,10 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherBorrows<'a, 'tcx> {
 
             self.insert_as_pending_if_two_phase(location, &assigned_place, kind, idx);
 
-            if let mir::PlaceBase::Local(local) = borrowed_place.base {
-                self.local_map.entry(local).or_default().insert(idx);
+            match borrowed_place.base {
+                mir::PlaceBase::Local(local) => {
+                    self.local_map.entry(local).or_default().insert(idx);
+                }
             }
         }
 

src/librustc_mir/borrow_check/constraint_generation.rs

@@ -238,13 +238,6 @@ impl<'cx, 'cg, 'tcx> ConstraintGeneration<'cx, 'cg, 'tcx> {
                     );
                 }
 
-                PlaceRef {
-                    base: &PlaceBase::Static(_),
-                    ..
-                } => {
-                    // Ignore kills of static or static mut variables.
-                }
-
                 PlaceRef {
                     base: &PlaceBase::Local(local),
                     projection: &[.., _],