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.

src/cargo/core/workspace.rs

@@ -139,8 +139,12 @@ impl<'cfg> Workspace<'cfg> {
     /// before returning it, so `Ok` is only returned for valid workspaces.
     pub fn new(manifest_path: &Path, config: &'cfg Config) -> CargoResult<Workspace<'cfg>> {
         let mut ws = Workspace::new_default(manifest_path.to_path_buf(), config);
-        ws.target_dir = config.target_dir()?;
         ws.root_manifest = ws.find_root(manifest_path)?;
+        if let Some(ref root_manifest) = ws.root_manifest {
+            ws.target_dir = config.target_dir(root_manifest)?;
+        } else {
+            ws.target_dir = config.target_dir(manifest_path)?;
+        }
         ws.find_members()?;
         ws.validate()?;
         Ok(ws)
@@ -174,7 +178,11 @@ impl<'cfg> Workspace<'cfg> {
     ) -> CargoResult<Workspace<'cfg>> {
         let mut ws = Workspace::new_default(current_manifest, config);
         ws.root_manifest = Some(root_path.join("Cargo.toml"));
-        ws.target_dir = config.target_dir()?;
+        if let Some(ref root_manifest) = ws.root_manifest {
+            ws.target_dir = config.target_dir(root_manifest)?;
+        } else {
+            ws.target_dir = config.target_dir(&ws.current_manifest)?;
+        }
         ws.packages
             .packages
             .insert(root_path, MaybePackage::Virtual(manifest));
@@ -204,13 +212,13 @@ impl<'cfg> Workspace<'cfg> {
         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.config.target_dir()?
+            ws.config.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

@@ -204,7 +204,7 @@ fn install_one(
     let mut needs_cleanup = false;
     let overidden_target_dir = if source_id.is_path() {
         None
-    } else if let Some(dir) = config.target_dir()? {
+    } else if let Some(dir) = config.target_dir(pkg.manifest_path())? {
         Some(dir)
     } else if let Ok(td) = TempFileBuilder::new().prefix("cargo-install").tempdir() {
         let p = td.path().to_owned();

src/cargo/util/config/mod.rs

@@ -339,11 +339,26 @@ impl Config {
         &self.cwd
     }
 
-    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) = env::var_os("CARGO_TARGET_DIR") {
             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() {
+                failure::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(_) => failure::bail!("Current directory must be an absolute path"),
+            }
         } else if let Some(val) = &self.build_config()?.target_dir {
             let val = val.resolve_path(self);
             Ok(Some(Filesystem::new(val)))

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

@@ -14,6 +14,10 @@ system:
   this variable overrides the 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.
 * `RUSTC` — Instead of running `rustc`, Cargo will execute this specified

tests/testsuite/build.rs

@@ -2997,6 +2997,63 @@ fn panic_abort_compiles_with_panic_abort() {
         .run();
 }
 
+#[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()