Improve distribution id performance

crates/uv-resolver/src/pins.rs

@@ -1,5 +1,3 @@
-use std::collections::hash_map::Entry;
-
 use rustc_hash::FxHashMap;
 
 use uv_distribution_types::{CompatibleDist, DistributionId, Identifier, ResolvedDist};
@@ -27,26 +25,16 @@ pub(crate) struct FilePins(FxHashMap<(PackageName, uv_pep440::Version), FilePin>
 // final resolution).
 impl FilePins {
     /// Pin a candidate package.
+    ///
+    /// Within a single fork, the same `(name, version)` always resolves to the same distribution,
+    /// so we skip construction when an entry already exists.
     pub(crate) fn insert(&mut self, candidate: &Candidate, dist: &CompatibleDist) {
-        let pin = FilePin {
-            dist: dist.for_installation().to_owned(),
-            metadata_id: dist.for_resolution().distribution_id(),
-        };
-        match self
-            .0
+        self.0
             .entry((candidate.name().clone(), candidate.version().clone()))
-        {
-            Entry::Occupied(mut entry) => {
-                if entry.get().dist.distribution_id() != pin.dist.distribution_id()
-                    || entry.get().metadata_id != pin.metadata_id
-                {
-                    entry.insert(pin);
-                }
-            }
-            Entry::Vacant(entry) => {
-                entry.insert(pin);
-            }
-        }
+            .or_insert_with(|| FilePin {
+                dist: dist.for_installation().to_owned(),
+                metadata_id: dist.for_resolution().distribution_id(),
+            });
     }
 
     /// Return the pinned file for the given package name and version, if it exists.
@@ -60,14 +48,14 @@ impl FilePins {
             .map(|pin| &pin.dist)
     }
 
-    /// Return the distribution id whose metadata was used during resolution.
-    pub(crate) fn metadata_id(
+    /// Return the pinned distribution and its metadata id in a single lookup.
+    pub(crate) fn dist_and_id(
         &self,
         name: &PackageName,
         version: &uv_pep440::Version,
-    ) -> Option<&DistributionId> {
+    ) -> Option<(&ResolvedDist, &DistributionId)> {
         self.0
             .get(&(name.clone(), version.clone()))
-            .map(|pin| &pin.metadata_id)
+            .map(|pin| (&pin.dist, &pin.metadata_id))
     }
 }

crates/uv-resolver/src/resolution/output.rs

@@ -456,14 +456,11 @@ impl ResolverOutput {
                 Some(metadata),
             )
         } else {
-            let dist = pins
-                .get(name, version)
-                .expect("Every package should be pinned")
-                .clone();
+            let (dist, metadata_id) = pins
+                .dist_and_id(name, version)
+                .expect("Every package should be pinned");
+            let dist = dist.clone();
             let hashes_id = dist.distribution_id();
-            let metadata_id = pins
-                .metadata_id(name, version)
-                .expect("Every package should have pinned metadata");
 
             // Track yanks for any registry distributions.
             match dist.yanked() {

crates/uv-resolver/src/resolver/mod.rs

@@ -1810,17 +1810,16 @@ impl<InstalledPackages: InstalledPackagesProvider> ResolverState<InstalledPackag
                     return Ok(Dependencies::Unforkable(Vec::default()));
                 }
 
-                let (distribution_id, task) = if let Some(distribution_id) =
-                    pins.metadata_id(name, version)
+                // Look up the distribution ID from the pins (common case) or fork URLs.
+                let owned_id;
+                let distribution_id = if let Some((_, metadata_id)) =
+                    pins.dist_and_id(name, version)
                 {
-                    (
-                        distribution_id.clone(),
-                        pins.get(name, version)
-                            .map_or_else(|| format!("{name}=={version}"), ToString::to_string),
-                    )
+                    metadata_id
                 } else if let Some(url) = fork_urls.get(name) {
                     let dist = Dist::from_url(name.clone(), url.clone())?;
-                    (dist.distribution_id(), dist.to_string())
+                    owned_id = dist.distribution_id();
+                    &owned_id
                 } else {
                     debug_assert!(
                         false,
@@ -1845,8 +1844,8 @@ impl<InstalledPackages: InstalledPackagesProvider> ResolverState<InstalledPackag
                 let response = self
                     .index
                     .distributions()
-                    .wait_blocking(&distribution_id)
-                    .ok_or_else(|| ResolveError::UnregisteredTask(task))?;
+                    .wait_blocking(distribution_id)
+                    .ok_or_else(|| ResolveError::UnregisteredTask(format!("{name}=={version}")))?;
 
                 let metadata = match &*response {
                     MetadataResponse::Found(archive) => &archive.metadata,