Add some misc. touch-ups in resolver (#9954)

crates/uv-resolver/src/graph_ops.rs

@@ -192,7 +192,7 @@ pub(crate) fn simplify_conflict_markers(
 
     let mut inferences: FxHashMap<NodeIndex, Vec<FxHashSet<Inference>>> = FxHashMap::default();
     for (node_id, sets) in activated {
-        let mut new_sets = vec![];
+        let mut new_sets = Vec::with_capacity(sets.len());
         for set in sets {
             let mut new_set = FxHashSet::default();
             for item in set {

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

@@ -155,15 +155,15 @@ impl PubGrubPackage {
 
     /// Returns the marker expression associated with this PubGrub package, if
     /// it has one.
-    pub(crate) fn marker(&self) -> Option<MarkerTree> {
+    pub(crate) fn marker(&self) -> MarkerTree {
         match &**self {
             // A root can never be a dependency of another package, and a `Python` pubgrub
             // package is never returned by `get_dependencies`. So these cases never occur.
-            PubGrubPackageInner::Root(_) | PubGrubPackageInner::Python(_) => None,
+            PubGrubPackageInner::Root(_) | PubGrubPackageInner::Python(_) => MarkerTree::TRUE,
             PubGrubPackageInner::Package { marker, .. }
             | PubGrubPackageInner::Extra { marker, .. }
-            | PubGrubPackageInner::Dev { marker, .. } => Some(*marker),
-            PubGrubPackageInner::Marker { marker, .. } => Some(*marker),
+            | PubGrubPackageInner::Dev { marker, .. } => *marker,
+            PubGrubPackageInner::Marker { marker, .. } => *marker,
         }
     }
 

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

@@ -435,7 +435,7 @@ impl<'d> ForkingPossibility<'d> {
         env: &ResolverEnvironment,
         dep: &'d PubGrubDependency,
     ) -> ForkingPossibility<'d> {
-        let marker = dep.package.marker().unwrap_or(MarkerTree::TRUE);
+        let marker = dep.package.marker();
         if !env.included_by_marker(marker) {
             ForkingPossibility::DependencyAlwaysExcluded
         } else if marker.is_true() {
@@ -506,7 +506,7 @@ impl<'d> Forker<'d> {
     /// Returns true if the dependency represented by this forker may be
     /// included in the given resolver environment.
     pub(crate) fn included(&self, env: &ResolverEnvironment) -> bool {
-        let marker = self.package.marker().unwrap_or(MarkerTree::TRUE);
+        let marker = self.package.marker();
         env.included_by_marker(marker)
     }
 }

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

@@ -3053,16 +3053,13 @@ impl Forks {
                 // For example, given `requires-python = ">=3.7"` and `uv ; python_version >= "3.8"`,
                 // where uv itself only supports Python 3.8 and later, we need to fork to ensure
                 // that the resolution can find a solution.
-                if !dep
-                    .package
-                    .marker()
-                    .and_then(marker::requires_python)
-                    .is_some_and(|bound| python_requirement.raises(&bound))
+                if marker::requires_python(dep.package.marker())
+                    .is_none_or(|bound| !python_requirement.raises(&bound))
                 {
                     let dep = deps.pop().unwrap();
-                    let markers = dep.package.marker().unwrap_or(MarkerTree::TRUE);
+                    let marker = dep.package.marker();
                     for fork in &mut forks {
-                        if fork.env.included_by_marker(markers) {
+                        if fork.env.included_by_marker(marker) {
                             fork.add_dependency(dep.clone());
                         }
                     }
@@ -3249,10 +3246,8 @@ impl Fork {
     fn set_env(&mut self, env: ResolverEnvironment) {
         self.env = env;
         self.dependencies.retain(|dep| {
-            let Some(markers) = dep.package.marker() else {
-                return true;
-            };
-            if self.env.included_by_marker(markers) {
+            let marker = dep.package.marker();
+            if self.env.included_by_marker(marker) {
                 return true;
             }
             if let Some(conflicting_item) = dep.package.conflicting_item() {