check span owners in debug builds

Author: jdonszelmann

compiler/rustc_hir/src/stable_hash_impls.rs

@@ -1,5 +1,5 @@
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHashKey};
-use rustc_span::def_id::DefPathHash;
+use rustc_span::def_id::{DefPathHash, LocalDefId};
 
 use crate::HashIgnoredAttrId;
 use crate::hir::{
@@ -13,6 +13,8 @@ use crate::lints::DelayedLints;
 /// instead of implementing everything in `rustc_middle`.
 pub trait HashStableContext: rustc_ast::HashStableContext + rustc_abi::HashStableContext {
     fn hash_attr_id(&mut self, id: &HashIgnoredAttrId, hasher: &mut StableHasher);
+
+    fn set_current_owner_node_defid(&mut self, local_def_id: Option<LocalDefId>);
 }
 
 impl<HirCtx: crate::HashStableContext> ToStableHashKey<HirCtx> for BodyId {

compiler/rustc_middle/src/hir/mod.rs

@@ -177,12 +177,27 @@ impl<'tcx> TyCtxt<'tcx> {
         }
 
         self.with_stable_hashing_context(|mut hcx| {
+            // With debug assertions on, *while hashing*,
+            // we will check whether spans properly set their parent to the current node's defid
+            // For that we set the defid here to check against
+            #[cfg(debug_assertions)]
+            if self.sess.opts.incremental.is_some() && !matches!(node, OwnerNode::Synthetic) {
+                hcx.set_current_owner_node_defid(Some(node.def_id().def_id));
+            }
+
             let mut stable_hasher = StableHasher::new();
             node.hash_stable(&mut hcx, &mut stable_hasher);
             // Bodies are stored out of line, so we need to pull them explicitly in the hash.
             bodies.hash_stable(&mut hcx, &mut stable_hasher);
             let h1 = stable_hasher.finish();
 
+            // At the start of hashing an owner node we set this to the node's defid.
+            // We clear it again here, ending checking of spans.
+            #[cfg(debug_assertions)]
+            if self.sess.opts.incremental.is_some() {
+                hcx.set_current_owner_node_defid(None);
+            }
+
             let mut stable_hasher = StableHasher::new();
             attrs.hash_stable(&mut hcx, &mut stable_hasher);
 

compiler/rustc_query_system/src/ich/hcx.rs

@@ -21,6 +21,10 @@ pub struct StableHashingContext<'a> {
     // The value of `-Z incremental-ignore-spans`.
     // This field should only be used by `unstable_opts_incremental_ignore_span`
     incremental_ignore_spans: bool,
+
+    #[cfg(debug_assertions)]
+    pub(crate) current_owner_node_did: Option<LocalDefId>,
+
     // Very often, we are hashing something that does not need the
     // `CachingSourceMapView`, so we initialize it lazily.
     raw_source_map: &'a SourceMap,
@@ -36,6 +40,8 @@ impl<'a> StableHashingContext<'a> {
         StableHashingContext {
             untracked,
             incremental_ignore_spans: sess.opts.unstable_opts.incremental_ignore_spans,
+            #[cfg(debug_assertions)]
+            current_owner_node_did: None,
             caching_source_map: None,
             raw_source_map: sess.source_map(),
             hashing_controls: HashingControls { hash_spans: hash_spans_initial },
@@ -126,6 +132,26 @@ impl<'a> rustc_span::HashStableContext for StableHashingContext<'a> {
     fn hashing_controls(&self) -> HashingControls {
         self.hashing_controls.clone()
     }
+
+    #[cfg(debug_assertions)]
+    fn validate_span_parent(&self, span: Span) {
+        // If we're hashing an owner node right now...
+        let Some(current_owner_node_did) = self.current_owner_node_did else {
+            return;
+        };
+
+        // we don't care about the dummy span
+        if span.is_dummy() {
+            return;
+        }
+
+        // then the parent must be set and match that defid.
+        assert!(
+            span.parent().is_some_and(|i| i == current_owner_node_did),
+            "Expected span to be lowered. Lowered spans have their parent set to their enclosing owner node. However, contained in the owner node with defid={current_owner_node_did:?} a span={span:?} was found whose parent is {:?}.",
+            span.parent()
+        )
+    }
 }
 
 impl<'a> rustc_session::HashStableContext for StableHashingContext<'a> {}

compiler/rustc_query_system/src/ich/impls_syntax.rs

@@ -2,6 +2,7 @@
 //! from various crates in no particular order.
 
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_hir::def_id::LocalDefId;
 use rustc_hir::{self as hir, HashIgnoredAttrId};
 use rustc_span::SourceFile;
 use smallvec::SmallVec;
@@ -39,6 +40,15 @@ impl<'ctx> rustc_hir::HashStableContext for StableHashingContext<'ctx> {
     fn hash_attr_id(&mut self, _id: &HashIgnoredAttrId, _hasher: &mut StableHasher) {
         /* we don't hash HashIgnoredAttrId, we ignore them */
     }
+
+    #[cfg(debug_assertions)]
+    fn set_current_owner_node_defid(&mut self, local_def_id: Option<LocalDefId>) {
+        if local_def_id.is_some() && self.current_owner_node_did.is_some() {
+            panic!("already in owner node");
+        }
+
+        self.current_owner_node_did = local_def_id;
+    }
 }
 
 impl<'a> HashStable<StableHashingContext<'a>> for SourceFile {

compiler/rustc_span/src/lib.rs

@@ -2634,6 +2634,9 @@ pub trait HashStableContext {
         span: &SpanData,
     ) -> Option<(StableSourceFileId, usize, BytePos, usize, BytePos)>;
     fn hashing_controls(&self) -> HashingControls;
+
+    #[cfg(debug_assertions)]
+    fn validate_span_parent(&self, span: Span);
 }
 
 impl<CTX> HashStable<CTX> for Span
@@ -2663,6 +2666,12 @@ where
         span.ctxt.hash_stable(ctx, hasher);
         span.parent.hash_stable(ctx, hasher);
 
+        // check whether the span is lowered correctly when hashing
+        #[cfg(debug_assertions)]
+        {
+            ctx.validate_span_parent(*self);
+        }
+
         if span.is_dummy() {
             Hash::hash(&TAG_INVALID_SPAN, hasher);
             return;