just pushing it

Author: ranger-ross

crates/cargo-test-support/src/lib.rs

@@ -504,8 +504,20 @@ impl Project {
     /// p.cargo("build --bin foo").run();
     /// ```
     pub fn cargo(&self, cmd: &str) -> Execs {
+        self.cargo_with_working_dir(cmd, &self.root())
+    }
+
+    /// Creates a `ProcessBuilder` to run cargo in a given directory.
+    /// [`Project::cargo`] is preferred when executing from the project root.
+    ///
+    /// Arguments can be separated by spaces.
+    ///
+    /// For `cargo run`, see [`Project::rename_run`].
+    pub fn cargo_with_working_dir(&self, cmd: &str, dir: &PathBuf) -> Execs {
         let cargo = cargo_exe();
-        let mut execs = self.process(&cargo);
+        let mut p = process(&cargo);
+        p.cwd(dir);
+        let mut execs = execs().with_process_builder(p);
         if let Some(ref mut p) = execs.process_builder {
             p.env("CARGO", cargo);
             p.arg_line(cmd);

src/cargo/util/context/mod.rs

@@ -672,6 +672,8 @@ impl GlobalContext {
                         .to_string(),
                 ),
                 ("{workspace-path-hash}", {
+                    println!("ROSS ==> {workspace_manifest_path:?}");
+                    let can = std::fs::canonicalize(workspace_manifest_path);
                     let hash = crate::util::hex::short_hash(&workspace_manifest_path);
                     format!("{}{}{}", &hash[0..2], std::path::MAIN_SEPARATOR, &hash[2..])
                 }),

tests/testsuite/build_dir.rs

@@ -11,8 +11,8 @@
 
 use std::path::PathBuf;
 
-use cargo_test_support::prelude::*;
 use cargo_test_support::{paths, project, str};
+use cargo_test_support::{prelude::*, Project};
 use std::env::consts::{DLL_PREFIX, DLL_SUFFIX, EXE_SUFFIX};
 
 #[cargo_test]
@@ -609,6 +609,85 @@ fn template_workspace_manfiest_path_hash() {
     assert_exists(&p.root().join(&format!("target-dir/debug/foo{EXE_SUFFIX}")));
 }
 
+/// Verify that the {workspace-manifest-path-hash} does not changes if cargo is run from inside of
+/// a symlinked directory.
+/// The test approach is to build a project twice from the non-symlinked directory and a symlinked
+/// directory and then compare the build-dir paths.
+#[cargo_test]
+fn template_workspace_manfiest_path_hash_should_handle_symlink() {
+    #[cfg(unix)]
+    use std::os::unix::fs::symlink;
+    #[cfg(windows)]
+    use std::os::windows::fs::symlink_dir as symlink;
+
+    let p = project()
+        .file("src/main.rs", r#"fn main() { println!("Hello, World!") }"#)
+        .file(
+            "Cargo.toml",
+            r#"
+             [package]
+             name = "foo"
+             version = "1.0.0"
+             authors = []
+             edition = "2015"
+             "#,
+        )
+        .file(
+            ".cargo/config.toml",
+            r#"
+             [build]
+             build-dir = "foo/{workspace-path-hash}/build-dir"
+             "#,
+        )
+        .build();
+
+    // Build from the non-symlinked directory
+    p.cargo("build -Z build-dir")
+        .masquerade_as_nightly_cargo(&["build-dir"])
+        .enable_mac_dsym()
+        .stream()
+        .run();
+
+    // Parse and verify the hash dir created from the non-symlinked dir
+    let foo_dir = p.root().join("foo");
+    assert_exists(&foo_dir);
+    let original_hash_dir = parse_workspace_manifest_path_hash(&foo_dir);
+    verify_layouts(&p, &original_hash_dir);
+
+    // Create a symlink of the project root.
+    let mut symlinked_dir = p.root().clone();
+    symlinked_dir.pop();
+    symlinked_dir = symlinked_dir.join("bar");
+    symlink(p.root(), &symlinked_dir).unwrap();
+
+    // Remove the foo dir (which contains the build-dir) before we rebuild from a symlinked dir.
+    foo_dir.rm_rf();
+
+    // Run cargo from the symlinked dir
+    p.cargo_with_working_dir("build -Z build-dir", &symlinked_dir)
+        .masquerade_as_nightly_cargo(&["build-dir"])
+        .enable_mac_dsym()
+        .stream()
+        .run();
+
+    // Parse and verify the hash created from the symlinked dir
+    assert_exists(&foo_dir);
+    let symlink_hash_dir = parse_workspace_manifest_path_hash(&foo_dir);
+    verify_layouts(&p, &symlink_hash_dir);
+
+    // Verify the hash dir created from the symlinked and non-symlinked dirs are the same.
+    assert_eq!(original_hash_dir, symlink_hash_dir);
+    //panic!("PASSED");
+
+    fn verify_layouts(p: &Project, build_dir_parent: &PathBuf) {
+        let build_dir = build_dir_parent.as_path().join("build-dir");
+        assert_build_dir_layout(build_dir, "debug");
+        assert_artifact_dir_layout(p.root().join("target"), "debug");
+        // Verify the binary was uplifted to the target-dir
+        assert_exists(&p.root().join(&format!("target/debug/foo{EXE_SUFFIX}")));
+    }
+}
+
 fn parse_workspace_manifest_path_hash(hash_dir: &PathBuf) -> PathBuf {
     // Since the hash will change between test runs simply find the first directories and assume
     // that is the hash dir. The format is a 2 char directory followed by the remaining hash in the