Extend rustc::middle::dataflow to allow filtering the kills from flow-exits.

Fix borrowck analysis so that it will not treat a break that pops
through an assignment `x = { ... break; ... }` as a kill of the
"moved-out" bit for `x`.

Fix #24267.

Author: pnkfelix

src/librustc/middle/dataflow.rs

@@ -187,6 +187,13 @@ fn build_nodeid_to_index(decl: Option<&ast::FnDecl>,
     }
 }
 
+pub struct FlowExit {
+    pub breaking_node: CFGIndex,
+    pub exiting_scope: (ast::NodeId, CFGIndex),
+}
+
+pub enum FlowExitEffect { AddKills, IgnoreKills }
+
 impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> {
     pub fn new(tcx: &'a ty::ctxt<'tcx>,
                analysis_name: &'static str,
@@ -393,7 +400,9 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> {
         return true;
     }
 
-    pub fn add_kills_from_flow_exits(&mut self, cfg: &cfg::CFG) {
+    pub fn add_kills_from_flow_exits<P>(&mut self, cfg: &cfg::CFG, mut p:P)
+        where P: FnMut(FlowExit) -> FlowExitEffect
+    {
         //! Whenever you have a `break` or `continue` statement, flow
         //! exits through any number of enclosing scopes on its way to
         //! the new destination. This function infers the kill bits of
@@ -402,6 +411,11 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> {
         //!
         //! This is usually called (if it is called at all), after
         //! all add_gen and add_kill calls, but before propagate.
+        //!
+        //! The callback predicate `p(b, e)` is invoked on each node
+        //! `e` that has been registered as an `exiting_scope` for a
+        //! given control-breaking node `b`, to determine whether to
+        //! include the associated kill-effects or not.
 
         debug!("{} add_kills_from_flow_exits", self.analysis_name);
         if self.bits_per_id == 0 {
@@ -420,10 +434,21 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> {
                 match opt_cfg_idx {
                     Some(indices) => {
                         for &cfg_idx in indices {
-                            let (start, end) = self.compute_id_range(cfg_idx);
-                            let kills = &self.kills[start.. end];
-                            if bitwise(&mut orig_kills, kills, &Union) {
-                                changed = true;
+                            match p(FlowExit {
+                                breaking_node: flow_exit,
+                                exiting_scope: (node_id, cfg_idx) }) {
+                                FlowExitEffect::IgnoreKills => continue,
+                                FlowExitEffect::AddKills => {
+                                    let (start, end) = self.compute_id_range(cfg_idx);
+                                    let kills = &self.kills[start.. end];
+                                    if bitwise(&mut orig_kills, kills, &Union) {
+                                        debug!("scope exits: scope id={} \
+                                                (node={:?} of {:?}) added killset: {}",
+                                               node_id, cfg_idx, indices,
+                                               bits_to_string(kills));
+                                        changed = true;
+                                    }
+                                }
                             }
                         }
                     }

src/librustc_borrowck/borrowck/mod.rs

@@ -24,6 +24,7 @@ use rustc::middle::cfg;
 use rustc::middle::dataflow::DataFlowContext;
 use rustc::middle::dataflow::BitwiseOperator;
 use rustc::middle::dataflow::DataFlowOperator;
+use rustc::middle::dataflow::FlowExitEffect;
 use rustc::middle::expr_use_visitor as euv;
 use rustc::middle::mem_categorization as mc;
 use rustc::middle::region;
@@ -169,7 +170,9 @@ fn build_borrowck_dataflow_data<'a, 'tcx>(this: &mut BorrowckCtxt<'a, 'tcx>,
         loan_dfcx.add_gen(loan.gen_scope.node_id(), loan_idx);
         loan_dfcx.add_kill(loan.kill_scope.node_id(), loan_idx);
     }
-    loan_dfcx.add_kills_from_flow_exits(cfg);
+    loan_dfcx.add_kills_from_flow_exits(cfg, |_flow_exit| {
+        FlowExitEffect::AddKills
+    });
     loan_dfcx.propagate(cfg, body);
 
     let flowed_moves = move_data::FlowedMoveData::new(move_data,

src/librustc_borrowck/borrowck/move_data.rs

@@ -18,6 +18,7 @@ use rustc::middle::cfg;
 use rustc::middle::dataflow::DataFlowContext;
 use rustc::middle::dataflow::BitwiseOperator;
 use rustc::middle::dataflow::DataFlowOperator;
+use rustc::middle::dataflow::FlowExitEffect;
 use rustc::middle::expr_use_visitor as euv;
 use rustc::middle::ty;
 use rustc::util::nodemap::{FnvHashMap, NodeSet};
@@ -59,6 +60,9 @@ pub struct MoveData<'tcx> {
     /// Assignments to a variable or path, like `x = foo`, but not `x += foo`.
     pub assignee_ids: RefCell<NodeSet>,
 
+    /// AST node ids for move entries that have kind `Declared`.
+    pub declared_ids: RefCell<NodeSet>,
+
     /// Path-fragments from moves in to or out of parts of structured data.
     pub fragments: RefCell<fragments::FragmentSets>,
 }
@@ -216,6 +220,7 @@ impl<'tcx> MoveData<'tcx> {
             var_assignments: RefCell::new(Vec::new()),
             variant_matches: RefCell::new(Vec::new()),
             assignee_ids: RefCell::new(NodeSet()),
+            declared_ids: RefCell::new(NodeSet()),
             fragments: RefCell::new(fragments::FragmentSets::new()),
         }
     }
@@ -376,6 +381,10 @@ impl<'tcx> MoveData<'tcx> {
         let next_move = self.path_first_move(path_index);
         self.set_path_first_move(path_index, move_index);
 
+        if kind == MoveKind::Declared {
+            self.declared_ids.borrow_mut().insert(id);
+        }
+
         self.moves.borrow_mut().push(Move {
             path: path_index,
             id: id,
@@ -614,8 +623,20 @@ impl<'a, 'tcx> FlowedMoveData<'a, 'tcx> {
                                 &mut dfcx_moves,
                                 &mut dfcx_assign);
 
-        dfcx_moves.add_kills_from_flow_exits(cfg);
-        dfcx_assign.add_kills_from_flow_exits(cfg);
+        dfcx_moves.add_kills_from_flow_exits(cfg, |flow_exit| {
+            // A `let x = { ... break ...};` statement should kill the
+            // move-bit for `x`, but a `x = { ... break; ... };
+            // statement should leave it alone (#24267).
+            let (exiting_scope_id, _) = flow_exit.exiting_scope;
+            if move_data.declared_ids.borrow().contains(&exiting_scope_id) {
+                FlowExitEffect::AddKills
+            } else {
+                FlowExitEffect::IgnoreKills
+            }
+        });
+        dfcx_assign.add_kills_from_flow_exits(cfg, |_flow_exit| {
+            FlowExitEffect::AddKills
+        });
 
         dfcx_moves.propagate(cfg, body);
         dfcx_assign.propagate(cfg, body);