refactor(ws): Reuse build-dir logic for script target-dir

Author: epage

src/cargo/core/workspace.rs

@@ -444,13 +444,14 @@ impl<'gctx> Workspace<'gctx> {
 
     fn default_target_dir(&self) -> Filesystem {
         if self.root_maybe().is_embedded() {
-            let hash = crate::util::hex::short_hash(&self.root_manifest().to_string_lossy());
-            let mut rel_path = PathBuf::new();
-            rel_path.push("target");
-            rel_path.push(&hash[0..2]);
-            rel_path.push(&hash[2..]);
-
-            self.gctx().home().join(rel_path)
+            let default = ConfigRelativePath::new(
+                "{cargo-cache-home}/target/{workspace-path-hash}"
+                    .to_owned()
+                    .into(),
+            );
+            self.gctx()
+                .custom_build_dir(&default, self.root_manifest())
+                .expect("template is correct")
         } else {
             Filesystem::new(self.root().join("target"))
         }

src/cargo/util/context/de.rs

@@ -564,18 +564,19 @@ impl<'de, 'gctx> de::MapAccess<'de> for ValueDeserializer<'gctx> {
         // ... otherwise we're deserializing the `definition` field, so we need
         // to figure out where the field we just deserialized was defined at.
         match self.definition() {
+            Definition::BuiltIn => seed.deserialize(0.into_deserializer()),
             Definition::Path(path) => {
-                seed.deserialize(Tuple2Deserializer(0i32, path.to_string_lossy()))
+                seed.deserialize(Tuple2Deserializer(1i32, path.to_string_lossy()))
             }
             Definition::Environment(env) => {
-                seed.deserialize(Tuple2Deserializer(1i32, env.as_str()))
+                seed.deserialize(Tuple2Deserializer(2i32, env.as_str()))
             }
             Definition::Cli(path) => {
                 let s = path
                     .as_ref()
                     .map(|p| p.to_string_lossy())
                     .unwrap_or_default();
-                seed.deserialize(Tuple2Deserializer(2i32, s))
+                seed.deserialize(Tuple2Deserializer(3i32, s))
             }
         }
     }

src/cargo/util/context/mod.rs

@@ -1371,7 +1371,9 @@ impl GlobalContext {
         let abs = |path: &str, def: &Definition| -> (String, PathBuf, Definition) {
             let abs_path = match def {
                 Definition::Path(p) | Definition::Cli(Some(p)) => p.parent().unwrap().join(&path),
-                Definition::Environment(_) | Definition::Cli(None) => self.cwd().join(&path),
+                Definition::Environment(_) | Definition::Cli(None) | Definition::BuiltIn => {
+                    self.cwd().join(&path)
+                }
             };
             (path.to_string(), abs_path, def.clone())
         };

src/cargo/util/context/value.rs

@@ -55,6 +55,7 @@ pub(crate) static FIELDS: [&str; 2] = [VALUE_FIELD, DEFINITION_FIELD];
 /// Location where a config value is defined.
 #[derive(Clone, Debug, Eq)]
 pub enum Definition {
+    BuiltIn,
     /// Defined in a `.cargo/config`, includes the path to the file.
     Path(PathBuf),
     /// Defined in an environment variable, includes the environment key.
@@ -90,7 +91,7 @@ impl Definition {
     pub fn root<'a>(&'a self, gctx: &'a GlobalContext) -> &'a Path {
         match self {
             Definition::Path(p) | Definition::Cli(Some(p)) => p.parent().unwrap().parent().unwrap(),
-            Definition::Environment(_) | Definition::Cli(None) => gctx.cwd(),
+            Definition::Environment(_) | Definition::Cli(None) | Definition::BuiltIn => gctx.cwd(),
         }
     }
 
@@ -102,7 +103,10 @@ impl Definition {
             (self, other),
             (Definition::Cli(_), Definition::Environment(_))
                 | (Definition::Cli(_), Definition::Path(_))
+                | (Definition::Cli(_), Definition::BuiltIn)
                 | (Definition::Environment(_), Definition::Path(_))
+                | (Definition::Environment(_), Definition::BuiltIn)
+                | (Definition::Path(_), Definition::BuiltIn)
         )
     }
 }
@@ -123,6 +127,16 @@ impl fmt::Display for Definition {
             Definition::Path(p) | Definition::Cli(Some(p)) => p.display().fmt(f),
             Definition::Environment(key) => write!(f, "environment variable `{}`", key),
             Definition::Cli(None) => write!(f, "--config cli option"),
+            Definition::BuiltIn => write!(f, "default"),
+        }
+    }
+}
+
+impl<T> From<T> for Value<T> {
+    fn from(val: T) -> Self {
+        Self {
+            val,
+            definition: Definition::BuiltIn,
         }
     }
 }
@@ -236,9 +250,10 @@ impl<'de> de::Deserialize<'de> for Definition {
     {
         let (discr, value) = <(u32, String)>::deserialize(deserializer)?;
         match discr {
-            0 => Ok(Definition::Path(value.into())),
-            1 => Ok(Definition::Environment(value)),
-            2 => {
+            0 => Ok(Definition::BuiltIn),
+            1 => Ok(Definition::Path(value.into())),
+            2 => Ok(Definition::Environment(value)),
+            3 => {
                 let path = (value.len() > 0).then_some(value.into());
                 Ok(Definition::Cli(path))
             }