Remove unmapped_path from SourceFile as information can be obtained from virtualized name

Author: cbeuw

compiler/rustc_expand/src/base.rs

@@ -1114,7 +1114,7 @@ impl<'a> ExtCtxt<'a> {
         // after macro expansion (that is, they are unhygienic).
         if !path.is_absolute() {
             let callsite = span.source_callsite();
-            let mut result = match self.source_map().span_to_unmapped_path(callsite) {
+            let mut result = match self.source_map().span_to_filename(callsite) {
                 FileName::Real(name) => name.into_local_path(),
                 FileName::DocTest(path, _) => path,
                 other => {

compiler/rustc_expand/src/expand.rs

@@ -361,7 +361,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
     // FIXME: Avoid visiting the crate as a `Mod` item,
     // make crate a first class expansion target instead.
     pub fn expand_crate(&mut self, mut krate: ast::Crate) -> ast::Crate {
-        let file_path = match self.cx.source_map().span_to_unmapped_path(krate.span) {
+        let file_path = match self.cx.source_map().span_to_filename(krate.span) {
             FileName::Real(name) => name.into_local_path(),
             other => PathBuf::from(other.to_string()),
         };

compiler/rustc_interface/src/passes.rs

@@ -575,7 +575,7 @@ fn write_out_deps(
             .iter()
             .filter(|fmap| fmap.is_real_file())
             .filter(|fmap| !fmap.is_imported())
-            .map(|fmap| escape_dep_filename(&fmap.unmapped_path.as_ref().unwrap_or(&fmap.name)))
+            .map(|fmap| escape_dep_filename(&fmap.name))
             .collect();
 
         if let Some(ref backend) = sess.opts.debugging_opts.codegen_backend {

compiler/rustc_middle/src/ich/impls_syntax.rs

@@ -62,7 +62,6 @@ impl<'a> HashStable<StableHashingContext<'a>> for SourceFile {
             name: _, // We hash the smaller name_hash instead of this
             name_hash,
             name_was_remapped,
-            unmapped_path: _,
             cnum,
             // Do not hash the source as it is not encoded
             src: _,

compiler/rustc_span/src/lib.rs

@@ -1120,10 +1120,6 @@ pub struct SourceFile {
     pub name: FileName,
     /// `true` if the `name` field above has been modified by `--remap-path-prefix`.
     pub name_was_remapped: bool,
-    /// The unmapped path of the file that the source came from.
-    /// Set to `None` if the `SourceFile` was imported from an external crate.
-    /// as it is not encoded.
-    pub unmapped_path: Option<FileName>,
     /// The complete source code.
     pub src: Option<Lrc<String>>,
     /// The source code's hash.
@@ -1274,7 +1270,6 @@ impl<D: Decoder> Decodable<D> for SourceFile {
             Ok(SourceFile {
                 name,
                 name_was_remapped,
-                unmapped_path: None,
                 start_pos,
                 end_pos,
                 src: None,
@@ -1303,7 +1298,6 @@ impl SourceFile {
     pub fn new(
         name: FileName,
         name_was_remapped: bool,
-        unmapped_path: FileName,
         mut src: String,
         start_pos: BytePos,
         hash_kind: SourceFileHashAlgorithm,
@@ -1326,7 +1320,6 @@ impl SourceFile {
         SourceFile {
             name,
             name_was_remapped,
-            unmapped_path: Some(unmapped_path),
             src: Some(Lrc::new(src)),
             src_hash,
             external_src: Lock::new(ExternalSource::Unneeded),

compiler/rustc_span/src/source_map.rs

@@ -127,30 +127,17 @@ pub struct StableSourceFileId(u128);
 // StableSourceFileId, perhaps built atop source_file.name_hash.
 impl StableSourceFileId {
     pub fn new(source_file: &SourceFile) -> StableSourceFileId {
-        StableSourceFileId::new_from_pieces(
-            &source_file.name,
-            source_file.name_was_remapped,
-            source_file.unmapped_path.as_ref(),
-        )
+        StableSourceFileId::new_from_pieces(&source_file.name, source_file.name_was_remapped)
     }
 
-    fn new_from_pieces(
-        name: &FileName,
-        name_was_remapped: bool,
-        unmapped_path: Option<&FileName>,
-    ) -> StableSourceFileId {
+    fn new_from_pieces(name: &FileName, name_was_remapped: bool) -> StableSourceFileId {
         let mut hasher = StableHasher::new();
 
-        if let FileName::Real(real_name) = name {
-            // rust-lang/rust#70924: Use the stable (virtualized) name when
-            // available. (We do not want artifacts from transient file system
-            // paths for libstd to leak into our build artifacts.)
-            real_name.stable_name().hash(&mut hasher)
-        } else {
-            name.hash(&mut hasher);
-        }
+        // If name was virtualized, we need to take both the local path
+        // and stablised path into account, in case two different paths were
+        // mapped to the same
+        name.hash(&mut hasher);
         name_was_remapped.hash(&mut hasher);
-        unmapped_path.hash(&mut hasher);
 
         StableSourceFileId(hasher.finish())
     }
@@ -286,25 +273,21 @@ impl SourceMap {
         filename: FileName,
         src: String,
     ) -> Result<Lrc<SourceFile>, OffsetOverflowError> {
-        // We need to preserve the unmapped path is as it is
-        // used to determine the directory for loading submodules and include files.
         // Note that filename may not be a valid path, eg it may be `<anon>` etc,
         // but this is okay because the directory determined by `path.pop()` will
         // be empty, so the working directory will be used.
-        let (mapped_filename, was_remapped) = self.path_mapping.map_filename_prefix(&filename);
+        let (filename, was_remapped) = self.path_mapping.map_filename_prefix(&filename);
 
-        let file_id =
-            StableSourceFileId::new_from_pieces(&mapped_filename, was_remapped, Some(&filename));
+        let file_id = StableSourceFileId::new_from_pieces(&filename, was_remapped);
 
         let lrc_sf = match self.source_file_by_stable_id(file_id) {
             Some(lrc_sf) => lrc_sf,
             None => {
                 let start_pos = self.allocate_address_space(src.len())?;
 
                 let source_file = Lrc::new(SourceFile::new(
-                    mapped_filename,
-                    was_remapped,
                     filename,
+                    was_remapped,
                     src,
                     Pos::from_usize(start_pos),
                     self.hash_kind,
@@ -368,7 +351,6 @@ impl SourceMap {
         let source_file = Lrc::new(SourceFile {
             name: filename,
             name_was_remapped: name_was_remapped || name_is_remapped,
-            unmapped_path: None,
             src: None,
             src_hash,
             external_src: Lock::new(ExternalSource::Foreign {
@@ -459,14 +441,6 @@ impl SourceMap {
         self.lookup_char_pos(sp.lo()).file.name.clone()
     }
 
-    pub fn span_to_unmapped_path(&self, sp: Span) -> FileName {
-        self.lookup_char_pos(sp.lo())
-            .file
-            .unmapped_path
-            .clone()
-            .expect("`SourceMap::span_to_unmapped_path` called for imported `SourceFile`?")
-    }
-
     pub fn is_multiline(&self, sp: Span) -> bool {
         let lo = self.lookup_char_pos(sp.lo());
         let hi = self.lookup_char_pos(sp.hi());

src/librustdoc/doctest.rs

@@ -792,8 +792,6 @@ impl Tester for Collector {
         let target = self.options.target.clone();
         let target_str = target.to_string();
 
-        // FIXME(#44940): if doctests ever support path remapping, then this filename
-        // needs to be the result of `SourceMap::span_to_unmapped_path`.
         let path = match &filename {
             FileName::Real(path) => path.local_path().to_path_buf(),
             _ => PathBuf::from(r"doctest.rs"),