Rename things

Author: Zoxc

compiler/rustc_query_impl/src/job.rs

@@ -117,7 +117,10 @@ pub(crate) fn find_dep_kind_root<'tcx>(
 /// We'll use this to remove the waiter using `QueryLatch::extract_waiter` if we're waking it up.
 type ResumableWaiterLocation = (QueryJobId, usize);
 
-struct Waiter {
+/// This abstracts over non-resumable waiters which are found in `QueryJob`'s `parent` field
+/// and resumable waiters are in `latch` field.
+struct AbstractedWaiter {
+    /// The span corresponding to the reason for why we're waiting on this query.
     span: Span,
     /// The query which we are waiting from, if none the waiter is from a compiler root.
     parent: Option<QueryJobId>,
@@ -126,11 +129,11 @@ struct Waiter {
 
 /// Returns all the non-resumable and resumable waiters of a query.
 /// This is used so we can uniformly loop over both non-resumable and resumable waiters.
-fn waiters_of(job_map: &QueryJobMap<'_>, query: QueryJobId) -> Vec<Waiter> {
+fn abstracted_waiters_of(job_map: &QueryJobMap<'_>, query: QueryJobId) -> Vec<AbstractedWaiter> {
     let mut result = Vec::new();
 
     // Add the parent which is a non-resumable waiter since it's on the same stack
-    result.push(Waiter {
+    result.push(AbstractedWaiter {
         span: job_map.span_of(query),
         parent: job_map.parent_of(query),
         resumable: None,
@@ -139,7 +142,7 @@ fn waiters_of(job_map: &QueryJobMap<'_>, query: QueryJobId) -> Vec<Waiter> {
     // Add the explicit waiters which use condvars and are resumable
     if let Some(latch) = job_map.latch_of(query) {
         for (i, waiter) in latch.waiters.lock().as_ref().unwrap().iter().enumerate() {
-            result.push(Waiter {
+            result.push(AbstractedWaiter {
                 span: waiter.span,
                 parent: waiter.parent,
                 resumable: Some((query, i)),
@@ -162,11 +165,11 @@ fn cycle_check<'tcx>(
     visited: &mut FxHashSet<QueryJobId>,
 ) -> ControlFlow<Option<ResumableWaiterLocation>> {
     if !visited.insert(query) {
-        return if let Some(p) = stack.iter().position(|q| q.1 == query) {
+        return if let Some(pos) = stack.iter().position(|q| q.1 == query) {
             // We detected a query cycle, fix up the initial span and return Some
 
             // Remove previous stack entries
-            stack.drain(0..p);
+            stack.drain(0..pos);
             // Replace the span for the first query with the cycle cause
             stack[0].0 = span;
             ControlFlow::Break(None)
@@ -179,16 +182,16 @@ fn cycle_check<'tcx>(
     stack.push((span, query));
 
     // Visit all the waiters
-    for waiter in waiters_of(job_map, query) {
-        let Some(waiter_query) = waiter.parent else {
+    for abstracted_waiter in abstracted_waiters_of(job_map, query) {
+        let Some(parent) = abstracted_waiter.parent else {
             // Skip waiters which are not queries
             continue;
         };
-        if let ControlFlow::Break(maybe_waiter) =
-            cycle_check(job_map, waiter_query, waiter.span, stack, visited)
+        if let ControlFlow::Break(maybe_resumable) =
+            cycle_check(job_map, parent, abstracted_waiter.span, stack, visited)
         {
             // Return the resumable waiter in `waiter.resumable` if present
-            return ControlFlow::Break(waiter.resumable.or(maybe_waiter));
+            return ControlFlow::Break(abstracted_waiter.resumable.or(maybe_resumable));
         }
     }
 
@@ -212,12 +215,12 @@ fn connected_to_root<'tcx>(
     }
 
     // Visit all the waiters
-    for waiter in waiters_of(job_map, query) {
-        match waiter.parent {
+    for abstracted_waiter in abstracted_waiters_of(job_map, query) {
+        match abstracted_waiter.parent {
             // This query is connected to the root
             None => return true,
-            Some(waiter) => {
-                if connected_to_root(job_map, waiter, visited) {
+            Some(parent) => {
+                if connected_to_root(job_map, parent, visited) {
                     return true;
                 }
             }
@@ -240,7 +243,7 @@ fn remove_cycle<'tcx>(
     let mut visited = FxHashSet::default();
     let mut stack = Vec::new();
     // Look for a cycle starting with the last query in `jobs`
-    if let ControlFlow::Break(waiter) =
+    if let ControlFlow::Break(resumable) =
         cycle_check(job_map, jobs.pop().unwrap(), DUMMY_SP, &mut stack, &mut visited)
     {
         // The stack is a vector of pairs of spans and queries; reverse it so that
@@ -262,7 +265,7 @@ fn remove_cycle<'tcx>(
 
         struct EntryPoint {
             query_in_cycle: QueryJobId,
-            waiter: Option<(Span, QueryJobId)>,
+            query_waiting_on_cycle: Option<(Span, QueryJobId)>,
         }
 
         // Find the queries in the cycle which are
@@ -271,11 +274,11 @@ fn remove_cycle<'tcx>(
             .iter()
             .filter_map(|&(_, query_in_cycle)| {
                 let mut entrypoint = false;
-                let mut found_waiter = None;
+                let mut query_waiting_on_cycle = None;
 
                 // Find a direct waiter who leads to the root
-                for waiter in waiters_of(job_map, query_in_cycle) {
-                    let Some(waiter_query) = waiter.parent else {
+                for abstracted_waiter in abstracted_waiters_of(job_map, query_in_cycle) {
+                    let Some(parent) = abstracted_waiter.parent else {
                         // The query in the cycle is directly connected to root.
                         entrypoint = true;
                         continue;
@@ -285,21 +288,21 @@ fn remove_cycle<'tcx>(
                     // so paths to the root through the cycle itself won't count.
                     let mut visited = FxHashSet::from_iter(stack.iter().map(|q| q.1));
 
-                    if connected_to_root(job_map, waiter_query, &mut visited) {
-                        found_waiter = Some((waiter.span, waiter_query));
+                    if connected_to_root(job_map, parent, &mut visited) {
+                        query_waiting_on_cycle = Some((abstracted_waiter.span, parent));
                         entrypoint = true;
                         break;
                     }
                 }
 
-                entrypoint.then_some(EntryPoint { query_in_cycle, waiter: found_waiter })
+                entrypoint.then_some(EntryPoint { query_in_cycle, query_waiting_on_cycle })
             })
             .collect::<Vec<EntryPoint>>();
 
         // Pick an entry point, preferring ones with waiters
         let entry_point = entry_points
             .iter()
-            .find(|entry_point| entry_point.waiter.is_some())
+            .find(|entry_point| entry_point.query_waiting_on_cycle.is_some())
             .unwrap_or(&entry_points[0]);
 
         // Shift the stack so that our entry point is first
@@ -309,7 +312,9 @@ fn remove_cycle<'tcx>(
             stack.rotate_left(pos);
         }
 
-        let usage = entry_point.waiter.map(|(span, job)| (span, job_map.frame_of(job).clone()));
+        let usage = entry_point
+            .query_waiting_on_cycle
+            .map(|(span, job)| (span, job_map.frame_of(job).clone()));
 
         // Create the cycle error
         let error = CycleError {
@@ -320,9 +325,9 @@ fn remove_cycle<'tcx>(
                 .collect(),
         };
 
-        // We unwrap `waiter` here since there must always be one
+        // We unwrap `resumable` here since there must always be one
         // edge which is resumable / waited using a query latch
-        let (waitee_query, waiter_idx) = waiter.unwrap();
+        let (waitee_query, waiter_idx) = resumable.unwrap();
 
         // Extract the waiter we want to resume
         let waiter = job_map.latch_of(waitee_query).unwrap().extract_waiter(waiter_idx);