RE-ORDERME treat borrows of "free-regions" specially, rather than struggle with the overall infrastructure right now.

Author: pnkfelix

src/librustc/hir/map/mod.rs

@@ -433,6 +433,21 @@ impl<'hir> Map<'hir> {
         }
     }
 
+    /// Returns `(owner, body)` where `owner` is nearest closure or
+    /// item that contains `node_id`, and `body` is owner's body.
+    pub fn node_owner(&self, mut node_id: NodeId) -> (NodeId, NodeId) {
+        let mut parent = self.get_parent_node(node_id);
+        assert!(parent != node_id); // if parent == node_id { return parent; }
+        loop {
+            if self.map[parent.as_usize()].is_body_owner(node_id) {
+                return (parent, node_id);
+            }
+            node_id = parent;
+            parent = self.get_parent_node(node_id);
+            assert!(node_id != parent);
+        }
+    }
+
     pub fn body_owner_def_id(&self, id: BodyId) -> DefId {
         self.local_def_id(self.body_owner(id))
     }

src/librustc_mir/build/expr/as_rvalue.rs

@@ -70,8 +70,30 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
             }
             ExprKind::Borrow { region, borrow_kind, arg } => {
                 if let Region::ReScope(extent) = *region {
-                    this.seen_borrows.insert(extent);
+                    let tcx = this.hir.tcx();
+
+                    // Find extent for the body of the immediately enclosing closure or fn.
+                    let expr_code_extent = match expr.temp_lifetime {
+                        None => panic!("should not see ReScope borrows outside of closures/fns"),
+                        Some(expr_code_extent) => expr_code_extent,
+                    };
+                    let expr_id = expr_code_extent.node_id(&tcx.region_maps);
+                    let (_owner_id, body_id) = tcx.hir.node_owner(expr_id);
+                    // FIXME: should this be destruction scope of
+                    // `body_id` (or a CallSiteScope)?
+                    let body_extent = tcx.region_maps.node_extent(body_id);
+                    assert!(tcx.region_maps.is_subscope_of(expr_code_extent, body_extent));
+
+                    if tcx.region_maps.is_subscope_of(extent, body_extent) {
+                        // extent of borrow ends during this execution
+                        this.seen_borrows.insert(extent);
+                        this.mark_borrowed(extent, expr_span);
+                    } else {
+                        // must be borrow of region outside closure; do nothing.
+                        debug!("extent {:?} is outside of body extent: {:?}", extent, body_extent);
+                    }
                 }
+
                 let arg_lvalue = unpack!(block = this.as_lvalue(block, arg));
                 block.and(Rvalue::Ref(region, borrow_kind, arg_lvalue))
             }