Refactor and add PlaceContext::AscribeUserTy.

This commit refactors `PlaceContext` to split it into four different
smaller enums based on if the context represents a mutating use,
non-mutating use, maybe-mutating use or a non-use (this is based on the
recommendation from @oli-obk on Zulip[1]).

This commit then introduces a `PlaceContext::AscribeUserTy` variant.
`StatementKind::AscribeUserTy` is now correctly mapped to
`PlaceContext::AscribeUserTy` instead of `PlaceContext::Validate`.
`PlaceContext::AscribeUserTy` can also now be correctly categorized as a
non-use which fixes an issue with constant promotion in statics after a
cast introduces a `AscribeUserTy` statement.

[1]: https://rust-lang.zulipchat.com/#narrow/stream/122657-wg-nll/subject/.2355288.20cast.20fails.20to.20promote.20to.20'static/near/136536949

Author: davidtwco

src/librustc/mir/visit.rs

@@ -15,7 +15,7 @@ use rustc_data_structures::bit_set::BitSet;
 use rustc_data_structures::graph::dominators::Dominators;
 use rustc_data_structures::indexed_vec::{Idx, IndexVec};
 use rustc::mir::{self, Location, TerminatorKind};
-use rustc::mir::visit::{Visitor, PlaceContext};
+use rustc::mir::visit::{Visitor, PlaceContext, MutatingUseContext, NonMutatingUseContext};
 use rustc::mir::traversal;
 use rustc::ty;
 use rustc::ty::layout::LayoutOf;
@@ -116,7 +116,11 @@ impl Visitor<'tcx> for LocalAnalyzer<'mir, 'a, 'll, 'tcx> {
                 self.not_ssa(index);
             }
         } else {
-            self.visit_place(place, PlaceContext::Store, location);
+            self.visit_place(
+                place,
+                PlaceContext::MutatingUse(MutatingUseContext::Store),
+                location
+            );
         }
 
         self.visit_rvalue(rvalue, location);
@@ -142,7 +146,11 @@ impl Visitor<'tcx> for LocalAnalyzer<'mir, 'a, 'll, 'tcx> {
                 // is not guaranteed to be statically dominated by the
                 // definition of x, so x must always be in an alloca.
                 if let mir::Operand::Move(ref place) = args[0] {
-                    self.visit_place(place, PlaceContext::Drop, location);
+                    self.visit_place(
+                        place,
+                        PlaceContext::MutatingUse(MutatingUseContext::Drop),
+                        location
+                    );
                 }
             }
         }
@@ -160,7 +168,8 @@ impl Visitor<'tcx> for LocalAnalyzer<'mir, 'a, 'll, 'tcx> {
         if let mir::Place::Projection(ref proj) = *place {
             // Allow uses of projections that are ZSTs or from scalar fields.
             let is_consume = match context {
-                PlaceContext::Copy | PlaceContext::Move => true,
+                PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy) |
+                PlaceContext::NonMutatingUse(NonMutatingUseContext::Move) => true,
                 _ => false
             };
             if is_consume {
@@ -190,7 +199,11 @@ impl Visitor<'tcx> for LocalAnalyzer<'mir, 'a, 'll, 'tcx> {
 
             // A deref projection only reads the pointer, never needs the place.
             if let mir::ProjectionElem::Deref = proj.elem {
-                return self.visit_place(&proj.base, PlaceContext::Copy, location);
+                return self.visit_place(
+                    &proj.base,
+                    PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy),
+                    location
+                );
             }
         }
 
@@ -202,16 +215,14 @@ impl Visitor<'tcx> for LocalAnalyzer<'mir, 'a, 'll, 'tcx> {
                    context: PlaceContext<'tcx>,
                    location: Location) {
         match context {
-            PlaceContext::Call => {
+            PlaceContext::MutatingUse(MutatingUseContext::Call) => {
                 self.assign(local, location);
             }
 
-            PlaceContext::StorageLive |
-            PlaceContext::StorageDead |
-            PlaceContext::Validate => {}
+            PlaceContext::NonUse(_) => {}
 
-            PlaceContext::Copy |
-            PlaceContext::Move => {
+            PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy) |
+            PlaceContext::NonMutatingUse(NonMutatingUseContext::Move) => {
                 // Reads from uninitialized variables (e.g. in dead code, after
                 // optimizations) require locals to be in (uninitialized) memory.
                 // NB: there can be uninitialized reads of a local visited after
@@ -227,15 +238,19 @@ impl Visitor<'tcx> for LocalAnalyzer<'mir, 'a, 'll, 'tcx> {
                 }
             }
 
-            PlaceContext::Inspect |
-            PlaceContext::Store |
-            PlaceContext::AsmOutput |
-            PlaceContext::Borrow { .. } |
-            PlaceContext::Projection(..) => {
+            PlaceContext::NonMutatingUse(NonMutatingUseContext::Inspect) |
+            PlaceContext::MutatingUse(MutatingUseContext::Store) |
+            PlaceContext::MutatingUse(MutatingUseContext::AsmOutput) |
+            PlaceContext::MutatingUse(MutatingUseContext::Borrow(..)) |
+            PlaceContext::MutatingUse(MutatingUseContext::Projection) |
+            PlaceContext::NonMutatingUse(NonMutatingUseContext::SharedBorrow(..)) |
+            PlaceContext::NonMutatingUse(NonMutatingUseContext::UniqueBorrow(..)) |
+            PlaceContext::NonMutatingUse(NonMutatingUseContext::ShallowBorrow(..)) |
+            PlaceContext::NonMutatingUse(NonMutatingUseContext::Projection) => {
                 self.not_ssa(local);
             }
 
-            PlaceContext::Drop => {
+            PlaceContext::MutatingUse(MutatingUseContext::Drop) => {
                 let ty = mir::Place::Local(local).ty(self.fx.mir, self.fx.cx.tcx);
                 let ty = self.fx.monomorphize(&ty.to_ty(self.fx.cx.tcx));
 

src/librustc_codegen_llvm/mir/analyze.rs

@@ -12,7 +12,9 @@ use borrow_check::place_ext::PlaceExt;
 use dataflow::indexes::BorrowIndex;
 use dataflow::move_paths::MoveData;
 use rustc::mir::traversal;
-use rustc::mir::visit::{PlaceContext, Visitor};
+use rustc::mir::visit::{
+    PlaceContext, Visitor, NonUseContext, MutatingUseContext, NonMutatingUseContext
+};
 use rustc::mir::{self, Location, Mir, Place, Local};
 use rustc::ty::{Region, TyCtxt};
 use rustc::util::nodemap::{FxHashMap, FxHashSet};
@@ -116,7 +118,7 @@ impl LocalsStateAtExit {
 
         impl<'tcx> Visitor<'tcx> for HasStorageDead {
             fn visit_local(&mut self, local: &Local, ctx: PlaceContext<'tcx>, _: Location) {
-                if ctx == PlaceContext::StorageDead {
+                if ctx == PlaceContext::NonUse(NonUseContext::StorageDead) {
                     self.0.insert(*local);
                 }
             }
@@ -266,7 +268,9 @@ impl<'a, 'gcx, 'tcx> Visitor<'tcx> for GatherBorrows<'a, 'gcx, 'tcx> {
 
                 // Watch out: the use of TMP in the borrow itself
                 // doesn't count as an activation. =)
-                if borrow_data.reserve_location == location && context == PlaceContext::Store {
+                if borrow_data.reserve_location == location &&
+                    context == PlaceContext::MutatingUse(MutatingUseContext::Store)
+                {
                     return;
                 }
 
@@ -287,10 +291,9 @@ impl<'a, 'gcx, 'tcx> Visitor<'tcx> for GatherBorrows<'a, 'gcx, 'tcx> {
                 borrow_data.activation_location = match context {
                     // The use of TMP in a shared borrow does not
                     // count as an actual activation.
-                    PlaceContext::Borrow { kind: mir::BorrowKind::Shared, .. }
-                    | PlaceContext::Borrow { kind: mir::BorrowKind::Shallow, .. } => {
-                        TwoPhaseActivation::NotActivated
-                    }
+                    PlaceContext::NonMutatingUse(NonMutatingUseContext::SharedBorrow(..)) |
+                    PlaceContext::NonMutatingUse(NonMutatingUseContext::ShallowBorrow(..)) =>
+                        TwoPhaseActivation::NotActivated,
                     _ => {
                         // Double check: This borrow is indeed a two-phase borrow (that is,
                         // we are 'transitioning' from `NotActivated` to `ActivatedAt`) and

src/librustc_mir/borrow_check/borrow_set.rs

@@ -35,7 +35,7 @@ use rustc::infer::outlives::env::RegionBoundPairs;
 use rustc::infer::{InferCtxt, InferOk, LateBoundRegionConversionTime};
 use rustc::mir::interpret::EvalErrorKind::BoundsCheck;
 use rustc::mir::tcx::PlaceTy;
-use rustc::mir::visit::{PlaceContext, Visitor};
+use rustc::mir::visit::{PlaceContext, Visitor, MutatingUseContext, NonMutatingUseContext};
 use rustc::mir::*;
 use rustc::traits::query::type_op;
 use rustc::traits::query::type_op::custom::CustomTypeOp;
@@ -472,9 +472,9 @@ impl<'a, 'b, 'gcx, 'tcx> TypeVerifier<'a, 'b, 'gcx, 'tcx> {
             }
             Place::Projection(ref proj) => {
                 let base_context = if context.is_mutating_use() {
-                    PlaceContext::Projection(Mutability::Mut)
+                    PlaceContext::MutatingUse(MutatingUseContext::Projection)
                 } else {
-                    PlaceContext::Projection(Mutability::Not)
+                    PlaceContext::NonMutatingUse(NonMutatingUseContext::Projection)
                 };
                 let base_ty = self.sanitize_place(&proj.base, location, base_context);
                 if let PlaceTy::Ty { ty } = base_ty {
@@ -488,7 +488,7 @@ impl<'a, 'b, 'gcx, 'tcx> TypeVerifier<'a, 'b, 'gcx, 'tcx> {
                 self.sanitize_projection(base_ty, &proj.elem, place, location)
             }
         };
-        if let PlaceContext::Copy = context {
+        if let PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy) = context {
             let tcx = self.tcx();
             let trait_ref = ty::TraitRef {
                 def_id: tcx.lang_items().copy_trait().unwrap(),

src/librustc_mir/borrow_check/nll/type_check/mod.rs

@@ -14,7 +14,6 @@ use rustc::mir::{Local, Location, Place};
 use rustc_data_structures::fx::FxHashSet;
 
 use borrow_check::MirBorrowckCtxt;
-use util::collect_writes::is_place_assignment;
 
 impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
     /// Walks the MIR looking for assignments to a set of locals, as part of the unused mutable
@@ -46,7 +45,7 @@ impl<'visit, 'cx, 'gcx, 'tcx> Visitor<'tcx> for GatherUsedMutsVisitor<'visit, 'c
             return;
         }
 
-        if is_place_assignment(&place_context) {
+        if place_context.is_place_assignment() {
             // Propagate the Local assigned at this Location as a used mutable local variable
             for moi in &self.mbcx.move_data.loc_map[location] {
                 let mpi = &self.mbcx.move_data.moves[*moi].path;

src/librustc_mir/borrow_check/used_muts.rs

@@ -19,7 +19,7 @@ use rustc::hir::Node;
 use rustc::hir::def_id::DefId;
 use rustc::lint::builtin::{SAFE_EXTERN_STATICS, SAFE_PACKED_BORROWS, UNUSED_UNSAFE};
 use rustc::mir::*;
-use rustc::mir::visit::{PlaceContext, Visitor};
+use rustc::mir::visit::{PlaceContext, Visitor, MutatingUseContext};
 
 use syntax::ast;
 use syntax::symbol::Symbol;
@@ -152,7 +152,7 @@ impl<'a, 'tcx> Visitor<'tcx> for UnsafetyChecker<'a, 'tcx> {
                     place: &Place<'tcx>,
                     context: PlaceContext<'tcx>,
                     location: Location) {
-        if let PlaceContext::Borrow { .. } = context {
+        if context.is_borrow() {
             if util::is_disaligned(self.tcx, self.mir, self.param_env, place) {
                 let source_info = self.source_info;
                 let lint_root =
@@ -193,9 +193,11 @@ impl<'a, 'tcx> Visitor<'tcx> for UnsafetyChecker<'a, 'tcx> {
                     }
                     ty::Adt(adt, _) => {
                         if adt.is_union() {
-                            if context == PlaceContext::Store ||
-                                context == PlaceContext::AsmOutput ||
-                                context == PlaceContext::Drop
+                            if context == PlaceContext::MutatingUse(MutatingUseContext::Store) ||
+                                context == PlaceContext::MutatingUse(MutatingUseContext::Drop) ||
+                                context == PlaceContext::MutatingUse(
+                                    MutatingUseContext::AsmOutput
+                                )
                             {
                                 let elem_ty = match elem {
                                     &ProjectionElem::Field(_, ty) => ty,

src/librustc_mir/transform/check_unsafety.rs

@@ -16,7 +16,7 @@ use rustc::hir::def::Def;
 use rustc::mir::{Constant, Location, Place, Mir, Operand, Rvalue, Local};
 use rustc::mir::{NullOp, UnOp, StatementKind, Statement, BasicBlock, LocalKind};
 use rustc::mir::{TerminatorKind, ClearCrossCrate, SourceInfo, BinOp, ProjectionElem};
-use rustc::mir::visit::{Visitor, PlaceContext};
+use rustc::mir::visit::{Visitor, PlaceContext, MutatingUseContext, NonMutatingUseContext};
 use rustc::mir::interpret::{
     ConstEvalErr, EvalErrorKind, Scalar, GlobalId, EvalResult,
 };
@@ -533,17 +533,18 @@ impl<'tcx> Visitor<'tcx> for CanConstProp {
             // Constants must have at most one write
             // FIXME(oli-obk): we could be more powerful here, if the multiple writes
             // only occur in independent execution paths
-            Store => if self.found_assignment[local] {
+            MutatingUse(MutatingUseContext::Store) => if self.found_assignment[local] {
                 self.can_const_prop[local] = false;
             } else {
                 self.found_assignment[local] = true
             },
             // Reading constants is allowed an arbitrary number of times
-            Copy | Move |
-            StorageDead | StorageLive |
-            Validate |
-            Projection(_) |
-            Inspect => {},
+            NonMutatingUse(NonMutatingUseContext::Copy) |
+            NonMutatingUse(NonMutatingUseContext::Move) |
+            NonMutatingUse(NonMutatingUseContext::Inspect) |
+            NonMutatingUse(NonMutatingUseContext::Projection) |
+            MutatingUse(MutatingUseContext::Projection) |
+            NonUse(_) => {},
             _ => self.can_const_prop[local] = false,
         }
     }

src/librustc_mir/transform/const_prop.rs

@@ -23,7 +23,7 @@
 //! move analysis runs after promotion on broken MIR.
 
 use rustc::mir::*;
-use rustc::mir::visit::{PlaceContext, MutVisitor, Visitor};
+use rustc::mir::visit::{PlaceContext, MutatingUseContext, MutVisitor, Visitor};
 use rustc::mir::traversal::ReversePostorder;
 use rustc::ty::TyCtxt;
 use syntax_pos::Span;
@@ -97,11 +97,11 @@ impl<'tcx> Visitor<'tcx> for TempCollector<'tcx> {
 
         // Ignore drops, if the temp gets promoted,
         // then it's constant and thus drop is noop.
-        // Storage live ranges are also irrelevant.
-        if context.is_drop() || context.is_storage_marker() {
+        // Non-uses are also irrelevent.
+        if context.is_drop() || !context.is_use() {
             debug!(
-                "visit_local: context.is_drop={:?} context.is_storage_marker={:?}",
-                context.is_drop(), context.is_storage_marker(),
+                "visit_local: context.is_drop={:?} context.is_use={:?}",
+                context.is_drop(), context.is_use(),
             );
             return;
         }
@@ -110,9 +110,9 @@ impl<'tcx> Visitor<'tcx> for TempCollector<'tcx> {
         debug!("visit_local: temp={:?}", temp);
         if *temp == TempState::Undefined {
             match context {
-                PlaceContext::Store |
-                PlaceContext::AsmOutput |
-                PlaceContext::Call => {
+                PlaceContext::MutatingUse(MutatingUseContext::Store) |
+                PlaceContext::MutatingUse(MutatingUseContext::AsmOutput) |
+                PlaceContext::MutatingUse(MutatingUseContext::Call) => {
                     *temp = TempState::Defined {
                         location,
                         uses: 0
@@ -124,10 +124,7 @@ impl<'tcx> Visitor<'tcx> for TempCollector<'tcx> {
         } else if let TempState::Defined { ref mut uses, .. } = *temp {
             // We always allow borrows, even mutable ones, as we need
             // to promote mutable borrows of some ZSTs e.g. `&mut []`.
-            let allowed_use = match context {
-                PlaceContext::Borrow {..} => true,
-                _ => context.is_nonmutating_use()
-            };
+            let allowed_use = context.is_borrow() || context.is_nonmutating_use();
             debug!("visit_local: allowed_use={:?}", allowed_use);
             if allowed_use {
                 *uses += 1;

src/librustc_mir/transform/promote_consts.rs

@@ -26,7 +26,7 @@ use rustc::ty::cast::CastTy;
 use rustc::ty::query::Providers;
 use rustc::mir::*;
 use rustc::mir::traversal::ReversePostorder;
-use rustc::mir::visit::{PlaceContext, Visitor};
+use rustc::mir::visit::{PlaceContext, Visitor, MutatingUseContext, NonMutatingUseContext};
 use rustc::middle::lang_items;
 use rustc_target::spec::abi::Abi;
 use syntax::ast::LitKind;
@@ -271,7 +271,11 @@ impl<'a, 'tcx> Qualifier<'a, 'tcx, 'tcx> {
             // This must be an explicit assignment.
             _ => {
                 // Catch more errors in the destination.
-                self.visit_place(dest, PlaceContext::Store, location);
+                self.visit_place(
+                    dest,
+                    PlaceContext::MutatingUse(MutatingUseContext::Store),
+                    location
+                );
                 self.statement_like();
             }
         }
@@ -610,10 +614,17 @@ impl<'a, 'tcx> Visitor<'tcx> for Qualifier<'a, 'tcx, 'tcx> {
             }
 
             if is_reborrow {
-                self.super_place(place, PlaceContext::Borrow {
-                    region,
-                    kind
-                }, location);
+                let ctx = match kind {
+                    BorrowKind::Shared =>
+                        PlaceContext::NonMutatingUse(NonMutatingUseContext::SharedBorrow(region)),
+                    BorrowKind::Shallow =>
+                        PlaceContext::NonMutatingUse(NonMutatingUseContext::ShallowBorrow(region)),
+                    BorrowKind::Unique =>
+                        PlaceContext::NonMutatingUse(NonMutatingUseContext::UniqueBorrow(region)),
+                    BorrowKind::Mut { .. } =>
+                        PlaceContext::MutatingUse(MutatingUseContext::Borrow(region)),
+                };
+                self.super_place(place, ctx, location);
             } else {
                 self.super_rvalue(rvalue, location);
             }

src/librustc_mir/transform/qualify_consts.rs

@@ -331,8 +331,10 @@ struct DeclMarker {
 
 impl<'tcx> Visitor<'tcx> for DeclMarker {
     fn visit_local(&mut self, local: &Local, ctx: PlaceContext<'tcx>, _: Location) {
-        // ignore these altogether, they get removed along with their otherwise unused decls.
-        if ctx != PlaceContext::StorageLive && ctx != PlaceContext::StorageDead {
+        // Ignore storage markers altogether, they get removed along with their otherwise unused
+        // decls.
+        // FIXME: Extend this to all non-uses.
+        if !ctx.is_storage_marker() {
             self.locals.insert(*local);
         }
     }

src/librustc_mir/transform/simplify.rs

@@ -39,7 +39,7 @@
 use rustc::ty;
 use rustc::ty::TyCtxt;
 use rustc::mir::*;
-use rustc::mir::visit::{Visitor, PlaceContext};
+use rustc::mir::visit::{Visitor, PlaceContext, NonUseContext};
 use transform::{MirPass, MirSource};
 use util::patch::MirPatch;
 use rustc_data_structures::indexed_vec::{IndexVec};
@@ -316,8 +316,8 @@ impl<'tcx> Visitor<'tcx> for RestoreDataCollector {
                    location: Location) {
         let local_use = &mut self.locals_use[*local];
         match context {
-            PlaceContext::StorageLive => local_use.alive = Some(location),
-            PlaceContext::StorageDead => local_use.dead = Some(location),
+            PlaceContext::NonUse(NonUseContext::StorageLive) => local_use.alive = Some(location),
+            PlaceContext::NonUse(NonUseContext::StorageDead) => local_use.dead = Some(location),
             _ => {
                 local_use.use_count += 1;
                 if local_use.first_use.is_none() {