Update on-disk cache span encoder.

Author: cjgillot

compiler/rustc_middle/src/query/on_disk_cache.rs

@@ -38,6 +38,7 @@ const TAG_FULL_SPAN: u8 = 0;
 // A partial span with no location information, encoded only with a `SyntaxContext`
 const TAG_PARTIAL_SPAN: u8 = 1;
 const TAG_RELATIVE_SPAN: u8 = 2;
+const TAG_RELATIVE_OUTER_SPAN: u8 = 3;
 
 const TAG_SYNTAX_CONTEXT: u8 = 0;
 const TAG_EXPN_DATA: u8 = 1;
@@ -654,6 +655,17 @@ impl<'a, 'tcx> SpanDecoder for CacheDecoder<'a, 'tcx> {
                 let enclosing = self.tcx.source_span_untracked(parent.unwrap()).data_untracked();
                 (enclosing.lo + BytePos::from_u32(dlo), enclosing.lo + BytePos::from_u32(dto))
             }
+            TAG_RELATIVE_OUTER_SPAN => {
+                let dlo = isize::decode(self);
+                let dto = isize::decode(self);
+
+                let enclosing = self.tcx.source_span_untracked(parent.unwrap()).data_untracked();
+                let reference = enclosing.lo.to_u32() as isize;
+                (
+                    BytePos::from_usize((reference + dlo) as usize),
+                    BytePos::from_usize((reference + dto) as usize),
+                )
+            }
             TAG_FULL_SPAN => {
                 let file_lo_index = SourceFileIndex::decode(self);
                 let line_lo = usize::decode(self);
@@ -664,6 +676,7 @@ impl<'a, 'tcx> SpanDecoder for CacheDecoder<'a, 'tcx> {
                 let lo = file_lo.lines()[line_lo - 1] + col_lo;
                 let lo = file_lo.absolute_position(lo);
                 let hi = lo + len;
+
                 (lo, hi)
             }
             _ => unreachable!(),
@@ -892,30 +905,33 @@ impl<'a, 'tcx> SpanEncoder for CacheEncoder<'a, 'tcx> {
             return TAG_PARTIAL_SPAN.encode(self);
         }
 
-        if let Some(parent) = span_data.parent {
-            let enclosing = self.tcx.source_span_untracked(parent).data_untracked();
-            if enclosing.contains(span_data) {
-                TAG_RELATIVE_SPAN.encode(self);
-                (span_data.lo - enclosing.lo).to_u32().encode(self);
-                (span_data.hi - enclosing.lo).to_u32().encode(self);
-                return;
-            }
+        let parent =
+            span_data.parent.map(|parent| self.tcx.source_span_untracked(parent).data_untracked());
+        if let Some(parent) = parent
+            && parent.contains(span_data)
+        {
+            TAG_RELATIVE_SPAN.encode(self);
+            (span_data.lo - parent.lo).to_u32().encode(self);
+            (span_data.hi - parent.lo).to_u32().encode(self);
+            return;
         }
 
-        let pos = self.source_map.byte_pos_to_line_and_col(span_data.lo);
-        let partial_span = match &pos {
-            Some((file_lo, _, _)) => !file_lo.contains(span_data.hi),
-            None => true,
+        let Some((file_lo, line_lo, col_lo)) =
+            self.source_map.byte_pos_to_line_and_col(span_data.lo)
+        else {
+            return TAG_PARTIAL_SPAN.encode(self);
         };
 
-        if partial_span {
-            return TAG_PARTIAL_SPAN.encode(self);
+        if let Some(parent) = parent
+            && file_lo.contains(parent.lo)
+        {
+            TAG_RELATIVE_OUTER_SPAN.encode(self);
+            (span_data.lo.to_u32() as isize - parent.lo.to_u32() as isize).encode(self);
+            (span_data.hi.to_u32() as isize - parent.lo.to_u32() as isize).encode(self);
+            return;
         }
 
-        let (file_lo, line_lo, col_lo) = pos.unwrap();
-
         let len = span_data.hi - span_data.lo;
-
         let source_file_index = self.source_file_index(file_lo);
 
         TAG_FULL_SPAN.encode(self);

compiler/rustc_span/src/lib.rs

@@ -2653,6 +2653,7 @@ where
     /// codepoint offsets. For the purpose of the hash that's sufficient.
     /// Also, hashing filenames is expensive so we avoid doing it twice when the
     /// span starts and ends in the same file, which is almost always the case.
+    // Important: changes to this method should be reflected in implementations of `SpanEncoder`.
     fn hash_stable(&self, ctx: &mut CTX, hasher: &mut StableHasher) {
         const TAG_VALID_SPAN: u8 = 0;
         const TAG_INVALID_SPAN: u8 = 1;