make Span's HashStable impl actually valid i think

Author: compiler-errors

compiler/rustc_query_system/src/ich/hcx.rs

@@ -1,13 +1,11 @@
-use std::sync::Arc;
-
 use rustc_ast as ast;
 use rustc_data_structures::stable_hasher::{HashStable, HashingControls, StableHasher};
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::definitions::DefPathHash;
 use rustc_session::Session;
 use rustc_session::cstore::Untracked;
 use rustc_span::source_map::SourceMap;
-use rustc_span::{BytePos, CachingSourceMapView, DUMMY_SP, SourceFile, Span, SpanData, Symbol};
+use rustc_span::{CachingSourceMapView, DUMMY_SP, Span, SpanData, StableSourceFileId, Symbol};
 
 use crate::ich;
 
@@ -115,11 +113,8 @@ impl<'a> rustc_span::HashStableContext for StableHashingContext<'a> {
     }
 
     #[inline]
-    fn span_data_to_lines_and_cols(
-        &mut self,
-        span: &SpanData,
-    ) -> Option<(Arc<SourceFile>, usize, BytePos, usize, BytePos)> {
-        self.source_map().span_data_to_lines_and_cols(span)
+    fn span_to_file(&mut self, span: &SpanData) -> Option<StableSourceFileId> {
+        Some(self.source_map().span_data_to_lines_and_cols(span)?.0.stable_id)
     }
 
     #[inline]

compiler/rustc_span/src/caching_source_map_view.rs

@@ -118,7 +118,7 @@ impl<'sm> CachingSourceMapView<'sm> {
         self.time_stamp += 1;
 
         // Check if lo and hi are in the cached lines.
-        let lo_cache_idx: isize = self.cache_entry_index(span_data.lo);
+        let lo_cache_idx = self.cache_entry_index(span_data.lo);
         let hi_cache_idx = self.cache_entry_index(span_data.hi);
 
         if lo_cache_idx != -1 && hi_cache_idx != -1 {

compiler/rustc_span/src/lib.rs

@@ -2597,10 +2597,7 @@ pub trait HashStableContext {
     /// we don't have easy access to a `Session`
     fn unstable_opts_incremental_ignore_spans(&self) -> bool;
     fn def_span(&self, def_id: LocalDefId) -> Span;
-    fn span_data_to_lines_and_cols(
-        &mut self,
-        span: &SpanData,
-    ) -> Option<(Arc<SourceFile>, usize, BytePos, usize, BytePos)>;
+    fn span_to_file(&mut self, span: &SpanData) -> Option<StableSourceFileId>;
     fn hashing_controls(&self) -> HashingControls;
 }
 
@@ -2641,6 +2638,7 @@ where
             if def_span.contains(span) {
                 // This span is enclosed in a definition: only hash the relative position.
                 Hash::hash(&TAG_RELATIVE_SPAN, hasher);
+                parent.hash_stable(ctx, hasher);
                 (span.lo - def_span.lo).to_u32().hash_stable(ctx, hasher);
                 (span.hi - def_span.lo).to_u32().hash_stable(ctx, hasher);
                 return;
@@ -2650,32 +2648,15 @@ where
         // If this is not an empty or invalid span, we want to hash the last
         // position that belongs to it, as opposed to hashing the first
         // position past it.
-        let Some((file, line_lo, col_lo, line_hi, col_hi)) = ctx.span_data_to_lines_and_cols(&span)
-        else {
+        let Some(stable_id) = ctx.span_to_file(&span) else {
             Hash::hash(&TAG_INVALID_SPAN, hasher);
             return;
         };
 
         Hash::hash(&TAG_VALID_SPAN, hasher);
-        Hash::hash(&file.stable_id, hasher);
-
-        // Hash both the length and the end location (line/column) of a span. If we
-        // hash only the length, for example, then two otherwise equal spans with
-        // different end locations will have the same hash. This can cause a problem
-        // during incremental compilation wherein a previous result for a query that
-        // depends on the end location of a span will be incorrectly reused when the
-        // end location of the span it depends on has changed (see issue #74890). A
-        // similar analysis applies if some query depends specifically on the length
-        // of the span, but we only hash the end location. So hash both.
-
-        let col_lo_trunc = (col_lo.0 as u64) & 0xFF;
-        let line_lo_trunc = ((line_lo as u64) & 0xFF_FF_FF) << 8;
-        let col_hi_trunc = (col_hi.0 as u64) & 0xFF << 32;
-        let line_hi_trunc = ((line_hi as u64) & 0xFF_FF_FF) << 40;
-        let col_line = col_lo_trunc | line_lo_trunc | col_hi_trunc | line_hi_trunc;
-        let len = (span.hi - span.lo).0;
-        Hash::hash(&col_line, hasher);
-        Hash::hash(&len, hasher);
+        Hash::hash(&stable_id, hasher);
+        Hash::hash(&span.lo.0, hasher);
+        Hash::hash(&span.hi.0, hasher);
     }
 }