Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
66 changes: 29 additions & 37 deletions crates/uv-resolver/src/resolution/output.rs
Original file line number Diff line number Diff line change
Expand Up @@ -30,7 +30,7 @@ use crate::{InMemoryIndex, MetadataResponse, Options, ResolveError, VersionsResp

/// Create a new [`ResolverOutput`] from the resolved PubGrub state.
pub(crate) fn from_state(
mut resolutions: Vec<ResolvedFork>,
resolutions: Vec<ResolvedFork>,
project: Option<&PackageName>,
workspace_members: &BTreeSet<PackageName>,
requirements: Vec<Requirement>,
Expand All @@ -45,6 +45,8 @@ pub(crate) fn from_state(
options: Options,
) -> Result<ResolverOutput, ResolveError> {
let size_guess = resolutions[0].nodes.len();
let has_forks = resolutions.len() > 1;
let mut fork_markers = Vec::new();
let mut graph: Graph<ResolutionGraphNode, UniversalMarker, Directed> =
Graph::with_capacity(size_guess, size_guess);
let mut inverse: FxHashMap<ResolutionNode, NodeIndex<u32>> =
Expand All @@ -54,16 +56,26 @@ pub(crate) fn from_state(
// Add the root node.
let root_index = graph.add_node(ResolutionGraphNode::Root);

for resolution in &mut resolutions {
let mut seen = FxHashSet::default();
for resolution in resolutions {
let marker = resolution.env.try_universal_markers().unwrap_or_default();
// A single unconditional resolution has no fork markers.
if has_forks || !marker.is_true() {
fork_markers.push(marker);
}
let mut node_indices = Vec::with_capacity(resolution.nodes.len());
// Add every package to the graph.
for (package, selected) in resolution.nodes.drain(..) {
for (package, selected) in resolution.nodes {
let node = ResolutionNode {
package,
version: selected.version().clone(),
};
let Entry::Vacant(entry) = inverse.entry(node) else {
// Insert each node only once.
continue;
let entry = match inverse.entry(node) {
Entry::Occupied(entry) => {
node_indices.push(*entry.get());
continue;
}
Entry::Vacant(entry) => entry,
};
let package = &entry.key().package;
let package_role = if project == Some(&package.name) {
Expand All @@ -84,42 +96,25 @@ pub(crate) fn from_state(
package_role,
);
entry.insert(node);
node_indices.push(node);
}
}

let mut seen = FxHashSet::default();
for resolution in &resolutions {
let marker = resolution.env.try_universal_markers().unwrap_or_default();

// Add every edge to the graph, propagating the marker for the current fork, if
// necessary.
for edge in &resolution.edges {
if !seen.insert((edge, marker)) {
// Insert each node only once.
for edge in resolution.edges {
let from_index = edge.from.map_or(root_index, |from| node_indices[from.0]);
let to_index = node_indices[edge.to.0];
// Local indices can denote different packages in different forks. Deduplicate only
// after translating both endpoints into the merged graph.
if !seen.insert((from_index, to_index, edge.marker, marker)) {
// Insert each edge only once.
continue;
}

add_edge(&mut graph, &inverse, root_index, edge, marker);
add_edge(&mut graph, from_index, to_index, &edge, marker);
}
}

let fork_markers: Vec<UniversalMarker> = if let [resolution] = resolutions.as_slice() {
// In the case of a singleton marker, we only include it if it's not
// always true. Otherwise, we keep our `fork_markers` empty as there
// are no forks.
resolution
.env
.try_universal_markers()
.into_iter()
.filter(|marker| !marker.is_true())
.collect()
} else {
resolutions
.iter()
.map(|resolution| resolution.env.try_universal_markers().unwrap_or_default())
.collect()
};

// Compute and apply the marker reachability.
let mut reachability = marker_reachability(&graph, &fork_markers);

Expand Down Expand Up @@ -199,14 +194,11 @@ pub(crate) fn from_state(

fn add_edge(
graph: &mut Graph<ResolutionGraphNode, UniversalMarker>,
inverse: &FxHashMap<ResolutionNode, NodeIndex>,
root_index: NodeIndex,
from_index: NodeIndex,
to_index: NodeIndex,
edge: &ResolutionDependencyEdge,
marker: UniversalMarker,
) {
let from_index = edge.from.as_ref().map_or(root_index, |from| inverse[from]);
let to_index = inverse[&edge.to];

let edge_marker = {
let mut edge_marker = edge.universal_marker();
edge_marker.and(marker);
Expand Down
143 changes: 72 additions & 71 deletions crates/uv-resolver/src/resolver/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -89,8 +89,8 @@ use crate::yanks::AllowedYanks;
use crate::{DependencyMode, Exclusions, FlatIndex, Options, ResolutionMode, VersionMap, marker};
pub(crate) use provider::MetadataUnavailable;
pub(crate) use resolution::{
Resolution, ResolutionDependencyEdge, ResolutionNode, ResolutionPackage, ResolvedFork,
SelectedDistribution,
Resolution, ResolutionDependencyEdge, ResolutionNode, ResolutionNodeId, ResolutionPackage,
ResolvedFork, SelectedDistribution,
};
use uv_configuration::ForkStrategy;

Expand Down Expand Up @@ -845,8 +845,8 @@ impl<InstalledPackages: InstalledPackagesProvider> ResolverState<InstalledPackag
if let Some(env) = resolution.env.end_user_fork_display() {
let packages: FxHashSet<_> = resolution
.nodes
.keys()
.map(|package| &package.name)
.iter()
.map(|(package, _)| &package.name)
.collect();
debug!(
"Distinct solution for {env} with {} package(s)",
Expand Down Expand Up @@ -3108,12 +3108,69 @@ impl<'index> ForkState<'index> {

fn into_resolution(self) -> Resolution<'index> {
let solution: FxHashMap<_, _> = self.pubgrub.partial_solution.extract_solution().collect();
// Node order can affect diagnostic order and which artifact hashes `requirements.txt`
// emits when it merges the same package version from different sources.
let nodes: FxHashMap<_, _> = solution
.iter()
.filter_map(|(&package, version)| {
if let PubGrubPackageInner::Package {
name,
kind,
marker: MarkerTree::TRUE,
} = &*self.pubgrub.package_store[package]
{
let (url, index) = self.source(name, version);
Some((
ResolutionPackage {
name: name.clone(),
kind: kind.clone(),
url: url.cloned(),
index: index.cloned(),
},
version.clone(),
))
} else {
None
}
})
.collect();
let nodes: Vec<_> = nodes.into_iter().collect();
let node_indices: FxHashMap<_, _> = nodes
.iter()
.enumerate()
.map(|(index, (package, version))| {
(
(
&package.name,
&package.kind,
package.url.as_ref(),
package.index.as_ref(),
version,
),
ResolutionNodeId(index),
)
})
.collect();

let edge_count: usize = solution
.keys()
.map(|package| self.pubgrub.incompatibilities[package].len())
.sum();
let mut edges: Vec<ResolutionDependencyEdge> = Vec::with_capacity(edge_count);
for (package, self_version) in &solution {
let (self_name, self_kind) = match &*self.pubgrub.package_store[*package] {
PubGrubPackageInner::Package { name, kind, .. } => (Some(name), kind),
PubGrubPackageInner::Root(_) => (None, &PackageNodeKind::Base),
PubGrubPackageInner::Python(_)
| PubGrubPackageInner::System(_)
| PubGrubPackageInner::Marker { .. }
| PubGrubPackageInner::Extra { .. }
| PubGrubPackageInner::Group { .. } => continue,
};
let from = self_name.map(|name| {
let (url, index) = self.source(name, self_version);
node_indices[&(name, self_kind, url, index, self_version)]
});
for id in &self.pubgrub.incompatibilities[package] {
let incompatibility = &self.pubgrub.incompatibility_store[*id];
let pubgrub::Kind::FromDependencyOf(self_package, dependency_package) =
Expand Down Expand Up @@ -3142,21 +3199,8 @@ impl<'index> ForkState<'index> {
continue;
}

let self_package = &self.pubgrub.package_store[self_package];
let dependency_package = &self.pubgrub.package_store[dependency_package];

let (self_name, self_kind) = match &**self_package {
PubGrubPackageInner::Package {
name: self_name,
kind: self_kind,
marker: _,
} => (Some(self_name), self_kind),

PubGrubPackageInner::Root(_) => (None, &PackageNodeKind::Base),

_ => continue,
};

let (name, kind, marker) = match &**dependency_package {
PubGrubPackageInner::Package { name, kind, marker } => {
debug_assert!(kind.is_base(), "Packages should depend on a variant proxy");
Expand Down Expand Up @@ -3196,69 +3240,26 @@ impl<'index> ForkState<'index> {
| PubGrubPackageInner::Python(_)
| PubGrubPackageInner::System(_) => continue,
};
let from = self_name.map(|name| {
let (url, index) = self.source(name, self_version);
ResolutionNode {
package: ResolutionPackage {
name: name.clone(),
kind: self_kind.clone(),
url: url.cloned(),
index: index.cloned(),
},
version: self_version.clone(),
}
});

let (url, index) = self.source(name, dependency_version);
let to = ResolutionNode {
package: ResolutionPackage {
name: name.clone(),
kind,
url: url.cloned(),
index: index.cloned(),
},
version: dependency_version.clone(),
};
let edge = ResolutionDependencyEdge { from, to, marker };
edges.push(ResolutionDependencyEdge {
from,
to: node_indices[&(name, &kind, url, index, dependency_version)],
marker,
});

// An extra proxy requires both the extra and its base package. A group proxy
// only requires the group itself.
if let PubGrubPackageInner::Extra { .. } = &**dependency_package {
let mut base_edge = edge.clone();
base_edge.to.package.kind = PackageNodeKind::Base;
edges.push(edge);
edges.push(base_edge);
} else {
edges.push(edge);
edges.push(ResolutionDependencyEdge {
from,
to: node_indices
[&(name, &PackageNodeKind::Base, url, index, dependency_version)],
marker,
});
}
}
}

let nodes = solution
.into_iter()
.filter_map(|(package, version)| {
if let PubGrubPackageInner::Package {
name,
kind,
marker: MarkerTree::TRUE,
} = &*self.pubgrub.package_store[package]
{
let (url, index) = self.source(name, &version);
Some((
ResolutionPackage {
name: name.clone(),
kind: kind.clone(),
url: url.cloned(),
index: index.cloned(),
},
version,
))
} else {
None
}
})
.collect();

Resolution {
nodes,
edges,
Expand Down
Loading
Loading
⌂ 换网址