refactor(layout): Moved Layout accessors to BuildDirLayout and ArtifactDirLayout

Author: ranger-ross

src/cargo/core/compiler/build_context/target_info.rs

@@ -1141,7 +1141,7 @@ impl RustDocFingerprint {
 
         let fingerprint_path = build_runner
             .files()
-            .host_root()
+            .host_build_root()
             .join(".rustdoc_fingerprint.json");
         let write_fingerprint = || -> CargoResult<()> {
             paths::write(
@@ -1181,7 +1181,7 @@ impl RustDocFingerprint {
             .bcx
             .all_kinds
             .iter()
-            .map(|kind| build_runner.files().layout(*kind).doc())
+            .map(|kind| build_runner.files().layout(*kind).artifact_dir().doc())
             .filter(|path| path.exists())
             .try_for_each(|path| clean_doc(path))?;
         write_fingerprint()?;

src/cargo/core/compiler/build_runner/compilation_files.rs

@@ -211,13 +211,13 @@ impl<'a, 'gctx: 'a> CompilationFiles<'a, 'gctx> {
         // Docscrape units need to have doc/ set as the out_dir so sources for reverse-dependencies
         // will be put into doc/ and not into deps/ where the *.examples files are stored.
         if unit.mode.is_doc() || unit.mode.is_doc_scrape() {
-            self.layout(unit.kind).doc().to_path_buf()
+            self.layout(unit.kind).artifact_dir().doc().to_path_buf()
         } else if unit.mode.is_doc_test() {
             panic!("doc tests do not have an out dir");
         } else if unit.target.is_custom_build() {
             self.build_script_dir(unit)
         } else if unit.target.is_example() {
-            self.layout(unit.kind).build_examples().to_path_buf()
+            self.layout(unit.kind).build_dir().examples().to_path_buf()
         } else if unit.artifact.is_true() {
             self.artifact_dir(unit)
         } else {
@@ -250,41 +250,41 @@ impl<'a, 'gctx: 'a> CompilationFiles<'a, 'gctx> {
 
     /// Returns the final artifact path for the host (`/…/target/debug`)
     pub fn host_dest(&self) -> &Path {
-        self.host.dest()
+        self.host.artifact_dir().dest()
     }
 
-    /// Returns the root of the build output tree for the host (`/…/target`)
-    pub fn host_root(&self) -> &Path {
-        self.host.root()
+    /// Returns the root of the build output tree for the host (`/…/build-dir`)
+    pub fn host_build_root(&self) -> &Path {
+        self.host.build_dir().root()
     }
 
     /// Returns the host `deps` directory path.
     pub fn host_deps(&self, unit: &Unit) -> PathBuf {
         let dir = self.pkg_dir(unit);
-        self.host.deps(&dir)
+        self.host.build_dir().deps(&dir)
     }
 
     /// Returns the directories where Rust crate dependencies are found for the
     /// specified unit.
     pub fn deps_dir(&self, unit: &Unit) -> PathBuf {
         let dir = self.pkg_dir(unit);
-        self.layout(unit.kind).deps(&dir)
+        self.layout(unit.kind).build_dir().deps(&dir)
     }
 
     /// Directory where the fingerprint for the given unit should go.
     pub fn fingerprint_dir(&self, unit: &Unit) -> PathBuf {
         let dir = self.pkg_dir(unit);
-        self.layout(unit.kind).fingerprint(&dir)
+        self.layout(unit.kind).build_dir().fingerprint(&dir)
     }
 
     /// Directory where incremental output for the given unit should go.
     pub fn incremental_dir(&self, unit: &Unit) -> &Path {
-        self.layout(unit.kind).incremental()
+        self.layout(unit.kind).build_dir().incremental()
     }
 
     /// Directory where timing output should go.
     pub fn timings_dir(&self) -> &Path {
-        self.host.timings()
+        self.host.artifact_dir().timings()
     }
 
     /// Returns the path for a file in the fingerprint directory.
@@ -319,7 +319,9 @@ impl<'a, 'gctx: 'a> CompilationFiles<'a, 'gctx> {
         assert!(!unit.mode.is_run_custom_build());
         assert!(self.metas.contains_key(unit));
         let dir = self.pkg_dir(unit);
-        self.layout(CompileKind::Host).build_script(&dir)
+        self.layout(CompileKind::Host)
+            .build_dir()
+            .build_script(&dir)
     }
 
     /// Returns the directory for compiled artifacts files.
@@ -343,7 +345,11 @@ impl<'a, 'gctx: 'a> CompilationFiles<'a, 'gctx> {
                 invalid
             ),
         };
-        self.layout(unit.kind).artifact().join(dir).join(kind)
+        self.layout(unit.kind)
+            .build_dir()
+            .artifact()
+            .join(dir)
+            .join(kind)
     }
 
     /// Returns the directory where information about running a build script
@@ -353,7 +359,9 @@ impl<'a, 'gctx: 'a> CompilationFiles<'a, 'gctx> {
         assert!(unit.target.is_custom_build());
         assert!(unit.mode.is_run_custom_build());
         let dir = self.pkg_dir(unit);
-        self.layout(unit.kind).build_script_execution(&dir)
+        self.layout(unit.kind)
+            .build_dir()
+            .build_script_execution(&dir)
     }
 
     /// Returns the "`OUT_DIR`" directory for running a build script.
@@ -372,7 +380,7 @@ impl<'a, 'gctx: 'a> CompilationFiles<'a, 'gctx> {
         bcx: &BuildContext<'_, '_>,
     ) -> CargoResult<PathBuf> {
         assert!(target.is_bin());
-        let dest = self.layout(kind).dest();
+        let dest = self.layout(kind).artifact_dir().dest();
         let info = bcx.target_data.info(kind);
         let (file_types, _) = info
             .rustc_outputs(
@@ -440,11 +448,14 @@ impl<'a, 'gctx: 'a> CompilationFiles<'a, 'gctx> {
         let filename = file_type.uplift_filename(&unit.target);
         let uplift_path = if unit.target.is_example() {
             // Examples live in their own little world.
-            self.layout(unit.kind).examples().join(filename)
+            self.layout(unit.kind)
+                .artifact_dir()
+                .examples()
+                .join(filename)
         } else if unit.target.is_custom_build() {
             self.build_script_dir(unit).join(filename)
         } else {
-            self.layout(unit.kind).dest().join(filename)
+            self.layout(unit.kind).artifact_dir().dest().join(filename)
         };
         if from_path == uplift_path {
             // This can happen with things like examples that reside in the

src/cargo/core/compiler/build_runner/mod.rs

@@ -401,7 +401,7 @@ impl<'a, 'gctx> BuildRunner<'a, 'gctx> {
             let layout = files.layout(kind);
             self.compilation
                 .root_output
-                .insert(kind, layout.dest().to_path_buf());
+                .insert(kind, layout.artifact_dir().dest().to_path_buf());
             if self.bcx.gctx.cli_unstable().build_dir_new_layout {
                 for (unit, _) in self.bcx.unit_graph.iter() {
                     let dep_dir = self.files().deps_dir(unit);
@@ -411,7 +411,7 @@ impl<'a, 'gctx> BuildRunner<'a, 'gctx> {
             } else {
                 self.compilation
                     .deps_output
-                    .insert(kind, layout.legacy_deps().to_path_buf());
+                    .insert(kind, layout.build_dir().legacy_deps().to_path_buf());
             }
         }
         Ok(())

src/cargo/core/compiler/layout.rs

@@ -237,101 +237,125 @@ impl Layout {
 
     /// Makes sure all directories stored in the Layout exist on the filesystem.
     pub fn prepare(&mut self) -> CargoResult<()> {
-        if !self.build_dir.is_new_layout {
-            paths::create_dir_all(&self.build_dir.deps)?;
-            paths::create_dir_all(&self.build_dir.fingerprint)?;
-        }
-        paths::create_dir_all(&self.build_dir.incremental)?;
-        paths::create_dir_all(&self.artifact_dir.examples)?;
-        paths::create_dir_all(&self.build_dir.examples)?;
-        paths::create_dir_all(&self.build_dir.build)?;
+        self.artifact_dir.prepare()?;
+        self.build_dir.prepare()?;
 
         Ok(())
     }
 
+    pub fn artifact_dir(&self) -> &ArtifactDirLayout {
+        &self.artifact_dir
+    }
+
+    pub fn build_dir(&self) -> &BuildDirLayout {
+        &self.build_dir
+    }
+}
+
+impl ArtifactDirLayout {
+    /// Makes sure all directories stored in the Layout exist on the filesystem.
+    pub fn prepare(&mut self) -> CargoResult<()> {
+        paths::create_dir_all(&self.examples)?;
+
+        Ok(())
+    }
     /// Fetch the destination path for final artifacts  (`/…/target/debug`).
     pub fn dest(&self) -> &Path {
-        &self.artifact_dir.dest
+        &self.dest
+    }
+    /// Fetch the examples path.
+    pub fn examples(&self) -> &Path {
+        &self.examples
+    }
+    /// Fetch the doc path.
+    pub fn doc(&self) -> &Path {
+        &self.doc
+    }
+    /// Fetch the cargo-timings path.
+    pub fn timings(&self) -> &Path {
+        &self.timings
+    }
+}
+
+impl BuildDirLayout {
+    /// Makes sure all directories stored in the Layout exist on the filesystem.
+    pub fn prepare(&mut self) -> CargoResult<()> {
+        if !self.is_new_layout {
+            paths::create_dir_all(&self.deps)?;
+            paths::create_dir_all(&self.fingerprint)?;
+        }
+        paths::create_dir_all(&self.incremental)?;
+        paths::create_dir_all(&self.examples)?;
+        paths::create_dir_all(&self.build)?;
+
+        Ok(())
     }
     /// Fetch the deps path.
     pub fn deps(&self, pkg_dir: &str) -> PathBuf {
-        if self.build_dir.is_new_layout {
+        if self.is_new_layout {
             self.build_unit(pkg_dir).join("deps")
         } else {
             self.legacy_deps().to_path_buf()
         }
     }
     /// Fetch the deps path. (old layout)
     pub fn legacy_deps(&self) -> &Path {
-        &self.build_dir.deps
+        &self.deps
     }
-    /// Fetch the examples path.
-    pub fn examples(&self) -> &Path {
-        &self.artifact_dir.examples
+    pub fn root(&self) -> &Path {
+        &self.root
     }
     /// Fetch the build examples path.
-    pub fn build_examples(&self) -> &Path {
-        &self.build_dir.examples
-    }
-    /// Fetch the doc path.
-    pub fn doc(&self) -> &Path {
-        &self.artifact_dir.doc
-    }
-    /// Fetch the root path (`/…/target`).
-    pub fn root(&self) -> &Path {
-        &self.build_dir.root
+    pub fn examples(&self) -> &Path {
+        &self.examples
     }
     /// Fetch the incremental path.
     pub fn incremental(&self) -> &Path {
-        &self.build_dir.incremental
-    }
-    /// Fetch the timings path.
-    pub fn timings(&self) -> &Path {
-        &self.artifact_dir.timings
+        &self.incremental
     }
     /// Fetch the fingerprint path.
     pub fn fingerprint(&self, pkg_dir: &str) -> PathBuf {
-        if self.build_dir.is_new_layout {
+        if self.is_new_layout {
             self.build_unit(pkg_dir).join("fingerprint")
         } else {
             self.legacy_fingerprint().to_path_buf().join(pkg_dir)
         }
     }
     /// Fetch the fingerprint path. (old layout)
     pub fn legacy_fingerprint(&self) -> &Path {
-        &self.build_dir.fingerprint
+        &self.fingerprint
     }
     /// Fetch the build path.
     pub fn build(&self) -> &Path {
-        &self.build_dir.build
+        &self.build
     }
     /// Fetch the build script path.
     pub fn build_script(&self, pkg_dir: &str) -> PathBuf {
-        if self.build_dir.is_new_layout {
+        if self.is_new_layout {
             self.build_unit(pkg_dir).join("build-script")
         } else {
             self.build().join(pkg_dir)
         }
     }
     /// Fetch the build script execution path.
     pub fn build_script_execution(&self, pkg_dir: &str) -> PathBuf {
-        if self.build_dir.is_new_layout {
+        if self.is_new_layout {
             self.build_unit(pkg_dir).join("build-script-execution")
         } else {
             self.build().join(pkg_dir)
         }
     }
     /// Fetch the artifact path.
     pub fn artifact(&self) -> &Path {
-        &self.build_dir.artifact
+        &self.artifact
     }
     /// Fetch the build unit path
     pub fn build_unit(&self, pkg_dir: &str) -> PathBuf {
         self.build().join(pkg_dir)
     }
     /// Create and return the tmp path.
     pub fn prepare_tmp(&self) -> CargoResult<&Path> {
-        paths::create_dir_all(&self.build_dir.tmp)?;
-        Ok(&self.build_dir.tmp)
+        paths::create_dir_all(&self.tmp)?;
+        Ok(&self.tmp)
     }
 }

src/cargo/core/compiler/mod.rs

@@ -781,7 +781,11 @@ fn prepare_rustc(build_runner: &BuildRunner<'_, '_>, unit: &Unit) -> CargoResult
     }
 
     if unit.target.is_test() || unit.target.is_bench() {
-        let tmp = build_runner.files().layout(unit.kind).prepare_tmp()?;
+        let tmp = build_runner
+            .files()
+            .layout(unit.kind)
+            .build_dir()
+            .prepare_tmp()?;
         base.env("CARGO_TARGET_TMPDIR", tmp.display().to_string());
     }
 

src/cargo/core/compiler/output_depinfo.rs

@@ -58,7 +58,7 @@ fn add_deps_for_unit(
         let dep_info_loc = fingerprint::dep_info_loc(build_runner, unit);
         if let Some(paths) = fingerprint::parse_dep_info(
             unit.pkg.root(),
-            build_runner.files().host_root(),
+            build_runner.files().host_build_root(),
             &dep_info_loc,
         )? {
             for path in paths.files.into_keys() {