Auto merge of #80692 - Aaron1011:feature/query-result-debug, r=estebank

Enforce that query results implement Debug

Currently, we require that query keys implement `Debug`, but we do not do the same for query values. This can make incremental compilation bugs difficult to debug - there isn't a good place to print out the result loaded from disk.

This PR adds `Debug` bounds to several query-related functions, allowing us to debug-print the query value when an 'unstable fingerprint' error occurs. This required adding `#[derive(Debug)]` to a fairly large number of types - hopefully, this doesn't have much of an impact on compiler bootstrapping times.

compiler/rustc_attr/src/builtin.rs

@@ -66,21 +66,21 @@ fn handle_errors(sess: &ParseSess, span: Span, error: AttrError) {
  }
 }
 
-#[derive(Copy, Clone, PartialEq, Encodable, Decodable)]
+#[derive(Copy, Clone, PartialEq, Encodable, Decodable, Debug)]
 pub enum InlineAttr {
  None,
  Hint,
  Always,
  Never,
 }
 
-#[derive(Clone, Encodable, Decodable)]
+#[derive(Clone, Encodable, Decodable, Debug)]
 pub enum InstructionSetAttr {
  ArmA32,
  ArmT32,
 }
 
-#[derive(Clone, Encodable, Decodable)]
+#[derive(Clone, Encodable, Decodable, Debug)]
 pub enum OptimizeAttr {
  None,
  Speed,

compiler/rustc_data_structures/src/stable_hasher.rs

@@ -552,6 +552,7 @@ pub fn hash_stable_hashmap<HCX, K, V, R, SK, F>(
 
 /// A vector container that makes sure that its items are hashed in a stable
 /// order.
+#[derive(Debug)]
 pub struct StableVec<T>(Vec<T>);
 
 impl<T> StableVec<T> {

compiler/rustc_data_structures/src/steal.rs

@@ -21,6 +21,7 @@ use crate::sync::{MappedReadGuard, ReadGuard, RwLock};
 /// -- once the value is stolen -- it will never be read from again.
 //
 // FIXME(#41710): what is the best way to model linear queries?
+#[derive(Debug)]
 pub struct Steal<T> {
  value: RwLock<Option<T>>,
 }

compiler/rustc_feature/src/active.rs

@@ -36,7 +36,7 @@ macro_rules! declare_features {
  ),+];
 
  /// A set of features to be used by later passes.
- #[derive(Clone, Default)]
+ #[derive(Clone, Default, Debug)]
  pub struct Features {
  /// `#![feature]` attrs for language features, for error reporting.
  pub declared_lang_features: Vec<(Symbol, Span, Option<Symbol>)>,

compiler/rustc_hir/src/lang_items.rs

@@ -67,7 +67,7 @@ macro_rules! language_item_table {
  }
  }
 
- #[derive(HashStable_Generic)]
+ #[derive(HashStable_Generic, Debug)]
  pub struct LanguageItems {
  /// Mappings from lang items to their possibly found `DefId`s.
  /// The index corresponds to the order in `LangItem`.

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

@@ -85,11 +85,13 @@ fn is_body_owner<'hir>(node: Node<'hir>, hir_id: HirId) -> bool {
  }
 }
 
+#[derive(Debug)]
 pub(super) struct HirOwnerData<'hir> {
  pub(super) signature: Option<&'hir Owner<'hir>>,
  pub(super) with_bodies: Option<&'hir mut OwnerNodes<'hir>>,
 }
 
+#[derive(Debug)]
 pub struct IndexedHir<'hir> {
  /// The SVH of the local crate.
  pub crate_hash: Svh,

compiler/rustc_middle/src/hir/mod.rs

@@ -17,6 +17,7 @@ use rustc_hir::*;
 use rustc_index::vec::IndexVec;
 use rustc_span::DUMMY_SP;
 
+#[derive(Debug)]
 pub struct Owner<'tcx> {
  parent: HirId,
  node: Node<'tcx>,
@@ -32,12 +33,13 @@ impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for Owner<'tcx> {
  }
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct ParentedNode<'tcx> {
  parent: ItemLocalId,
  node: Node<'tcx>,
 }
 
+#[derive(Debug)]
 pub struct OwnerNodes<'tcx> {
  hash: Fingerprint,
  nodes: IndexVec<ItemLocalId, Option<ParentedNode<'tcx>>>,

compiler/rustc_middle/src/lint.rs

@@ -12,7 +12,7 @@ use rustc_span::source_map::{DesugaringKind, ExpnKind, MultiSpan};
 use rustc_span::{symbol, Span, Symbol, DUMMY_SP};
 
 /// How a lint level was set.
-#[derive(Clone, Copy, PartialEq, Eq, HashStable)]
+#[derive(Clone, Copy, PartialEq, Eq, HashStable, Debug)]
 pub enum LintLevelSource {
  /// Lint is at the default level as declared
  /// in rustc or a plugin.
@@ -48,11 +48,13 @@ impl LintLevelSource {
 /// A tuple of a lint level and its source.
 pub type LevelAndSource = (Level, LintLevelSource);
 
+#[derive(Debug)]
 pub struct LintLevelSets {
  pub list: Vec<LintSet>,
  pub lint_cap: Level,
 }
 
+#[derive(Debug)]
 pub enum LintSet {
  CommandLine {
  // -A,-W,-D flags, a `Symbol` for the flag itself and `Level` for which
@@ -139,6 +141,7 @@ impl LintLevelSets {
  }
 }
 
+#[derive(Debug)]
 pub struct LintLevelMap {
  pub sets: LintLevelSets,
  pub id_to_set: FxHashMap<HirId, u32>,

compiler/rustc_middle/src/middle/codegen_fn_attrs.rs

@@ -3,7 +3,7 @@ use rustc_attr::{InlineAttr, InstructionSetAttr, OptimizeAttr};
 use rustc_session::config::SanitizerSet;
 use rustc_span::symbol::Symbol;
 
-#[derive(Clone, TyEncodable, TyDecodable, HashStable)]
+#[derive(Clone, TyEncodable, TyDecodable, HashStable, Debug)]
 pub struct CodegenFnAttrs {
  pub flags: CodegenFnAttrFlags,
  /// Parsed representation of the `#[inline]` attribute

compiler/rustc_middle/src/middle/cstore.rs

@@ -96,7 +96,7 @@ pub struct NativeLib {
  pub wasm_import_module: Option<Symbol>,
 }
 
-#[derive(Clone, TyEncodable, TyDecodable, HashStable)]
+#[derive(Clone, TyEncodable, TyDecodable, HashStable, Debug)]
 pub struct ForeignModule {
  pub foreign_items: Vec<DefId>,
  pub def_id: DefId,

compiler/rustc_middle/src/middle/mod.rs

@@ -7,7 +7,7 @@ pub mod lib_features {
  use rustc_data_structures::fx::{FxHashMap, FxHashSet};
  use rustc_span::symbol::Symbol;
 
- #[derive(HashStable)]
+ #[derive(HashStable, Debug)]
  pub struct LibFeatures {
  // A map from feature to stabilisation version.
  pub stable: FxHashMap<Symbol, Symbol>,

compiler/rustc_middle/src/middle/resolve_lifetime.rs

@@ -68,7 +68,7 @@ pub type ObjectLifetimeDefault = Set1<Region>;
 
 /// Maps the id of each lifetime reference to the lifetime decl
 /// that it corresponds to.
-#[derive(Default, HashStable)]
+#[derive(Default, HashStable, Debug)]
 pub struct ResolveLifetimes {
  /// Maps from every use of a named (not anonymous) lifetime to a
  /// `Region` describing how that region is bound

compiler/rustc_middle/src/middle/stability.rs

@@ -36,7 +36,7 @@ impl StabilityLevel {
 }
 
 /// An entry in the `depr_map`.
-#[derive(Clone, HashStable)]
+#[derive(Clone, HashStable, Debug)]
 pub struct DeprecationEntry {
  /// The metadata of the attribute associated with this entry.
  pub attr: Deprecation,
@@ -63,7 +63,7 @@ impl DeprecationEntry {
 }
 
 /// A stability index, giving the stability level for items and methods.
-#[derive(HashStable)]
+#[derive(HashStable, Debug)]
 pub struct Index<'tcx> {
  /// This is mostly a cache, except the stabilities of local items
  /// are filled by the annotator.

compiler/rustc_middle/src/mir/interpret/value.rs

@@ -13,7 +13,7 @@ use crate::ty::{ParamEnv, ScalarInt, Ty, TyCtxt};
 use super::{AllocId, Allocation, InterpResult, Pointer, PointerArithmetic};
 
 /// Represents the result of const evaluation via the `eval_to_allocation` query.
-#[derive(Clone, HashStable, TyEncodable, TyDecodable)]
+#[derive(Clone, HashStable, TyEncodable, TyDecodable, Debug)]
 pub struct ConstAlloc<'tcx> {
  // the value lives here, at offset 0, and that allocation definitely is a `AllocKind::Memory`
  // (so you can use `AllocMap::unwrap_memory`).

compiler/rustc_middle/src/mir/mono.rs

@@ -216,6 +216,7 @@ impl<'tcx> fmt::Display for MonoItem<'tcx> {
  }
 }
 
+#[derive(Debug)]
 pub struct CodegenUnit<'tcx> {
  /// A name for this CGU. Incremental compilation requires that
  /// name be unique amongst **all** crates. Therefore, it should

compiler/rustc_middle/src/mir/query.rs

@@ -17,7 +17,7 @@ use std::fmt::{self, Debug};
 
 use super::{Field, SourceInfo};
 
-#[derive(Copy, Clone, PartialEq, TyEncodable, TyDecodable, HashStable)]
+#[derive(Copy, Clone, PartialEq, TyEncodable, TyDecodable, HashStable, Debug)]
 pub enum UnsafetyViolationKind {
  /// Only permitted in regular `fn`s, prohibited in `const fn`s.
  General,
@@ -36,7 +36,7 @@ pub enum UnsafetyViolationKind {
  UnsafeFnBorrowPacked,
 }
 
-#[derive(Copy, Clone, PartialEq, TyEncodable, TyDecodable, HashStable)]
+#[derive(Copy, Clone, PartialEq, TyEncodable, TyDecodable, HashStable, Debug)]
 pub enum UnsafetyViolationDetails {
  CallToUnsafeFunction,
  UseOfInlineAssembly,
@@ -121,15 +121,15 @@ impl UnsafetyViolationDetails {
  }
 }
 
-#[derive(Copy, Clone, PartialEq, TyEncodable, TyDecodable, HashStable)]
+#[derive(Copy, Clone, PartialEq, TyEncodable, TyDecodable, HashStable, Debug)]
 pub struct UnsafetyViolation {
  pub source_info: SourceInfo,
  pub lint_root: hir::HirId,
  pub kind: UnsafetyViolationKind,
  pub details: UnsafetyViolationDetails,
 }
 
-#[derive(Clone, TyEncodable, TyDecodable, HashStable)]
+#[derive(Clone, TyEncodable, TyDecodable, HashStable, Debug)]
 pub struct UnsafetyCheckResult {
  /// Violations that are propagated *upwards* from this function.
  pub violations: Lrc<[UnsafetyViolation]>,

compiler/rustc_middle/src/traits/specialization_graph.rs

@@ -23,7 +23,7 @@ use rustc_span::symbol::Ident;
 /// parents of a given specializing impl, which is needed for extracting
 /// default items amongst other things. In the simple "chain" rule, every impl
 /// has at most one parent.
-#[derive(TyEncodable, TyDecodable, HashStable)]
+#[derive(TyEncodable, TyDecodable, HashStable, Debug)]
 pub struct Graph {
  /// All impls have a parent; the "root" impls have as their parent the `def_id`
  /// of the trait.
@@ -50,7 +50,7 @@ impl Graph {
 
 /// Children of a given impl, grouped into blanket/non-blanket varieties as is
 /// done in `TraitDef`.
-#[derive(Default, TyEncodable, TyDecodable)]
+#[derive(Default, TyEncodable, TyDecodable, Debug)]
 pub struct Children {
  // Impls of a trait (or specializations of a given impl). To allow for
  // quicker lookup, the impls are indexed by a simplified version of their

compiler/rustc_middle/src/ty/inhabitedness/def_id_forest.rs

@@ -18,7 +18,7 @@ use DefIdForest::*;
 /// We store the minimal set of `DefId`s required to represent the whole set. If A and B are
 /// `DefId`s in the `DefIdForest`, and A is a parent of B, then only A will be stored. When this is
 /// used with `type_uninhabited_from`, there will very rarely be more than one `DefId` stored.
-#[derive(Clone, HashStable)]
+#[derive(Clone, HashStable, Debug)]
 pub enum DefIdForest {
  Empty,
  Single(DefId),

compiler/rustc_middle/src/ty/mod.rs

@@ -185,7 +185,7 @@ pub struct ImplHeader<'tcx> {
  pub predicates: Vec<Predicate<'tcx>>,
 }
 
-#[derive(Copy, Clone, PartialEq, TyEncodable, TyDecodable, HashStable)]
+#[derive(Copy, Clone, PartialEq, TyEncodable, TyDecodable, HashStable, Debug)]
 pub enum ImplPolarity {
  /// `impl Trait for Type`
  Positive,
@@ -435,7 +435,7 @@ pub enum Variance {
 /// HIR of every item in the local crate. Instead, use
 /// `tcx.variances_of()` to get the variance for a *particular*
 /// item.
-#[derive(HashStable)]
+#[derive(HashStable, Debug)]
 pub struct CrateVariancesMap<'tcx> {
  /// For each item with generics, maps to a vector of the variance
  /// of its generics. If an item has no generics, it will have no
@@ -1174,7 +1174,7 @@ pub enum PredicateKind<'tcx> {
 /// HIR of every item in the local crate. Instead, use
 /// `tcx.inferred_outlives_of()` to get the outlives for a *particular*
 /// item.
-#[derive(HashStable)]
+#[derive(HashStable, Debug)]
 pub struct CratePredicatesMap<'tcx> {
  /// For each struct with outlive bounds, maps to a vector of the
  /// predicate of its outlive bounds. If an item has no outlives
@@ -3107,7 +3107,7 @@ impl<'tcx> TyCtxt<'tcx> {
  }
 }
 
-#[derive(Clone, HashStable)]
+#[derive(Clone, HashStable, Debug)]
 pub struct AdtSizedConstraint<'tcx>(pub &'tcx [Ty<'tcx>]);
 
 /// Yields the parent function's `DefId` if `def_id` is an `impl Trait` definition.

compiler/rustc_middle/src/ty/trait_def.rs

@@ -63,7 +63,7 @@ pub enum TraitSpecializationKind {
  AlwaysApplicable,
 }
 
-#[derive(Default)]
+#[derive(Default, Debug)]
 pub struct TraitImpls {
  blanket_impls: Vec<DefId>,
  /// Impls indexed by their simplified self type, for fast lookup.

compiler/rustc_query_system/src/query/caches.rs

@@ -15,7 +15,7 @@ pub trait CacheSelector<K, V> {
 }
 
 pub trait QueryStorage: Default {
- type Value;
+ type Value: Debug;
  type Stored: Clone;
 
  /// Store a value without putting it in the cache.
@@ -75,7 +75,7 @@ impl<K, V> Default for DefaultCache<K, V> {
  }
 }
 
-impl<K: Eq + Hash, V: Clone> QueryStorage for DefaultCache<K, V> {
+impl<K: Eq + Hash, V: Clone + Debug> QueryStorage for DefaultCache<K, V> {
  type Value = V;
  type Stored = V;
 
@@ -89,7 +89,7 @@ impl<K: Eq + Hash, V: Clone> QueryStorage for DefaultCache<K, V> {
 impl<K, V> QueryCache for DefaultCache<K, V>
 where
  K: Eq + Hash + Clone + Debug,
- V: Clone,
+ V: Clone + Debug,
 {
  type Key = K;
  type Sharded = FxHashMap<K, (V, DepNodeIndex)>;
@@ -156,7 +156,7 @@ impl<'tcx, K, V> Default for ArenaCache<'tcx, K, V> {
  }
 }
 
-impl<'tcx, K: Eq + Hash, V: 'tcx> QueryStorage for ArenaCache<'tcx, K, V> {
+impl<'tcx, K: Eq + Hash, V: Debug + 'tcx> QueryStorage for ArenaCache<'tcx, K, V> {
  type Value = V;
  type Stored = &'tcx V;
 
@@ -171,6 +171,7 @@ impl<'tcx, K: Eq + Hash, V: 'tcx> QueryStorage for ArenaCache<'tcx, K, V> {
 impl<'tcx, K, V: 'tcx> QueryCache for ArenaCache<'tcx, K, V>
 where
  K: Eq + Hash + Clone + Debug,
+ V: Debug,
 {
  type Key = K;
  type Sharded = FxHashMap<K, &'tcx (V, DepNodeIndex)>;

compiler/rustc_query_system/src/query/plumbing.rs

@@ -20,6 +20,7 @@ use rustc_errors::{Diagnostic, FatalError};
 use rustc_span::source_map::DUMMY_SP;
 use rustc_span::Span;
 use std::collections::hash_map::Entry;
+use std::fmt::Debug;
 use std::hash::{Hash, Hasher};
 use std::mem;
 use std::num::NonZeroU32;
@@ -478,7 +479,7 @@ where
  result
 }
 
-fn load_from_disk_and_cache_in_memory<CTX, K, V>(
+fn load_from_disk_and_cache_in_memory<CTX, K, V: Debug>(
  tcx: CTX,
  key: K,
  prev_dep_node_index: SerializedDepNodeIndex,
@@ -539,7 +540,7 @@ where
 
 #[inline(never)]
 #[cold]
-fn incremental_verify_ich<CTX, K, V>(
+fn incremental_verify_ich<CTX, K, V: Debug>(
  tcx: CTX,
  result: &V,
  dep_node: &DepNode<CTX::DepKind>,

compiler/rustc_session/src/config.rs

@@ -361,7 +361,7 @@ impl Default for TrimmedDefPaths {
 /// Use tree-based collections to cheaply get a deterministic `Hash` implementation.
 /// *Do not* switch `BTreeMap` out for an unsorted container type! That would break
 /// dependency tracking for command-line arguments.
-#[derive(Clone, Hash)]
+#[derive(Clone, Hash, Debug)]
 pub struct OutputTypes(BTreeMap<OutputType, Option<PathBuf>>);
 
 impl_stable_hash_via_hash!(OutputTypes);
@@ -552,7 +552,7 @@ impl Input {
  }
 }
 
-#[derive(Clone, Hash)]
+#[derive(Clone, Hash, Debug)]
 pub struct OutputFilenames {
  pub out_directory: PathBuf,
  filestem: String,