Add support for CARGO_TARGET_DIR_PREFIX

This change adds support for a new environment variable,
CARGO_TARGET_DIR_PREFIX, to cargo. This variable, when set, is treated
as a prefix to the target directory.
Note that support for the functionality behind this variable is not
trivial to implement with the current design. In particular, we wanted
to stick as close to the existing CARGO_TARGET_DIR logic. However, the
Config in which it is implemented really does not know anything about
the directory of the particular crate we concerned with. As a quick work
around to this problem, we just pass in the path to the Cargo.toml from
the "upper layer". That works, but ultimately it would be better to make
the other layer handle the CARGO_TARGET_DIR_PREFIX logic.
This change addresses rust-lang#5544.

TODO: Definitely not finished. This patch needs more tests and may need
      additional config.toml support (?).
TODO: There is also the potential for a permission related problems.
      E.g., when user root compiles something below /tmp/ and then user
      nobody tries to do the same the resulting directory
      ${CARGO_TARGET_DIR_PREFIX}/tmp/ may be owned by root, causing the
      build for nobody to fail with a permission denied error.

Author: d-e-s-o

src/cargo/core/workspace.rs

@@ -208,7 +208,6 @@ impl<'gctx> Workspace<'gctx> {
     /// before returning it, so `Ok` is only returned for valid workspaces.
     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()?;
 
         if manifest_path.is_relative() {
             bail!(
@@ -219,6 +218,12 @@ impl<'gctx> Workspace<'gctx> {
             ws.root_manifest = ws.find_root(manifest_path)?;
         }
 
+        if let Some(ref root_manifest) = ws.root_manifest {
+            ws.target_dir = gctx.target_dir(root_manifest)?;
+        } else {
+            ws.target_dir = gctx.target_dir(manifest_path)?;
+        }
+
         ws.custom_metadata = ws
             .load_workspace_config()?
             .and_then(|cfg| cfg.custom_metadata);
@@ -273,13 +278,13 @@ impl<'gctx> Workspace<'gctx> {
         ws.require_optional_deps = require_optional_deps;
         let key = ws.current_manifest.parent().unwrap();
         let id = package.package_id();
-        let package = MaybePackage::Package(package);
-        ws.packages.packages.insert(key.to_path_buf(), package);
         ws.target_dir = if let Some(dir) = target_dir {
             Some(dir)
         } else {
-            ws.gctx.target_dir()?
+            ws.gctx.target_dir(package.manifest_path())?
         };
+        let package = MaybePackage::Package(package);
+        ws.packages.packages.insert(key.to_path_buf(), package);
         ws.members.push(ws.current_manifest.clone());
         ws.member_ids.insert(id);
         ws.default_members.push(ws.current_manifest.clone());

src/cargo/ops/cargo_install.rs

@@ -305,7 +305,8 @@ impl<'gctx> InstallablePackage<'gctx> {
         let mut td_opt = None;
         let mut needs_cleanup = false;
         if !self.source_id.is_path() {
-            let target_dir = if let Some(dir) = self.gctx.target_dir()? {
+            let manifest_path = self.pkg.manifest_path().to_path_buf();
+            let target_dir = if let Some(dir) = self.gctx.target_dir(manifest_path)? {
                 dir
             } else if let Ok(td) = TempFileBuilder::new().prefix("cargo-install").tempdir() {
                 let p = td.path().to_owned();

src/cargo/util/context/mod.rs

@@ -604,7 +604,7 @@ impl GlobalContext {
     /// Returns `None` if the user has not chosen an explicit directory.
     ///
     /// Callers should prefer `Workspace::target_dir` instead.
-    pub fn target_dir(&self) -> CargoResult<Option<Filesystem>> {
+    pub fn target_dir(&self, manifest: impl Into<PathBuf>) -> CargoResult<Option<Filesystem>> {
         if let Some(dir) = &self.target_dir {
             Ok(Some(dir.clone()))
         } else if let Some(dir) = self.get_env_os("CARGO_TARGET_DIR") {
@@ -617,6 +617,21 @@ impl GlobalContext {
             }
 
             Ok(Some(Filesystem::new(self.cwd.join(dir))))
+        } else if let Some(dir) = env::var_os("CARGO_TARGET_DIR_PREFIX") {
+            let prefix = Path::new(&dir);
+            if !prefix.is_absolute() {
+                bail!("CARGO_TARGET_DIR_PREFIX must describe an absolute path");
+            }
+            let mut manifest = manifest.into();
+            let result = manifest.pop();
+            assert!(result);
+
+            match manifest.strip_prefix("/") {
+                Ok(dir) => Ok(Some(Filesystem::new(prefix.join(&dir).join("target")))),
+                // FIXME: This logic is probably not safe on Windows. Not sure how
+                //        to make a path relative there.
+                Err(_) => bail!("Current directory must be an absolute path"),
+            }
         } else if let Some(val) = &self.build_config()?.target_dir {
             let path = val.resolve_path(self);
 

src/doc/src/reference/environment-variables.md

@@ -20,6 +20,10 @@ system:
   location of this directory. Once a crate is cached it is not removed by the
   clean command.
   For more details refer to the [guide](../guide/cargo-home.md).
+* `CARGO_TARGET_DIR_PREFIX` — Prefix to the location where to place all
+  generated artifacts. The current working directory will be appended to this
+  prefix to form the final path for generated artifacts. Note that
+  `CARGO_TARGET_DIR`, if set, takes precedence over this variable.
 * `CARGO_TARGET_DIR` --- Location of where to place all generated artifacts,
   relative to the current working directory. See [`build.target-dir`] to set
   via config.

tests/testsuite/build.rs

@@ -4126,6 +4126,63 @@ fn panic_abort_compiles_with_panic_abort() {
 }
 
 #[allow(deprecated)]
+#[cargo_test]
+fn custom_target_dir_prefix() {
+    fn test(cwd: &str) {
+        let tmpdir = tempfile::Builder::new()
+            .tempdir()
+            .unwrap()
+            .path()
+            .to_path_buf();
+
+        let p = project()
+            .file(
+                "Cargo.toml",
+                r#"
+                [package]
+                name = "foo"
+                version = "0.0.1"
+                authors = []
+            "#,
+            )
+            .file("src/main.rs", "fn main() {}")
+            .build();
+
+        let root = p.root();
+        let root_suffix = root.strip_prefix("/").unwrap();
+        let exe_name = format!("foo{}", env::consts::EXE_SUFFIX);
+
+        p.cargo("build")
+            .env("CARGO_TARGET_DIR_PREFIX", tmpdir.clone())
+            .cwd(p.root().join(cwd))
+            .run();
+
+        assert!(
+            tmpdir
+                .clone()
+                .join(root_suffix)
+                .join("target/debug")
+                .join(&exe_name)
+                .is_file()
+        );
+        assert!(!&p.root().join("target/debug").join(&exe_name).is_file());
+
+        p.cargo("build").run();
+        assert!(
+            tmpdir
+                .clone()
+                .join(root_suffix)
+                .join("target/debug")
+                .join(&exe_name)
+                .is_file()
+        );
+        assert!(&p.root().join("target/debug").join(&exe_name).is_file())
+    }
+
+    test(".");
+    test("src");
+}
+
 #[cargo_test]
 fn compiler_json_error_format() {
     let p = project()

tests/testsuite/config.rs

@@ -1604,7 +1604,7 @@ target-dir = ''
     let gctx = new_gctx();
 
     assert_error(
-        gctx.target_dir().unwrap_err(),
+        gctx.target_dir(Path::new("")).unwrap_err(),
         "the target directory is set to an empty string in [..]/.cargo/config.toml",
     );
 }