Remove QueryInfo.

`CycleError` has one field containing a `(Span, QueryStackFrame<I>)` and
another field containing a `QueryInfo`, which is a struct containing
just a `Span` and a `QueryStackFrame<I>`.

We already have the `Spanned` type for adding a span to something. This
commit uses it for both fields in `CycleError`, removing the need for
`QueryInfo`. Which is good for the following reasons.
- Any type with `Info` in the name is suspect, IMO.
- `QueryInfo` can no longer be confused with the similar `QueryJobInfo`.
- The doc comment on `QueryInfo` was wrong; it didn't contain a query
  key.

Author: nnethercote

compiler/rustc_middle/src/query/job.rs

@@ -7,23 +7,9 @@ use parking_lot::{Condvar, Mutex};
 use rustc_span::Span;
 
 use crate::query::plumbing::CycleError;
-use crate::query::stack::{QueryStackDeferred, QueryStackFrame, QueryStackFrameExtra};
+use crate::query::stack::QueryStackDeferred;
 use crate::ty::TyCtxt;
 
-/// Represents a span and a query key.
-#[derive(Clone, Debug)]
-pub struct QueryInfo<I> {
-    /// The span corresponding to the reason for which this query was required.
-    pub span: Span,
-    pub frame: QueryStackFrame<I>,
-}
-
-impl<'tcx> QueryInfo<QueryStackDeferred<'tcx>> {
-    pub(crate) fn lift(&self) -> QueryInfo<QueryStackFrameExtra> {
-        QueryInfo { span: self.span, frame: self.frame.lift() }
-    }
-}
-
 /// A value uniquely identifying an active query job.
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
 pub struct QueryJobId(pub NonZero<u64>);

compiler/rustc_middle/src/query/mod.rs

@@ -1,7 +1,7 @@
 use rustc_hir::def_id::LocalDefId;
 
 pub use self::caches::{DefIdCache, DefaultCache, QueryCache, SingleCache, VecCache};
-pub use self::job::{QueryInfo, QueryJob, QueryJobId, QueryLatch, QueryWaiter};
+pub use self::job::{QueryJob, QueryJobId, QueryLatch, QueryWaiter};
 pub use self::keys::{AsLocalQueryKey, LocalCrate, QueryKey};
 pub use self::plumbing::{
     ActiveKeyStatus, CycleError, CycleErrorHandling, EnsureMode, IntoQueryParam, QueryMode,

compiler/rustc_middle/src/query/plumbing.rs

@@ -8,6 +8,7 @@ use rustc_data_structures::sync::{AtomicU64, WorkerLocal};
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::hir_id::OwnerId;
 use rustc_macros::HashStable;
+use rustc_span::source_map::{Spanned, respan};
 use rustc_span::{ErrorGuaranteed, Span};
 pub use sealed::IntoQueryParam;
 
@@ -16,7 +17,7 @@ use crate::ich::StableHashingContext;
 use crate::queries::{ExternProviders, Providers, QueryArenas, QueryVTables};
 use crate::query::on_disk_cache::OnDiskCache;
 use crate::query::stack::{QueryStackDeferred, QueryStackFrame, QueryStackFrameExtra};
-use crate::query::{QueryCache, QueryInfo, QueryJob};
+use crate::query::{QueryCache, QueryJob};
 use crate::ty::TyCtxt;
 
 /// For a particular query, keeps track of "active" keys, i.e. keys whose
@@ -64,15 +65,15 @@ pub enum CycleErrorHandling {
 #[derive(Clone, Debug)]
 pub struct CycleError<I = QueryStackFrameExtra> {
     /// The query and related span that uses the cycle.
-    pub usage: Option<(Span, QueryStackFrame<I>)>,
-    pub cycle: Vec<QueryInfo<I>>,
+    pub usage: Option<Spanned<QueryStackFrame<I>>>,
+    pub cycle: Vec<Spanned<QueryStackFrame<I>>>,
 }
 
 impl<'tcx> CycleError<QueryStackDeferred<'tcx>> {
     pub fn lift(&self) -> CycleError<QueryStackFrameExtra> {
         CycleError {
-            usage: self.usage.as_ref().map(|(span, frame)| (*span, frame.lift())),
-            cycle: self.cycle.iter().map(|info| info.lift()).collect(),
+            usage: self.usage.as_ref().map(|usage| respan(usage.span, usage.node.lift())),
+            cycle: self.cycle.iter().map(|frame| respan(frame.span, frame.node.lift())).collect(),
         }
     }
 }

compiler/rustc_query_impl/src/execution.rs

@@ -112,7 +112,7 @@ fn mk_cycle<'tcx, C: QueryCache>(
         }
         CycleErrorHandling::Stash => {
             let guar = if let Some(root) = cycle_error.cycle.first()
-                && let Some(span) = root.frame.info.span
+                && let Some(span) = root.node.info.span
             {
                 error.stash(span, StashKey::Cycle).unwrap()
             } else {

compiler/rustc_query_impl/src/from_cycle_error.rs

@@ -60,9 +60,9 @@ impl<'tcx> FromCycleError<'tcx> for ty::Binder<'_, ty::FnSig<'_>> {
     fn from_cycle_error(tcx: TyCtxt<'tcx>, cycle_error: CycleError, guar: ErrorGuaranteed) -> Self {
         let err = Ty::new_error(tcx, guar);
 
-        let arity = if let Some(info) = cycle_error.cycle.get(0)
-            && info.frame.dep_kind == DepKind::fn_sig
-            && let Some(def_id) = info.frame.def_id
+        let arity = if let Some(frame) = cycle_error.cycle.get(0)
+            && frame.node.dep_kind == DepKind::fn_sig
+            && let Some(def_id) = frame.node.def_id
             && let Some(node) = tcx.hir_get_if_local(def_id)
             && let Some(sig) = node.fn_sig()
         {
@@ -94,11 +94,11 @@ impl<'tcx> FromCycleError<'tcx> for Representability {
     ) -> Self {
         let mut item_and_field_ids = Vec::new();
         let mut representable_ids = FxHashSet::default();
-        for info in &cycle_error.cycle {
-            if info.frame.dep_kind == DepKind::check_representability
-                && let Some(field_id) = info.frame.def_id
+        for frame in &cycle_error.cycle {
+            if frame.node.dep_kind == DepKind::check_representability
+                && let Some(field_id) = frame.node.def_id
                 && let Some(field_id) = field_id.as_local()
-                && let Some(DefKind::Field) = info.frame.info.def_kind
+                && let Some(DefKind::Field) = frame.node.info.def_kind
             {
                 let parent_id = tcx.parent(field_id.to_def_id());
                 let item_id = match tcx.def_kind(parent_id) {
@@ -108,9 +108,9 @@ impl<'tcx> FromCycleError<'tcx> for Representability {
                 item_and_field_ids.push((item_id.expect_local(), field_id));
             }
         }
-        for info in &cycle_error.cycle {
-            if info.frame.dep_kind == DepKind::check_representability_adt_ty
-                && let Some(def_id) = info.frame.def_id_for_ty_in_cycle
+        for frame in &cycle_error.cycle {
+            if frame.node.dep_kind == DepKind::check_representability_adt_ty
+                && let Some(def_id) = frame.node.def_id_for_ty_in_cycle
                 && let Some(def_id) = def_id.as_local()
                 && !item_and_field_ids.iter().any(|&(id, _)| id == def_id)
             {
@@ -145,9 +145,9 @@ impl<'tcx> FromCycleError<'tcx> for &[ty::Variance] {
         search_for_cycle_permutation(
             &cycle_error.cycle,
             |cycle| {
-                if let Some(info) = cycle.get(0)
-                    && info.frame.dep_kind == DepKind::variances_of
-                    && let Some(def_id) = info.frame.def_id
+                if let Some(frame) = cycle.get(0)
+                    && frame.node.dep_kind == DepKind::variances_of
+                    && let Some(def_id) = frame.node.def_id
                 {
                     let n = tcx.generics_of(def_id).own_params.len();
                     ControlFlow::Break(vec![ty::Bivariant; n].leak())
@@ -157,7 +157,7 @@ impl<'tcx> FromCycleError<'tcx> for &[ty::Variance] {
             },
             || {
                 span_bug!(
-                    cycle_error.usage.as_ref().unwrap().0,
+                    cycle_error.usage.as_ref().unwrap().span,
                     "only `variances_of` returns `&[ty::Variance]`"
                 )
             },
@@ -193,8 +193,8 @@ impl<'tcx, T> FromCycleError<'tcx> for Result<T, &'_ ty::layout::LayoutError<'_>
         let diag = search_for_cycle_permutation(
             &cycle_error.cycle,
             |cycle| {
-                if cycle[0].frame.dep_kind == DepKind::layout_of
-                    && let Some(def_id) = cycle[0].frame.def_id_for_ty_in_cycle
+                if cycle[0].node.dep_kind == DepKind::layout_of
+                    && let Some(def_id) = cycle[0].node.def_id_for_ty_in_cycle
                     && let Some(def_id) = def_id.as_local()
                     && let def_kind = tcx.def_kind(def_id)
                     && matches!(def_kind, DefKind::Closure)
@@ -217,18 +217,18 @@ impl<'tcx, T> FromCycleError<'tcx> for Result<T, &'_ ty::layout::LayoutError<'_>
                         tcx.def_kind_descr_article(def_kind, def_id.to_def_id()),
                         tcx.def_kind_descr(def_kind, def_id.to_def_id()),
                     );
-                    for (i, info) in cycle.iter().enumerate() {
-                        if info.frame.dep_kind != DepKind::layout_of {
+                    for (i, frame) in cycle.iter().enumerate() {
+                        if frame.node.dep_kind != DepKind::layout_of {
                             continue;
                         }
-                        let Some(frame_def_id) = info.frame.def_id_for_ty_in_cycle else {
+                        let Some(frame_def_id) = frame.node.def_id_for_ty_in_cycle else {
                             continue;
                         };
                         let Some(frame_coroutine_kind) = tcx.coroutine_kind(frame_def_id) else {
                             continue;
                         };
                         let frame_span =
-                            info.frame.info.default_span(cycle[(i + 1) % cycle.len()].span);
+                            frame.node.info.default_span(cycle[(i + 1) % cycle.len()].span);
                         if frame_span.is_dummy() {
                             continue;
                         }

compiler/rustc_query_impl/src/job.rs

@@ -7,11 +7,11 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::{Diag, DiagCtxtHandle};
 use rustc_hir::def::DefKind;
 use rustc_middle::query::{
-    CycleError, QueryInfo, QueryJob, QueryJobId, QueryLatch, QueryStackDeferred, QueryStackFrame,
-    QueryWaiter,
+    CycleError, QueryJob, QueryJobId, QueryLatch, QueryStackDeferred, QueryStackFrame, QueryWaiter,
 };
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
+use rustc_span::source_map::respan;
 use rustc_span::{DUMMY_SP, Span};
 
 use crate::collect_active_jobs_from_all_queries;
@@ -66,7 +66,7 @@ pub(crate) fn find_cycle_in_stack<'tcx>(
 
     while let Some(job) = current_job {
         let info = &job_map.map[&job];
-        cycle.push(QueryInfo { span: info.job.span, frame: info.frame.clone() });
+        cycle.push(respan(info.job.span, info.frame.clone()));
 
         if job == id {
             cycle.reverse();
@@ -79,7 +79,7 @@ pub(crate) fn find_cycle_in_stack<'tcx>(
             // Find out why the cycle itself was used
             let usage = try {
                 let parent = info.job.parent?;
-                (info.job.span, job_map.frame_of(parent).clone())
+                respan(info.job.span, job_map.frame_of(parent).clone())
             };
             return CycleError { usage, cycle };
         }
@@ -291,14 +291,15 @@ 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.waiter.map(|(span, job)| respan(span, job_map.frame_of(job).clone()));
 
         // Create the cycle error
         let error = CycleError {
             usage,
             cycle: stack
                 .iter()
-                .map(|&(span, job)| QueryInfo { span, frame: job_map.frame_of(job).clone() })
+                .map(|&(span, job)| respan(span, job_map.frame_of(job).clone()))
                 .collect(),
         };
 
@@ -433,37 +434,37 @@ pub(crate) fn report_cycle<'a>(
 ) -> Diag<'a> {
     assert!(!stack.is_empty());
 
-    let span = stack[0].frame.info.default_span(stack[1 % stack.len()].span);
+    let span = stack[0].node.info.default_span(stack[1 % stack.len()].span);
 
     let mut cycle_stack = Vec::new();
 
     use crate::error::StackCount;
-    let stack_bottom = stack[0].frame.info.description.to_owned();
+    let stack_bottom = stack[0].node.info.description.to_owned();
     let stack_count = if stack.len() == 1 {
         StackCount::Single { stack_bottom: stack_bottom.clone() }
     } else {
         StackCount::Multiple { stack_bottom: stack_bottom.clone() }
     };
 
     for i in 1..stack.len() {
-        let frame = &stack[i].frame;
+        let frame = &stack[i].node;
         let span = frame.info.default_span(stack[(i + 1) % stack.len()].span);
         cycle_stack
             .push(crate::error::CycleStack { span, desc: frame.info.description.to_owned() });
     }
 
     let mut cycle_usage = None;
-    if let Some((span, ref query)) = *usage {
+    if let Some(usage) = usage {
         cycle_usage = Some(crate::error::CycleUsage {
-            span: query.info.default_span(span),
-            usage: query.info.description.to_string(),
+            span: usage.node.info.default_span(usage.span),
+            usage: usage.node.info.description.to_string(),
         });
     }
 
     let alias =
-        if stack.iter().all(|entry| matches!(entry.frame.info.def_kind, Some(DefKind::TyAlias))) {
+        if stack.iter().all(|entry| matches!(entry.node.info.def_kind, Some(DefKind::TyAlias))) {
             Some(crate::error::Alias::Ty)
-        } else if stack.iter().all(|entry| entry.frame.info.def_kind == Some(DefKind::TraitAlias)) {
+        } else if stack.iter().all(|entry| entry.node.info.def_kind == Some(DefKind::TraitAlias)) {
             Some(crate::error::Alias::Trait)
         } else {
             None