[WIP] per-fn RegionMaps

Author: cramertj

src/librustc/dep_graph/dep_node.rs

@@ -58,7 +58,8 @@ pub enum DepNode<D: Clone + Debug> {
     // Represents different phases in the compiler.
     CollectLanguageItems,
     ResolveLifetimes,
-    RegionResolveCrate,
+    RegionResolveFn(D),
+    CheckLoops,
     PluginRegistrar,
     StabilityIndex,
     CollectItem(D),
@@ -213,7 +214,7 @@ impl<D: Clone + Debug> DepNode<D> {
             TypeckBodiesKrate => Some(TypeckBodiesKrate),
             CollectLanguageItems => Some(CollectLanguageItems),
             ResolveLifetimes => Some(ResolveLifetimes),
-            RegionResolveCrate => Some(RegionResolveCrate),
+            CheckLoops => Some(CheckLoops),
             PluginRegistrar => Some(PluginRegistrar),
             StabilityIndex => Some(StabilityIndex),
             Coherence => Some(Coherence),
@@ -255,6 +256,7 @@ impl<D: Clone + Debug> DepNode<D> {
                 def_ids.map(MirShim)
             }
             BorrowCheck(ref d) => op(d).map(BorrowCheck),
+            RegionResolveFn(ref d) => op(d).map(RegionResolveFn),
             RvalueCheck(ref d) => op(d).map(RvalueCheck),
             StabilityCheck(ref d) => op(d).map(StabilityCheck),
             TransCrateItem(ref d) => op(d).map(TransCrateItem),

src/librustc/middle/region.rs

@@ -32,8 +32,7 @@ use syntax::codemap::DUMMY_SP;
 use ty::TyCtxt;
 use ty::maps::Providers;
 
-use hir;
-use hir::def_id::{CrateNum, LOCAL_CRATE};
+use hir; use hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
 use hir::intravisit::{self, Visitor, FnKind, NestedVisitorMap};
 use hir::{Block, Item, FnDecl, Arm, Pat, PatKind, Stmt, Expr, Local};
 
@@ -347,7 +346,11 @@ struct RegionResolutionVisitor<'hir: 'a, 'a> {
     /// arbitrary amounts of stack space. Terminating scopes end
     /// up being contained in a DestructionScope that contains the
     /// destructor's execution.
-    terminating_scopes: NodeSet
+    terminating_scopes: NodeSet,
+
+    target_fn_id: DefId,
+
+    found_target_fn: bool,
 }
 
 
@@ -1139,50 +1142,54 @@ fn resolve_fn<'a, 'tcx>(visitor: &mut RegionResolutionVisitor<'tcx, 'a>,
                         body_id: hir::BodyId,
                         sp: Span,
                         id: ast::NodeId) {
-    debug!("region::resolve_fn(id={:?}, \
-                               span={:?}, \
-                               body.id={:?}, \
-                               cx.parent={:?})",
-           id,
-           visitor.sess.codemap().span_to_string(sp),
-           body_id,
-           visitor.cx.parent);
 
     visitor.cx.parent = visitor.new_code_extent(
         CodeExtentData::CallSiteScope { fn_id: id, body_id: body_id.node_id });
 
-    let fn_decl_scope = visitor.new_code_extent(
-        CodeExtentData::ParameterScope { fn_id: id, body_id: body_id.node_id });
-
-    if let Some(root_id) = visitor.cx.root_id {
-        visitor.region_maps.record_fn_parent(body_id.node_id, root_id);
+    if body_id == visitor.target_fn_id {
+        // We've found the top level `fn`. Store it and its children in the `RegionMaps`
+        visitor.found_target_fn = true;
     }
 
-    let outer_cx = visitor.cx;
-    let outer_ts = mem::replace(&mut visitor.terminating_scopes, NodeSet());
-    visitor.terminating_scopes.insert(body_id.node_id);
-
-    // The arguments and `self` are parented to the fn.
-    visitor.cx = Context {
-        root_id: Some(body_id.node_id),
-        parent: ROOT_CODE_EXTENT,
-        var_parent: fn_decl_scope,
-    };
+    if visitor.found_target_fn {
+        debug!("region::resolve_fn(id={:?}, \
+                                   span={:?}, \
+                                   body.id={:?}, \
+                                   cx.parent={:?})",
+            id,
+            visitor.sess.codemap().span_to_string(sp),
+            body_id,
+            visitor.cx.parent);
+
+        let fn_decl_scope = visitor.new_code_extent(
+            CodeExtentData::ParameterScope { fn_id: id, body_id: body_id.node_id });
+
+        let outer_cx = visitor.cx;
+        let outer_ts = mem::replace(&mut visitor.terminating_scopes, NodeSet());
+        visitor.terminating_scopes.insert(body_id.node_id);
+
+        // The arguments and `self` are parented to the fn.
+        visitor.cx = Context {
+            root_id: Some(body_id.node_id),
+            parent: ROOT_CODE_EXTENT,
+            var_parent: fn_decl_scope,
+        };
 
-    intravisit::walk_fn_decl(visitor, decl);
-    intravisit::walk_fn_kind(visitor, kind);
+        intravisit::walk_fn_decl(visitor, decl);
+        intravisit::walk_fn_kind(visitor, kind);
 
-    // The body of the every fn is a root scope.
-    visitor.cx = Context {
-        root_id: Some(body_id.node_id),
-        parent: fn_decl_scope,
-        var_parent: fn_decl_scope
-    };
-    visitor.visit_nested_body(body_id);
+        // The body of the every fn is a root scope.
+        visitor.cx = Context {
+            root_id: Some(body_id.node_id),
+            parent: fn_decl_scope,
+            var_parent: fn_decl_scope
+        };
+        visitor.visit_nested_body(body_id);
 
-    // Restore context we had at the start.
-    visitor.cx = outer_cx;
-    visitor.terminating_scopes = outer_ts;
+        // Restore context we had at the start.
+        visitor.cx = outer_cx;
+        visitor.terminating_scopes = outer_ts;
+    }
 }
 
 impl<'hir, 'a> RegionResolutionVisitor<'hir, 'a> {
@@ -1264,14 +1271,12 @@ impl<'hir, 'a> Visitor<'hir> for RegionResolutionVisitor<'hir, 'a> {
 }
 
 pub fn resolve_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Rc<RegionMaps> {
-    ty::queries::region_resolve_crate::get(tcx, DUMMY_SP, LOCAL_CRATE)
+    ty::queries::region_resolve_fn::get(tcx, DUMMY_SP, LOCAL_CRATE)
 }
 
-fn region_resolve_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
+fn region_resolve_fn<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, fn_id: DefId)
     -> Rc<RegionMaps>
 {
-    debug_assert!(crate_num == LOCAL_CRATE);
-
     let sess = &tcx.sess;
     let hir_map = &tcx.hir;
 
@@ -1302,16 +1307,19 @@ fn region_resolve_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateN
                 parent: ROOT_CODE_EXTENT,
                 var_parent: ROOT_CODE_EXTENT
             },
-            terminating_scopes: NodeSet()
+            terminating_scopes: NodeSet(),
+            target_fn_id: fn_id,
+            found_target_fn: false,
         };
         krate.visit_all_item_likes(&mut visitor.as_deep_visitor());
+        debug_assert!(visitor.found_target_fn);
     }
     Rc::new(maps)
 }
 
 pub fn provide(providers: &mut Providers) {
     *providers = Providers {
-        region_resolve_crate,
+        region_resolve_fn,
         ..*providers
     };
 }

src/librustc/ty/maps.rs

@@ -217,12 +217,6 @@ impl<'tcx> QueryDescription for queries::reachable_set<'tcx> {
     }
 }
 
-impl<'tcx> QueryDescription for queries::region_resolve_crate<'tcx> {
-    fn describe(_: TyCtxt, _: CrateNum) -> String {
-        format!("resolve crate")
-    }
-}
-
 macro_rules! define_maps {
     (<$tcx:tt>
      $($(#[$attr:meta])*
@@ -457,7 +451,10 @@ define_maps! { <'tcx>
 
     pub reachable_set: reachability_dep_node(CrateNum) -> NodeSet,
 
-    pub region_resolve_crate: region_resolve_crate_dep_node(CrateNum) -> Rc<RegionMaps>,
+    /// Per-function `RegionMaps`. Regions are referenced through their top-most containing
+    /// function, e.g. `fn outer() { fn inner() { ... } }` produces a single entry which can
+    /// be accessed using the `DefId` of `outer`.
+    pub region_resolve_fn: RegionResolveFn(DefId) -> Rc<RegionMaps>,
 
     pub mir_shims: mir_shim(ty::InstanceDef<'tcx>) -> &'tcx RefCell<mir::Mir<'tcx>>
 }
@@ -474,10 +471,6 @@ fn reachability_dep_node(_: CrateNum) -> DepNode<DefId> {
     DepNode::Reachability
 }
 
-fn region_resolve_crate_dep_node(_: CrateNum) -> DepNode<DefId> {
-    DepNode::RegionResolveCrate
-}
-
 fn mir_shim(instance: ty::InstanceDef) -> DepNode<DefId> {
     instance.dep_node()
 }