Fix dependency group handling

Author: konstin

crates/uv-resolver/src/pubgrub/package.rs

@@ -133,6 +133,32 @@ impl PubGrubPackage {
         }
     }
 
+    /// If this package is a proxy package, return the base package it depends on.
+    ///
+    /// While dependency groups may be attached to a package, we don't consider them here as
+    /// there is no (mandatory) dependency from a dependency group to the package.
+    pub(crate) fn base_package(&self) -> Option<Self> {
+        match &**self {
+            PubGrubPackageInner::Root(_)
+            | PubGrubPackageInner::Python(_)
+            | PubGrubPackageInner::System(_)
+            | PubGrubPackageInner::Package { .. } => None,
+            PubGrubPackageInner::Group { .. } => {
+                // The dependency groups of a package do not by themselves require the package
+                // itself.
+                None
+            }
+            PubGrubPackageInner::Extra { name, .. } | PubGrubPackageInner::Marker { name, .. } => {
+                Some(Self::from_package(
+                    name.clone(),
+                    None,
+                    None,
+                    MarkerTree::TRUE,
+                ))
+            }
+        }
+    }
+
     /// Returns the name of this PubGrub package, if it has one.
     pub(crate) fn name(&self) -> Option<&PackageName> {
         match &**self {

crates/uv-resolver/src/pubgrub/priority.rs

@@ -151,11 +151,11 @@ impl PubGrubPriorities {
                 let package_tiebreaker = match self.virtual_package_tiebreaker.get(package) {
                     Some(tiebreaker) => *tiebreaker,
                     None => {
-                        //if cfg!(debug_assertions) {
-                        //    panic!("Virtual package not known: `{package}`")
-                        //} else {
-                        PubGrubTiebreaker(Reverse(u32::MAX))
-                        //}
+                        if cfg!(debug_assertions) {
+                            panic!("Package not registered in prioritization: `{package:?}`")
+                        } else {
+                            PubGrubTiebreaker(Reverse(u32::MAX))
+                        }
                     }
                 };
 

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

@@ -2866,6 +2866,12 @@ impl ForkState {
 
             // Update the package priorities.
             self.priorities.insert(package, version, &self.fork_urls);
+            // As we're adding an incompatibility from the proxy package to the base package,
+            // we need to register the base package.
+            if let Some(base_package) = package.base_package() {
+                self.priorities
+                    .insert(&base_package, version, &self.fork_urls);
+            }
         }
 
         Ok(())
@@ -2886,20 +2892,8 @@ impl ForkState {
                 url: _,
             } = dependency;
 
-            let base_package = match &**package {
-                PubGrubPackageInner::Root(_)
-                | PubGrubPackageInner::Python(_)
-                | PubGrubPackageInner::System(_)
-                | PubGrubPackageInner::Package { .. } => continue,
-                PubGrubPackageInner::Dev { .. } => {
-                    // The dependency groups of a package do not by themselves require the package
-                    // itself.
-                    continue;
-                }
-                PubGrubPackageInner::Extra { name, .. }
-                | PubGrubPackageInner::Marker { name, .. } => {
-                    PubGrubPackage::from_package(name.clone(), None, None, MarkerTree::TRUE)
-                }
+            let Some(base_package) = package.base_package() else {
+                continue;
             };
 
             let proxy_package = self.pubgrub.package_store.alloc(package.clone());