Avoid lookups to repo if possible

Author: Keats

src/lockfile.rs

@@ -89,6 +89,10 @@ impl Source {
         matches!(self, Source::Git { .. } | Source::Url { .. })
     }
 
+    pub fn is_repo(&self) -> bool {
+        matches!(self, Source::Repository { .. })
+    }
+
     /// The key to use in the cache: URL for a package repository, git URL for a git repository
     /// and for local the actual path
     pub fn source_path(&self) -> &str {

src/resolver/mod.rs

@@ -503,6 +503,12 @@ impl<'d> Resolver<'d> {
                 None
                 | Some(ConfigDependency::Detailed { .. })
                 | Some(ConfigDependency::Simple(_)) => {
+                    // If we already have something that will satisfy the dependency, no need
+                    // to look it up again
+                    if item.version_requirement.is_none() && result.found_in_repo(&item.name) {
+                        continue;
+                    }
+
                     if let Some((resolved_dep, items)) = self.repositories_lookup(&item, cache) {
                         result.add_found(resolved_dep);
                         queue.extend(items);

src/resolver/result.rs

@@ -32,6 +32,15 @@ impl<'d> Resolution<'d> {
         self.found.push(dep);
     }
 
+    /// If we already found something matching, we skip trying to get it.
+    /// This is only called when we would look up a repo for a package without a version requirement
+    pub(crate) fn found_in_repo(&self, name: &str) -> bool {
+        self.found
+            .iter()
+            .find(|d| d.source.is_repo() && d.name == name)
+            .is_some()
+    }
+
     pub fn finalize(&mut self) {
         let mut solver = DependencySolver::default();
         for package in &self.found {