Auto merge of rust-lang#141408 - compiler-errors:start-and-end-point, r=<try>

Cache start and end point

r? `@ghost`

Author: bors

compiler/rustc_ast_lowering/src/expr.rs

@@ -641,7 +641,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             } else {
                 let try_span = this.mark_span_with_reason(
                     DesugaringKind::TryBlock,
-                    this.tcx.sess.source_map().end_point(body.span),
+                    this.tcx.end_point(body.span),
                     Some(Arc::clone(&this.allow_try_trait)),
                 );
 
@@ -1968,7 +1968,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             span,
             Some(Arc::clone(&self.allow_try_trait)),
         );
-        let try_span = self.tcx.sess.source_map().end_point(span);
+        let try_span = self.tcx.end_point(span);
         let try_span = self.mark_span_with_reason(
             DesugaringKind::QuestionMark,
             try_span,

compiler/rustc_ast_lowering/src/lib.rs

@@ -1402,7 +1402,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 } else {
                     self.next_node_id()
                 };
-                let span = self.tcx.sess.source_map().start_point(t.span).shrink_to_hi();
+                let span = self.tcx.start_point(t.span).shrink_to_hi();
                 let region = Lifetime { ident: Ident::new(kw::UnderscoreLifetime, span), id };
                 (region, LifetimeSyntax::Hidden)
             }

compiler/rustc_middle/src/query/erase.rs

@@ -333,6 +333,7 @@ trivial! {
     rustc_span::ExpnHash,
     rustc_span::ExpnId,
     rustc_span::Span,
+    (rustc_span::Span, rustc_span::Span),
     rustc_span::Symbol,
     rustc_span::Ident,
     rustc_target::spec::PanicStrategy,

compiler/rustc_middle/src/query/keys.rs

@@ -70,6 +70,14 @@ impl Key for () {
     }
 }
 
+impl Key for Span {
+    type Cache<V> = DefaultCache<Self, V>;
+
+    fn default_span(&self, _: TyCtxt<'_>) -> Span {
+        *self
+    }
+}
+
 impl<'tcx> Key for ty::InstanceKind<'tcx> {
     type Cache<V> = DefaultCache<Self, V>;
 

compiler/rustc_middle/src/query/mod.rs

@@ -159,6 +159,10 @@ rustc_queries! {
         desc { "getting the source span" }
     }
 
+    query start_and_end_point(key: Span) -> (Span, Span) {
+        desc { "computing the start and end points for span" }
+    }
+
     /// Represents crate as a whole (as distinct from the top-level crate module).
     ///
     /// If you call `tcx.hir_crate(())` we will have to assume that any change

compiler/rustc_middle/src/ty/context.rs

@@ -2116,6 +2116,14 @@ impl<'tcx> TyCtxt<'tcx> {
         self.untracked.source_span.get(def_id).unwrap_or(DUMMY_SP)
     }
 
+    pub fn start_point(self, span: Span) -> Span {
+        self.start_and_end_point(span).0
+    }
+
+    pub fn end_point(self, span: Span) -> Span {
+        self.start_and_end_point(span).1
+    }
+
     #[inline(always)]
     pub fn with_stable_hashing_context<R>(
         self,
@@ -3430,6 +3438,10 @@ pub fn provide(providers: &mut Providers) {
         tcx.lang_items().panic_impl().is_some_and(|did| did.is_local())
     };
     providers.source_span = |tcx, def_id| tcx.untracked.source_span.get(def_id).unwrap_or(DUMMY_SP);
+    providers.start_and_end_point = |tcx, span| {
+        let sm = tcx.sess.source_map();
+        (sm.start_point(span), sm.end_point(span))
+    };
 }
 
 pub fn contains_name(attrs: &[Attribute], name: Symbol) -> bool {

compiler/rustc_mir_build/src/builder/matches/mod.rs

@@ -2489,7 +2489,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 });
 
             let source_info = self.source_info(guard_span);
-            let guard_end = self.source_info(tcx.sess.source_map().end_point(guard_span));
+            let guard_end = self.source_info(tcx.end_point(guard_span));
             let guard_frame = self.guard_context.pop().unwrap();
             debug!("Exiting guard building context with locals: {:?}", guard_frame);
 

compiler/rustc_mir_build/src/builder/scope.rs

@@ -1165,7 +1165,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             if scope.region_scope == region_scope {
                 let region_scope_span = region_scope.span(self.tcx, self.region_scope_tree);
                 // Attribute scope exit drops to scope's closing brace.
-                let scope_end = self.tcx.sess.source_map().end_point(region_scope_span);
+                let scope_end = self.tcx.end_point(region_scope_span);
 
                 scope.drops.push(DropData {
                     source_info: SourceInfo { span: scope_end, scope: scope.source_scope },
@@ -1196,7 +1196,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             scope.invalidate_cache();
             if scope.region_scope == region_scope {
                 let region_scope_span = region_scope.span(self.tcx, self.region_scope_tree);
-                let scope_end = self.tcx.sess.source_map().end_point(region_scope_span);
+                let scope_end = self.tcx.end_point(region_scope_span);
 
                 scope.drops.push(DropData {
                     source_info: SourceInfo { span: scope_end, scope: scope.source_scope },

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_resolve/src/late.rs

@@ -831,7 +831,7 @@ impl<'ra: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'_, 'ast, 'r
                 // Elided lifetime in reference: we resolve as if there was some lifetime `'_` with
                 // NodeId `ty.id`.
                 // This span will be used in case of elision failure.
-                let span = self.r.tcx.sess.source_map().start_point(ty.span);
+                let span = self.r.tcx.start_point(ty.span);
                 self.resolve_elided_lifetime(ty.id, span);
                 visit::walk_ty(self, ty);
             }

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);
     }
 }
 

compiler/rustc_span/src/source_map.rs

@@ -886,8 +886,7 @@ impl SourceMap {
     /// Returns a new span representing just the first character of the given span.
     pub fn start_point(&self, sp: Span) -> Span {
         let width = {
-            let sp = sp.data();
-            let local_begin = self.lookup_byte_offset(sp.lo);
+            let local_begin = self.lookup_byte_offset(sp.lo());
             let start_index = local_begin.pos.to_usize();
             let src = local_begin.sf.external_src.read();