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

@@ -758,6 +758,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,8 +467,7 @@ 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 });
 }
 
 /// Check whether an item marked with `deprecated(since="X")` is currently
@@ -494,6 +494,7 @@ pub fn deprecation_in_effect(since: &str) -> bool {
     }
 }
 
+#[derive(Clone)]
 struct Checker<'a, 'tcx: 'a> {
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
 }
@@ -807,7 +808,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 = tcx.features().declared_lib_features;

src/librustc/traits/mod.rs

@@ -32,7 +32,6 @@ use infer::{InferCtxt};
 
 use rustc_data_structures::sync::Lrc;
 use std::fmt::Debug;
-use std::rc::Rc;
 use syntax::ast;
 use syntax_pos::{Span, DUMMY_SP};
 
@@ -261,7 +260,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

@@ -44,13 +44,12 @@ use ty::relate::TypeRelation;
 use middle::lang_items;
 use mir::interpret::{GlobalId};
 
-use rustc_data_structures::sync::Lock;
+use rustc_data_structures::sync::{Lrc, Lock};
 use rustc_data_structures::bitvec::BitVector;
 use std::iter;
 use std::cmp;
 use std::fmt;
 use std::mem;
-use std::rc::Rc;
 use rustc_target::spec::abi::Abi;
 use hir;
 use util::nodemap::{FxHashMap, FxHashSet};
@@ -3406,7 +3405,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

@@ -16,7 +16,7 @@ use ty::fold::{TypeFoldable, TypeFolder, TypeVisitor};
 use ty::{self, Lift, TyCtxt};
 
 use std::fmt;
-use std::rc::Rc;
+use rustc_data_structures::sync::Lrc;
 
 // structural impls for the structs in traits
 
@@ -246,7 +246,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

@@ -22,6 +22,7 @@ use rustc_data_structures::sync::Lrc;
 use mir::interpret;
 
 use std::rc::Rc;
+use std::sync::Arc;
 
 ///////////////////////////////////////////////////////////////////////////
 // Atomic structs
@@ -699,6 +700,16 @@ EnumTypeFoldableImpl! {
     } where T: TypeFoldable<'tcx>
 }
 
+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_codegen_llvm/lib.rs

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

src/librustc_codegen_utils/symbol_names_test.rs

@@ -33,10 +33,12 @@ pub fn report_symbol_names<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
 
     tcx.dep_graph.with_ignore(|| {
         let mut visitor = SymbolNamesTest { tcx: tcx };
+        // FIXME: Try parallel version
         tcx.hir.krate().visit_all_item_likes(&mut visitor);
     })
 }
 
+#[derive(Clone)]
 struct SymbolNamesTest<'a, 'tcx:'a> {
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
 }

src/librustc_mir/hair/pattern/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_passes/lib.rs

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

src/librustc_passes/rvalue_promotion.rs

@@ -51,10 +51,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_typeck/check/mod.rs

@@ -682,8 +682,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

@@ -727,6 +727,7 @@ fn check_false_global_bounds<'a, 'gcx, 'tcx>(
     fcx.select_all_obligations_or_error();
 }
 
+#[derive(Clone)]
 pub struct CheckTypeWellFormedVisitor<'a, 'tcx: 'a> {
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
 }

src/librustc_typeck/collect.rs

@@ -50,16 +50,14 @@ use syntax_pos::{Span, DUMMY_SP};
 
 use rustc::hir::{self, map as hir_map, CodegenFnAttrs, CodegenFnAttrFlags, Unsafety};
 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, LOCAL_CRATE};
 
 ///////////////////////////////////////////////////////////////////////////
 // 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) {
@@ -104,14 +102,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,21 +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"
@@ -40,6 +38,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) { }
 }