refactor(gctx): decouple gctx from schemas

Pass in current working directory instead,
so that schema types can avoid depend on GlobalContext

Author: weihanglo

src/cargo/core/compiler/compile_kind.rs

@@ -114,7 +114,7 @@ impl CompileKind {
         let kinds = match (fallback, &gctx.build_config()?.target) {
             (_, None) | (CompileKindFallback::JustHost, _) => Ok(vec![CompileKind::Host]),
             (CompileKindFallback::BuildConfig, Some(build_target_config)) => {
-                dedup(&build_target_config.values(gctx)?)
+                dedup(&build_target_config.values(gctx.cwd())?)
             }
         };
 

src/cargo/ops/resolve.rs

@@ -540,7 +540,7 @@ pub fn add_overrides<'a>(
         // The path listed next to the string is the config file in which the
         // key was located, so we want to pop off the `.cargo/config` component
         // to get the directory containing the `.cargo` folder.
-        (paths::normalize_path(&def.root(gctx).join(s)), def)
+        (paths::normalize_path(&def.root(gctx.cwd()).join(s)), def)
     });
 
     for (path, definition) in paths {

src/cargo/util/context/mod.rs

@@ -1002,7 +1002,7 @@ impl GlobalContext {
     fn string_to_path(&self, value: &str, definition: &Definition) -> PathBuf {
         let is_path = value.contains('/') || (cfg!(windows) && value.contains('\\'));
         if is_path {
-            definition.root(self).join(value)
+            definition.root(self.cwd()).join(value)
         } else {
             // A pathless name.
             PathBuf::from(value)
@@ -1675,7 +1675,7 @@ impl GlobalContext {
         // This handles relative file: URLs, relative to the config definition.
         let base = index
             .definition
-            .root(self)
+            .root(self.cwd())
             .join("truncated-by-url_with_base");
         // Parse val to check it is a URL, not a relative path without a protocol.
         let _parsed = index.val.into_url()?;
@@ -1921,7 +1921,7 @@ impl GlobalContext {
                     .into_iter()
                     .filter_map(|(k, v)| {
                         if v.is_force() || self.get_env_os(&k).is_none() {
-                            Some((k, v.resolve(self).to_os_string()))
+                            Some((k, v.resolve(self.cwd()).to_os_string()))
                         } else {
                             None
                         }

src/cargo/util/context/path.rs

@@ -30,7 +30,7 @@ impl ConfigRelativePath {
     /// This will always return an absolute path where it's relative to the
     /// location for configuration for this value.
     pub fn resolve_path(&self, gctx: &GlobalContext) -> PathBuf {
-        self.0.definition.root(gctx).join(&self.0.val)
+        self.0.definition.root(gctx.cwd()).join(&self.0.val)
     }
 
     /// Same as [`Self::resolve_path`] but will make string replacements
@@ -72,7 +72,7 @@ impl ConfigRelativePath {
             });
         }
 
-        Ok(self.0.definition.root(gctx).join(&value))
+        Ok(self.0.definition.root(gctx.cwd()).join(&value))
     }
 
     /// Resolves this configuration-relative path to either an absolute path or

src/cargo/util/context/schema.rs

@@ -6,8 +6,9 @@ use std::fmt;
 use serde::Deserialize;
 use serde_untagged::UntaggedEnumVisitor;
 
+use std::path::Path;
+
 use crate::CargoResult;
-use crate::GlobalContext;
 
 use super::StringList;
 use super::Value;
@@ -219,14 +220,14 @@ impl<'de> Deserialize<'de> for BuildTargetConfigInner {
 
 impl BuildTargetConfig {
     /// Gets values of `build.target` as a list of strings.
-    pub fn values(&self, gctx: &GlobalContext) -> CargoResult<Vec<String>> {
+    pub fn values(&self, cwd: &Path) -> CargoResult<Vec<String>> {
         let map = |s: &String| {
             if s.ends_with(".json") {
                 // Path to a target specification file (in JSON).
                 // <https://doc.rust-lang.org/rustc/targets/custom.html>
                 self.inner
                     .definition
-                    .root(gctx)
+                    .root(cwd)
                     .join(s)
                     .to_str()
                     .expect("must be utf-8 in toml")
@@ -412,7 +413,7 @@ impl EnvConfigValue {
         }
     }
 
-    pub fn resolve<'a>(&'a self, gctx: &GlobalContext) -> Cow<'a, OsStr> {
+    pub fn resolve<'a>(&'a self, cwd: &Path) -> Cow<'a, OsStr> {
         match self.inner.val {
             EnvConfigValueInner::Simple(ref s) => Cow::Borrowed(OsStr::new(s.as_str())),
             EnvConfigValueInner::WithOptions {
@@ -421,7 +422,7 @@ impl EnvConfigValue {
                 ..
             } => {
                 if relative {
-                    let p = self.inner.definition.root(gctx).join(&value);
+                    let p = self.inner.definition.root(cwd).join(&value);
                     Cow::Owned(p.into_os_string())
                 } else {
                     Cow::Borrowed(OsStr::new(value.as_str()))

src/cargo/util/context/value.rs

@@ -42,7 +42,6 @@
 //!
 //! [`de`]: crate::util::context::de
 
-use crate::util::context::GlobalContext;
 use serde::de;
 use std::cmp::Ordering;
 use std::fmt;
@@ -104,12 +103,12 @@ impl Ord for Definition {
 impl Definition {
     /// Root directory where this is defined.
     ///
-    /// If from a file, it is the directory above `.cargo/config`.
-    /// CLI and env are the current working directory.
-    pub fn root<'a>(&'a self, gctx: &'a GlobalContext) -> &'a Path {
+    /// If from a file, it is the directory above `.cargo/config.toml`.
+    /// CLI and env use the provided current working directory.
+    pub fn root<'a>(&'a self, cwd: &'a Path) -> &'a Path {
         match self {
             Definition::Path(p) | Definition::Cli(Some(p)) => p.parent().unwrap().parent().unwrap(),
-            Definition::Environment(_) | Definition::Cli(None) | Definition::BuiltIn => gctx.cwd(),
+            Definition::Environment(_) | Definition::Cli(None) | Definition::BuiltIn => cwd,
         }
     }