Resolver: Parallelize the import resolution loop

compiler/rustc_data_structures/src/sync.rs

@@ -38,7 +38,7 @@ pub use self::mode::{
     FromDyn, check_dyn_thread_safe, is_dyn_thread_safe, set_dyn_thread_safe_mode,
 };
 pub use self::parallel::{
-    broadcast, par_fns, par_for_each_in, par_join, par_map, parallel_guard, spawn,
+    broadcast, par_filter_map, par_fns, par_for_each_in, par_join, par_map, parallel_guard, spawn,
     try_par_for_each_in,
 };
 pub use self::vec::{AppendOnlyIndexVec, AppendOnlyVec};
@@ -189,6 +189,7 @@ impl<T> RwLock<T> {
     }
 
     #[inline(always)]
+    #[track_caller]
     pub fn read(&self) -> ReadGuard<'_, T> {
         if ERROR_CHECKING {
             self.0.try_read().expect("lock was already held")
@@ -203,6 +204,7 @@ impl<T> RwLock<T> {
     }
 
     #[inline(always)]
+    #[track_caller]
     pub fn write(&self) -> WriteGuard<'_, T> {
         if ERROR_CHECKING {
             self.0.try_write().expect("lock was already held")

compiler/rustc_data_structures/src/sync/parallel.rs

@@ -247,6 +247,33 @@ pub fn par_map<I: DynSend, T: IntoIterator<Item = I>, R: DynSend, C: FromIterato
     })
 }
 
+pub fn par_filter_map<I: DynSend, T: IntoIterator<Item = I>, R: DynSend, C: FromIterator<R>>(
+    t: T,
+    map: impl Fn(I) -> Option<R> + DynSync + DynSend,
+) -> C {
+    parallel_guard(|guard| {
+        if let Some(proof) = mode::check_dyn_thread_safe() {
+            let map = proof.derive(map);
+
+            let mut items: Vec<(Option<I>, Option<Option<R>>)> =
+                t.into_iter().map(|i| (Some(i), None)).collect();
+
+            par_slice(
+                &mut items,
+                guard,
+                |i| {
+                    i.1 = Some(map(i.0.take().unwrap()));
+                },
+                proof,
+            );
+
+            items.into_iter().filter_map(|(_, r)| r.flatten()).collect()
+        } else {
+            t.into_iter().filter_map(|i| guard.run(|| map(i)).flatten()).collect()
+        }
+    })
+}
+
 pub fn broadcast<R: DynSend>(op: impl Fn(usize) -> R + DynSync) -> Vec<R> {
     if let Some(proof) = mode::check_dyn_thread_safe() {
         let op = proof.derive(op);

compiler/rustc_interface/src/passes.rs

@@ -791,7 +791,8 @@ fn resolver_for_lowering_raw<'tcx>(
     &'tcx Steal<ast::Crate>,
     &'tcx ty::ResolverGlobalCtxt,
 ) {
-    let arenas = Resolver::arenas();
+    let arenas = Resolver::new_arenas();
+    let extern_arenas = Resolver::new_arenas();
     let _ = tcx.registered_tools(()); // Uses `crate_for_resolver`.
     let (krate, pre_configured_attrs) = tcx.crate_for_resolver(()).steal();
     let mut resolver = Resolver::new(
@@ -800,6 +801,7 @@ fn resolver_for_lowering_raw<'tcx>(
         krate.spans.inner_span,
         krate.spans.inject_use_span,
         &arenas,
+        &extern_arenas,
     );
     let krate = configure_and_expand(krate, &pre_configured_attrs, &mut resolver);