Only apply to locals, if a version is available

Author: charliermarsh

crates/uv-distribution-types/src/prioritized_distribution.rs

@@ -119,9 +119,6 @@ impl IncompatibleDist {
                     None => format!("has {self}"),
                 },
                 IncompatibleWheel::RequiresPython(..) => format!("requires {self}"),
-                IncompatibleWheel::MissingPlatform(_) => {
-                    format!("has {self}")
-                }
             },
             Self::Source(incompatibility) => match incompatibility {
                 IncompatibleSource::NoBuild => format!("has {self}"),
@@ -149,9 +146,6 @@ impl IncompatibleDist {
                     None => format!("have {self}"),
                 },
                 IncompatibleWheel::RequiresPython(..) => format!("require {self}"),
-                IncompatibleWheel::MissingPlatform(_) => {
-                    format!("have {self}")
-                }
             },
             Self::Source(incompatibility) => match incompatibility {
                 IncompatibleSource::NoBuild => format!("have {self}"),
@@ -202,9 +196,6 @@ impl Display for IncompatibleDist {
                 IncompatibleWheel::RequiresPython(python, _) => {
                     write!(f, "Python {python}")
                 }
-                IncompatibleWheel::MissingPlatform(platform) => {
-                    write!(f, "no {platform}-compatible wheels")
-                }
             },
             Self::Source(incompatibility) => match incompatibility {
                 IncompatibleSource::NoBuild => f.write_str("no usable wheels"),
@@ -257,8 +248,6 @@ pub enum IncompatibleWheel {
     Yanked(Yanked),
     /// The use of binary wheels is disabled.
     NoBinary,
-    /// The distribution is missing support for the target platform.
-    MissingPlatform(String),
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -618,40 +607,28 @@ impl IncompatibleWheel {
                         timestamp_other < timestamp_self
                     }
                 },
-                Self::MissingPlatform(_)
-                | Self::NoBinary
-                | Self::RequiresPython(_, _)
-                | Self::Tag(_)
-                | Self::Yanked(_) => true,
+                Self::NoBinary | Self::RequiresPython(_, _) | Self::Tag(_) | Self::Yanked(_) => {
+                    true
+                }
             },
             Self::Tag(tag_self) => match other {
                 Self::ExcludeNewer(_) => false,
                 Self::Tag(tag_other) => tag_self > tag_other,
-                Self::MissingPlatform(_)
-                | Self::NoBinary
-                | Self::RequiresPython(_, _)
-                | Self::Yanked(_) => true,
+                Self::NoBinary | Self::RequiresPython(_, _) | Self::Yanked(_) => true,
             },
             Self::RequiresPython(_, _) => match other {
                 Self::ExcludeNewer(_) | Self::Tag(_) => false,
                 // Version specifiers cannot be reasonably compared
                 Self::RequiresPython(_, _) => false,
-                Self::MissingPlatform(_) | Self::NoBinary | Self::Yanked(_) => true,
+                Self::NoBinary | Self::Yanked(_) => true,
             },
             Self::Yanked(_) => match other {
                 Self::ExcludeNewer(_) | Self::Tag(_) | Self::RequiresPython(_, _) => false,
                 // Yanks with a reason are more helpful for errors
                 Self::Yanked(yanked_other) => matches!(yanked_other, Yanked::Reason(_)),
-                Self::MissingPlatform(_) | Self::NoBinary => true,
-            },
-            Self::NoBinary => match other {
-                Self::MissingPlatform(_) => true,
-                _ => false,
-            },
-            Self::MissingPlatform(platform_other) => match other {
-                Self::MissingPlatform(platform_self) => platform_self > platform_other,
-                _ => false,
+                Self::NoBinary => true,
             },
+            Self::NoBinary => false,
         }
     }
 }

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

@@ -228,11 +228,6 @@ impl PubGrubPackage {
         }
     }
 
-    /// Returns `true` if this PubGrub package is the root package.
-    pub(crate) fn is_root(&self) -> bool {
-        matches!(&**self, PubGrubPackageInner::Root(_))
-    }
-
     /// Returns `true` if this PubGrub package is a proxy package.
     pub(crate) fn is_proxy(&self) -> bool {
         matches!(

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

@@ -3,8 +3,7 @@ use std::fmt::{Display, Formatter};
 use uv_distribution_types::IncompatibleDist;
 use uv_pep440::{Version, VersionSpecifiers};
 
-use crate::resolver::MetadataUnavailable;
-use crate::ResolverEnvironment;
+use crate::resolver::{MetadataUnavailable, VersionFork};
 
 /// The reason why a package or a version cannot be used.
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -170,6 +169,6 @@ pub(crate) enum ResolverVersion {
     Unavailable(Version, UnavailableVersion),
     /// A usable version
     Unforked(Version),
-    /// A set of forks.
-    Forked(Vec<ResolverEnvironment>),
+    /// A set of forks, optionally with resolved versions
+    Forked(Vec<VersionFork>),
 }

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

@@ -559,7 +559,7 @@ pub(crate) fn fork_version_by_python_requirement(
 pub(crate) fn fork_version_by_marker(
     env: &ResolverEnvironment,
     marker: MarkerTree,
-) -> Vec<ResolverEnvironment> {
+) -> Option<(ResolverEnvironment, ResolverEnvironment)> {
     let Kind::Universal {
         markers: ref env_marker,
         ..
@@ -584,20 +584,18 @@ pub(crate) fn fork_version_by_marker(
     // `sys_platform == 'win32'`, return an empty list, since the following isn't satisfiable:
     //
     //   python_version >= '3.10' and sys_platform == 'linux' and sys_platform == 'win32'
-
-    let mut envs = vec![];
     if env_marker.is_disjoint(marker) {
-        return vec![];
+        return None;
     }
-    envs.push(env.narrow_environment(marker));
+    let with_marker = env.narrow_environment(marker);
 
     let complement = marker.negate();
     if env_marker.is_disjoint(complement) {
-        return vec![];
+        return None;
     }
-    envs.push(env.narrow_environment(complement));
+    let without_marker = env.narrow_environment(complement);
 
-    envs
+    Some((with_marker, without_marker))
 }
 
 #[cfg(test)]