Use the correct FakeReadCause

Author: roxelo

compiler/rustc_middle/src/ty/context.rs

@@ -47,6 +47,7 @@ use rustc_hir::{
 };
 use rustc_index::vec::{Idx, IndexVec};
 use rustc_macros::HashStable;
+use rustc_middle::mir::FakeReadCause;
 use rustc_serialize::opaque::{FileEncodeResult, FileEncoder};
 use rustc_session::config::{BorrowckMode, CrateType, OutputFilenames};
 use rustc_session::lint::{Level, Lint};
@@ -430,8 +431,7 @@ pub struct TypeckResults<'tcx> {
     /// see `MinCaptureInformationMap` for more details.
     pub closure_min_captures: ty::MinCaptureInformationMap<'tcx>,
 
-    /// [FIXME] RFC2229 Change to use HashSet instead of Vec
-    pub closure_fake_reads: FxHashMap<DefId, Vec<HirPlace<'tcx>>>,
+    pub closure_fake_reads: FxHashMap<DefId, Vec<(HirPlace<'tcx>, FakeReadCause)>>,
 
     /// Stores the type, expression, span and optional scope span of all types
     /// that are live across the yield of this generator (if a generator).

compiler/rustc_mir_build/src/build/block.rs

@@ -94,14 +94,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         )
                     );
                 }
-                // ROX:
-                //
-                // Where the handling of destructure patterns start
-                //
-                // let (a, b, c, _ ) = something
-                //
-                // (a, b, c, _) is the pattern
-                // something is the initializer
                 StmtKind::Let { remainder_scope, init_scope, pattern, initializer, lint_level } => {
                     let ignores_expr_result = matches!(*pattern.kind, PatKind::Wild);
                     this.block_context.push(BlockFrame::Statement { ignores_expr_result });
@@ -133,8 +125,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                                             ArmHasGuard(false),
                                             Some((None, initializer_span)),
                                         );
-                                        // This is where we get into pattern handling of the let
-                                        // statement
                                         this.expr_into_pattern(block, pattern.clone(), init)
                                     })
                                 }

compiler/rustc_mir_build/src/build/expr/as_place.rs

@@ -84,20 +84,25 @@ fn convert_to_hir_projections_and_truncate_for_capture<'tcx>(
     mir_projections: &[PlaceElem<'tcx>],
 ) -> Vec<HirProjectionKind> {
     let mut hir_projections = Vec::new();
+    let mut variant = None;
 
     for mir_projection in mir_projections {
         let hir_projection = match mir_projection {
             ProjectionElem::Deref => HirProjectionKind::Deref,
             ProjectionElem::Field(field, _) => {
                 // We will never encouter this for multivariant enums,
                 // read the comment for `Downcast`.
-                HirProjectionKind::Field(field.index() as u32, VariantIdx::new(0))
+                let variant = variant.unwrap_or(VariantIdx::new(0));
+                HirProjectionKind::Field(field.index() as u32, variant)
             }
-            ProjectionElem::Downcast(..) => {
-                // This projections exist only for enums that have
-                // multiple variants. Since such enums that are captured
-                // completely, we can stop here.
-                break;
+            ProjectionElem::Downcast(.., idx) => {
+                // This projections exist for enums that have
+                // single and multiple variants.
+                // For single variants, enums are not captured completely.
+                // We keep track of VariantIdx so we can use this information
+                // if the next ProjectionElem is a Field
+                variant = Some(*idx);
+                continue;
             }
             ProjectionElem::Index(..)
             | ProjectionElem::ConstantIndex { .. }
@@ -107,7 +112,7 @@ fn convert_to_hir_projections_and_truncate_for_capture<'tcx>(
                 break;
             }
         };
-
+        variant = None;
         hir_projections.push(hir_projection);
     }
 
@@ -231,13 +236,12 @@ fn to_upvars_resolved_place_builder<'a, 'tcx>(
                         from_builder.projection
                     )
                 } else {
-                    // FIXME(project-rfc-2229#24): Handle this case properly
                     debug!(
                         "No associated capture found for {:?}[{:#?}]",
                         var_hir_id, from_builder.projection,
                     );
                 }
-                return Err(upvar_resolved_place_builder);
+                return Err(from_builder);
             };
 
             let closure_ty = typeck_results
@@ -289,11 +293,10 @@ impl<'tcx> PlaceBuilder<'tcx> {
         if let PlaceBase::Local(local) = self.base {
             Place { local, projection: tcx.intern_place_elems(&self.projection) }
         } else {
-            self.try_upvars_resolved(tcx, typeck_results).into_place(tcx, typeck_results)
+            self.expect_upvars_resolved(tcx, typeck_results).into_place(tcx, typeck_results)
         }
     }
 
-    /// ROX: Function that will be called when we really do need a place
     fn expect_upvars_resolved<'a>(
         self,
         tcx: TyCtxt<'tcx>,
@@ -302,14 +305,14 @@ impl<'tcx> PlaceBuilder<'tcx> {
         to_upvars_resolved_place_builder(self, tcx, typeck_results).unwrap()
     }
 
-    fn try_upvars_resolved<'a>(
+    crate fn try_upvars_resolved<'a>(
         self,
         tcx: TyCtxt<'tcx>,
         typeck_results: &'a ty::TypeckResults<'tcx>,
-    ) -> PlaceBuilder<'tcx> {
+    ) -> Result<PlaceBuilder<'tcx>, PlaceBuilder<'tcx>> {
         match to_upvars_resolved_place_builder(self, tcx, typeck_results) {
-            Ok(upvars_resolved) => upvars_resolved,
-            Err(upvars_unresolved) => upvars_unresolved,
+            Ok(upvars_resolved) => Ok(upvars_resolved),
+            Err(upvars_unresolved) => Err(upvars_unresolved),
         }
     }
 
@@ -376,7 +379,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         block.and(place_builder.into_place(self.tcx, self.typeck_results))
     }
 
-    // ROX: As place builder
     /// This is used when constructing a compound `Place`, so that we can avoid creating
     /// intermediate `Place` values until we know the full set of projections.
     crate fn as_place_builder(

compiler/rustc_mir_build/src/build/expr/as_rvalue.rs

@@ -165,7 +165,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
                 block.and(Rvalue::Aggregate(box AggregateKind::Tuple, fields))
             }
-            ExprKind::Closure { closure_id, substs, upvars, movability, fake_reads } => {
+            ExprKind::Closure {
+                closure_id,
+                substs,
+                upvars,
+                movability,
+                fake_reads: opt_fake_reads,
+            } => {
                 // see (*) above
                 let operands: Vec<_> = upvars
                     .into_iter()
@@ -204,18 +210,19 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         }
                     })
                     .collect();
-
-                if let Some(fake_reads) = fake_reads {
-                    for thir_place in fake_reads.into_iter() {
-                        //  = this.hir.mirror(thir_place);
-                        let mir_place = unpack!(block = this.as_place(block, thir_place));
-                        // [FIXME] RFC2229 FakeReadCause can be ForLet or ForMatch, need to use the correct one
-                        this.cfg.push_fake_read(
-                            block,
-                            source_info,
-                            FakeReadCause::ForMatchedPlace,
-                            mir_place,
-                        );
+                if let Some(fake_reads) = opt_fake_reads {
+                    for (thir_place, cause) in fake_reads.into_iter() {
+                        let place_builder =
+                            unpack!(block = this.as_place_builder(block, thir_place));
+
+                        if let Ok(place_builder_resolved) =
+                            place_builder.clone().try_upvars_resolved(this.tcx, this.typeck_results)
+                        {
+                            let mir_place = place_builder_resolved
+                                .clone()
+                                .into_place(this.tcx, this.typeck_results);
+                            this.cfg.push_fake_read(block, source_info, cause, mir_place);
+                        }
                     }
                 }
 

compiler/rustc_mir_build/src/build/expr/into.rs

@@ -280,7 +280,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let field_names: Vec<_> =
                     (0..adt_def.variants[variant_index].fields.len()).map(Field::new).collect();
 
-                // ROX: This is probably here the function record/struct update pattern is done.
                 let fields: Vec<_> = if let Some(FruInfo { base, field_types }) = base {
                     let place_builder = unpack!(block = this.as_place_builder(block, base));
 

compiler/rustc_mir_build/src/build/matches/mod.rs

@@ -1,6 +1,3 @@
-// ROX: this folder contains all code for handling patterns, including exhaustiveness checking etc.
-// We want to be careful ^^'
-
 //! Code related to match expressions. These are sufficiently complex to
 //! warrant their own module and submodules. :) This main module includes the
 //! high-level algorithm, the submodules contain the details.
@@ -100,7 +97,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         let scrutinee_place =
             unpack!(block = self.lower_scrutinee(block, scrutinee, scrutinee_span,));
 
-        let mut arm_candidates = self.create_match_candidates(scrutinee_place.clone(), &arms);
+        let mut arm_candidates =
+            self.create_match_candidates(scrutinee_place.clone(), &arms.clone());
 
         let match_has_guard = arms.iter().any(|arm| arm.guard.is_some());
         let mut candidates =
@@ -127,8 +125,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         scrutinee_span: Span,
     ) -> BlockAnd<PlaceBuilder<'tcx>> {
         let scrutinee_place_builder = unpack!(block = self.as_place_builder(block, scrutinee));
-        let scrutinee_place =
-            scrutinee_place_builder.clone().into_place(self.tcx, self.typeck_results);
         // Matching on a `scrutinee_place` with an uninhabited type doesn't
         // generate any memory reads by itself, and so if the place "expression"
         // contains unsafe operations like raw pointer dereferences or union
@@ -146,7 +142,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         // check safety.
         let cause_matched_place = FakeReadCause::ForMatchedPlace;
         let source_info = self.source_info(scrutinee_span);
-        self.cfg.push_fake_read(block, source_info, cause_matched_place, scrutinee_place);
+
+        if let Ok(scrutinee_builder) =
+            scrutinee_place_builder.clone().try_upvars_resolved(self.tcx, self.typeck_results)
+        {
+            let scrutinee_place =
+                scrutinee_builder.clone().into_place(self.tcx, self.typeck_results);
+            self.cfg.push_fake_read(block, source_info, cause_matched_place, scrutinee_place);
+        }
 
         block.and(scrutinee_place_builder)
     }
@@ -228,7 +231,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     fn lower_match_arms(
         &mut self,
         destination: Place<'tcx>,
-        scrutinee_place: PlaceBuilder<'tcx>,
+        scrutinee_place_builder: PlaceBuilder<'tcx>,
         scrutinee_span: Span,
         arm_candidates: Vec<(&'_ Arm<'_, 'tcx>, Candidate<'_, 'tcx>)>,
         outer_source_info: SourceInfo,
@@ -242,17 +245,23 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let arm_source_info = self.source_info(arm.span);
                 let arm_scope = (arm.scope, arm_source_info);
                 self.in_scope(arm_scope, arm.lint_level, |this| {
+                    let body = arm.body.clone();
+                    let mut opt_scrutinee_place: Option<(Option<&Place<'tcx>>, Span)> = None;
+                    let scrutinee_place: Place<'tcx>;
+                    if let Ok(scrutinee_builder) = scrutinee_place_builder
+                        .clone()
+                        .try_upvars_resolved(this.tcx, this.typeck_results)
+                    {
+                        scrutinee_place =
+                            scrutinee_builder.clone().into_place(this.tcx, this.typeck_results);
+                        opt_scrutinee_place = Some((Some(&scrutinee_place), scrutinee_span));
+                    }
                     let scope = this.declare_bindings(
                         None,
                         arm.span,
                         &arm.pattern,
                         ArmHasGuard(arm.guard.is_some()),
-                        Some((
-                            Some(
-                                &scrutinee_place.clone().into_place(this.tcx, this.typeck_results),
-                            ),
-                            scrutinee_span,
-                        )),
+                        opt_scrutinee_place,
                     );
 
                     let arm_block = this.bind_pattern(
@@ -457,15 +466,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             }
 
             _ => {
-                // Converts the destruct pattern into a place
-                //
-                // We don't want to convert to a place right away
-                // because in case of such pattern inside a closure, the projections matching a
-                // captured place might have not been applied.
-                // [FIXME] Need to find where this is happening and make the necessary changes there once
-                // Candidate is modified
-                //
-                // We want to use a place builder; Maybe use `as_place_builder`
                 let place_builder = unpack!(block = self.as_place_builder(block, initializer));
                 self.place_into_pattern(block, irrefutable_pat, place_builder, true)
             }
@@ -479,12 +479,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         initializer: PlaceBuilder<'tcx>,
         set_match_place: bool,
     ) -> BlockAnd<()> {
-        let place = initializer.clone().into_place(self.tcx, self.typeck_results);
-        let mut candidate = Candidate::new(initializer, &irrefutable_pat, false);
-
+        let mut candidate = Candidate::new(initializer.clone(), &irrefutable_pat, false);
         let fake_borrow_temps =
             self.lower_match_tree(block, irrefutable_pat.span, false, &mut [&mut candidate]);
-
         // For matches and function arguments, the place that is being matched
         // can be set when creating the variables. But the place for
         // let PATTERN = ... might not even exist until we do the assignment.
@@ -499,7 +496,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         VarBindingForm { opt_match_place: Some((ref mut match_place, _)), .. },
                     )))) = self.local_decls[local].local_info
                     {
-                        *match_place = Some(place);
+                        if let Ok(match_pair_resolved) =
+                            initializer.clone().try_upvars_resolved(self.tcx, self.typeck_results)
+                        {
+                            let place = match_pair_resolved
+                                .clone()
+                                .into_place(self.tcx, self.typeck_results);
+                            *match_place = Some(place);
+                        }
                     } else {
                         bug!("Let binding to non-user variable.")
                     }
@@ -1461,7 +1465,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
         // Insert a Shallow borrow of any places that is switched on.
         if let Some(fb) = fake_borrows {
-            fb.insert(match_place.clone().into_place(self.tcx, self.typeck_results));
+            if let Ok(match_place_resolved) =
+                match_place.clone().try_upvars_resolved(self.tcx, self.typeck_results)
+            {
+                let resolved_place =
+                    match_place_resolved.clone().into_place(self.tcx, self.typeck_results);
+                fb.insert(resolved_place);
+            }
         }
 
         // perform the test, branching to one of N blocks. For each of
@@ -1776,28 +1786,36 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 }
                 Guard::IfLet(pat, scrutinee) => {
                     let scrutinee_span = scrutinee.span;
-                    let scrutinee_place = unpack!(
+                    let scrutinee_place_builder = unpack!(
                         block = self.lower_scrutinee(block, scrutinee.clone(), scrutinee_span)
                     );
-                    let mut guard_candidate = Candidate::new(scrutinee_place.clone(), &pat, false);
+                    let mut guard_candidate =
+                        Candidate::new(scrutinee_place_builder.clone(), &pat, false);
                     let wildcard = Pat::wildcard_from_ty(pat.ty);
                     let mut otherwise_candidate =
-                        Candidate::new(scrutinee_place.clone(), &wildcard, false);
+                        Candidate::new(scrutinee_place_builder.clone(), &wildcard, false);
                     let fake_borrow_temps = self.lower_match_tree(
                         block,
                         pat.span,
                         false,
                         &mut [&mut guard_candidate, &mut otherwise_candidate],
                     );
+                    let mut opt_scrutinee_place: Option<(Option<&Place<'tcx>>, Span)> = None;
+                    let scrutinee_place: Place<'tcx>;
+                    if let Ok(scrutinee_builder) = scrutinee_place_builder
+                        .clone()
+                        .try_upvars_resolved(self.tcx, self.typeck_results)
+                    {
+                        scrutinee_place =
+                            scrutinee_builder.clone().into_place(self.tcx, self.typeck_results);
+                        opt_scrutinee_place = Some((Some(&scrutinee_place), scrutinee_span));
+                    }
                     self.declare_bindings(
                         None,
                         pat.span.to(arm_span.unwrap()),
                         pat,
                         ArmHasGuard(false),
-                        Some((
-                            Some(&scrutinee_place.clone().into_place(tcx, self.typeck_results)),
-                            scrutinee.span,
-                        )),
+                        opt_scrutinee_place,
                     );
                     let post_guard_block = self.bind_pattern(
                         self.source_info(pat.span),