Apply --remap-path-prefix to imported sources

RealFileName::Devirtualized is renamed to Virtualized as it is
also used to store remapped paths (in virtual_name) along with
original path (in local_path)

Author: cbeuw

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -1671,7 +1671,7 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
                                     virtual_name.display(),
                                     new_path.display(),
                                 );
-                                let new_name = rustc_span::RealFileName::Devirtualized {
+                                let new_name = rustc_span::RealFileName::Virtualized {
                                     local_path: new_path,
                                     virtual_name,
                                 };

compiler/rustc_span/src/lib.rs

@@ -114,17 +114,16 @@ pub fn with_default_session_globals<R>(f: impl FnOnce() -> R) -> R {
 // deserialization.
 scoped_tls::scoped_thread_local!(pub static SESSION_GLOBALS: SessionGlobals);
 
-// FIXME: Perhaps this should not implement Rustc{Decodable, Encodable}
-//
 // FIXME: We should use this enum or something like it to get rid of the
 // use of magic `/rust/1.x/...` paths across the board.
 #[derive(Debug, Eq, PartialEq, Clone, Ord, PartialOrd, Hash)]
 #[derive(HashStable_Generic, Decodable, Encodable)]
 pub enum RealFileName {
     Named(PathBuf),
-    /// For de-virtualized paths (namely paths into libstd that have been mapped
-    /// to the appropriate spot on the local host's file system),
-    Devirtualized {
+    /// For virtualized paths (namely paths into libstd that have been mapped
+    /// to the appropriate spot on the local host's file system, and local file
+    /// system paths that have been remapped with `FilePathMapping`),
+    Virtualized {
         /// `local_path` is the (host-dependent) local path to the file.
         local_path: PathBuf,
         /// `virtual_name` is the stable path rustc will store internally within
@@ -139,7 +138,7 @@ impl RealFileName {
     pub fn local_path(&self) -> &Path {
         match self {
             RealFileName::Named(p)
-            | RealFileName::Devirtualized { local_path: p, virtual_name: _ } => &p,
+            | RealFileName::Virtualized { local_path: p, virtual_name: _ } => &p,
         }
     }
 
@@ -148,7 +147,7 @@ impl RealFileName {
     pub fn into_local_path(self) -> PathBuf {
         match self {
             RealFileName::Named(p)
-            | RealFileName::Devirtualized { local_path: p, virtual_name: _ } => p,
+            | RealFileName::Virtualized { local_path: p, virtual_name: _ } => p,
         }
     }
 
@@ -159,7 +158,7 @@ impl RealFileName {
     pub fn stable_name(&self) -> &Path {
         match self {
             RealFileName::Named(p)
-            | RealFileName::Devirtualized { local_path: _, virtual_name: p } => &p,
+            | RealFileName::Virtualized { local_path: _, virtual_name: p } => &p,
         }
     }
 }
@@ -192,13 +191,7 @@ impl std::fmt::Display for FileName {
     fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         use FileName::*;
         match *self {
-            Real(RealFileName::Named(ref path)) => write!(fmt, "{}", path.display()),
-            // FIXME: might be nice to display both components of Devirtualized.
-            // But for now (to backport fix for issue #70924), best to not
-            // perturb diagnostics so its obvious test suite still works.
-            Real(RealFileName::Devirtualized { ref local_path, virtual_name: _ }) => {
-                write!(fmt, "{}", local_path.display())
-            }
+            Real(ref name) => write!(fmt, "{}", name.stable_name().display()),
             QuoteExpansion(_) => write!(fmt, "<quote expansion>"),
             MacroExpansion(_) => write!(fmt, "<macro expansion>"),
             Anon(_) => write!(fmt, "<anon>"),
@@ -1129,6 +1122,7 @@ pub struct SourceFile {
     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>>,

compiler/rustc_span/src/source_map.rs

@@ -15,11 +15,11 @@ pub use crate::*;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::stable_hasher::StableHasher;
 use rustc_data_structures::sync::{AtomicU32, Lrc, MappedReadGuard, ReadGuard, RwLock};
-use std::cmp;
 use std::convert::TryFrom;
 use std::hash::Hash;
 use std::path::{Path, PathBuf};
 use std::sync::atomic::Ordering;
+use std::{clone::Clone, cmp};
 
 use std::fs;
 use std::io;
@@ -283,45 +283,28 @@ impl SourceMap {
 
     fn try_new_source_file(
         &self,
-        mut filename: FileName,
+        filename: FileName,
         src: String,
     ) -> Result<Lrc<SourceFile>, OffsetOverflowError> {
-        // The path is used to determine the directory for loading submodules and
-        // include files, so it must be before remapping.
+        // 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 unmapped_path = filename.clone();
-
-        let was_remapped;
-        if let FileName::Real(real_filename) = &mut filename {
-            match real_filename {
-                RealFileName::Named(path_to_be_remapped)
-                | RealFileName::Devirtualized {
-                    local_path: path_to_be_remapped,
-                    virtual_name: _,
-                } => {
-                    let mapped = self.path_mapping.map_prefix(path_to_be_remapped.clone());
-                    was_remapped = mapped.1;
-                    *path_to_be_remapped = mapped.0;
-                }
-            }
-        } else {
-            was_remapped = false;
-        }
+        let (mapped_filename, was_remapped) = self.path_mapping.map_filename_prefix(&filename);
 
         let file_id =
-            StableSourceFileId::new_from_pieces(&filename, was_remapped, Some(&unmapped_path));
+            StableSourceFileId::new_from_pieces(&mapped_filename, was_remapped, Some(&filename));
 
         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(
-                    filename,
+                    mapped_filename,
                     was_remapped,
-                    unmapped_path,
+                    filename,
                     src,
                     Pos::from_usize(start_pos),
                     self.hash_kind,
@@ -380,9 +363,11 @@ impl SourceMap {
             nc.pos = nc.pos + start_pos;
         }
 
+        let (filename, name_is_remapped) = self.path_mapping.map_filename_prefix(&filename);
+
         let source_file = Lrc::new(SourceFile {
             name: filename,
-            name_was_remapped,
+            name_was_remapped: name_was_remapped || name_is_remapped,
             unmapped_path: None,
             src: None,
             src_hash,
@@ -1046,9 +1031,26 @@ impl FilePathMapping {
     fn map_filename_prefix(&self, file: &FileName) -> (FileName, bool) {
         match file {
             FileName::Real(realfile) => {
-                let path = realfile.local_path();
-                let (path, mapped) = self.map_prefix(path.to_path_buf());
-                (FileName::Real(RealFileName::Named(path)), mapped)
+                // If the file is the Name variant with only local_path, then clearly we want to map that
+                // to a virtual_name
+                // If the file is already Virtualized, then we want to map virtual_name further
+                // but we leave local_path alone
+                let path = realfile.stable_name();
+                let (mapped_path, mapped) = self.map_prefix(path.to_path_buf());
+                if mapped {
+                    let mapped_realfile = match realfile {
+                        RealFileName::Named(local_path)
+                        | RealFileName::Virtualized { local_path, virtual_name: _ } => {
+                            RealFileName::Virtualized {
+                                local_path: local_path.clone(),
+                                virtual_name: mapped_path,
+                            }
+                        }
+                    };
+                    (FileName::Real(mapped_realfile), mapped)
+                } else {
+                    (file.clone(), false)
+                }
             }
             other => (other.clone(), false),
         }