Parallelize type collecting and item-types checking

Author: Zoxc

src/librustc/hir/map/mod.rs

@@ -8,10 +8,12 @@ use crate::middle::cstore::CrateStoreDyn;
 use crate::ty::query::Providers;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::svh::Svh;
+
+use rustc_data_structures::sync::{self, par_for_each};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{DefId, DefIndex, LocalDefId, CRATE_DEF_INDEX};
 use rustc_hir::intravisit;
-use rustc_hir::itemlikevisit::ItemLikeVisitor;
+use rustc_hir::itemlikevisit::{ItemLikeVisitor, ParItemLikeVisitor};
 use rustc_hir::print::Nested;
 use rustc_hir::*;
 use rustc_index::vec::IndexVec;
@@ -582,6 +584,40 @@ impl<'hir> Map<'hir> {
         }
     }
 
+    /// A parallel version of `visit_item_likes_in_module`.
+    pub fn par_visit_item_likes_in_module<V>(&self, module: DefId, visitor: &V)
+    where
+        V: ParItemLikeVisitor<'hir> + sync::Sync,
+    {
+        let hir_id = self.as_local_hir_id(module).unwrap();
+
+        // Read the module so we'll be re-executed if new items
+        // appear immediately under in the module. If some new item appears
+        // in some nested item in the module, we'll be re-executed due to reads
+        // in the expect_* calls the loops below
+        self.read(hir_id);
+
+        let module = &self.forest.krate.modules[&hir_id];
+
+        parallel!(
+            {
+                par_for_each(&module.items, |id| {
+                    visitor.visit_item(self.expect_item(*id));
+                });
+            },
+            {
+                par_for_each(&module.trait_items, |id| {
+                    visitor.visit_trait_item(self.expect_trait_item(id.hir_id));
+                });
+            },
+            {
+                par_for_each(&module.impl_items, |id| {
+                    visitor.visit_impl_item(self.expect_impl_item(id.hir_id));
+                });
+            }
+        );
+    }
+
     /// Retrieves the `Node` corresponding to `id`, panicking if it cannot be found.
     pub fn get(&self, id: HirId) -> Node<'hir> {
         // read recorded by `find`

src/librustc_hir/intravisit.rs

@@ -70,6 +70,13 @@ pub trait IntoVisitor<'hir> {
     fn into_visitor(&self) -> Self::Visitor;
 }
 
+impl<'hir, T: Clone + Visitor<'hir>> IntoVisitor<'hir> for T {
+    type Visitor = Self;
+    fn into_visitor(&self) -> Self::Visitor {
+        self.clone()
+    }
+}
+
 pub struct ParDeepVisitor<V>(pub V);
 
 impl<'hir, V> ParItemLikeVisitor<'hir> for ParDeepVisitor<V>

src/librustc_typeck/check/mod.rs

@@ -123,7 +123,7 @@ use rustc_hir as hir;
 use rustc_hir::def::{CtorOf, DefKind, Res};
 use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, DefIdSet, LOCAL_CRATE};
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
-use rustc_hir::itemlikevisit::ItemLikeVisitor;
+use rustc_hir::itemlikevisit::ParItemLikeVisitor;
 use rustc_hir::{ExprKind, GenericArg, HirIdMap, Item, ItemKind, Node, PatKind, QPath};
 use rustc_index::vec::Idx;
 use rustc_span::hygiene::DesugaringKind;
@@ -729,12 +729,12 @@ struct CheckItemTypesVisitor<'tcx> {
     tcx: TyCtxt<'tcx>,
 }
 
-impl ItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'tcx> {
-    fn visit_item(&mut self, i: &'tcx hir::Item<'tcx>) {
+impl ParItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'tcx> {
+    fn visit_item(&self, i: &'tcx hir::Item<'tcx>) {
         check_item_type(self.tcx, i);
     }
-    fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem<'tcx>) {}
-    fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem<'tcx>) {}
+    fn visit_trait_item(&self, _: &'tcx hir::TraitItem<'tcx>) {}
+    fn visit_impl_item(&self, _: &'tcx hir::ImplItem<'tcx>) {}
 }
 
 pub fn check_wf_new(tcx: TyCtxt<'_>) {
@@ -743,7 +743,7 @@ pub fn check_wf_new(tcx: TyCtxt<'_>) {
 }
 
 fn check_mod_item_types(tcx: TyCtxt<'_>, module_def_id: DefId) {
-    tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
+    tcx.hir().par_visit_item_likes_in_module(module_def_id, &CheckItemTypesVisitor { tcx });
 }
 
 fn typeck_item_bodies(tcx: TyCtxt<'_>, crate_num: CrateNum) {

src/librustc_typeck/collect.rs

@@ -40,7 +40,7 @@ use rustc_errors::{struct_span_err, Applicability, StashKey};
 use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
-use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
+use rustc_hir::intravisit::{self, NestedVisitorMap, ParDeepVisitor, Visitor};
 use rustc_hir::{GenericParamKind, Node, Unsafety};
 use rustc_span::symbol::{kw, sym, Symbol};
 use rustc_span::{Span, DUMMY_SP};
@@ -54,9 +54,9 @@ struct OnlySelfBounds(bool);
 // Main entry point
 
 fn collect_mod_item_types(tcx: TyCtxt<'_>, module_def_id: DefId) {
-    tcx.hir().visit_item_likes_in_module(
+    tcx.hir().par_visit_item_likes_in_module(
         module_def_id,
-        &mut CollectItemTypesVisitor { tcx }.as_deep_visitor(),
+        &ParDeepVisitor(CollectItemTypesVisitor { tcx }),
     );
 }
 
@@ -117,6 +117,7 @@ impl<'v> Visitor<'v> for PlaceholderHirTyCollector {
     }
 }
 
+#[derive(Clone)]
 struct CollectItemTypesVisitor<'tcx> {
     tcx: TyCtxt<'tcx>,
 }

src/librustc_typeck/lib.rs

@@ -102,6 +102,7 @@ use rustc::ty::subst::SubstsRef;
 use rustc::ty::{self, Ty, TyCtxt};
 use rustc::util;
 use rustc::util::common::ErrorReported;
+use rustc_data_structures::sync::par_for_each;
 use rustc_errors::struct_span_err;
 use rustc_hir as hir;
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
@@ -308,9 +309,13 @@ pub fn check_crate(tcx: TyCtxt<'_>) -> Result<(), ErrorReported> {
     // FIXME(matthewjasper) We shouldn't need to do this.
     tcx.sess.track_errors(|| {
         tcx.sess.time("type_collecting", || {
-            for &module in tcx.hir().krate().modules.keys() {
+            // Run dependencies of type collecting before entering the loop
+            tcx.inferred_outlives_crate(LOCAL_CRATE);
+
+            let _prof_timer = tcx.sess.timer("type_collecting_loop");
+            par_for_each(&tcx.hir().krate().modules, |(&module, _)| {
                 tcx.ensure().collect_mod_item_types(tcx.hir().local_def_id(module));
-            }
+            });
         });
     })?;
 
@@ -339,9 +344,9 @@ pub fn check_crate(tcx: TyCtxt<'_>) -> Result<(), ErrorReported> {
     })?;
 
     tcx.sess.time("item_types_checking", || {
-        for &module in tcx.hir().krate().modules.keys() {
+        par_for_each(&tcx.hir().krate().modules, |(&module, _)| {
             tcx.ensure().check_mod_item_types(tcx.hir().local_def_id(module));
-        }
+        });
     });
 
     tcx.sess.time("item_bodies_checking", || tcx.typeck_item_bodies(LOCAL_CRATE));

src/test/ui/span/issue-35987.rs

@@ -3,10 +3,11 @@ struct Foo<T: Clone>(T);
 use std::ops::Add;
 
 impl<T: Clone, Add> Add for Foo<T> {
-//~^ ERROR expected trait, found type parameter
+    //~^ ERROR expected trait, found type parameter
     type Output = usize;
 
     fn add(self, rhs: Self) -> Self::Output {
+        //~^ ERROR ambiguous associated type
         unimplemented!();
     }
 }

src/test/ui/span/issue-35987.stderr

@@ -9,6 +9,13 @@ help: possible better candidate is found in another module, you can import it in
 LL | use std::ops::Add;
    |
 
-error: aborting due to previous error
+error[E0223]: ambiguous associated type
+  --> $DIR/issue-35987.rs:9:32
+   |
+LL |     fn add(self, rhs: Self) -> Self::Output {
+   |                                ^^^^^^^^^^^^ help: use fully-qualified syntax: `<Foo<T> as Trait>::Output`
+
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0404`.
+Some errors have detailed explanations: E0223, E0404.
+For more information about an error, try `rustc --explain E0223`.