Extract config patch on use

Author: Jon Gjengset

src/cargo/core/resolver/encode.rs

@@ -154,7 +154,7 @@ impl EncodableResolve {
     /// primary uses is to be used with `resolve_with_previous` to guide the
     /// resolver to create a complete Resolve.
     pub fn into_resolve(self, original: &str, ws: &Workspace<'_>) -> CargoResult<Resolve> {
-        let path_deps = build_path_deps(ws);
+        let path_deps = build_path_deps(ws)?;
         let mut checksums = HashMap::new();
 
         let mut version = match self.version {
@@ -402,7 +402,7 @@ impl EncodableResolve {
     }
 }
 
-fn build_path_deps(ws: &Workspace<'_>) -> HashMap<String, SourceId> {
+fn build_path_deps(ws: &Workspace<'_>) -> CargoResult<HashMap<String, SourceId>> {
     // If a crate is **not** a path source, then we're probably in a situation
     // such as `cargo install` with a lock file from a remote dependency. In
     // that case we don't need to fixup any path dependencies (as they're not
@@ -424,7 +424,7 @@ fn build_path_deps(ws: &Workspace<'_>) -> HashMap<String, SourceId> {
     for member in members.iter() {
         build_pkg(member, ws, &mut ret, &mut visited);
     }
-    for deps in ws.root_patch().values() {
+    for deps in ws.root_patch()?.values() {
         for dep in deps {
             build_dep(dep, ws, &mut ret, &mut visited);
         }
@@ -433,7 +433,7 @@ fn build_path_deps(ws: &Workspace<'_>) -> HashMap<String, SourceId> {
         build_dep(dep, ws, &mut ret, &mut visited);
     }
 
-    return ret;
+    return Ok(ret);
 
     fn build_pkg(
         pkg: &Package,

src/cargo/core/workspace.rs

@@ -16,12 +16,12 @@ use crate::core::resolver::ResolveBehavior;
 use crate::core::{Dependency, Edition, PackageId, PackageIdSpec};
 use crate::core::{EitherManifest, Package, SourceId, VirtualManifest};
 use crate::ops;
-use crate::sources::PathSource;
+use crate::sources::{PathSource, CRATES_IO_INDEX, CRATES_IO_REGISTRY};
 use crate::util::errors::{CargoResult, CargoResultExt, ManifestError};
 use crate::util::interning::InternedString;
 use crate::util::paths;
-use crate::util::toml::{read_manifest, TomlProfiles};
-use crate::util::{Config, Filesystem};
+use crate::util::toml::{read_manifest, TomlDependency, TomlProfiles};
+use crate::util::{config::ConfigRelativePath, Config, Filesystem, IntoUrl};
 
 /// The core abstraction in Cargo for working with a workspace of crates.
 ///
@@ -362,31 +362,89 @@ impl<'cfg> Workspace<'cfg> {
         }
     }
 
+    fn config_patch(&self) -> CargoResult<HashMap<Url, Vec<Dependency>>> {
+        let config_patch: Option<
+            BTreeMap<String, BTreeMap<String, TomlDependency<ConfigRelativePath>>>,
+        > = self.config.get("patch")?;
+
+        if config_patch.is_some() && !self.config.cli_unstable().patch_in_config {
+            self.config.shell().warn("`[patch]` in cargo config was ignored, the -Zpatch-in-config command-line flag is required".to_owned())?;
+            return Ok(HashMap::new());
+        }
+
+        let source = SourceId::for_path(self.root())?;
+
+        let mut warnings = Vec::new();
+        let mut nested_paths = Vec::new();
+
+        let mut patch = HashMap::new();
+        for (url, deps) in config_patch.into_iter().flatten() {
+            let url = match &url[..] {
+                CRATES_IO_REGISTRY => CRATES_IO_INDEX.parse().unwrap(),
+                url => self
+                    .config
+                    .get_registry_index(url)
+                    .or_else(|_| url.into_url())
+                    .chain_err(|| {
+                        format!("[patch] entry `{}` should be a URL or registry name", url)
+                    })?,
+            };
+            patch.insert(
+                url,
+                deps.iter()
+                    .map(|(name, dep)| {
+                        dep.to_dependency_split(
+                            name,
+                            /* pkg_id */ None,
+                            source,
+                            &mut nested_paths,
+                            self.config,
+                            &mut warnings,
+                            /* platform */ None,
+                            // NOTE: Since we use ConfigRelativePath, this root isn't used as
+                            // any relative paths are resolved before they'd be joined with root.
+                            self.root(),
+                            self.unstable_features(),
+                            None,
+                        )
+                    })
+                    .collect::<CargoResult<Vec<_>>>()?,
+            );
+        }
+
+        for message in warnings {
+            self.config
+                .shell()
+                .warn(format!("[patch] in cargo config: {}", message))?
+        }
+
+        let _ = nested_paths;
+
+        Ok(patch)
+    }
+
     /// Returns the root `[patch]` section of this workspace.
     ///
     /// This may be from a virtual crate or an actual crate.
-    pub fn root_patch(&self) -> HashMap<Url, Vec<Dependency>> {
+    pub fn root_patch(&self) -> CargoResult<HashMap<Url, Vec<Dependency>>> {
         let from_manifest = match self.root_maybe() {
             MaybePackage::Package(p) => p.manifest().patch(),
             MaybePackage::Virtual(vm) => vm.patch(),
         };
 
-        let from_config = self
-            .config
-            .patch()
-            .expect("config [patch] was never parsed");
+        let from_config = self.config_patch()?;
         if from_config.is_empty() {
-            return from_manifest.clone();
+            return Ok(from_manifest.clone());
         }
         if from_manifest.is_empty() {
-            return from_config.clone();
+            return Ok(from_config.clone());
         }
 
         // We could just chain from_manifest and from_config,
         // but that's not quite right as it won't deal with overlaps.
         let mut combined = from_manifest.clone();
         for (url, cdeps) in from_config {
-            if let Some(deps) = combined.get_mut(url) {
+            if let Some(deps) = combined.get_mut(&url) {
                 // We want from_manifest to take precedence for each patched name.
                 // NOTE: This is inefficient if the number of patches is large!
                 let mut left = cdeps.clone();
@@ -404,7 +462,7 @@ impl<'cfg> Workspace<'cfg> {
                 combined.insert(url.clone(), cdeps.clone());
             }
         }
-        combined
+        Ok(combined)
     }
 
     /// Returns an iterator over all packages in this workspace

src/cargo/ops/resolve.rs

@@ -240,7 +240,7 @@ pub fn resolve_with_previous<'cfg>(
     // locked.
     let mut avoid_patch_ids = HashSet::new();
     if register_patches {
-        for (url, patches) in ws.root_patch().iter() {
+        for (url, patches) in ws.root_patch()?.iter() {
             let previous = match previous {
                 Some(r) => r,
                 None => {

src/cargo/util/config/mod.rs

@@ -74,7 +74,7 @@ use url::Url;
 use self::ConfigValue as CV;
 use crate::core::compiler::rustdoc::RustdocExternMap;
 use crate::core::shell::Verbosity;
-use crate::core::{features, CliUnstable, Dependency, Shell, SourceId, Workspace};
+use crate::core::{features, CliUnstable, Shell, SourceId, Workspace};
 use crate::ops;
 use crate::util::errors::{CargoResult, CargoResultExt};
 use crate::util::toml as cargo_toml;
@@ -176,8 +176,6 @@ pub struct Config {
     /// Lock, if held, of the global package cache along with the number of
     /// acquisitions so far.
     package_cache_lock: RefCell<Option<(Option<FileLock>, usize)>>,
-    /// `[patch]` section parsed from configuration.
-    patch: LazyCell<HashMap<Url, Vec<Dependency>>>,
     /// Cached configuration parsed by Cargo
     http_config: LazyCell<CargoHttpConfig>,
     net_config: LazyCell<CargoNetConfig>,
@@ -279,7 +277,6 @@ impl Config {
             upper_case_env,
             updated_sources: LazyCell::new(),
             package_cache_lock: RefCell::new(None),
-            patch: LazyCell::new(),
             http_config: LazyCell::new(),
             net_config: LazyCell::new(),
             build_config: LazyCell::new(),
@@ -1327,17 +1324,6 @@ impl Config {
         Ok(*(self.crates_io_source_id.try_borrow_with(f)?))
     }
 
-    pub fn maybe_init_patch<F>(&self, f: F) -> CargoResult<&HashMap<Url, Vec<Dependency>>>
-    where
-        F: FnMut() -> CargoResult<HashMap<Url, Vec<Dependency>>>,
-    {
-        self.patch.try_borrow_with(f)
-    }
-
-    pub fn patch(&self) -> Option<&HashMap<Url, Vec<Dependency>>> {
-        self.patch.borrow()
-    }
-
     pub fn creation_time(&self) -> Instant {
         self.creation_time
     }