feat: delay file patches register to next round of resolution

Only after a few dependency resolution happen, can a `[patch]` entry
with patch files know which version it is going to patch. Hence we need
to "delay" the patch process until at least one resolution is done, and
re-resolves the graph is any patch become applicable with the newly
resolved dependency graph.

Author: weihanglo

crates/cargo-util-schemas/src/core/package_id_spec.rs

@@ -625,7 +625,11 @@ mod tests {
                 name: String::from("bar"),
                 version: Some("1.2.0".parse().unwrap()),
                 url: Some(Url::parse("patched+https://crates.io/foo").unwrap()),
-                kind: Some(SourceKind::Patched(PatchInfo::new("bar".into(), "1.2.0".into(), vec!["/to/a.patch".into(), "/b.patch".into()]))),
+                kind: Some(SourceKind::Patched(PatchInfo::Resolved {
+                    name: "bar".into(),
+                    version: "1.2.0".into(),
+                    patches: vec!["/to/a.patch".into(), "/b.patch".into()],
+                })),
             },
             "patched+https://crates.io/foo?name=bar&version=1.2.0&patch=%2Fto%2Fa.patch&patch=%2Fb.patch#bar@1.2.0",
         );

crates/cargo-util-schemas/src/core/source_kind.rs

@@ -211,26 +211,29 @@ impl<'a> std::fmt::Display for PrettyRef<'a> {
 
 /// Information to find the source package and patch files.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct PatchInfo {
-    /// Name of the package to be patched.
-    name: String,
-    /// Verision of the package to be patched.
-    version: String,
-    /// Absolute paths to patch files.
-    ///
-    /// These are absolute to ensure Cargo can locate them in the patching phase.
-    patches: Vec<PathBuf>,
+pub enum PatchInfo {
+    /// The package to be patched is known and finalized.
+    Resolved {
+        /// Name and version of the package to be patched.
+        name: String,
+        /// Version of the package to be patched.
+        version: String,
+        /// Absolute paths to patch files.
+        ///
+        /// These are absolute to ensure Cargo can locate them in the patching phase.
+        patches: Vec<PathBuf>,
+    },
+    /// The package to be patched hasn't yet be resolved. Usually after a few
+    /// times of dependecy resolution, this will become [`PatchInfo::Resolved`].
+    Deferred {
+        /// Absolute paths to patch files.
+        ///
+        /// These are absolute to ensure Cargo can locate them in the patching phase.
+        patches: Vec<PathBuf>,
+    },
 }
 
 impl PatchInfo {
-    pub fn new(name: String, version: String, patches: Vec<PathBuf>) -> PatchInfo {
-        PatchInfo {
-            name,
-            version,
-            patches,
-        }
-    }
-
     /// Collects patch information from query string.
     ///
     /// * `name` --- Package name
@@ -256,24 +259,34 @@ impl PatchInfo {
         if patches.is_empty() {
             return Err(PatchInfoError("path"));
         }
-        Ok(PatchInfo::new(name, version, patches))
+        Ok(PatchInfo::Resolved {
+            name,
+            version,
+            patches,
+        })
     }
 
     /// As a URL query string.
     pub fn as_query(&self) -> PatchInfoQuery<'_> {
         PatchInfoQuery(self)
     }
 
-    pub fn name(&self) -> &str {
-        self.name.as_str()
-    }
-
-    pub fn version(&self) -> &str {
-        self.version.as_str()
+    pub fn finalize(self, name: String, version: String) -> Self {
+        match self {
+            PatchInfo::Deferred { patches } => PatchInfo::Resolved {
+                name,
+                version,
+                patches,
+            },
+            _ => panic!("patch info has already finalized: {self:?}"),
+        }
     }
 
     pub fn patches(&self) -> &[PathBuf] {
-        self.patches.as_slice()
+        match self {
+            PatchInfo::Resolved { patches, .. } => patches.as_slice(),
+            PatchInfo::Deferred { patches } => patches.as_slice(),
+        }
     }
 }
 
@@ -282,22 +295,38 @@ pub struct PatchInfoQuery<'a>(&'a PatchInfo);
 
 impl<'a> std::fmt::Display for PatchInfoQuery<'a> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "name=")?;
-        for value in url::form_urlencoded::byte_serialize(self.0.name.as_bytes()) {
-            write!(f, "{value}")?;
-        }
-        write!(f, "&version=")?;
-        for value in url::form_urlencoded::byte_serialize(self.0.version.as_bytes()) {
-            write!(f, "{value}")?;
+        match self.0 {
+            PatchInfo::Resolved {
+                name,
+                version,
+                patches,
+            } => {
+                f.write_str("name=")?;
+                for value in url::form_urlencoded::byte_serialize(name.as_bytes()) {
+                    write!(f, "{value}")?;
+                }
+                f.write_str("&version=")?;
+                for value in url::form_urlencoded::byte_serialize(version.as_bytes()) {
+                    write!(f, "{value}")?;
+                }
+                if !patches.is_empty() {
+                    f.write_str("&")?;
+                }
+            }
+            _ => {}
         }
-        for path in &self.0.patches {
-            write!(f, "&patch=")?;
+
+        let mut patches = self.0.patches().iter().peekable();
+        while let Some(path) = patches.next() {
+            f.write_str("patch=")?;
             let path = path.to_str().expect("utf8 patch").replace("\\", "/");
             for value in url::form_urlencoded::byte_serialize(path.as_bytes()) {
                 write!(f, "{value}")?;
             }
+            if patches.peek().is_some() {
+                f.write_str("&")?
+            }
         }
-
         Ok(())
     }
 }

src/cargo/core/registry.rs

@@ -517,6 +517,13 @@ impl<'gctx> PackageRegistry<'gctx> {
         &self.patches
     }
 
+    /// Removes all residual state of patches.
+    pub fn clear_patch(&mut self) {
+        self.patches = Default::default();
+        self.patches_locked = false;
+        self.patches_available = Default::default();
+    }
+
     /// Loads the [`Source`] for a given [`SourceId`] to this registry, making
     /// them available to resolution.
     fn load(&mut self, source_id: SourceId, kind: Kind) -> CargoResult<()> {

src/cargo/core/source_id.rs

@@ -396,6 +396,11 @@ impl SourceId {
         matches!(self.inner.kind, SourceKind::Git(_))
     }
 
+    /// Returns `true` if this source is patched by patch files.
+    pub fn is_patched(self) -> bool {
+        matches!(self.inner.kind, SourceKind::Patched(_))
+    }
+
     /// Creates an implementation of `Source` corresponding to this ID.
     ///
     /// * `yanked_whitelist` --- Packages allowed to be used, even if they are yanked.
@@ -451,6 +456,14 @@ impl SourceId {
         }
     }
 
+    /// Gets the patch information if this is a patched source, otherwise `None`.
+    pub fn patch_info(self) -> Option<&'static PatchInfo> {
+        match &self.inner.kind {
+            SourceKind::Patched(i) => Some(i),
+            _ => None,
+        }
+    }
+
     /// Check if the precise data field has bean set
     pub fn has_precise(self) -> bool {
         self.inner.precise.is_some()
@@ -689,9 +702,10 @@ impl fmt::Display for SourceId {
             SourceKind::Patched(ref patch_info) => {
                 let n = patch_info.patches().len();
                 let plural = if n == 1 { "" } else { "s" };
-                let name = patch_info.name();
-                let version = patch_info.version();
-                write!(f, "{name}@{version} with {n} patch file{plural}")
+                if let PatchInfo::Resolved { name, version, .. } = &patch_info {
+                    write!(f, "{name}@{version} ")?;
+                }
+                write!(f, "with {n} patch file{plural}")
             }
         }
     }
@@ -889,11 +903,15 @@ mod tests {
         assert_eq!(gen_hash(source_id), 17459999773908528552);
         assert_eq!(crate::util::hex::short_hash(&source_id), "6568fe2c2fab5bfe");
 
-        let patch_info = PatchInfo::new("foo".into(), "1.0.0".into(), vec![path.into()]);
+        let patch_info = PatchInfo::Resolved {
+            name: "foo".into(),
+            version: "1.0.0".into(),
+            patches: vec![path.into()],
+        };
         let registry_source_id = SourceId::for_registry(&url).unwrap();
         let source_id = SourceId::for_patches(registry_source_id, patch_info).unwrap();
-        assert_eq!(gen_hash(source_id), 10476212805277277232);
-        assert_eq!(crate::util::hex::short_hash(&source_id), "45f3b913ab447282");
+        assert_eq!(gen_hash(source_id), 15459318675065232737);
+        assert_eq!(crate::util::hex::short_hash(&source_id), "87ca345b36470e4d");
     }
 
     #[test]