fix nits

Author: SparrowLii

compiler/rustc_data_structures/src/sharded.rs

@@ -76,11 +76,7 @@ impl<T: Default> Sharded<T> {
     }
 
     #[inline]
-    pub fn with_get_shard_by_hash<F: FnOnce(&mut T) -> R, R>(
-        &self,
-        hash: u64,
-        f: F,
-    ) -> R {
+    pub fn with_get_shard_by_hash<F: FnOnce(&mut T) -> R, R>(&self, hash: u64, f: F) -> R {
         if likely(self.single_thread) {
             let shard = &self.shard;
             assert!(!shard.borrow.replace(true));
@@ -92,6 +88,15 @@ impl<T: Default> Sharded<T> {
         }
     }
 
+    #[inline]
+    pub fn get_shard_by_value<K: Hash + ?Sized>(&self, val: &K) -> &Lock<T> {
+        if likely(self.single_thread) {
+            &self.shard
+        } else {
+            &self.shards[get_shard_index_by_hash(make_hash(val))].0
+        }
+    }
+
     #[inline]
     pub fn get_shard_by_hash(&self, hash: u64) -> &Lock<T> {
         if likely(self.single_thread) {

compiler/rustc_errors/src/lib.rs

@@ -639,12 +639,7 @@ impl Handler {
     ) -> String {
         let inner = self.inner.borrow();
         let args = crate::translation::to_fluent_args(args);
-        inner
-            .emitter
-            .translate_message(&message, &args)
-            .map_err(Report::new)
-            .unwrap()
-            .to_string()
+        inner.emitter.translate_message(&message, &args).map_err(Report::new).unwrap().to_string()
     }
 
     // This is here to not allow mutation of flags;

compiler/rustc_query_system/src/query/plumbing.rs

@@ -13,24 +13,22 @@ use crate::query::SerializedDepNodeIndex;
 use crate::query::{QueryContext, QueryMap, QuerySideEffects, QueryStackFrame};
 use crate::values::Value;
 use crate::HandleCycleError;
+#[cfg(parallel_compiler)]
+use rustc_data_structures::cold_path;
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::fx::FxHashMap;
-use rustc_data_structures::stack::ensure_sufficient_stack;
-use rustc_data_structures::sync::Lock;
-#[cfg(parallel_compiler)]
-use rustc_data_structures::{cold_path, sharded::Sharded};
-use rustc_data_structures::profiling::TimingGuard;
 use rustc_data_structures::sharded::Sharded;
 use rustc_data_structures::stack::ensure_sufficient_stack;
-
 use rustc_data_structures::sync::Lock;
+
 use rustc_errors::{DiagnosticBuilder, ErrorGuaranteed, FatalError};
-use rustc_session::Session;use rustc_span::{Span, DUMMY_SP};
+use rustc_span::{Span, DUMMY_SP};
 use std::cell::Cell;
 use std::collections::hash_map::Entry;
 use std::fmt::Debug;
 use std::hash::Hash;
 use std::mem;
+use std::ops::DerefMut;
 use thin_vec::ThinVec;
 
 use super::QueryConfig;
@@ -226,7 +224,6 @@ where
 
 #[cold]
 #[inline(never)]
-#[cfg(not(parallel_compiler))]
 fn cycle_error<Q, Qcx>(
     query: Q,
     qcx: Qcx,
@@ -296,7 +293,10 @@ where
     Qcx: QueryContext,
 {
     let state = query.query_state(qcx);
-    /*// For the parallel compiler we need to check both the query cache and query state structures
+    let mut state_lock = state.active.get_shard_by_value(&key).lock();
+    let lock = state_lock.deref_mut();
+
+    // For the parallel compiler we need to check both the query cache and query state structures
     // while holding the state lock to ensure that 1) the query has not yet completed and 2) the
     // query is not still executing. Without checking the query cache here, we can end up
     // re-executing the query since `try_start` only checks that the query is not currently
@@ -307,35 +307,44 @@ where
             qcx.dep_context().profiler().query_cache_hit(index.into());
             return (value, Some(index));
         }
-    }*/
-
-    let job = state.active.with_get_shard_by_value(&key, |state_lock| {
-        JobOwner::<'_, Q::Key, Qcx::DepKind>::try_start(&qcx, state, state_lock, span, key)
-    });
-
-    match job {
-        TryGetJob::NotYetStarted(job) => {
-            let (result, dep_node_index) = execute_job(query, qcx, key.clone(), dep_node, job.id);
-            let cache = query.query_cache(qcx);
-            if query.feedable() {
-                // We should not compute queries that also got a value via feeding.
-                // This can't happen, as query feeding adds the very dependencies to the fed query
-                // as its feeding query had. So if the fed query is red, so is its feeder, which will
-                // get evaluated first, and re-feed the query.
-                if let Some((cached_result, _)) = cache.lookup(&key) {
-                    panic!(
-                        "fed query later has its value computed. The already cached value: {cached_result:?}"
-                    );
-
-
+    }
 
+    let current_job_id = qcx.current_query_job();
 
+    match lock.entry(key) {
+        Entry::Vacant(entry) => {
+            // Nothing has computed or is computing the query, so we start a new job and insert it in the
+            // state map.
+            let id = qcx.next_job_id();
+            let job = QueryJob::new(id, span, current_job_id);
+            entry.insert(QueryResult::Started(job));
 
+            // Drop the lock before we start executing the query
+            drop(state_lock);
 
+            execute_job(query, qcx, state, key, id, dep_node)
+        }
+        Entry::Occupied(mut entry) => {
+            match entry.get_mut() {
+                #[cfg(not(parallel_compiler))]
+                QueryResult::Started(job) => {
+                    let id = job.id;
+                    drop(state_lock);
 
+                    // If we are single-threaded we know that we have cycle error,
+                    // so we just return the error.
+                    cycle_error(query, qcx, id, span)
                 }
                 #[cfg(parallel_compiler)]
                 QueryResult::Started(job) => {
+                    if std::intrinsics::likely(!rustc_data_structures::sync::active()) {
+                        let id = job.id;
+                        drop(state_lock);
+
+                        // If we are single-threaded we know that we have cycle error,
+                        // so we just return the error.
+                        return cycle_error(query, qcx, id, span);
+                    }
                     // Get the latch out
                     let latch = job.latch();
                     drop(state_lock);
@@ -345,30 +354,41 @@ where
                 QueryResult::Poisoned => FatalError.raise(),
             }
         }
-        TryGetJob::Cycle(error) => {
-            let result = mk_cycle(qcx, error, query.handle_cycle_error());
-            (result, None)
+    }
+}
+
+#[inline(always)]
+fn execute_job<Q, Qcx>(
+    query: Q,
+    qcx: Qcx,
+    state: &QueryState<Q::Key, Qcx::DepKind>,
+    key: Q::Key,
+    id: QueryJobId,
+    dep_node: Option<DepNode<Qcx::DepKind>>,
+) -> (Q::Value, Option<DepNodeIndex>)
+where
+    Q: QueryConfig<Qcx>,
+    Qcx: QueryContext,
+{
+    // Use `JobOwner` so the query will be poisoned if executing it panics.
+    let job_owner = JobOwner { state, key };
+
+    let (result, dep_node_index) = match qcx.dep_context().dep_graph().data() {
+        None => execute_job_non_incr(query, qcx, key, id),
+        Some(data) => execute_job_incr(query, qcx, data, key, dep_node, id),
+    };
+
+    let cache = query.query_cache(qcx);
+    if query.feedable() {
+        // We should not compute queries that also got a value via feeding.
+        // This can't happen, as query feeding adds the very dependencies to the fed query
+        // as its feeding query had. So if the fed query is red, so is its feeder, which will
+        // get evaluated first, and re-feed the query.
+        if let Some((cached_result, _)) = cache.lookup(&key) {
+            panic!(
+                "fed query later has its value computed. The already cached value: {cached_result:?}"
+            );
         }
-        #[cfg(parallel_compiler)]
-        TryGetJob::JobWait(current_job_id, query_blocked_prof_timer, latch) => {
-            // With parallel queries we might just have to wait on some other
-            // thread.
-            let result = latch.wait_on(current_job_id, span);
-            match result {
-                Ok(()) => {
-                    let Some((v, index)) = query.query_cache(qcx).lookup(&key) else {
-                        panic!("value must be in cache after waiting")
-                    };
-                    qcx.dep_context().profiler().query_cache_hit(index.into());
-                    query_blocked_prof_timer.finish_with_query_invocation_id(index.into());
-
-                    (v, Some(index))
-                }
-                Err(error) => {
-                    let result = mk_cycle(qcx, error, query.handle_cycle_error());
-                    (result, None)
-                }
-            }        }
     }
     job_owner.complete(cache, result, dep_node_index);
 

src/bootstrap/config.rs

@@ -1126,7 +1126,7 @@ impl Config {
             set(&mut config.use_lld, rust.use_lld);
             set(&mut config.lld_enabled, rust.lld);
             set(&mut config.llvm_tools_enabled, rust.llvm_tools);
-            config.rustc_parallel = rust.parallel_compiler.unwrap_or(false);
+            config.rustc_parallel = rust.parallel_compiler.unwrap_or(true);
             config.rustc_default_linker = rust.default_linker;
             config.musl_root = rust.musl_root.map(PathBuf::from);
             config.save_toolstates = rust.save_toolstates.map(PathBuf::from);

src/librustdoc/clean/utils.rs

@@ -470,6 +470,12 @@ pub(crate) fn get_auto_trait_and_blanket_impls(
     cx: &mut DocContext<'_>,
     item_def_id: DefId,
 ) -> impl Iterator<Item = Item> {
+    // FIXME: To be removed once `parallel_compiler` bugs are fixed!
+    // More information in <https://github.com/rust-lang/rust/pull/106930>.
+    if cfg!(parallel_compiler) {
+        return vec![].into_iter().chain(vec![].into_iter());
+    }
+
     let auto_impls = cx
         .sess()
         .prof