Do not store copy of the full path for each SearchPathFile

Author: Kobzol

compiler/rustc_metadata/src/locator.rs

@@ -438,7 +438,8 @@ impl<'a> CrateLocator<'a> {
                 }
                 if let Some(matches) = spf.query(prefix, suffix) {
                     for (hash, spf) in matches {
-                        info!("lib candidate: {}", spf.path.display());
+                        let spf_path = spf.path();
+                        info!("lib candidate: {}", spf_path.display());
 
                         let (rlibs, rmetas, dylibs, interfaces) =
                             candidates.entry(hash).or_default();
@@ -447,21 +448,20 @@ impl<'a> CrateLocator<'a> {
                             // ones we've already seen. This allows us to ignore crates
                             // we know are exactual equal to ones we've already found.
                             // Going to the same crate through different symlinks does not change the result.
-                            let path = try_canonicalize(&spf.path)
-                                .unwrap_or_else(|_| spf.path.to_path_buf());
+                            let path =
+                                try_canonicalize(&spf_path).unwrap_or_else(|_| spf_path.clone());
                             if seen_paths.contains(&path) {
                                 continue;
                             };
                             seen_paths.insert(path);
                         }
                         // Use the original path (potentially with unresolved symlinks),
                         // filesystem code should not care, but this is nicer for diagnostics.
-                        let path = spf.path.to_path_buf();
                         match kind {
-                            CrateFlavor::Rlib => rlibs.insert(path),
-                            CrateFlavor::Rmeta => rmetas.insert(path),
-                            CrateFlavor::Dylib => dylibs.insert(path),
-                            CrateFlavor::SDylib => interfaces.insert(path),
+                            CrateFlavor::Rlib => rlibs.insert(spf_path),
+                            CrateFlavor::Rmeta => rmetas.insert(spf_path),
+                            CrateFlavor::Dylib => dylibs.insert(spf_path),
+                            CrateFlavor::SDylib => interfaces.insert(spf_path),
                         };
                     }
                 }
@@ -471,10 +471,9 @@ impl<'a> CrateLocator<'a> {
                 .flatten()
             {
                 for (_, spf) in static_matches {
-                    crate_rejections.via_kind.push(CrateMismatch {
-                        path: spf.path.to_path_buf(),
-                        got: "static".to_string(),
-                    });
+                    crate_rejections
+                        .via_kind
+                        .push(CrateMismatch { path: spf.path(), got: "static".to_string() });
                 }
             }
         }

compiler/rustc_session/src/search_paths.rs

@@ -61,8 +61,16 @@ impl FilesIndex {
 /// UTF-8, and so a non-UTF-8 filename couldn't be one we're looking for.)
 #[derive(Clone, Debug)]
 pub struct SearchPathFile {
-    pub path: Arc<Path>,
-    pub file_name_str: Arc<str>,
+    // We store the directory in a shared Arc, as many files can share the same directory.
+    dir: Arc<Path>,
+    file_name_str: Arc<str>,
+}
+
+impl SearchPathFile {
+    /// Constructs the full path to the file.
+    pub fn path(&self) -> PathBuf {
+        self.dir.join(&*self.file_name_str)
+    }
 }
 
 #[derive(PartialEq, Clone, Copy, Debug, Hash, Eq, Encodable, Decodable, HashStable_Generic)]
@@ -129,18 +137,19 @@ impl SearchPath {
     }
 
     pub fn new(kind: PathKind, dir: PathBuf) -> Self {
+        let dir_file: Arc<Path> = dir.clone().into();
         // Get the files within the directory.
         let mut files = match std::fs::read_dir(&dir) {
             Ok(files) => files
                 .filter_map(|e| {
                     e.ok().and_then(|e| {
                         e.file_name().to_str().map(|s| {
                             let file_name_str: Arc<str> = s.into();
-                            SearchPathFile { path: e.path().into(), file_name_str }
+                            SearchPathFile { dir: dir_file.clone(), file_name_str }
                         })
                     })
                 })
-                .collect::<Vec<_>>(),
+                .collect::<Vec<SearchPathFile>>(),
 
             Err(..) => Default::default(),
         };