Use Freeze for SourceFile.lines

compiler/rustc_codegen_cranelift/src/debuginfo/line_info.rs

@@ -81,7 +81,7 @@ impl DebugContext {
 
         match tcx.sess.source_map().lookup_line(span.lo()) {
             Ok(SourceFileAndLine { sf: file, line }) => {
-                let line_pos = file.lines(|lines| lines[line]);
+                let line_pos = file.lines()[line];
                 let col = file.relative_position(span.lo()) - line_pos;
 
                 (file, u64::try_from(line).unwrap() + 1, u64::from(col.to_u32()) + 1)

compiler/rustc_codegen_llvm/src/debuginfo/mod.rs

@@ -263,7 +263,7 @@ impl CodegenCx<'_, '_> {
     pub fn lookup_debug_loc(&self, pos: BytePos) -> DebugLoc {
         let (file, line, col) = match self.sess().source_map().lookup_line(pos) {
             Ok(SourceFileAndLine { sf: file, line }) => {
-                let line_pos = file.lines(|lines| lines[line]);
+                let line_pos = file.lines()[line];
 
                 // Use 1-based indexing.
                 let line = (line + 1) as u32;

compiler/rustc_data_structures/src/sync/freeze.rs

@@ -3,6 +3,7 @@ use crate::sync::{AtomicBool, ReadGuard, RwLock, WriteGuard};
 use crate::sync::{DynSend, DynSync};
 use std::{
     cell::UnsafeCell,
+    intrinsics::likely,
     marker::PhantomData,
     ops::{Deref, DerefMut},
     sync::atomic::Ordering,
@@ -49,6 +50,17 @@ impl<T> FreezeLock<T> {
         self.frozen.load(Ordering::Acquire)
     }
 
+    /// Get the inner value if frozen.
+    #[inline]
+    pub fn get(&self) -> Option<&T> {
+        if likely(self.frozen.load(Ordering::Acquire)) {
+            // SAFETY: This is frozen so the data cannot be modified.
+            unsafe { Some(&*self.data.get()) }
+        } else {
+            None
+        }
+    }
+
     #[inline]
     pub fn read(&self) -> FreezeReadGuard<'_, T> {
         FreezeReadGuard {

compiler/rustc_middle/src/query/on_disk_cache.rs

@@ -692,7 +692,7 @@ impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for Span {
         let len = BytePos::decode(decoder);
 
         let file_lo = decoder.file_index_to_file(file_lo_index);
-        let lo = file_lo.lines(|lines| lines[line_lo - 1] + col_lo);
+        let lo = file_lo.lines()[line_lo - 1] + col_lo;
         let lo = file_lo.absolute_position(lo);
         let hi = lo + len;
 

compiler/rustc_query_system/src/ich/impls_syntax.rs

@@ -79,15 +79,16 @@ impl<'a> HashStable<StableHashingContext<'a>> for SourceFile {
 
         src_hash.hash_stable(hcx, hasher);
 
+        {
             // We are always in `Lines` form by the time we reach here.
-        assert!(self.lines.borrow().is_lines());
+            assert!(self.lines.read().is_lines());
-        self.lines(|lines| {
+            let lines = self.lines();
             // We only hash the relative position within this source_file
             lines.len().hash_stable(hcx, hasher);
             for &line in lines.iter() {
                 line.hash_stable(hcx, hasher);
             }
-        });
+        }
 
         // We only hash the relative position within this source_file
         multibyte_chars.len().hash_stable(hcx, hasher);

compiler/rustc_span/src/lib.rs

@@ -33,7 +33,7 @@ extern crate rustc_macros;
 #[macro_use]
 extern crate tracing;
 
-use rustc_data_structures::AtomicRef;
+use rustc_data_structures::{cold_path, AtomicRef};
 use rustc_macros::HashStable_Generic;
 use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
 
@@ -1348,7 +1348,7 @@ pub struct SourceFile {
     /// The byte length of this source.
     pub source_len: RelativeBytePos,
     /// Locations of lines beginnings in the source code.
-    pub lines: Lock<SourceFileLines>,
+    pub lines: FreezeLock<SourceFileLines>,
     /// Locations of multi-byte characters in the source code.
     pub multibyte_chars: Vec<MultiByteChar>,
     /// Width of characters that are not narrow in the source code.
@@ -1373,7 +1373,10 @@ impl Clone for SourceFile {
             },
             start_pos: self.start_pos,
             source_len: self.source_len,
-            lines: Lock::new(self.lines.borrow().clone()),
+            lines: {
+                let lock = self.lines.read();
+                FreezeLock::with(lock.clone(), self.lines.is_frozen())
+            },
             multibyte_chars: self.multibyte_chars.clone(),
             non_narrow_chars: self.non_narrow_chars.clone(),
             normalized_pos: self.normalized_pos.clone(),
@@ -1391,8 +1394,8 @@ impl<S: Encoder> Encodable<S> for SourceFile {
         self.source_len.encode(s);
 
         // We are always in `Lines` form by the time we reach here.
-        assert!(self.lines.borrow().is_lines());
+        assert!(self.lines.read().is_lines());
-        self.lines(|lines| {
+        let lines = self.lines();
         // Store the length.
         s.emit_u32(lines.len() as u32);
 
@@ -1448,7 +1451,6 @@ impl<S: Encoder> Encodable<S> for SourceFile {
             }
             s.emit_raw_bytes(&raw_diffs);
         }
-        });
 
         self.multibyte_chars.encode(s);
         self.non_narrow_chars.encode(s);
@@ -1491,7 +1493,7 @@ impl<D: Decoder> Decodable<D> for SourceFile {
             // Unused - the metadata decoder will construct
             // a new SourceFile, filling in `external_src` properly
             external_src: FreezeLock::frozen(ExternalSource::Unneeded),
-            lines: Lock::new(lines),
+            lines: FreezeLock::new(lines),
             multibyte_chars,
             non_narrow_chars,
             normalized_pos,
@@ -1535,7 +1537,7 @@ impl SourceFile {
             external_src: FreezeLock::frozen(ExternalSource::Unneeded),
             start_pos: BytePos::from_u32(0),
             source_len: RelativeBytePos::from_u32(source_len),
-            lines: Lock::new(SourceFileLines::Lines(lines)),
+            lines: FreezeLock::frozen(SourceFileLines::Lines(lines)),
             multibyte_chars,
             non_narrow_chars,
             normalized_pos,
@@ -1544,14 +1546,18 @@ impl SourceFile {
         })
     }
 
-    pub fn lines<F, R>(&self, f: F) -> R
+    /// This converts the `lines` field to contain `SourceFileLines::Lines` if needed and freezes it.
-    where
+    fn convert_diffs_to_lines_frozen(&self) {
-        F: FnOnce(&[RelativeBytePos]) -> R,
+        let mut guard = if let Some(guard) = self.lines.try_write() { guard } else { return };
-    {
+
-        let mut guard = self.lines.borrow_mut();
+        let SourceFileDiffs { bytes_per_diff, num_diffs, raw_diffs } = match &*guard {
-        match &*guard {
+            SourceFileLines::Diffs(diffs) => diffs,
-            SourceFileLines::Lines(lines) => f(lines),
+            SourceFileLines::Lines(..) => {
-            SourceFileLines::Diffs(SourceFileDiffs { bytes_per_diff, num_diffs, raw_diffs }) => {
+                FreezeWriteGuard::freeze(guard);
+                return;
+            }
+        };
+
         // Convert from "diffs" form to "lines" form.
         let num_lines = num_diffs + 1;
         let mut lines = Vec::with_capacity(num_lines);
@@ -1591,18 +1597,31 @@ impl SourceFile {
             }
             _ => unreachable!(),
         }
-                let res = f(&lines);
+
         *guard = SourceFileLines::Lines(lines);
-                res
+
+        FreezeWriteGuard::freeze(guard);
     }
+
+    pub fn lines(&self) -> &[RelativeBytePos] {
+        if let Some(SourceFileLines::Lines(lines)) = self.lines.get() {
+            return &lines[..];
         }
+
+        cold_path(|| {
+            self.convert_diffs_to_lines_frozen();
+            if let Some(SourceFileLines::Lines(lines)) = self.lines.get() {
+                return &lines[..];
+            }
+            unreachable!()
+        })
     }
 
     /// Returns the `BytePos` of the beginning of the current line.
     pub fn line_begin_pos(&self, pos: BytePos) -> BytePos {
         let pos = self.relative_position(pos);
         let line_index = self.lookup_line(pos).unwrap();
-        let line_start_pos = self.lines(|lines| lines[line_index]);
+        let line_start_pos = self.lines()[line_index];
         self.absolute_position(line_start_pos)
     }
 
@@ -1662,7 +1681,7 @@ impl SourceFile {
         }
 
         let begin = {
-            let line = self.lines(|lines| lines.get(line_number).copied())?;
+            let line = self.lines().get(line_number).copied()?;
             line.to_usize()
         };
 
@@ -1686,7 +1705,7 @@ impl SourceFile {
     }
 
     pub fn count_lines(&self) -> usize {
-        self.lines(|lines| lines.len())
+        self.lines().len()
     }
 
     #[inline]
@@ -1709,7 +1728,7 @@ impl SourceFile {
     /// number. If the source_file is empty or the position is located before the
     /// first line, `None` is returned.
     pub fn lookup_line(&self, pos: RelativeBytePos) -> Option<usize> {
-        self.lines(|lines| lines.partition_point(|x| x <= &pos).checked_sub(1))
+        self.lines().partition_point(|x| x <= &pos).checked_sub(1)
     }
 
     pub fn line_bounds(&self, line_index: usize) -> Range<BytePos> {
@@ -1717,15 +1736,13 @@ impl SourceFile {
             return self.start_pos..self.start_pos;
         }
 
-        self.lines(|lines| {
+        let lines = self.lines();
         assert!(line_index < lines.len());
         if line_index == (lines.len() - 1) {
             self.absolute_position(lines[line_index])..self.end_position()
         } else {
-                self.absolute_position(lines[line_index])
+            self.absolute_position(lines[line_index])..self.absolute_position(lines[line_index + 1])
-                    ..self.absolute_position(lines[line_index + 1])
         }
-        })
     }
 
     /// Returns whether or not the file contains the given `SourceMap` byte
@@ -1811,7 +1828,7 @@ impl SourceFile {
         match self.lookup_line(pos) {
             Some(a) => {
                 let line = a + 1; // Line numbers start at 1
-                let linebpos = self.lines(|lines| lines[a]);
+                let linebpos = self.lines()[a];
                 let linechpos = self.bytepos_to_file_charpos(linebpos);
                 let col = chpos - linechpos;
                 debug!("byte pos {:?} is on the line at byte pos {:?}", pos, linebpos);
@@ -1831,7 +1848,7 @@ impl SourceFile {
         let (line, col_or_chpos) = self.lookup_file_pos(pos);
         if line > 0 {
             let col = col_or_chpos;
-            let linebpos = self.lines(|lines| lines[line - 1]);
+            let linebpos = self.lines()[line - 1];
             let col_display = {
                 let start_width_idx = self
                     .non_narrow_chars

compiler/rustc_span/src/source_map.rs

@@ -328,7 +328,7 @@ impl SourceMap {
         name_hash: Hash128,
         source_len: u32,
         cnum: CrateNum,
-        file_local_lines: Lock<SourceFileLines>,
+        file_local_lines: FreezeLock<SourceFileLines>,
         multibyte_chars: Vec<MultiByteChar>,
         non_narrow_chars: Vec<NonNarrowChar>,
         normalized_pos: Vec<NormalizedPos>,

compiler/rustc_span/src/source_map/tests.rs

@@ -1,6 +1,6 @@
 use super::*;
 
-use rustc_data_structures::sync::Lrc;
+use rustc_data_structures::sync::{FreezeLock, Lrc};
 
 fn init_source_map() -> SourceMap {
     let sm = SourceMap::new(FilePathMapping::empty());
@@ -246,7 +246,7 @@ fn t10() {
         name_hash,
         source_len.to_u32(),
         CrateNum::new(0),
-        lines,
+        FreezeLock::new(lines.read().clone()),
         multibyte_chars,
         non_narrow_chars,
         normalized_pos,

compiler/rustc_span/src/tests.rs

@@ -7,9 +7,7 @@ fn test_lookup_line() {
         SourceFile::new(FileName::Anon(Hash64::ZERO), source, SourceFileHashAlgorithm::Sha256)
             .unwrap();
     sf.start_pos = BytePos(3);
-    sf.lines(|lines| {
+    assert_eq!(sf.lines(), &[RelativeBytePos(0), RelativeBytePos(14), RelativeBytePos(25)]);
-        assert_eq!(lines, &[RelativeBytePos(0), RelativeBytePos(14), RelativeBytePos(25)])
-    });
 
     assert_eq!(sf.lookup_line(RelativeBytePos(0)), Some(0));
     assert_eq!(sf.lookup_line(RelativeBytePos(1)), Some(0));

src/tools/clippy/clippy_lints/src/undocumented_unsafe_blocks.rs

@@ -507,20 +507,18 @@ fn item_has_safety_comment(cx: &LateContext<'_>, item: &hir::Item<'_>) -> HasSaf
             && Lrc::ptr_eq(&unsafe_line.sf, &comment_start_line.sf)
             && let Some(src) = unsafe_line.sf.src.as_deref()
         {
-            return unsafe_line.sf.lines(|lines| {
+            return if comment_start_line.line >= unsafe_line.line {
-                if comment_start_line.line >= unsafe_line.line {
                 HasSafetyComment::No
             } else {
                 match text_has_safety_comment(
                     src,
-                        &lines[comment_start_line.line + 1..=unsafe_line.line],
+                    &unsafe_line.sf.lines()[comment_start_line.line + 1..=unsafe_line.line],
                     unsafe_line.sf.start_pos,
                 ) {
                     Some(b) => HasSafetyComment::Yes(b),
                     None => HasSafetyComment::No,
                 }
-                }
+            };
-            });
         }
     }
     HasSafetyComment::Maybe
@@ -551,20 +549,18 @@ fn stmt_has_safety_comment(cx: &LateContext<'_>, span: Span, hir_id: HirId) -> H
             && Lrc::ptr_eq(&unsafe_line.sf, &comment_start_line.sf)
             && let Some(src) = unsafe_line.sf.src.as_deref()
         {
-            return unsafe_line.sf.lines(|lines| {
+            return if comment_start_line.line >= unsafe_line.line {
-                if comment_start_line.line >= unsafe_line.line {
                 HasSafetyComment::No
             } else {
                 match text_has_safety_comment(
                     src,
-                        &lines[comment_start_line.line + 1..=unsafe_line.line],
+                    &unsafe_line.sf.lines()[comment_start_line.line + 1..=unsafe_line.line],
                     unsafe_line.sf.start_pos,
                 ) {
                     Some(b) => HasSafetyComment::Yes(b),
                     None => HasSafetyComment::No,
                 }
-                }
+            };
-            });
         }
     }
     HasSafetyComment::Maybe
@@ -614,11 +610,10 @@ fn span_from_macro_expansion_has_safety_comment(cx: &LateContext<'_>, span: Span
             && Lrc::ptr_eq(&unsafe_line.sf, &macro_line.sf)
             && let Some(src) = unsafe_line.sf.src.as_deref()
         {
-            unsafe_line.sf.lines(|lines| {
             if macro_line.line < unsafe_line.line {
                 match text_has_safety_comment(
                     src,
-                        &lines[macro_line.line + 1..=unsafe_line.line],
+                    &unsafe_line.sf.lines()[macro_line.line + 1..=unsafe_line.line],
                     unsafe_line.sf.start_pos,
                 ) {
                     Some(b) => HasSafetyComment::Yes(b),
@@ -627,7 +622,6 @@ fn span_from_macro_expansion_has_safety_comment(cx: &LateContext<'_>, span: Span
             } else {
                 HasSafetyComment::No
             }
-            })
         } else {
             // Problem getting source text. Pretend a comment was found.
             HasSafetyComment::Maybe
@@ -671,13 +665,11 @@ fn span_in_body_has_safety_comment(cx: &LateContext<'_>, span: Span) -> bool {
             // Get the text from the start of function body to the unsafe block.
             //     fn foo() { some_stuff; unsafe { stuff }; other_stuff; }
             //              ^-------------^
-            unsafe_line.sf.lines(|lines| {
             body_line.line < unsafe_line.line && text_has_safety_comment(
                 src,
-                    &lines[body_line.line + 1..=unsafe_line.line],
+                &unsafe_line.sf.lines()[body_line.line + 1..=unsafe_line.line],
                 unsafe_line.sf.start_pos,
             ).is_some()
-            })
         } else {
             // Problem getting source text. Pretend a comment was found.
             true

src/tools/clippy/clippy_utils/src/source.rs

@@ -118,7 +118,7 @@ fn first_char_in_first_line<T: LintContext>(cx: &T, span: Span) -> Option<BytePo
 fn line_span<T: LintContext>(cx: &T, span: Span) -> Span {
     let span = original_sp(span, DUMMY_SP);
     let SourceFileAndLine { sf, line } = cx.sess().source_map().lookup_line(span.lo()).unwrap();
-    let line_start = sf.lines(|lines| lines[line]);
+    let line_start = sf.lines()[line];
     let line_start = sf.absolute_position(line_start);
     span.with_lo(line_start)
 }