Implemented templating support for build.build-dir

Author: ranger-ross

src/cargo/core/workspace.rs

@@ -213,7 +213,6 @@ impl<'gctx> Workspace<'gctx> {
     pub fn new(manifest_path: &Path, gctx: &'gctx GlobalContext) -> CargoResult<Workspace<'gctx>> {
         let mut ws = Workspace::new_default(manifest_path.to_path_buf(), gctx);
         ws.target_dir = gctx.target_dir()?;
-        ws.build_dir = gctx.build_dir()?;
 
         if manifest_path.is_relative() {
             bail!(
@@ -224,6 +223,12 @@ impl<'gctx> Workspace<'gctx> {
             ws.root_manifest = ws.find_root(manifest_path)?;
         }
 
+        ws.build_dir = gctx.build_dir(
+            ws.root_manifest
+                .as_ref()
+                .unwrap_or(&manifest_path.to_path_buf()),
+        )?;
+
         ws.custom_metadata = ws
             .load_workspace_config()?
             .and_then(|cfg| cfg.custom_metadata);

src/cargo/util/context/mod.rs

@@ -636,13 +636,36 @@ impl GlobalContext {
     /// Falls back to the target directory if not specified.
     ///
     /// Callers should prefer [`Workspace::build_dir`] instead.
-    pub fn build_dir(&self) -> CargoResult<Option<Filesystem>> {
+    pub fn build_dir(&self, manifest_path: &PathBuf) -> CargoResult<Option<Filesystem>> {
         if !self.cli_unstable().build_dir {
             return self.target_dir();
         }
         if let Some(val) = &self.build_config()?.build_dir {
-            let path = val.resolve_path(self);
-
+            let replacements = vec![
+                (
+                    "{workspace-root}",
+                    manifest_path
+                        .parent()
+                        .unwrap()
+                        .to_str()
+                        .context("workspace root was not valid utf-8")?
+                        .to_string(),
+                ),
+                (
+                    "{cargo-cache}",
+                    self.home()
+                        .as_path_unlocked()
+                        .to_str()
+                        .context("cargo home was not valid utf-8")?
+                        .to_string(),
+                ),
+                (
+                    "{workspace-manifest-path-hash}",
+                    crate::util::hex::short_hash(manifest_path),
+                ),
+            ];
+
+            let path = val.resolve_templated_path(self, replacements);
             // Check if the target directory is set to an empty string in the config.toml file.
             if val.raw_value().is_empty() {
                 bail!(

src/cargo/util/context/path.rs

@@ -32,6 +32,25 @@ impl ConfigRelativePath {
         self.0.definition.root(gctx).join(&self.0.val)
     }
 
+    /// Same as [`Self::resolve_path`] but will make string replacements
+    /// before resolving the path.
+    ///
+    /// `replacements` should be an an [`IntoIterator`] of tuples with the "from" and "to" for the
+    /// string replacement
+    pub fn resolve_templated_path(
+        &self,
+        gctx: &GlobalContext,
+        replacements: impl IntoIterator<Item = (impl AsRef<str>, impl AsRef<str>)>,
+    ) -> PathBuf {
+        let mut value = self.0.val.clone();
+
+        for (from, to) in replacements {
+            value = value.replace(from.as_ref(), to.as_ref());
+        }
+
+        self.0.definition.root(gctx).join(&value)
+    }
+
     /// Resolves this configuration-relative path to either an absolute path or
     /// something appropriate to execute from `PATH`.
     ///

tests/testsuite/build_dir.rs

@@ -498,20 +498,15 @@ mod templating {
 
     #[cargo_test]
     fn workspace_root() {
-        let p = project();
-        let root = p.root();
-        let p = p
+        let p = project()
             .file("src/main.rs", r#"fn main() { println!("Hello, World!") }"#)
             .file(
                 ".cargo/config.toml",
-                &format!(
-                    r#"
-                    [build]
-                    build-dir = "{}/build-dir"
-                    target-dir = "target-dir"
-                    "#,
-                    root.display()
-                ),
+                r#"
+                [build]
+                build-dir = "{workspace-root}/build-dir"
+                target-dir = "target-dir"
+                "#,
             )
             .build();
 
@@ -533,14 +528,11 @@ mod templating {
             .file("src/main.rs", r#"fn main() { println!("Hello, World!") }"#)
             .file(
                 ".cargo/config.toml",
-                &format!(
-                    r#"
-                    [build]
-                    build-dir = "{}/build-dir"
-                    target-dir = "target-dir"
-                    "#,
-                    paths::home().join(".cargo").display()
-                ),
+                r#"
+                [build]
+                build-dir = "{cargo-cache}/build-dir"
+                target-dir = "target-dir"
+                "#,
             )
             .build();
 
@@ -574,7 +566,7 @@ mod templating {
                 ".cargo/config.toml",
                 r#"
                 [build]
-                build-dir = "foo/a70a942ddb7da6b4/build-dir"
+                build-dir = "foo/{workspace-manifest-path-hash}/build-dir"
                 target-dir = "target-dir"
                 "#,
             )