more incr stuff

Author: Zoxc

src/librustc/dep_graph/dep_node.rs

@@ -491,6 +491,9 @@ define_dep_nodes!( <'tcx>
 
     [] CheckModAttrs(DefId),
     [] CheckModLoops(DefId),
+    [] CheckModUnstableApiUsage(DefId),
+    [] CheckModItemTypes(DefId),
+    [] CollectModItemTypes(DefId),
 
     [] Reachability,
     [] MirKeys,

src/librustc/middle/stability.rs

@@ -17,6 +17,8 @@ use lint;
 use hir::def::Def;
 use hir::def_id::{CrateNum, CRATE_DEF_INDEX, DefId, LOCAL_CRATE};
 use ty::{self, TyCtxt};
+use ty::maps::Providers;
+use ty::maps::queries;
 use middle::privacy::AccessLevels;
 use session::DiagnosticMessageId;
 use syntax::symbol::Symbol;
@@ -463,11 +465,23 @@ impl<'a, 'tcx> Index<'tcx> {
     }
 }
 
+pub fn check_unstable_api_usage<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
+    for &module in &tcx.hir.krate().modules {
+        queries::check_mod_unstable_api_usage::ensure(tcx, tcx.hir.local_def_id(module));
+    }
+}
+
 /// Cross-references the feature names of unstable APIs with enabled
 /// features and possibly prints errors.
-pub fn check_unstable_api_usage<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
-    let mut checker = Checker { tcx: tcx };
-    tcx.hir.krate().visit_all_item_likes(&mut checker.as_deep_visitor());
+pub fn check_mod_unstable_api_usage<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>, module_def_id: DefId) {
+    tcx.hir.visit_module_item_likes(module_def_id, Checker { tcx }.as_deep_visitor());
+}
+
+pub fn provide(providers: &mut Providers) {
+    *providers = Providers {
+        check_mod_unstable_api_usage,
+        ..*providers
+    };
 }
 
 /// Check whether an item marked with `deprecated(since="X")` is currently

src/librustc/ty/context.rs

@@ -1086,6 +1086,10 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
                                   f: F) -> R
                                   where F: for<'b> FnOnce(TyCtxt<'b, 'tcx, 'tcx>) -> R
     {
+        if s.verbose() {
+            eprintln!("entering tcx 1");
+        }
+
         let data_layout = TargetDataLayout::parse(&s.target.target).unwrap_or_else(|err| {
             s.fatal(&err);
         });
@@ -1096,6 +1100,10 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         let mut providers = IndexVec::from_elem_n(extern_providers, max_cnum + 1);
         providers[LOCAL_CRATE] = local_providers;
 
+        if s.verbose() {
+            eprintln!("entering tcx 2");
+        }
+
         let def_path_hash_to_def_id = if s.opts.build_dep_graph() {
             let upstream_def_path_tables: Vec<(CrateNum, Lrc<_>)> = cstore
                 .crates_untracked()
@@ -1128,6 +1136,10 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
             None
         };
 
+        if s.verbose() {
+            eprintln!("entering tcx 3");
+        }
+
         let mut trait_map = FxHashMap();
         for (k, v) in resolutions.trait_map {
             let hir_id = hir.node_to_hir_id(k);
@@ -1138,6 +1150,10 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
                                     Lrc::new(StableVec::new(v)));
         }
 
+        if s.verbose() {
+            eprintln!("entering tcx 4");
+        }
+
         let gcx = &GlobalCtxt {
             sess: s,
             cstore,
@@ -1181,6 +1197,10 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
 
         sync::assert_send_val(&gcx);
 
+        if s.verbose() {
+            eprintln!("entering tcx 5");
+        }
+
         tls::enter_global(gcx, f)
     }
 

src/librustc/ty/maps/mod.rs

@@ -195,9 +195,15 @@ define_maps! { <'tcx>
     /// Checks the attributes in the module
     [] fn check_mod_attrs: CheckModAttrs(DefId) -> (),
 
+    [] fn check_mod_unstable_api_usage: CheckModUnstableApiUsage(DefId) -> (),
+
     /// Checks the attributes in the module
     [] fn check_mod_loops: CheckModLoops(DefId) -> (),
 
+    [] fn check_mod_item_types: CheckModItemTypes(DefId) -> (),
+
+    [] fn collect_mod_item_types: CollectModItemTypes(DefId) -> (),
+
     /// The signature of functions and closures.
     [] fn fn_sig: FnSignature(DefId) -> ty::PolyFnSig<'tcx>,
 

src/librustc/ty/maps/plumbing.rs

@@ -586,6 +586,12 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         span: Span,
         dep_node: DepNode
     ) -> Result<(Q::Value, DepNodeIndex), CycleError<'gcx>> {
+        if self.sess.verbose() {
+            eprintln!("forcing queries {} key={:?})",
+                Q::NAME,
+                key);
+        }
+
         // We may be concurrently trying both execute and force a query
         // Ensure that only one of them runs the query
         let job = match JobOwner::try_get(self, span, &key) {
@@ -1049,6 +1055,9 @@ pub fn force_from_dep_node<'a, 'gcx, 'lcx>(tcx: TyCtxt<'a, 'gcx, 'lcx>,
         DepKind::UnsafeDeriveOnReprPacked => { force!(unsafe_derive_on_repr_packed, def_id!()); }
         DepKind::CheckModAttrs => { force!(check_mod_attrs, def_id!()); }
         DepKind::CheckModLoops => { force!(check_mod_loops, def_id!()); }
+        DepKind::CheckModUnstableApiUsage => { force!(check_mod_unstable_api_usage, def_id!()); }
+        DepKind::CheckModItemTypes => { force!(check_mod_item_types, def_id!()); }
+        DepKind::CollectModItemTypes => { force!(collect_mod_item_types, def_id!()); }
         DepKind::Reachability => { force!(reachable_set, LOCAL_CRATE); }
         DepKind::MirKeys => { force!(mir_keys, LOCAL_CRATE); }
         DepKind::CrateVariances => { force!(crate_variances, LOCAL_CRATE); }

src/librustc/util/common.rs

@@ -171,6 +171,13 @@ pub fn time_ext<T, F>(do_it: bool, sess: Option<&Session>, what: &str, f: F) ->
         r
     });
 
+    if sess.map(|s| s.verbose()).unwrap_or(false) {
+        let indentation = TIME_DEPTH.with(|slot| slot.get());
+        println!("{}start time: {}",
+                repeat("  ").take(indentation).collect::<String>(),
+                what);
+    }
+
     if let Some(sess) = sess {
         if cfg!(debug_assertions) {
             profq_msg(sess, ProfileQueriesMsg::TimeBegin(what.to_string()))

src/librustc_driver/driver.rs

@@ -1150,7 +1150,7 @@ pub fn default_provide(providers: &mut ty::maps::Providers) {
     typeck::provide(providers);
     ty::provide(providers);
     traits::provide(providers);
-    reachable::provide(providers);
+    stability::provide(providers);
     rustc_passes::provide(providers);
     rustc_traits::provide(providers);
     middle::region::provide(providers);
@@ -1228,7 +1228,7 @@ where
         |tcx| {
             // Do some initialization of the DepGraph that can only be done with the
             // tcx available.
-            rustc_incremental::dep_graph_tcx_init(tcx);
+            time(sess, "dep graph tcx init", || rustc_incremental::dep_graph_tcx_init(tcx));
 
             time(sess, "loop checking", || loops::check_crate(tcx));
 

src/librustc_typeck/check/mod.rs

@@ -99,7 +99,7 @@ use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
 use rustc::ty::{self, Ty, TyCtxt, GenericParamDefKind, Visibility, ToPredicate, RegionKind};
 use rustc::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability};
 use rustc::ty::fold::TypeFoldable;
-use rustc::ty::maps::Providers;
+use rustc::ty::maps::{queries, Providers};
 use rustc::ty::util::{Representability, IntTypeExt, Discr};
 use errors::{DiagnosticBuilder, DiagnosticId};
 
@@ -689,10 +689,16 @@ pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorRe
 
 pub fn check_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
     tcx.sess.track_errors(|| {
-        tcx.hir.krate().visit_all_item_likes(&mut CheckItemTypesVisitor { tcx });
+        for &module in &tcx.hir.krate().modules {
+            queries::check_mod_item_types::ensure(tcx, tcx.hir.local_def_id(module));
+        }
     })
 }
 
+fn check_mod_item_types<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>, module_def_id: DefId) {
+    tcx.hir.visit_module_item_likes(module_def_id, CheckItemTypesVisitor { tcx });
+}
+
 pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
     tcx.typeck_item_bodies(LOCAL_CRATE)
 }
@@ -731,6 +737,7 @@ pub fn provide(providers: &mut Providers) {
         check_item_well_formed,
         check_trait_item_well_formed,
         check_impl_item_well_formed,
+        check_mod_item_types,
         ..*providers
     };
 }

src/librustc_typeck/collect.rs

@@ -33,7 +33,7 @@ use rustc::mir::mono::Linkage;
 use rustc::ty::subst::Substs;
 use rustc::ty::{ToPredicate, ReprOptions};
 use rustc::ty::{self, AdtKind, ToPolyTraitRef, Ty, TyCtxt};
-use rustc::ty::maps::Providers;
+use rustc::ty::maps::{Providers, queries};
 use rustc::ty::util::IntTypeExt;
 use rustc::ty::util::Discr;
 use rustc::util::captures::Captures;
@@ -57,8 +57,16 @@ use rustc::hir::def_id::{DefId, LOCAL_CRATE};
 // Main entry point
 
 pub fn collect_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
-    let mut visitor = CollectItemTypesVisitor { tcx: tcx };
-    tcx.hir.krate().visit_all_item_likes(&mut visitor.as_deep_visitor());
+    for &module in &tcx.hir.krate().modules {
+        queries::collect_mod_item_types::ensure(tcx, tcx.hir.local_def_id(module));
+    }
+}
+
+fn collect_mod_item_types<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>, module_def_id: DefId) {
+    tcx.hir.visit_module_item_likes(
+        module_def_id,
+        CollectItemTypesVisitor { tcx }.as_deep_visitor()
+    );
 }
 
 pub fn provide(providers: &mut Providers) {
@@ -76,6 +84,7 @@ pub fn provide(providers: &mut Providers) {
         impl_polarity,
         is_foreign_item,
         codegen_fn_attrs,
+        collect_mod_item_types,
         ..*providers
     };
 }