Re-establish deref temporaries after fake edges

Author: Nadrieril

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

@@ -927,6 +927,17 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     }
 }
 
+/// A temporary that must be set like `let temp = Deref::deref(&place)` after the candidate
+/// `pre_binding_block`. This is because fake edges prevent us from keeping the temporaries we set
+/// up while testing which branch to take.
+#[derive(Debug, Copy, Clone)]
+struct DerefTemporary<'tcx> {
+    place: Place<'tcx>,
+    temp: Place<'tcx>,
+    ty: Ty<'tcx>,
+    span: Span,
+}
+
 /// Data extracted from a pattern that doesn't affect which branch is taken. Collected during
 /// pattern simplification and not mutated later.
 #[derive(Debug, Clone, Default)]
@@ -939,11 +950,15 @@ struct PatternExtraData<'tcx> {
 
     /// Types that must be asserted.
     ascriptions: Vec<Ascription<'tcx>>,
+
+    /// Temporaries that must be set up in order.
+    deref_temps: Vec<DerefTemporary<'tcx>>,
 }
 
 impl<'tcx> PatternExtraData<'tcx> {
     fn is_empty(&self) -> bool {
-        self.bindings.is_empty() && self.ascriptions.is_empty()
+        // FIXME(deref_patterns): can we merge trivial subcandidates that use deref patterns?
+        self.bindings.is_empty() && self.ascriptions.is_empty() && self.deref_temps.is_empty()
     }
 }
 
@@ -970,6 +985,7 @@ impl<'tcx, 'pat> FlatPat<'pat, 'tcx> {
                 span: pattern.span,
                 bindings: Vec::new(),
                 ascriptions: Vec::new(),
+                deref_temps: Vec::new(),
             },
         };
         cx.simplify_match_pairs(&mut flat_pat.match_pairs, &mut flat_pat.extra_data);
@@ -1986,6 +2002,23 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             block = fresh_block;
         }
 
+        for d in collected_data.iter() {
+            for deref_call in d.deref_temps.iter() {
+                // Re-establish `Deref::deref` temporaries because false edges trick borrowck into
+                // believing they may not be initialized.
+                let next_block = self.cfg.start_new_block();
+                self.call_deref(
+                    block,
+                    next_block,
+                    deref_call.place,
+                    deref_call.ty,
+                    deref_call.temp,
+                    deref_call.span,
+                );
+                block = next_block;
+            }
+        }
+
         self.ascribe_types(block, collected_data.iter().flat_map(|d| &d.ascriptions).cloned());
 
         // rust-lang/rust#27282: The `autoref` business deserves some

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

@@ -12,7 +12,9 @@
 //! sort of test: for example, testing which variant an enum is, or
 //! testing a value against a constant.
 
-use crate::build::matches::{Candidate, FlatPat, MatchPair, PatternExtraData, TestCase};
+use crate::build::matches::{
+    Candidate, DerefTemporary, FlatPat, MatchPair, PatternExtraData, TestCase,
+};
 use crate::build::Builder;
 
 use std::mem;
@@ -44,6 +46,17 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         // after any bindings in `pat`. This doesn't work for or-patterns: the current structure of
         // match lowering forces us to lower bindings inside or-patterns last.
         for mut match_pair in mem::take(match_pairs) {
+            if let TestCase::Deref { temp } = &match_pair.test_case {
+                // Re-establish these temporaries after matching the candidate in case we have
+                // bindings that depend on them.
+                extra_data.deref_temps.push(DerefTemporary {
+                    place: match_pair.place.to_place(self),
+                    temp: *temp,
+                    ty: match_pair.pattern.ty,
+                    span: match_pair.pattern.span,
+                });
+            }
+
             self.simplify_match_pairs(&mut match_pair.subpairs, extra_data);
             if let TestCase::Irrefutable { binding, ascription } = match_pair.test_case {
                 if let Some(binding) = binding {

tests/ui/pattern/deref-patterns/bindings.rs

@@ -1,12 +1,37 @@
+//@ run-pass
 #![feature(deref_patterns)]
 #![allow(incomplete_features)]
 
-fn main() {
-    // FIXME(deref_patterns): fix bindings wrt fake edges
-    match vec![1] {
-        box [] => unreachable!(),
-        box [x] => assert_eq!(x, 1),
-        //~^ ERROR used binding isn't initialized
-        _ => unreachable!(),
+fn simple_vec(vec: Vec<u32>) -> u32 {
+    match vec {
+        box [] => 100,
+        // FIXME(deref_patterns): fake borrows break guards
+        // box [x] if x == 4 => x + 4,
+        box [x] => x,
+        box [1, x] => x + 200,
+        box ref slice => slice.iter().sum(),
+        _ => 2000,
+    }
+}
+
+fn nested_vec(vecvec: Vec<Vec<u32>>) -> u32 {
+    match vecvec {
+        box [] => 0,
+        box [box [x]] => x,
+        box [box [0, x] | box [1, x]] => x,
+        box [ref x] => x.iter().sum(),
+        box [box [], box [1, x, y]] => y - x,
+        _ => 2000,
     }
 }
+
+fn main() {
+    assert_eq!(simple_vec(vec![1]), 1);
+    assert_eq!(simple_vec(vec![1, 2]), 202);
+    assert_eq!(simple_vec(vec![1, 2, 3]), 6);
+
+    assert_eq!(nested_vec(vec![vec![0, 42]]), 42);
+    assert_eq!(nested_vec(vec![vec![1, 42]]), 42);
+    assert_eq!(nested_vec(vec![vec![1, 2, 3]]), 6);
+    assert_eq!(nested_vec(vec![vec![], vec![1, 2, 3]]), 1);
+}