Implemented templating support for build.build-dir

Author: ranger-ross

crates/cargo-util/src/paths.rs

@@ -727,6 +727,26 @@ pub fn strip_prefix_canonical(
     canon_path.strip_prefix(canon_base).map(|p| p.to_path_buf())
 }
 
+/// Resolves all symlinks in a path.
+///
+/// This differs from the [`std::fs::canonicalize`] as `canonicalize` may change the
+/// structure of the path while this function will not.
+/// For example in Windows `canonicalize` will prefix the path with `\\?\`.
+///
+/// This is useful when the structure matters. (ie. when hashing a path)
+pub fn resolve_symlinks(path: &PathBuf) -> Result<PathBuf> {
+    let mut resolved = PathBuf::new();
+
+    for part in path {
+        resolved = resolved.join(part);
+        if resolved.is_symlink() {
+            resolved = resolved.read_link()?;
+        }
+    }
+
+    return Ok(resolved);
+}
+
 /// Creates an excluded from cache directory atomically with its parents as needed.
 ///
 /// The atomicity only covers creating the leaf directory and exclusion from cache. Any missing

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

@@ -652,13 +652,38 @@ 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, workspace_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 workspace_manifest_path = paths::resolve_symlinks(workspace_manifest_path)?;
+
+            let replacements = vec![
+                (
+                    "{workspace-root}",
+                    workspace_manifest_path
+                        .parent()
+                        .unwrap()
+                        .to_str()
+                        .context("workspace root was not valid utf-8")?
+                        .to_string(),
+                ),
+                (
+                    "{cargo-cache-home}",
+                    self.home()
+                        .as_path_unlocked()
+                        .to_str()
+                        .context("cargo home was not valid utf-8")?
+                        .to_string(),
+                ),
+                ("{workspace-manifest-path-hash}", {
+                    let hash = crate::util::hex::short_hash(&workspace_manifest_path);
+                    format!("{}{}{}", &hash[0..2], std::path::MAIN_SEPARATOR, &hash[2..])
+                }),
+            ];
+
+            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`.
     ///

src/doc/src/reference/unstable.md

@@ -260,6 +260,13 @@ build-dir = "out"
 
 The path to where internal files used as part of the build are placed.
 
+This option supports path templating.
+
+Avaiable template variables:
+* `{workspace-root}` resolves to root of the current workspace.
+* `{cargo-cache-home}` resolves to `CARGO_HOME`
+* `{workspace-manifest-path-hash}` resolves to a hash of the manifest path
+
 
 ## root-dir
 * Original Issue: [#9887](https://github.com/rust-lang/cargo/issues/9887)

tests/testsuite/build_dir.rs

@@ -493,20 +493,15 @@ fn future_incompat_should_output_to_build_dir() {
 
 #[cargo_test]
 fn template_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();
 
@@ -528,14 +523,11 @@ fn template_cargo_cache_home() {
         .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-home}/build-dir"
+            target-dir = "target-dir"
+            "#,
         )
         .build();
 
@@ -569,7 +561,7 @@ fn template_workspace_manfiest_path_hash() {
             ".cargo/config.toml",
             r#"
             [build]
-            build-dir = "foo/a7/0a942ddb7da6b4/build-dir"
+            build-dir = "foo/{workspace-manifest-path-hash}/build-dir"
             target-dir = "target-dir"
             "#,
         )
@@ -619,7 +611,7 @@ fn template_workspace_manfiest_path_hash_should_handle_symlink() {
             ".cargo/config.toml",
             r#"
             [build]
-            build-dir = "foo/a7/0a942ddb7da6b4/build-dir"
+            build-dir = "foo/{workspace-manifest-path-hash}/build-dir"
             target-dir = "target-dir"
             "#,
         )