Parallelize passes

Author: Zoxc

src/librustc/hir/itemlikevisit.rs

@@ -101,6 +101,17 @@ pub trait IntoVisitor<'hir> {
     fn into_visitor(&self) -> Self::Visitor;
 }
 
+#[derive(Clone)]
+pub struct ClonableVisitor<V>(pub V);
+
+impl<'hir, V: Visitor<'hir> + Clone> IntoVisitor<'hir> for ClonableVisitor<V> {
+    type Visitor = V;
+
+    fn into_visitor(&self) -> V {
+        self.clone().0
+    }
+}
+
 pub struct ParDeepVisitor<V>(pub V);
 
 impl<'hir, V> ParItemLikeVisitor<'hir> for ParDeepVisitor<V>

src/librustc/hir/mod.rs

@@ -695,6 +695,13 @@ impl Crate {
         });
     }
 
+    pub fn par_deep_visit_items<'hir, V>(&'hir self, visitor: V)
+        where V: intravisit::Visitor<'hir> + Clone + Sync + Send
+    {
+        let visitor = itemlikevisit::ClonableVisitor(visitor);
+        self.par_visit_all_item_likes(&itemlikevisit::ParDeepVisitor(visitor));
+    }
+
     pub fn body(&self, id: BodyId) -> &Body {
         &self.bodies[&id]
     }

src/librustc/middle/intrinsicck.rs

@@ -19,12 +19,10 @@ use hir::intravisit::{self, Visitor, NestedVisitorMap};
 use hir;
 
 pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
-    let mut visitor = ItemVisitor {
-        tcx,
-    };
-    tcx.hir.krate().visit_all_item_likes(&mut visitor.as_deep_visitor());
+    tcx.hir.krate().par_deep_visit_items(ItemVisitor { tcx });
 }
 
+#[derive(Clone)]
 struct ItemVisitor<'a, 'tcx: 'a> {
     tcx: TyCtxt<'a, 'tcx, 'tcx>
 }

src/librustc/middle/stability.rs

@@ -324,6 +324,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
     }
 }
 
+#[derive(Clone)]
 struct MissingStabilityAnnotations<'a, 'tcx: 'a> {
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
     access_levels: &'a AccessLevels,
@@ -466,10 +467,10 @@ impl<'a, 'tcx> Index<'tcx> {
 /// 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());
+    tcx.hir.krate().par_deep_visit_items(Checker { tcx: tcx });
 }
 
+#[derive(Clone)]
 struct Checker<'a, 'tcx: 'a> {
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
 }
@@ -733,7 +734,7 @@ pub fn check_unused_or_stable_features<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
         };
         missing.check_missing_stability(ast::CRATE_NODE_ID, krate.span);
         intravisit::walk_crate(&mut missing, krate);
-        krate.visit_all_item_likes(&mut missing.as_deep_visitor());
+        krate.par_deep_visit_items(missing);
     }
 
     let ref declared_lib_features = sess.features.borrow().declared_lib_features;

src/librustc/traits/mod.rs

@@ -26,7 +26,6 @@ use ty::error::{ExpectedFound, TypeError};
 use infer::{InferCtxt};
 
 use rustc_data_structures::sync::Lrc;
-use std::rc::Rc;
 use syntax::ast;
 use syntax_pos::{Span, DUMMY_SP};
 
@@ -225,7 +224,7 @@ pub struct DerivedObligationCause<'tcx> {
     parent_trait_ref: ty::PolyTraitRef<'tcx>,
 
     /// The parent trait had this cause
-    parent_code: Rc<ObligationCauseCode<'tcx>>
+    parent_code: Lrc<ObligationCauseCode<'tcx>>
 }
 
 pub type Obligations<'tcx, O> = Vec<Obligation<'tcx, O>>;

src/librustc/traits/select.rs

@@ -41,15 +41,14 @@ use ty::fast_reject;
 use ty::relate::TypeRelation;
 use middle::lang_items;
 
-use rustc_data_structures::sync::Lock;
+use rustc_data_structures::sync::{Lrc, Lock};
 use rustc_data_structures::bitvec::BitVector;
 use rustc_data_structures::snapshot_vec::{SnapshotVecDelegate, SnapshotVec};
 use std::iter;
 use std::cmp;
 use std::fmt;
 use std::marker::PhantomData;
 use std::mem;
-use std::rc::Rc;
 use syntax::abi::Abi;
 use hir;
 use lint;
@@ -3321,7 +3320,7 @@ impl<'tcx> TraitObligation<'tcx> {
         if obligation.recursion_depth >= 0 {
             let derived_cause = DerivedObligationCause {
                 parent_trait_ref: obligation.predicate.to_poly_trait_ref(),
-                parent_code: Rc::new(obligation.cause.code.clone())
+                parent_code: Lrc::new(obligation.cause.code.clone())
             };
             let derived_code = variant(derived_cause);
             ObligationCause::new(obligation.cause.span, obligation.cause.body_id, derived_code)

src/librustc/traits/structural_impls.rs

@@ -14,7 +14,7 @@ use ty::{self, Lift, TyCtxt};
 use ty::fold::{TypeFoldable, TypeFolder, TypeVisitor};
 
 use std::fmt;
-use std::rc::Rc;
+use rustc_data_structures::sync::Lrc;
 
 // structural impls for the structs in traits
 
@@ -253,7 +253,7 @@ impl<'a, 'tcx> Lift<'tcx> for traits::DerivedObligationCause<'a> {
             tcx.lift(&*self.parent_code).map(|code| {
                 traits::DerivedObligationCause {
                     parent_trait_ref: trait_ref,
-                    parent_code: Rc::new(code)
+                    parent_code: Lrc::new(code)
                 }
             })
         })

src/librustc/ty/structural_impls.rs

@@ -21,6 +21,7 @@ use rustc_data_structures::accumulate_vec::AccumulateVec;
 use rustc_data_structures::indexed_vec::{IndexVec, Idx};
 
 use std::rc::Rc;
+use std::sync::Arc;
 
 ///////////////////////////////////////////////////////////////////////////
 // Atomic structs
@@ -684,6 +685,16 @@ impl<'tcx, T: TypeFoldable<'tcx>> TypeFoldable<'tcx> for Option<T> {
     }
 }
 
+impl<'tcx, T: TypeFoldable<'tcx>> TypeFoldable<'tcx> for Arc<T> {
+    fn super_fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self {
+        Arc::new((**self).fold_with(folder))
+    }
+
+    fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
+        (**self).visit_with(visitor)
+    }
+}
+
 impl<'tcx, T: TypeFoldable<'tcx>> TypeFoldable<'tcx> for Rc<T> {
     fn super_fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self {
         Rc::new((**self).fold_with(folder))

src/librustc_const_eval/check_match.rs

@@ -37,6 +37,7 @@ use syntax::ast;
 use syntax::ptr::P;
 use syntax_pos::{Span, DUMMY_SP};
 
+#[derive(Clone)]
 struct OuterVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx> }
 
 impl<'a, 'tcx> Visitor<'tcx> for OuterVisitor<'a, 'tcx> {
@@ -52,7 +53,7 @@ impl<'a, 'tcx> Visitor<'tcx> for OuterVisitor<'a, 'tcx> {
 }
 
 pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
-    tcx.hir.krate().visit_all_item_likes(&mut OuterVisitor { tcx: tcx }.as_deep_visitor());
+    tcx.hir.krate().par_deep_visit_items(OuterVisitor { tcx: tcx });
     tcx.sess.abort_if_errors();
 }
 

src/librustc_const_eval/lib.rs

@@ -26,6 +26,8 @@
 #![feature(i128_type)]
 #![feature(from_ref)]
 
+#![recursion_limit="256"]
+
 extern crate arena;
 #[macro_use] extern crate syntax;
 #[macro_use] extern crate log;

src/librustc_passes/consts.rs

@@ -61,10 +61,7 @@ pub fn provide(providers: &mut Providers) {
 }
 
 pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
-    for &body_id in &tcx.hir.krate().body_ids {
-        let def_id = tcx.hir.body_owner_def_id(body_id);
-        tcx.const_is_rvalue_promotable_to_static(def_id);
-    }
+    tcx.par_body_owners(|def_id| { tcx.const_is_rvalue_promotable_to_static(def_id); });
     tcx.sess.abort_if_errors();
 }
 

src/librustc_passes/lib.rs

@@ -21,6 +21,8 @@
 
 #![feature(rustc_diagnostic_macros)]
 
+#![recursion_limit="256"]
+
 #[macro_use]
 extern crate rustc;
 extern crate rustc_const_eval;

src/librustc_trans/lib.rs

@@ -35,6 +35,8 @@
 #![feature(conservative_impl_trait)]
 #![feature(optin_builtin_traits)]
 
+#![recursion_limit="256"]
+
 use rustc::dep_graph::WorkProduct;
 use syntax_pos::symbol::Symbol;
 

src/librustc_trans_utils/symbol_names_test.rs

@@ -33,12 +33,13 @@ pub fn report_symbol_names<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
     }
 
     tcx.dep_graph.with_ignore(|| {
-        let mut visitor = SymbolNamesTest { tcx: tcx };
+        let visitor = SymbolNamesTest { tcx: tcx };
         // FIXME(#37712) could use ItemLikeVisitor if trait items were item-like
-        tcx.hir.krate().visit_all_item_likes(&mut visitor.as_deep_visitor());
+        tcx.hir.krate().par_deep_visit_items(visitor);
     })
 }
 
+#[derive(Clone)]
 struct SymbolNamesTest<'a, 'tcx:'a> {
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
 }

src/librustc_typeck/check/mod.rs

@@ -691,8 +691,8 @@ impl<'a, 'tcx> ParItemLikeVisitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
 
 pub fn check_wf_new<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
     tcx.sess.track_errors(|| {
-        let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
-        tcx.hir.krate().visit_all_item_likes(&mut visit.as_deep_visitor());
+        let visit = wfcheck::CheckTypeWellFormedVisitor::new(tcx);
+        tcx.hir.krate().par_deep_visit_items(visit);
     })
 }
 

src/librustc_typeck/check/wfcheck.rs

@@ -26,6 +26,7 @@ use errors::{DiagnosticBuilder, DiagnosticId};
 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
 use rustc::hir;
 
+#[derive(Clone)]
 pub struct CheckTypeWellFormedVisitor<'a, 'tcx:'a> {
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
     code: ObligationCauseCode<'tcx>,

src/librustc_typeck/check_unused.rs

@@ -15,7 +15,7 @@ use syntax::ast;
 use syntax_pos::{Span, DUMMY_SP};
 
 use rustc::hir::def_id::LOCAL_CRATE;
-use rustc::hir::itemlikevisit::ItemLikeVisitor;
+use rustc::hir::itemlikevisit::ParItemLikeVisitor;
 use rustc::hir;
 use rustc::util::nodemap::DefIdSet;
 
@@ -45,8 +45,8 @@ impl<'a, 'tcx> CheckVisitor<'a, 'tcx> {
     }
 }
 
-impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for CheckVisitor<'a, 'tcx> {
-    fn visit_item(&mut self, item: &hir::Item) {
+impl<'a, 'tcx, 'v> ParItemLikeVisitor<'v> for CheckVisitor<'a, 'tcx> {
+    fn visit_item(&self, item: &hir::Item) {
         if item.vis == hir::Public || item.span == DUMMY_SP {
             return;
         }
@@ -55,10 +55,10 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for CheckVisitor<'a, 'tcx> {
         }
     }
 
-    fn visit_trait_item(&mut self, _trait_item: &hir::TraitItem) {
+    fn visit_trait_item(&self, _trait_item: &hir::TraitItem) {
     }
 
-    fn visit_impl_item(&mut self, _impl_item: &hir::ImplItem) {
+    fn visit_impl_item(&self, _impl_item: &hir::ImplItem) {
     }
 }
 
@@ -71,8 +71,8 @@ pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
         used_trait_imports.extend(imports.iter());
     }
 
-    let mut visitor = CheckVisitor { tcx, used_trait_imports };
-    tcx.hir.krate().visit_all_item_likes(&mut visitor);
+    let visitor = CheckVisitor { tcx, used_trait_imports };
+    tcx.hir.krate().par_visit_all_item_likes(&visitor);
 
     for &(def_id, span) in tcx.maybe_unused_extern_crates(LOCAL_CRATE).iter() {
         // The `def_id` here actually was calculated during resolution (at least

src/librustc_typeck/collect.rs

@@ -47,16 +47,14 @@ use syntax_pos::{Span, DUMMY_SP};
 
 use rustc::hir::{self, map as hir_map};
 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
-use rustc::hir::itemlikevisit::{IntoVisitor, ParDeepVisitor};
 use rustc::hir::def::{Def, CtorKind};
 use rustc::hir::def_id::DefId;
 
 ///////////////////////////////////////////////////////////////////////////
 // Main entry point
 
 pub fn collect_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
-    let visitor = CollectItemTypesVisitor { tcx: tcx };
-    tcx.hir.krate().par_visit_all_item_likes(&ParDeepVisitor(visitor));
+    tcx.hir.krate().par_deep_visit_items(CollectItemTypesVisitor { tcx: tcx });
 }
 
 pub fn provide(providers: &mut Providers) {
@@ -99,14 +97,6 @@ struct CollectItemTypesVisitor<'a, 'tcx: 'a> {
     tcx: TyCtxt<'a, 'tcx, 'tcx>
 }
 
-impl<'a, 'tcx: 'a> IntoVisitor<'tcx> for CollectItemTypesVisitor<'a, 'tcx> {
-    type Visitor = Self;
-
-    fn into_visitor(&self) -> Self {
-        self.clone()
-    }
-}
-
 impl<'a, 'tcx> Visitor<'tcx> for CollectItemTypesVisitor<'a, 'tcx> {
     fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
         NestedVisitorMap::OnlyBodies(&self.tcx.hir)

src/librustc_typeck/outlives/test.rs

@@ -9,19 +9,19 @@
 // except according to those terms.
 
 use rustc::hir;
-use rustc::hir::itemlikevisit::ItemLikeVisitor;
+use rustc::hir::itemlikevisit::ParItemLikeVisitor;
 use rustc::ty::TyCtxt;
 
 pub fn test_inferred_outlives<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
-    tcx.hir.krate().visit_all_item_likes(&mut OutlivesTest { tcx });
+    tcx.hir.krate().par_visit_all_item_likes(&mut OutlivesTest { tcx });
 }
 
 struct OutlivesTest<'a, 'tcx: 'a> {
     tcx: TyCtxt<'a, 'tcx, 'tcx>
 }
 
-impl<'a, 'tcx> ItemLikeVisitor<'tcx> for OutlivesTest<'a, 'tcx> {
-    fn visit_item(&mut self, item: &'tcx hir::Item) {
+impl<'a, 'tcx> ParItemLikeVisitor<'tcx> for OutlivesTest<'a, 'tcx> {
+    fn visit_item(&self, item: &'tcx hir::Item) {
         let item_def_id = self.tcx.hir.local_def_id(item.id);
 
         // For unit testing: check for a special "rustc_outlives"
@@ -36,6 +36,6 @@ impl<'a, 'tcx> ItemLikeVisitor<'tcx> for OutlivesTest<'a, 'tcx> {
         }
     }
 
-    fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) { }
-    fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) { }
+    fn visit_trait_item(&self, _: &'tcx hir::TraitItem) { }
+    fn visit_impl_item(&self, _: &'tcx hir::ImplItem) { }
 }