refactor(layout): made artifact_dir optional in Layout

Author: ranger-ross

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

@@ -1181,7 +1181,14 @@ impl RustDocFingerprint {
             .bcx
             .all_kinds
             .iter()
-            .map(|kind| build_runner.files().layout(*kind).artifact_dir().doc())
+            .map(|kind| {
+                build_runner
+                    .files()
+                    .layout(*kind)
+                    .artifact_dir()
+                    .expect("artifact-dir was not locked")
+                    .doc()
+            })
             .filter(|path| path.exists())
             .try_for_each(|path| clean_doc(path))?;
         write_fingerprint()?;

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

@@ -211,7 +211,11 @@ 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).artifact_dir().doc().to_path_buf()
+            self.layout(unit.kind)
+                .artifact_dir()
+                .expect("artifact-dir was not locked")
+                .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() {
@@ -249,8 +253,8 @@ 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.artifact_dir().dest()
+    pub fn host_dest(&self) -> Option<&Path> {
+        self.host.artifact_dir().map(|v| v.dest())
     }
 
     /// Returns the root of the build output tree for the host (`/…/build-dir`)
@@ -283,8 +287,8 @@ impl<'a, 'gctx: 'a> CompilationFiles<'a, 'gctx> {
     }
 
     /// Directory where timing output should go.
-    pub fn timings_dir(&self) -> &Path {
-        self.host.artifact_dir().timings()
+    pub fn timings_dir(&self) -> Option<&Path> {
+        self.host.artifact_dir().map(|v| v.timings())
     }
 
     /// Returns the path for a file in the fingerprint directory.
@@ -378,9 +382,11 @@ impl<'a, 'gctx: 'a> CompilationFiles<'a, 'gctx> {
         target: &Target,
         kind: CompileKind,
         bcx: &BuildContext<'_, '_>,
-    ) -> CargoResult<PathBuf> {
+    ) -> CargoResult<Option<PathBuf>> {
         assert!(target.is_bin());
-        let dest = self.layout(kind).artifact_dir().dest();
+        let Some(dest) = self.layout(kind).artifact_dir().map(|v| v.dest()) else {
+            return Ok(None);
+        };
         let info = bcx.target_data.info(kind);
         let (file_types, _) = info
             .rustc_outputs(
@@ -396,7 +402,7 @@ impl<'a, 'gctx: 'a> CompilationFiles<'a, 'gctx> {
             .find(|file_type| file_type.flavor == FileFlavor::Normal)
             .expect("target must support `bin`");
 
-        Ok(dest.join(file_type.uplift_filename(target)))
+        Ok(Some(dest.join(file_type.uplift_filename(target))))
     }
 
     /// Returns the filenames that the given unit will generate.
@@ -450,12 +456,17 @@ impl<'a, 'gctx: 'a> CompilationFiles<'a, 'gctx> {
             // Examples live in their own little world.
             self.layout(unit.kind)
                 .artifact_dir()
+                .expect("artifact-dir was not locked")
                 .examples()
                 .join(filename)
         } else if unit.target.is_custom_build() {
             self.build_script_dir(unit).join(filename)
         } else {
-            self.layout(unit.kind).artifact_dir().dest().join(filename)
+            self.layout(unit.kind)
+                .artifact_dir()
+                .expect("artifact-dir was not locked")
+                .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

@@ -10,7 +10,7 @@ use crate::core::compiler::{self, Unit, artifact};
 use crate::util::cache_lock::CacheLockMode;
 use crate::util::errors::CargoResult;
 use annotate_snippets::{Level, Message};
-use anyhow::{Context as _, bail};
+use anyhow::{Context, bail};
 use cargo_util::paths;
 use filetime::FileTime;
 use itertools::Itertools;
@@ -392,9 +392,11 @@ impl<'a, 'gctx> BuildRunner<'a, 'gctx> {
         let files = self.files.as_ref().unwrap();
         for &kind in self.bcx.all_kinds.iter() {
             let layout = files.layout(kind);
-            self.compilation
-                .root_output
-                .insert(kind, layout.artifact_dir().dest().to_path_buf());
+            if let Some(artifact_dir) = layout.artifact_dir() {
+                self.compilation
+                    .root_output
+                    .insert(kind, 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);

src/cargo/core/compiler/compilation.rs

@@ -305,12 +305,14 @@ impl<'gctx> Compilation<'gctx> {
             }
             search_path.push(self.deps_output[&CompileKind::Host].clone());
         } else {
-            search_path.extend(super::filter_dynamic_search_path(
-                self.native_dirs.iter(),
-                &self.root_output[&kind],
-            ));
+            if let Some(path) = self.root_output.get(&kind) {
+                search_path.extend(super::filter_dynamic_search_path(
+                    self.native_dirs.iter(),
+                    path,
+                ));
+                search_path.push(path.clone());
+            }
             search_path.push(self.deps_output[&kind].clone());
-            search_path.push(self.root_output[&kind].clone());
             // For build-std, we don't want to accidentally pull in any shared
             // libs from the sysroot that ships with rustc. This may not be
             // required (at least I cannot craft a situation where it

src/cargo/core/compiler/custom_build.rs

@@ -473,7 +473,7 @@ fn build_work(build_runner: &mut BuildRunner<'_, '_>, unit: &Unit) -> CargoResul
     let output_file = script_run_dir.join("output");
     let err_file = script_run_dir.join("stderr");
     let root_output_file = script_run_dir.join("root-output");
-    let host_target_root = build_runner.files().host_dest().to_path_buf();
+    let host_target_root = build_runner.files().host_dest().map(|v| v.to_path_buf());
     let all = (
         id,
         library_name.clone(),
@@ -541,12 +541,14 @@ fn build_work(build_runner: &mut BuildRunner<'_, '_>, unit: &Unit) -> CargoResul
                     );
                 }
             }
-            if let Some(build_scripts) = build_scripts {
+            if let Some(build_scripts) = build_scripts
+                && let Some(ref host_target_root) = host_target_root
+            {
                 super::add_plugin_deps(
                     &mut cmd,
                     &build_script_outputs,
                     &build_scripts,
-                    &host_target_root,
+                    host_target_root,
                 )?;
             }
         }

src/cargo/core/compiler/layout.rs

@@ -112,7 +112,7 @@ use std::path::{Path, PathBuf};
 ///
 /// See module docs for more information.
 pub struct Layout {
-    artifact_dir: ArtifactDirLayout,
+    artifact_dir: Option<ArtifactDirLayout>,
     build_dir: BuildDirLayout,
 }
 
@@ -177,13 +177,13 @@ impl Layout {
         let artifact = deps.join("artifact");
 
         Ok(Layout {
-            artifact_dir: ArtifactDirLayout {
+            artifact_dir: Some(ArtifactDirLayout {
                 dest: dest.clone(),
                 examples: dest.join("examples"),
                 doc: root.join("doc"),
                 timings: root.join("cargo-timings"),
                 _lock: artifact_dir_lock,
-            },
+            }),
             build_dir: BuildDirLayout {
                 root: build_root.clone(),
                 deps,
@@ -201,14 +201,16 @@ impl Layout {
 
     /// Makes sure all directories stored in the Layout exist on the filesystem.
     pub fn prepare(&mut self) -> CargoResult<()> {
-        self.artifact_dir.prepare()?;
+        if let Some(ref mut artifact_dir) = self.artifact_dir {
+            artifact_dir.prepare()?;
+        }
         self.build_dir.prepare()?;
 
         Ok(())
     }
 
-    pub fn artifact_dir(&self) -> &ArtifactDirLayout {
-        &self.artifact_dir
+    pub fn artifact_dir(&self) -> Option<&ArtifactDirLayout> {
+        self.artifact_dir.as_ref()
     }
 
     pub fn build_dir(&self) -> &BuildDirLayout {

src/cargo/core/compiler/mod.rs

@@ -298,7 +298,7 @@ fn rustc(
     exec.init(build_runner, unit);
     let exec = exec.clone();
 
-    let root_output = build_runner.files().host_dest().to_path_buf();
+    let root_output = build_runner.files().host_dest().map(|v| v.to_path_buf());
     let build_dir = build_runner.bcx.ws.build_dir().into_path_unlocked();
     let pkg_root = unit.pkg.root().to_path_buf();
     let cwd = rustc
@@ -361,7 +361,9 @@ fn rustc(
                 current_id,
                 mode,
             )?;
-            add_plugin_deps(&mut rustc, &script_outputs, &build_scripts, &root_output)?;
+            if let Some(ref root_output) = root_output {
+                add_plugin_deps(&mut rustc, &script_outputs, &build_scripts, root_output)?;
+            }
             add_custom_flags(&mut rustc, &script_outputs, script_metadatas)?;
         }
 
@@ -1399,16 +1401,17 @@ fn build_base_args(
             .iter()
             .filter(|target| target.is_bin())
         {
-            let exe_path = build_runner.files().bin_link_for_target(
-                bin_target,
-                unit.kind,
-                build_runner.bcx,
-            )?;
-            let name = bin_target
-                .binary_filename()
-                .unwrap_or(bin_target.name().to_string());
-            let key = format!("CARGO_BIN_EXE_{}", name);
-            cmd.env(&key, exe_path);
+            if let Some(exe_path) =
+                build_runner
+                    .files()
+                    .bin_link_for_target(bin_target, unit.kind, build_runner.bcx)?
+            {
+                let name = bin_target
+                    .binary_filename()
+                    .unwrap_or(bin_target.name().to_string());
+                let key = format!("CARGO_BIN_EXE_{}", name);
+                cmd.env(&key, exe_path);
+            }
         }
     }
     Ok(())

src/cargo/core/compiler/timings.rs

@@ -11,7 +11,7 @@ use crate::util::log_message::LogMessage;
 use crate::util::machine_message::{self, Message};
 use crate::util::style;
 use crate::util::{CargoResult, GlobalContext};
-use anyhow::Context as _;
+use anyhow::Context;
 use cargo_util::paths;
 use indexmap::IndexMap;
 use itertools::Itertools;
@@ -457,7 +457,10 @@ impl<'gctx> Timings<'gctx> {
     ) -> CargoResult<()> {
         let duration = self.start.elapsed().as_secs_f64();
         let timestamp = self.start_str.replace(&['-', ':'][..], "");
-        let timings_path = build_runner.files().timings_dir();
+        let timings_path = build_runner
+            .files()
+            .timings_dir()
+            .expect("artifact-dir was not locked");
         paths::create_dir_all(&timings_path)?;
         let filename = timings_path.join(format!("cargo-timing-{}.html", timestamp));
         let mut f = BufWriter::new(paths::create(&filename)?);

src/cargo/ops/cargo_clean.rs

@@ -7,7 +7,7 @@ use crate::util::edit_distance;
 use crate::util::errors::CargoResult;
 use crate::util::interning::InternedString;
 use crate::util::{GlobalContext, Progress, ProgressStyle};
-use anyhow::bail;
+use anyhow::{Context, bail};
 use cargo_util::paths;
 use std::collections::{HashMap, HashSet};
 use std::fs;
@@ -236,19 +236,18 @@ fn clean_specs(
                     let (file_types, _unsupported) = target_data
                         .info(*compile_kind)
                         .rustc_outputs(mode, target.kind(), triple, clean_ctx.gctx)?;
+                    let artifact_dir = layout
+                        .artifact_dir()
+                        .context("artifact-dir was not locked during clean")?;
                     let (dir, uplift_dir) = match target.kind() {
-                        TargetKind::ExampleBin | TargetKind::ExampleLib(..) => (
-                            layout.build_dir().examples(),
-                            Some(layout.artifact_dir().examples()),
-                        ),
+                        TargetKind::ExampleBin | TargetKind::ExampleLib(..) => {
+                            (layout.build_dir().examples(), Some(artifact_dir.examples()))
+                        }
                         // Tests/benchmarks are never uplifted.
                         TargetKind::Test | TargetKind::Bench => {
                             (layout.build_dir().legacy_deps(), None)
                         }
-                        _ => (
-                            layout.build_dir().legacy_deps(),
-                            Some(layout.artifact_dir().dest()),
-                        ),
+                        _ => (layout.build_dir().legacy_deps(), Some(artifact_dir.dest())),
                     };
                     let mut dir_glob_str = escape_glob_path(dir)?;
                     let dir_glob = Path::new(&dir_glob_str);