From 22a4923d7f4bca1d0f77b05135812079bf0620ab Mon Sep 17 00:00:00 2001 From: Beast-ofcourse Date: Wed, 8 Jul 2026 11:48:57 +0530 Subject: [PATCH 1/3] fix(uv): preserve extra/group names in conflict error messages --- crates/uv-resolver/src/error.rs | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/crates/uv-resolver/src/error.rs b/crates/uv-resolver/src/error.rs index 1bcbfe86acf9d..28db592348f7b 100644 --- a/crates/uv-resolver/src/error.rs +++ b/crates/uv-resolver/src/error.rs @@ -481,13 +481,20 @@ impl NoSolutionError { } /// Given a [`DerivationTree`], collapse any [`External::FromDependencyOf`] incompatibilities - /// wrap an [`PubGrubPackageInner::Extra`] package. + /// that wrap a [`PubGrubPackageInner::Marker`] proxy. Extra and group proxies are preserved + /// since they carry user-meaningful information about which optional dependencies are involved. pub(crate) fn collapse_proxies(derivation_tree: ErrorTree) -> ErrorTree { fn is_proxy(tree: &ErrorTree) -> bool { + // Returns `true` if the package is a marker-only proxy (not extra or + // group, which carry user-meaningful information). + fn is_proxy_package(package: &PubGrubPackage) -> bool { + matches!(&**package, PubGrubPackageInner::Marker { .. }) + } + matches!( tree, DerivationTree::External(External::FromDependencyOf(package, ..)) - if package.is_proxy() + if is_proxy_package(package) ) } From 595d11d807ed1289b350486fdb2d923947af4825 Mon Sep 17 00:00:00 2001 From: Beast-ofcourse Date: Wed, 8 Jul 2026 13:14:25 +0530 Subject: [PATCH 2/3] test(error): verify collapse_proxies preserves Extra and Group proxies --- crates/uv-resolver/src/error.rs | 56 +++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) diff --git a/crates/uv-resolver/src/error.rs b/crates/uv-resolver/src/error.rs index 28db592348f7b..eeb7162532cac 100644 --- a/crates/uv-resolver/src/error.rs +++ b/crates/uv-resolver/src/error.rs @@ -1666,6 +1666,7 @@ fn simplify_range( #[cfg(test)] mod tests { use super::*; + use uv_normalize::GroupName; fn deep_derivation_tree() -> ErrorTree { let package = PubGrubPackage::from(PubGrubPackageInner::Root(None)); @@ -1741,6 +1742,61 @@ mod tests { Ok(()) } + #[test] + fn collapse_proxies_preserves_extra_and_group() { + // Build a tree with Extra and Group proxies. They should survive + // `collapse_proxies` since they carry user-meaningful information. + let extra = PubGrubPackage::from(PubGrubPackageInner::Extra { + name: PackageName::from_owned("pkg".to_string()).unwrap(), + extra: ExtraName::from_owned("my-extra".to_string()).unwrap(), + marker: None, + }); + let group = PubGrubPackage::from(PubGrubPackageInner::Group { + name: PackageName::from_owned("pkg".to_string()).unwrap(), + group: "my-group".parse::().unwrap(), + marker: None, + }); + let dep = PubGrubPackage::from(PubGrubPackageInner::Package { + name: PackageName::from_owned("dep".to_string()).unwrap(), + extra: None, + marker: None, + group: None, + }); + + let extra_leaf = ErrorTree::External(External::FromDependencyOf( + extra, + pubgrub::Range::any(), + dep.clone(), + pubgrub::Range::any(), + )); + let group_leaf = ErrorTree::External(External::FromDependencyOf( + group, + pubgrub::Range::any(), + dep, + pubgrub::Range::any(), + )); + // Combine them into a small tree so both survive the transformation. + let tree = ErrorTree::Derived(Derived { + terms: pubgrub::Map::default(), + shared_id: None, + cause1: Arc::new(extra_leaf), + cause2: Arc::new(group_leaf), + }); + + let collapsed = NoSolutionError::collapse_proxies(tree); + + // Both the Extra and Group proxies should still be present. + let packages: Vec<_> = derivation_tree_packages(&collapsed).collect(); + assert!( + packages.iter().any(|p| matches!(&**p, PubGrubPackageInner::Extra { .. })), + "Extra proxy should be preserved after collapse_proxies" + ); + assert!( + packages.iter().any(|p| matches!(&**p, PubGrubPackageInner::Group { .. })), + "Group proxy should be preserved after collapse_proxies" + ); + } + #[test] fn iterative_debug_matches_pubgrub_debug() { let package = PubGrubPackage::from(PubGrubPackageInner::Root(None)); From 4534a9366b5d99fa0a59c2d5085ea3c280f28e86 Mon Sep 17 00:00:00 2001 From: Beast-ofcourse Date: Wed, 8 Jul 2026 14:20:04 +0530 Subject: [PATCH 3/3] fix: clippy errors in collapse_proxies_preserves_extra_and_group test - marker: None -> marker: None.into() (MarkerTree, not Option) - pubgrub::Range::any() -> pubgrub::Range::full() (removed associated fn) - &**p -> &***p (extra deref through Arc) --- crates/uv-resolver/src/error.rs | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/crates/uv-resolver/src/error.rs b/crates/uv-resolver/src/error.rs index eeb7162532cac..58b26d6f25daf 100644 --- a/crates/uv-resolver/src/error.rs +++ b/crates/uv-resolver/src/error.rs @@ -1749,31 +1749,31 @@ mod tests { let extra = PubGrubPackage::from(PubGrubPackageInner::Extra { name: PackageName::from_owned("pkg".to_string()).unwrap(), extra: ExtraName::from_owned("my-extra".to_string()).unwrap(), - marker: None, + marker: None.into(), }); let group = PubGrubPackage::from(PubGrubPackageInner::Group { name: PackageName::from_owned("pkg".to_string()).unwrap(), group: "my-group".parse::().unwrap(), - marker: None, + marker: None.into(), }); let dep = PubGrubPackage::from(PubGrubPackageInner::Package { name: PackageName::from_owned("dep".to_string()).unwrap(), extra: None, - marker: None, + marker: None.into(), group: None, }); let extra_leaf = ErrorTree::External(External::FromDependencyOf( extra, - pubgrub::Range::any(), + pubgrub::Range::full(), dep.clone(), - pubgrub::Range::any(), + pubgrub::Range::full(), )); let group_leaf = ErrorTree::External(External::FromDependencyOf( group, - pubgrub::Range::any(), + pubgrub::Range::full(), dep, - pubgrub::Range::any(), + pubgrub::Range::full(), )); // Combine them into a small tree so both survive the transformation. let tree = ErrorTree::Derived(Derived { @@ -1788,11 +1788,11 @@ mod tests { // Both the Extra and Group proxies should still be present. let packages: Vec<_> = derivation_tree_packages(&collapsed).collect(); assert!( - packages.iter().any(|p| matches!(&**p, PubGrubPackageInner::Extra { .. })), + packages.iter().any(|p| matches!(&***p, PubGrubPackageInner::Extra { .. })), "Extra proxy should be preserved after collapse_proxies" ); assert!( - packages.iter().any(|p| matches!(&**p, PubGrubPackageInner::Group { .. })), + packages.iter().any(|p| matches!(&***p, PubGrubPackageInner::Group { .. })), "Group proxy should be preserved after collapse_proxies" ); }