Merge a07cb22 into 42ca6e4

compiler/rustc_hir_analysis/src/check/check.rs

@@ -1447,9 +1447,7 @@ pub(super) fn check_type_params_are_used<'tcx>(
 
 pub(super) fn check_mod_item_types(tcx: TyCtxt<'_>, module_def_id: LocalModDefId) {
     let module = tcx.hir_module_items(module_def_id);
-    for id in module.items() {
-        check_item_type(tcx, id);
-    }
+    module.par_items(|id| check_item_type(tcx, id));
     if module_def_id == LocalModDefId::CRATE_DEF_ID {
         super::entry::check_for_entry_fn(tcx);
     }

compiler/rustc_hir_analysis/src/collect.rs

@@ -50,7 +50,7 @@ mod type_of;
 // Main entry point
 
 fn collect_mod_item_types(tcx: TyCtxt<'_>, module_def_id: LocalModDefId) {
-    tcx.hir().visit_item_likes_in_module(module_def_id, &mut CollectItemTypesVisitor { tcx });
+    tcx.hir().par_visit_item_likes_in_module(module_def_id, || CollectItemTypesVisitor { tcx });
 }
 
 pub fn provide(providers: &mut Providers) {

compiler/rustc_hir_analysis/src/lib.rs

@@ -95,6 +95,7 @@ mod outlives;
 pub mod structured_errors;
 mod variance;
 
+use rustc_data_structures::sync::{join, par_for_each_in};
 use rustc_errors::ErrorGuaranteed;
 use rustc_errors::{DiagnosticMessage, SubdiagnosticMessage};
 use rustc_fluent_macro::fluent_messages;
@@ -168,7 +169,11 @@ pub fn check_crate(tcx: TyCtxt<'_>) -> Result<(), ErrorGuaranteed> {
     // FIXME(matthewjasper) We shouldn't need to use `track_errors`.
     tcx.sess.track_errors(|| {
         tcx.sess.time("type_collecting", || {
-            tcx.hir().for_each_module(|module| tcx.ensure().collect_mod_item_types(module))
+            // Run dependencies of type collecting before entering the loop
+            tcx.ensure_with_value().inferred_outlives_crate(());
+
+            let _prof_timer = tcx.sess.timer("type_collecting_loop");
+            tcx.hir().par_for_each_module(|module| tcx.ensure().collect_mod_item_types(module));
         });
     })?;
 
@@ -186,9 +191,9 @@ pub fn check_crate(tcx: TyCtxt<'_>) -> Result<(), ErrorGuaranteed> {
 
     tcx.sess.track_errors(|| {
         tcx.sess.time("coherence_checking", || {
-            for &trait_def_id in tcx.all_local_trait_impls(()).keys() {
-                tcx.ensure().coherent_trait(trait_def_id);
-            }
+            par_for_each_in(tcx.all_local_trait_impls(()), |(trait_def_id, _)| {
+                tcx.ensure().coherent_trait(*trait_def_id);
+            });
 
             // these queries are executed for side-effects (error reporting):
             tcx.ensure().crate_inherent_impls(());
@@ -208,26 +213,33 @@ pub fn check_crate(tcx: TyCtxt<'_>) -> Result<(), ErrorGuaranteed> {
         });
     })?;
 
-    // NOTE: This is copy/pasted in librustdoc/core.rs and should be kept in sync.
-    tcx.sess.time("item_types_checking", || {
-        tcx.hir().for_each_module(|module| tcx.ensure().check_mod_item_types(module))
+    tcx.sess.time("item_types_and_item_bodies_checking", || {
+        join(
+            || {
+                // NOTE: This is copy/pasted in librustdoc/core.rs and should be kept in sync.
+                tcx.sess.time("item_types_checking", || {
+                    tcx.hir()
+                        .par_for_each_module(|module| tcx.ensure().check_mod_item_types(module))
+                });
+            },
+            || {
+                // FIXME: Remove this when we implement creating `DefId`s
+                // for anon constants during their parents' typeck.
+                // Typeck all body owners in parallel will produce queries
+                // cycle errors because it may typeck on anon constants directly.
+                tcx.hir().par_body_owners(|item_def_id| {
+                    let def_kind = tcx.def_kind(item_def_id);
+                    if !matches!(def_kind, DefKind::AnonConst) {
+                        tcx.ensure().typeck(item_def_id);
+                    }
+                });
+            },
+        )
     });
 
     // Freeze definitions as we don't add new ones at this point. This improves performance by
     // allowing lock-free access to them.
     tcx.untracked().definitions.freeze();
-
-    // FIXME: Remove this when we implement creating `DefId`s
-    // for anon constants during their parents' typeck.
-    // Typeck all body owners in parallel will produce queries
-    // cycle errors because it may typeck on anon constants directly.
-    tcx.hir().par_body_owners(|item_def_id| {
-        let def_kind = tcx.def_kind(item_def_id);
-        if !matches!(def_kind, DefKind::AnonConst) {
-            tcx.ensure().typeck(item_def_id);
-        }
-    });
-
     tcx.ensure().check_unused_traits(());
 
     if let Some(reported) = tcx.sess.has_errors() { Err(reported) } else { Ok(()) }

compiler/rustc_interface/src/passes.rs

@@ -747,14 +747,28 @@ fn analysis(tcx: TyCtxt<'_>, (): ()) -> Result<()> {
                 CStore::from_tcx(tcx).report_unused_deps(tcx);
             },
             {
+                // Prefetch this as it is used later by the loop below
+                // to prevent multiple threads from blocking on it.
+                tcx.ensure_with_value().get_lang_items(());
+
+                let _timer = tcx.sess.timer("misc_module_passes");
                 tcx.hir().par_for_each_module(|module| {
                     tcx.ensure().check_mod_loops(module);
                     tcx.ensure().check_mod_attrs(module);
                     tcx.ensure().check_mod_naked_functions(module);
-                    tcx.ensure().check_mod_unstable_api_usage(module);
                     tcx.ensure().check_mod_const_bodies(module);
                 });
             },
+            {
+                // Prefetch this as it is used later by the loop below
+                // to prevent multiple threads from blocking on it.
+                tcx.ensure_with_value().stability_index(());
+
+                let _timer = tcx.sess.timer("check_unstable_api_usage");
+                tcx.hir().par_for_each_module(|module| {
+                    tcx.ensure().check_mod_unstable_api_usage(module);
+                });
+            },
             {
                 sess.time("unused_lib_feature_checking", || {
                     rustc_passes::stability::check_unused_or_stable_features(tcx)
@@ -774,28 +788,44 @@ fn analysis(tcx: TyCtxt<'_>, (): ()) -> Result<()> {
     // passes are timed inside typeck
     rustc_hir_analysis::check_crate(tcx)?;
 
-    sess.time("MIR_borrow_checking", || {
-        tcx.hir().par_body_owners(|def_id| tcx.ensure().mir_borrowck(def_id));
-    });
-
-    sess.time("MIR_effect_checking", || {
-        for def_id in tcx.hir().body_owners() {
-            tcx.ensure().thir_check_unsafety(def_id);
-            if !tcx.sess.opts.unstable_opts.thir_unsafeck {
-                rustc_mir_transform::check_unsafety::check_unsafety(tcx, def_id);
-            }
-            tcx.ensure().has_ffi_unwind_calls(def_id);
-
-            // If we need to codegen, ensure that we emit all errors from
-            // `mir_drops_elaborated_and_const_checked` now, to avoid discovering
-            // them later during codegen.
-            if tcx.sess.opts.output_types.should_codegen()
-                || tcx.hir().body_const_context(def_id).is_some()
+    sess.time("misc_checking_2", || {
+        parallel!(
+            {
+                // Prefetch this as it is used later by lint checking and privacy checking.
+                tcx.ensure_with_value().effective_visibilities(());
+            },
+            {
+                sess.time("MIR_borrow_checking", || {
+                    tcx.hir().par_body_owners(|def_id| tcx.ensure().mir_borrowck(def_id));
+                });
+            },
             {
-                tcx.ensure().mir_drops_elaborated_and_const_checked(def_id);
-                tcx.ensure().unused_generic_params(ty::InstanceDef::Item(def_id.to_def_id()));
+                sess.time("MIR_effect_checking", || {
+                    for def_id in tcx.hir().body_owners() {
+                        tcx.ensure().thir_check_unsafety(def_id);
+                        if !tcx.sess.opts.unstable_opts.thir_unsafeck {
+                            rustc_mir_transform::check_unsafety::check_unsafety(tcx, def_id);
+                        }
+                        tcx.ensure().has_ffi_unwind_calls(def_id);
+
+                        // If we need to codegen, ensure that we emit all errors from
+                        // `mir_drops_elaborated_and_const_checked` now, to avoid discovering
+                        // them later during codegen.
+                        if tcx.sess.opts.output_types.should_codegen()
+                            || tcx.hir().body_const_context(def_id).is_some()
+                        {
+                            tcx.ensure().mir_drops_elaborated_and_const_checked(def_id);
+                            tcx.ensure()
+                                .unused_generic_params(ty::InstanceDef::Item(def_id.to_def_id()));
+                        }
+                    }
+                });
+            },
+            {
+                sess.time("layout_testing", || layout_test::test_layout(tcx));
+                sess.time("abi_testing", || abi_test::test_abi(tcx));
             }
-        }
+        )
     });
 
     tcx.hir().par_body_owners(|def_id| {
@@ -805,9 +835,6 @@ fn analysis(tcx: TyCtxt<'_>, (): ()) -> Result<()> {
         }
     });
 
-    sess.time("layout_testing", || layout_test::test_layout(tcx));
-    sess.time("abi_testing", || abi_test::test_abi(tcx));
-
     // Avoid overwhelming user with errors if borrow checking failed.
     // I'm not sure how helpful this is, to be honest, but it avoids a
     // lot of annoying errors in the ui tests (basically,
@@ -820,25 +847,18 @@ fn analysis(tcx: TyCtxt<'_>, (): ()) -> Result<()> {
     sess.time("misc_checking_3", || {
         parallel!(
             {
-                tcx.ensure().effective_visibilities(());
-
-                parallel!(
-                    {
-                        tcx.ensure().check_private_in_public(());
-                    },
-                    {
-                        tcx.hir()
-                            .par_for_each_module(|module| tcx.ensure().check_mod_deathness(module));
-                    },
-                    {
-                        sess.time("lint_checking", || {
-                            rustc_lint::check_crate(tcx);
-                        });
-                    },
-                    {
-                        tcx.ensure().clashing_extern_declarations(());
-                    }
-                );
+                tcx.ensure().check_private_in_public(());
+            },
+            {
+                tcx.hir().par_for_each_module(|module| tcx.ensure().check_mod_deathness(module));
+            },
+            {
+                sess.time("lint_checking", || {
+                    rustc_lint::check_crate(tcx);
+                });
+            },
+            {
+                tcx.ensure().clashing_extern_declarations(());
             },
             {
                 sess.time("privacy_checking_modules", || {

compiler/rustc_middle/src/hir/map/mod.rs

@@ -619,6 +619,34 @@ impl<'hir> Map<'hir> {
         }
     }
 
+    /// A parallel version of `visit_item_likes_in_module`.
+    pub fn par_visit_item_likes_in_module<V>(
+        &self,
+        module: LocalModDefId,
+        make_visitor: impl Fn() -> V + DynSync,
+    ) where
+        V: Visitor<'hir>,
+    {
+        let module = self.tcx.hir_module_items(module);
+
+        parallel!(
+            {
+                module.par_items(|id| make_visitor().visit_item(self.item(id)));
+            },
+            {
+                module.par_trait_items(|id| make_visitor().visit_trait_item(self.trait_item(id)));
+            },
+            {
+                module.par_impl_items(|id| make_visitor().visit_impl_item(self.impl_item(id)));
+            },
+            {
+                module.par_foreign_items(|id| {
+                    make_visitor().visit_foreign_item(self.foreign_item(id))
+                });
+            }
+        );
+    }
+
     pub fn for_each_module(self, mut f: impl FnMut(LocalModDefId)) {
         let crate_items = self.tcx.hir_crate_items(());
         for module in crate_items.submodules.iter() {

compiler/rustc_monomorphize/src/collector.rs

@@ -165,7 +165,7 @@
 //! regardless of whether it is actually needed or not.
 
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_data_structures::sync::{par_for_each_in, MTLock, MTLockRef};
+use rustc_data_structures::sync::{join, par_for_each_in, MTLock, MTLockRef};
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, DefIdMap, LocalDefId};
@@ -258,8 +258,19 @@ pub fn collect_crate_mono_items(
 ) -> (FxHashSet<MonoItem<'_>>, UsageMap<'_>) {
     let _prof_timer = tcx.prof.generic_activity("monomorphization_collector");
 
-    let roots =
-        tcx.sess.time("monomorphization_collector_root_collections", || collect_roots(tcx, mode));
+    let (roots, _) = join(
+        || {
+            tcx.sess
+                .time("monomorphization_collector_root_collections", || collect_roots(tcx, mode))
+        },
+        || {
+            if tcx.sess.opts.share_generics() {
+                // Prefetch upstream_monomorphizations as it's very likely to be used in
+                // code generation later and this is decent spot to compute it.
+                tcx.ensure().upstream_monomorphizations(());
+            }
+        },
+    );
 
     debug!("building mono item graph, beginning at roots");
 

tests/ui/associated-inherent-types/bugs/cycle-iat-inside-of-adt.stderr

@@ -1,42 +1,32 @@
-error[E0391]: cycle detected when computing predicates of `Foo`
+error[E0391]: cycle detected when computing the inferred outlives predicates for items in this crate
+   |
+note: ...which requires computing type of `Foo::bar`...
+  --> $DIR/cycle-iat-inside-of-adt.rs:8:5
+   |
+LL |     bar: Self::Bar,
+   |     ^^^^^^^^^^^^^^
+note: ...which requires computing normalized predicates of `Foo`...
   --> $DIR/cycle-iat-inside-of-adt.rs:7:1
    |
 LL | struct Foo {
    | ^^^^^^^^^^
-   |
 note: ...which requires computing predicates of `Foo`...
   --> $DIR/cycle-iat-inside-of-adt.rs:7:1
    |
 LL | struct Foo {
    | ^^^^^^^^^^
-note: ...which requires computing inferred outlives predicates of `Foo`...
+note: ...which requires computing predicates of `Foo`...
   --> $DIR/cycle-iat-inside-of-adt.rs:7:1
    |
 LL | struct Foo {
    | ^^^^^^^^^^
-   = note: ...which requires computing the inferred outlives predicates for items in this crate...
-note: ...which requires computing type of `Foo::bar`...
-  --> $DIR/cycle-iat-inside-of-adt.rs:8:5
-   |
-LL |     bar: Self::Bar,
-   |     ^^^^^^^^^^^^^^
-note: ...which requires computing normalized predicates of `Foo`...
+note: ...which requires computing inferred outlives predicates of `Foo`...
   --> $DIR/cycle-iat-inside-of-adt.rs:7:1
    |
 LL | struct Foo {
    | ^^^^^^^^^^
-   = note: ...which again requires computing predicates of `Foo`, completing the cycle
-note: cycle used when collecting item types in top-level module
-  --> $DIR/cycle-iat-inside-of-adt.rs:3:1
-   |
-LL | / #![feature(inherent_associated_types)]
-LL | | #![allow(incomplete_features)]
-LL | | // FIXME(inherent_associated_types): This should pass.
-LL | |
-...  |
-LL | |
-LL | | fn main() {}
-   | |____________^
+   = note: ...which again requires computing the inferred outlives predicates for items in this crate, completing the cycle
+   = note: cycle used when running analysis passes on this crate
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
 error: aborting due to previous error