uv_resolver/

prioritized_distribution.rs

use std::fmt::{Display, Formatter};

use arcstr::ArcStr;
use owo_colors::OwoColorize;
use tracing::debug;

use uv_distribution_filename::{BuildTag, WheelFilename};
use uv_distribution_types::{
    File, IndexUrl, InstalledDist, MinimumLibcVersion, Name, RegistryBuiltDist, RegistryBuiltWheel,
    RegistrySourceDist, RequiresPython, VariantsJsonContent, VariantsJsonFilename,
};
use uv_normalize::PackageName;
use uv_pep440::{Version, VersionSpecifier, VersionSpecifiers};
use uv_pep508::{MarkerExpression, MarkerOperator, MarkerTree, MarkerValueString};
use uv_platform_tags::{
    AbiTag, BinaryFormat, IncompatibleTag, LanguageTag, PlatformTag, TagPriority, Tags,
};
use uv_pypi_types::{HashDigest, Yanked};

use crate::known_platform::KnownPlatform;
use crate::resolved::ResolvedDistRef;

/// A collection of distributions that have been filtered by relevance.
#[derive(Debug, Default, Clone)]
pub struct PrioritizedDist(Box<PrioritizedDistInner>);

/// Variant metadata for a package version on an index.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub(crate) struct RegistryVariantsJson {
    pub(crate) filename: VariantsJsonFilename,
    pub(crate) file: File,
    pub(crate) index: IndexUrl,
}

/// The contents of a [`PrioritizedDist`], boxed to keep the outer type small.
#[derive(Debug, Clone)]
struct PrioritizedDistInner {
    /// The highest-priority source distribution. Between compatible source distributions this priority is arbitrary.
    source: Option<(RegistrySourceDist, SourceDistCompatibility)>,
    /// The highest-priority wheel index. When present, it is
    /// guaranteed to be a valid index into `wheels`.
    best_wheel_index: Option<usize>,
    /// The set of all wheels associated with this distribution.
    wheels: Vec<(RegistryBuiltWheel, WheelCompatibility)>,
    /// Variant metadata files from the indexes contributing files for this version.
    variants_json: Vec<RegistryVariantsJson>,
    /// The hashes for each distribution.
    hashes: Vec<HashDigest>,
    /// Python coverage, unioned over compatible wheels independently of their platforms.
    python_markers: MarkerTree,
    /// Coverage for the glibc and musl baselines, unioned over compatible wheels separately.
    /// Unconfigured baselines use ordinary platform coverage. Intersect only after unioning, so
    /// separate glibc and musl wheels can jointly satisfy both baselines.
    markers: [MarkerTree; 2],
}

impl Default for PrioritizedDistInner {
    fn default() -> Self {
        Self {
            source: None,
            best_wheel_index: None,
            wheels: Vec::new(),
            variants_json: Vec::new(),
            hashes: Vec::new(),
            python_markers: MarkerTree::FALSE,
            markers: [MarkerTree::FALSE; 2],
        }
    }
}

/// A distribution that can be used for both resolution and installation.
#[derive(Debug, Copy, Clone)]
pub(crate) enum CompatibleDist<'a> {
    /// The distribution is already installed and can be used.
    InstalledDist(&'a InstalledDist),
    /// The distribution should be resolved and installed using a source distribution.
    SourceDist {
        /// The source distribution that should be used.
        sdist: &'a RegistrySourceDist,
        /// The prioritized distribution that the sdist came from.
        prioritized: &'a PrioritizedDist,
    },
    /// The distribution should be resolved and installed using a wheel distribution.
    CompatibleWheel {
        /// The wheel that should be used.
        wheel: &'a RegistryBuiltWheel,
        /// The prioritized distribution that the wheel came from.
        prioritized: &'a PrioritizedDist,
    },
    /// The distribution should be resolved using an incompatible wheel distribution, but
    /// installed using a source distribution.
    IncompatibleWheel {
        /// The sdist to be used during installation.
        sdist: &'a RegistrySourceDist,
        /// The wheel to be used during resolution.
        wheel: &'a RegistryBuiltWheel,
        /// The prioritized distribution that the wheel and sdist came from.
        prioritized: &'a PrioritizedDist,
    },
}

impl Name for CompatibleDist<'_> {
    fn name(&self) -> &PackageName {
        match self {
            Self::InstalledDist(dist) => dist.name(),
            Self::SourceDist {
                sdist,
                prioritized: _,
            } => sdist.name(),
            Self::CompatibleWheel {
                wheel,
                prioritized: _,
            } => wheel.name(),
            Self::IncompatibleWheel {
                sdist,
                wheel: _,
                prioritized: _,
            } => sdist.name(),
        }
    }
}

impl<'a> CompatibleDist<'a> {
    /// Return whether a usable source distribution or a wheel matching [`RequiresPython`] exists.
    ///
    /// Wheel compatibility must be checked against the current Python range when a resolver fork
    /// narrows the range used to construct the [`PrioritizedDist`].
    pub(crate) fn matches_python_requirement(&self, requires_python: &RequiresPython) -> bool {
        self.prioritized().is_none_or(|prioritized| {
            !prioritized
                .0
                .python_markers
                .is_disjoint(requires_python.to_marker_tree())
        })
    }

    /// Return the `requires-python` specifier for the distribution, if any.
    pub(crate) fn requires_python(&self) -> Option<&VersionSpecifiers> {
        match self {
            Self::InstalledDist(_) => None,
            Self::SourceDist { sdist, .. } => sdist.file.requires_python.as_deref(),
            Self::CompatibleWheel { wheel, .. } => wheel.file.requires_python.as_deref(),
            Self::IncompatibleWheel { sdist, .. } => sdist.file.requires_python.as_deref(),
        }
    }

    // For installable distributions, return the prioritized distribution it was derived from.
    pub(crate) fn prioritized(&self) -> Option<&'a PrioritizedDist> {
        match self {
            Self::InstalledDist(_) => None,
            Self::SourceDist { prioritized, .. }
            | Self::CompatibleWheel { prioritized, .. }
            | Self::IncompatibleWheel { prioritized, .. } => Some(prioritized),
        }
    }

    /// Return the set of supported platforms for the distribution, in terms of their markers.
    pub(crate) fn implied_markers(&self) -> MarkerTree {
        match self.prioritized() {
            Some(prioritized) => {
                let [glibc, musl] = prioritized.0.markers;
                glibc.and(musl)
            }
            None => MarkerTree::TRUE,
        }
    }
}

#[derive(Debug, PartialEq, Eq, Clone)]
pub enum IncompatibleDist {
    /// An incompatible wheel is available.
    Wheel(IncompatibleWheel),
    /// An incompatible source distribution is available.
    Source(IncompatibleSource),
    /// No distributions are available
    Unavailable,
}

impl IncompatibleDist {
    pub(crate) fn singular_message(&self) -> String {
        match self {
            Self::Wheel(incompatibility) => match incompatibility {
                IncompatibleWheel::NoBinary => format!("has {self}"),
                IncompatibleWheel::Tag(_) => format!("has {self}"),
                IncompatibleWheel::Yanked(_) => format!("was {self}"),
                IncompatibleWheel::ExcludeNewer(ts) => match ts {
                    Some(_) => format!("was {self}"),
                    None => format!("has {self}"),
                },
                IncompatibleWheel::RequiresPython(..) => format!("requires {self}"),
                IncompatibleWheel::MissingPlatform(_) => format!("has {self}"),
            },
            Self::Source(incompatibility) => match incompatibility {
                IncompatibleSource::NoBuild => format!("has {self}"),
                IncompatibleSource::Yanked(_) => format!("was {self}"),
                IncompatibleSource::ExcludeNewer(ts) => match ts {
                    Some(_) => format!("was {self}"),
                    None => format!("has {self}"),
                },
                IncompatibleSource::RequiresPython(..) => {
                    format!("requires {self}")
                }
                IncompatibleSource::NotPep625Filename => format!("has {self}"),
            },
            Self::Unavailable => format!("has {self}"),
        }
    }

    pub(crate) fn plural_message(&self) -> String {
        match self {
            Self::Wheel(incompatibility) => match incompatibility {
                IncompatibleWheel::NoBinary => format!("have {self}"),
                IncompatibleWheel::Tag(_) => format!("have {self}"),
                IncompatibleWheel::Yanked(_) => format!("were {self}"),
                IncompatibleWheel::ExcludeNewer(ts) => match ts {
                    Some(_) => format!("were {self}"),
                    None => format!("have {self}"),
                },
                IncompatibleWheel::RequiresPython(..) => format!("require {self}"),
                IncompatibleWheel::MissingPlatform(_) => format!("have {self}"),
            },
            Self::Source(incompatibility) => match incompatibility {
                IncompatibleSource::NoBuild => format!("have {self}"),
                IncompatibleSource::Yanked(_) => format!("were {self}"),
                IncompatibleSource::ExcludeNewer(ts) => match ts {
                    Some(_) => format!("were {self}"),
                    None => format!("have {self}"),
                },
                IncompatibleSource::RequiresPython(..) => {
                    format!("require {self}")
                }
                IncompatibleSource::NotPep625Filename => format!("have {self}"),
            },
            Self::Unavailable => format!("have {self}"),
        }
    }

    pub(crate) fn context_message(
        &self,
        tags: Option<&Tags>,
        requires_python: Option<AbiTag>,
    ) -> Option<String> {
        match self {
            Self::Wheel(incompatibility) => match incompatibility {
                IncompatibleWheel::Tag(IncompatibleTag::Python) => {
                    let tag = tags?.python_tag().as_ref().map(ToString::to_string)?;
                    Some(format!("(e.g., `{tag}`)", tag = tag.cyan()))
                }
                IncompatibleWheel::Tag(IncompatibleTag::Abi) => {
                    let tag = tags?.abi_tag().as_ref().map(ToString::to_string)?;
                    Some(format!("(e.g., `{tag}`)", tag = tag.cyan()))
                }
                IncompatibleWheel::Tag(IncompatibleTag::FreethreadedAbi) => None,
                IncompatibleWheel::Tag(IncompatibleTag::AbiPythonVersion) => {
                    let tag = requires_python?;
                    Some(format!("(e.g., `{tag}`)", tag = tag.cyan()))
                }
                IncompatibleWheel::Tag(IncompatibleTag::Platform) => {
                    let tag = tags?.platform_tag().map(ToString::to_string)?;
                    Some(format!("(e.g., `{tag}`)", tag = tag.cyan()))
                }
                IncompatibleWheel::Tag(IncompatibleTag::Invalid) => None,
                IncompatibleWheel::Tag(IncompatibleTag::Variant) => None,
                IncompatibleWheel::NoBinary => None,
                IncompatibleWheel::Yanked(..) => None,
                IncompatibleWheel::ExcludeNewer(..) => None,
                IncompatibleWheel::RequiresPython(..) => None,
                IncompatibleWheel::MissingPlatform(..) => None,
            },
            Self::Source(..) => None,
            Self::Unavailable => None,
        }
    }
}

impl Display for IncompatibleDist {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Wheel(incompatibility) => match incompatibility {
                IncompatibleWheel::NoBinary => f.write_str("no source distribution"),
                IncompatibleWheel::Tag(tag) => match tag {
                    IncompatibleTag::Variant => f.write_str("only unsupported wheel variants"),
                    IncompatibleTag::Invalid => f.write_str("no wheels with valid tags"),
                    IncompatibleTag::Python => {
                        f.write_str("no wheels with a matching Python implementation tag")
                    }
                    IncompatibleTag::Abi => f.write_str("no wheels with a matching Python ABI tag"),
                    IncompatibleTag::FreethreadedAbi => {
                        f.write_str("no wheels with a free-threading compatible ABI tag")
                    }
                    IncompatibleTag::AbiPythonVersion => {
                        f.write_str("no wheels with a matching Python version tag")
                    }
                    IncompatibleTag::Platform => {
                        f.write_str("no wheels with a matching platform tag")
                    }
                },
                IncompatibleWheel::Yanked(yanked) => match yanked {
                    Yanked::Bool(_) => f.write_str("yanked"),
                    Yanked::Reason(reason) => write!(
                        f,
                        "yanked (reason: {})",
                        reason.trim().trim_end_matches('.')
                    ),
                },
                IncompatibleWheel::ExcludeNewer(ts) => match ts {
                    Some(_) => f.write_str("published after the exclude newer time"),
                    None => f.write_str("no publish time"),
                },
                IncompatibleWheel::RequiresPython(python, _) => {
                    write!(f, "Python {python}")
                }
                IncompatibleWheel::MissingPlatform(marker) => {
                    if let Some(platform) = KnownPlatform::from_marker(*marker) {
                        write!(f, "no {platform}-compatible wheels")
                    } else if let Some(marker) = marker.try_to_string() {
                        write!(f, "no `{marker}`-compatible wheels")
                    } else {
                        write!(f, "no compatible wheels")
                    }
                }
            },
            Self::Source(incompatibility) => match incompatibility {
                IncompatibleSource::NoBuild => f.write_str("no usable wheels"),
                IncompatibleSource::Yanked(yanked) => match yanked {
                    Yanked::Bool(_) => f.write_str("yanked"),
                    Yanked::Reason(reason) => write!(
                        f,
                        "yanked (reason: {})",
                        reason.trim().trim_end_matches('.')
                    ),
                },
                IncompatibleSource::ExcludeNewer(ts) => match ts {
                    Some(_) => f.write_str("published after the exclude newer time"),
                    None => f.write_str("no publish time"),
                },
                IncompatibleSource::RequiresPython(python, _) => {
                    write!(f, "Python {python}")
                }
                IncompatibleSource::NotPep625Filename => {
                    f.write_str("a non-PEP 625-compliant source distribution filename")
                }
            },
            Self::Unavailable => f.write_str("no available distributions"),
        }
    }
}

#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub enum PythonRequirementKind {
    /// The installed version of Python.
    Installed,
    /// The target version of Python; that is, the version of Python for which we are resolving
    /// dependencies. This is typically the same as the installed version, but may be different
    /// when specifying an alternate Python version for the resolution.
    Target,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum WheelCompatibility {
    Incompatible(IncompatibleWheel),
    /// The wheel matches the platform tags, but its variant properties have not been checked.
    Variant(HashComparison, Option<TagPriority>, Option<BuildTag>),
    Compatible(HashComparison, Option<TagPriority>, Option<BuildTag>),
}

#[derive(Debug, PartialEq, Eq, Clone)]
pub enum IncompatibleWheel {
    /// The wheel was published after the exclude newer time.
    ExcludeNewer(Option<i64>),
    /// The wheel tags do not match those of the target Python platform.
    Tag(IncompatibleTag),
    /// The required Python version is not a superset of the target Python version range.
    RequiresPython(VersionSpecifiers, PythonRequirementKind),
    /// The wheel was yanked.
    Yanked(Yanked),
    /// The use of binary wheels is disabled.
    NoBinary,
    /// Wheels are not available for the current platform.
    MissingPlatform(MarkerTree),
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SourceDistCompatibility {
    Incompatible(IncompatibleSource),
    Compatible(HashComparison),
}

#[derive(Debug, PartialEq, Eq, Clone)]
pub enum IncompatibleSource {
    ExcludeNewer(Option<i64>),
    RequiresPython(VersionSpecifiers, PythonRequirementKind),
    Yanked(Yanked),
    NoBuild,
    /// The source distribution's filename does not confirm to PEP 625.
    NotPep625Filename,
}

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub enum HashComparison {
    /// The hash is present, but does not match the expected value.
    Mismatched,
    /// The hash is missing.
    Missing,
    /// The hash matches the expected value.
    Matched,
}

impl PrioritizedDist {
    pub(crate) fn insert_variants_json(&mut self, variants_json: RegistryVariantsJson) {
        // A flat index can list the same metadata link more than once.
        if !self.0.variants_json.contains(&variants_json) {
            self.0.variants_json.push(variants_json);
        }
    }

    pub(crate) fn variants_json(&self) -> &[RegistryVariantsJson] {
        &self.0.variants_json
    }

    /// Return the `variants.json` files we need to check the candidate wheels.
    ///
    /// Match on the index as well as the release: a flat index can include wheels from
    /// several sources, and each source describes only its own variants.
    pub(crate) fn variants_json_for_selection(
        &self,
    ) -> impl Iterator<Item = &RegistryVariantsJson> {
        self.0.variants_json.iter().filter(|metadata| {
            self.0.wheels.iter().any(|(wheel, compatibility)| {
                wheel.index == metadata.index
                    && matches!(compatibility, WheelCompatibility::Variant(..))
            })
        })
    }

    /// Choose the best compatible variant, or return `None` to use the ordinary wheel or sdist.
    pub(crate) fn prioritize_variants(
        &self,
        metadata: &[(&IndexUrl, &VariantsJsonContent)],
    ) -> Option<Self> {
        if metadata.is_empty() {
            return None;
        }
        // TODO(konsti): Run provider plugins to determine supported properties.
        let metadata: Vec<_> = metadata
            .iter()
            .map(|(source, metadata)| (*source, *metadata, metadata.static_supported_properties()))
            .collect();
        // Prefer wheels whose advertised hash matches a required hash, followed by wheels with
        // no advertised hash, then mismatches. If no hashes are required, all wheels match.
        // The installer verifies required hashes against the downloaded wheel.
        // Break ties by variant rank, platform tags, then build tag.
        let (best_index, (hash, _, priority, build_tag)) = self
            .0
            .wheels
            .iter()
            .enumerate()
            .filter_map(|(index, (wheel, compatibility))| {
                let WheelCompatibility::Variant(hash, priority, build_tag) = compatibility else {
                    return None;
                };
                let label = wheel.filename.variant()?;
                let score = metadata
                    .iter()
                    .filter(|(source, _, _)| *source == &wheel.index)
                    .filter_map(|(_, metadata, supported_properties)| {
                        metadata.score_variant(label, supported_properties)
                    })
                    .max()?;
                Some((index, (*hash, score, *priority, build_tag)))
            })
            .max_by(|(_, left), (_, right)| left.cmp(right))?;

        // Keep the ordinary wheel if its advertised hash ranks higher.
        if let Some((_, WheelCompatibility::Compatible(existing_hash, ..))) = self.best_wheel()
            && *existing_hash > hash
        {
            return None;
        }

        let mut prioritized = self.clone();
        prioritized.0.wheels[best_index].1 =
            WheelCompatibility::Compatible(hash, priority, build_tag.clone());
        prioritized.0.best_wheel_index = Some(best_index);
        Some(prioritized)
    }

    /// Insert the given built distribution into the [`PrioritizedDist`].
    pub(crate) fn insert_built(
        &mut self,
        dist: RegistryBuiltWheel,
        hashes: impl IntoIterator<Item = HashDigest>,
        compatibility: WheelCompatibility,
        minimum_libc_version: Option<MinimumLibcVersion>,
    ) {
        if compatibility.is_compatible()
            && (!self.0.python_markers.is_true()
                || !self.0.markers.iter().all(|markers| markers.is_true()))
        {
            let python = implied_python_markers(&dist.filename);
            self.0.python_markers = self.0.python_markers.or(python);
            for (coverage, markers) in self.0.markers.iter_mut().zip(implied_libc_markers(
                &dist.filename,
                python,
                minimum_libc_version,
            )) {
                *coverage = coverage.or(markers);
            }
        }
        // Track the hashes.
        if !compatibility.is_excluded() {
            self.0.hashes.extend(hashes);
        }
        // Before checking variant properties, prefer ordinary wheels as metadata sources even
        // when they cannot be installed (e.g., with `--no-binary`).
        if let Some((existing_wheel, existing_compatibility)) = self.best_wheel() {
            let is_more_compatible =
                match (dist.filename.variant(), existing_wheel.filename.variant()) {
                    (None, Some(_)) => true,
                    (Some(_), None) => false,
                    (None, None) | (Some(_), Some(_)) => {
                        compatibility.is_more_compatible(existing_compatibility)
                    }
                };
            if is_more_compatible {
                self.0.best_wheel_index = Some(self.0.wheels.len());
            }
        } else {
            self.0.best_wheel_index = Some(self.0.wheels.len());
        }
        self.0.wheels.push((dist, compatibility));
    }

    /// Insert the given source distribution into the [`PrioritizedDist`].
    pub fn insert_source(
        &mut self,
        dist: RegistrySourceDist,
        hashes: impl IntoIterator<Item = HashDigest>,
        compatibility: SourceDistCompatibility,
    ) {
        // A usable source distribution provides coverage for all environments.
        if compatibility.is_compatible() {
            self.0.python_markers = MarkerTree::TRUE;
            self.0.markers = [MarkerTree::TRUE; 2];
        }
        // Track the hashes.
        if !compatibility.is_excluded() {
            self.0.hashes.extend(hashes);
        }
        // Track the highest-priority source.
        if let Some((.., existing_compatibility)) = &self.0.source {
            if compatibility.is_more_compatible(existing_compatibility) {
                self.0.source = Some((dist, compatibility));
            }
        } else {
            self.0.source = Some((dist, compatibility));
        }
    }

    /// Return the highest-priority distribution for the package version, if any.
    pub(crate) fn get(&self) -> Option<CompatibleDist<'_>> {
        let best_wheel = self.0.best_wheel_index.map(|i| &self.0.wheels[i]);
        match (&best_wheel, &self.0.source) {
            // If both are compatible, break ties based on the hash outcome. For example, prefer a
            // source distribution with a matching hash over a wheel with a mismatched hash. When
            // the outcomes are equivalent (e.g., both have a matching hash), prefer the wheel.
            (
                Some((wheel, WheelCompatibility::Compatible(wheel_hash, ..))),
                Some((sdist, SourceDistCompatibility::Compatible(sdist_hash))),
            ) => {
                if sdist_hash > wheel_hash {
                    Some(CompatibleDist::SourceDist {
                        sdist,
                        prioritized: self,
                    })
                } else {
                    Some(CompatibleDist::CompatibleWheel {
                        wheel,
                        prioritized: self,
                    })
                }
            }
            // Prefer the highest-priority, platform-compatible wheel.
            (Some((wheel, WheelCompatibility::Compatible(..))), _) => {
                Some(CompatibleDist::CompatibleWheel {
                    wheel,
                    prioritized: self,
                })
            }
            // If we have a compatible source distribution and an incompatible wheel, return the
            // wheel. We assume that all distributions have the same metadata for a given package
            // version. If a compatible source distribution exists, we assume we can build it, but
            // using the wheel is faster.
            //
            // (If the incompatible wheel should actually be ignored entirely, fall through to
            // using the source distribution. Variant wheels need their properties checked before
            // they can provide metadata.)
            (
                Some((wheel, compatibility @ WheelCompatibility::Incompatible(_))),
                Some((sdist, SourceDistCompatibility::Compatible(_))),
            ) if !compatibility.is_excluded() && wheel.filename.variant().is_none() => {
                Some(CompatibleDist::IncompatibleWheel {
                    sdist,
                    wheel,
                    prioritized: self,
                })
            }
            // Otherwise, if we have a source distribution, return it.
            (.., Some((sdist, SourceDistCompatibility::Compatible(_)))) => {
                Some(CompatibleDist::SourceDist {
                    sdist,
                    prioritized: self,
                })
            }
            _ => None,
        }
    }

    /// Return the incompatibility for the best source distribution, if any.
    pub(crate) fn incompatible_source(&self) -> Option<&IncompatibleSource> {
        self.0
            .source
            .as_ref()
            .and_then(|(_, compatibility)| match compatibility {
                SourceDistCompatibility::Compatible(_) => None,
                SourceDistCompatibility::Incompatible(incompatibility) => Some(incompatibility),
            })
    }

    /// Return the incompatibility for the best wheel, if any.
    pub(crate) fn incompatible_wheel(&self) -> Option<&IncompatibleWheel> {
        self.0
            .best_wheel_index
            .map(|i| &self.0.wheels[i])
            .and_then(|(_, compatibility)| match compatibility {
                WheelCompatibility::Compatible(_, _, _) => None,
                WheelCompatibility::Incompatible(incompatibility) => Some(incompatibility),
                WheelCompatibility::Variant(..) => {
                    Some(&IncompatibleWheel::Tag(IncompatibleTag::Variant))
                }
            })
    }

    /// Return the hashes for each distribution.
    pub(crate) fn hashes(&self) -> &[HashDigest] {
        &self.0.hashes
    }

    /// Returns true if and only if this distribution does not contain any
    /// source distributions or wheels.
    pub(crate) fn is_empty(&self) -> bool {
        self.0.source.is_none() && self.0.wheels.is_empty()
    }

    /// If this prioritized dist has at least one wheel, then this creates
    /// a built distribution with the best wheel in this prioritized dist.
    pub(crate) fn built_dist(&self) -> Option<RegistryBuiltDist> {
        let best_wheel_index = self.0.best_wheel_index?;

        // Remove any excluded wheels from the list of wheels, and adjust the wheel index to be
        // relative to the filtered list.
        let mut adjusted_wheels = Vec::with_capacity(self.0.wheels.len());
        let mut adjusted_best_index = 0;
        for (i, (wheel, compatibility)) in self.0.wheels.iter().enumerate() {
            if compatibility.is_excluded() {
                continue;
            }
            if i == best_wheel_index {
                adjusted_best_index = adjusted_wheels.len();
            }
            adjusted_wheels.push(wheel.clone());
        }

        let sdist = self
            .0
            .source
            .as_ref()
            .filter(|(_, compatibility)| !compatibility.is_excluded())
            .map(|(sdist, _)| sdist.clone());
        Some(RegistryBuiltDist {
            wheels: adjusted_wheels,
            best_wheel_index: adjusted_best_index,
            sdist,
        })
    }

    /// If this prioritized dist has an sdist, then this creates a source
    /// distribution.
    pub(crate) fn source_dist(&self) -> Option<RegistrySourceDist> {
        let mut sdist = self
            .0
            .source
            .as_ref()
            .filter(|(_, compatibility)| !compatibility.is_excluded())
            .map(|(sdist, _)| sdist.clone())?;
        assert!(
            sdist.wheels.is_empty(),
            "source distribution should not have any wheels yet"
        );
        sdist.wheels = self
            .0
            .wheels
            .iter()
            .filter(|(_, compatibility)| !compatibility.is_excluded())
            .map(|(wheel, _)| wheel.clone())
            .collect();
        Some(sdist)
    }

    /// Returns the "best" wheel in this prioritized distribution, if one
    /// exists.
    pub(crate) fn best_wheel(&self) -> Option<&(RegistryBuiltWheel, WheelCompatibility)> {
        self.0.best_wheel_index.map(|i| &self.0.wheels[i])
    }

    /// Returns an iterator of all wheels and the source distribution, if any.
    pub(crate) fn files(&self) -> impl Iterator<Item = &File> {
        self.0
            .wheels
            .iter()
            .map(|(wheel, _)| wheel.file.as_ref())
            .chain(
                self.0
                    .source
                    .as_ref()
                    .map(|(source_dist, _)| source_dist.file.as_ref()),
            )
    }

    /// Returns an iterator over all Python tags for the distribution.
    pub(crate) fn python_tags(&self) -> impl Iterator<Item = LanguageTag> + '_ {
        self.0
            .wheels
            .iter()
            .flat_map(|(wheel, _)| wheel.filename.python_tags().iter().copied())
    }

    /// Returns an iterator over all ABI tags for the distribution.
    pub(crate) fn abi_tags(&self) -> impl Iterator<Item = AbiTag> + '_ {
        self.0
            .wheels
            .iter()
            .flat_map(|(wheel, _)| wheel.filename.abi_tags().iter().copied())
    }

    /// Returns the set of platform tags for the distribution that are ABI-compatible with the given
    /// tags.
    pub(crate) fn platform_tags<'a>(
        &'a self,
        tags: &'a Tags,
    ) -> impl Iterator<Item = &'a PlatformTag> + 'a {
        self.0.wheels.iter().flat_map(move |(wheel, _)| {
            if wheel.filename.python_tags().iter().any(|wheel_py| {
                wheel
                    .filename
                    .abi_tags()
                    .iter()
                    .any(|wheel_abi| tags.is_compatible_abi(*wheel_py, *wheel_abi))
            }) {
                wheel.filename.platform_tags().iter()
            } else {
                [].iter()
            }
        })
    }
}

impl<'a> CompatibleDist<'a> {
    /// Return the [`ResolvedDistRef`] to use during resolution.
    pub(crate) fn for_resolution(&self) -> ResolvedDistRef<'a> {
        match self {
            Self::InstalledDist(dist) => ResolvedDistRef::Installed { dist },
            Self::SourceDist { sdist, prioritized } => {
                ResolvedDistRef::InstallableRegistrySourceDist { sdist, prioritized }
            }
            Self::CompatibleWheel {
                wheel, prioritized, ..
            } => ResolvedDistRef::InstallableRegistryBuiltDist { wheel, prioritized },
            Self::IncompatibleWheel {
                wheel, prioritized, ..
            } => ResolvedDistRef::InstallableRegistryBuiltDist { wheel, prioritized },
        }
    }

    /// Return the [`ResolvedDistRef`] to use during installation.
    pub(crate) fn for_installation(&self) -> ResolvedDistRef<'a> {
        match self {
            Self::InstalledDist(dist) => ResolvedDistRef::Installed { dist },
            Self::SourceDist { sdist, prioritized } => {
                ResolvedDistRef::InstallableRegistrySourceDist { sdist, prioritized }
            }
            Self::CompatibleWheel {
                wheel, prioritized, ..
            } => ResolvedDistRef::InstallableRegistryBuiltDist { wheel, prioritized },
            Self::IncompatibleWheel {
                sdist, prioritized, ..
            } => ResolvedDistRef::InstallableRegistrySourceDist { sdist, prioritized },
        }
    }

    /// Returns a [`RegistryBuiltWheel`] if the distribution includes a compatible or incompatible
    /// wheel.
    pub(crate) fn wheel(&self) -> Option<&RegistryBuiltWheel> {
        match self {
            Self::InstalledDist(_) => None,
            Self::SourceDist { .. } => None,
            Self::CompatibleWheel { wheel, .. } => Some(wheel),
            Self::IncompatibleWheel { wheel, .. } => Some(wheel),
        }
    }
}

impl WheelCompatibility {
    /// Record platform compatibility, deferring the property check for a variant wheel.
    pub(crate) fn from_tag_priority(
        filename: &WheelFilename,
        hash: HashComparison,
        priority: Option<TagPriority>,
    ) -> Self {
        let build_tag = filename.build_tag().cloned();
        if filename.variant().is_some() {
            Self::Variant(hash, priority, build_tag)
        } else {
            Self::Compatible(hash, priority, build_tag)
        }
    }

    /// Return `true` if the distribution is compatible.
    fn is_compatible(&self) -> bool {
        matches!(self, Self::Compatible(_, _, _))
    }

    /// Return `true` if the distribution is excluded.
    fn is_excluded(&self) -> bool {
        matches!(self, Self::Incompatible(IncompatibleWheel::ExcludeNewer(_)))
    }

    /// Return `true` if the current compatibility is more compatible than another.
    ///
    /// Compatible wheels are always higher more compatible than incompatible wheels.
    /// Compatible wheel ordering is determined by tag priority.
    fn is_more_compatible(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::Compatible(_, _, _), Self::Incompatible(_) | Self::Variant(..)) => true,
            (
                Self::Compatible(hash, tag_priority, build_tag),
                Self::Compatible(other_hash, other_tag_priority, other_build_tag),
            ) => {
                (hash, tag_priority, build_tag) > (other_hash, other_tag_priority, other_build_tag)
            }
            (Self::Incompatible(_) | Self::Variant(..), Self::Compatible(_, _, _)) => false,
            (Self::Incompatible(incompatibility), Self::Incompatible(other_incompatibility)) => {
                incompatibility.is_more_compatible(other_incompatibility)
            }
            (Self::Variant(..), Self::Incompatible(other)) => {
                IncompatibleWheel::Tag(IncompatibleTag::Variant).is_more_compatible(other)
            }
            (Self::Incompatible(incompatibility), Self::Variant(..)) => incompatibility
                .is_more_compatible(&IncompatibleWheel::Tag(IncompatibleTag::Variant)),
            (Self::Variant(..), Self::Variant(..)) => false,
        }
    }
}

impl SourceDistCompatibility {
    /// Return `true` if the distribution is compatible.
    fn is_compatible(&self) -> bool {
        matches!(self, Self::Compatible(_))
    }

    /// Return `true` if the distribution is excluded.
    fn is_excluded(&self) -> bool {
        matches!(
            self,
            Self::Incompatible(IncompatibleSource::ExcludeNewer(_))
        )
    }

    /// Return the higher priority compatibility.
    ///
    /// Compatible source distributions are always higher priority than incompatible source distributions.
    /// Compatible source distribution priority is arbitrary.
    /// Incompatible source distribution priority selects a source distribution that was "closest" to being usable.
    fn is_more_compatible(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::Compatible(_), Self::Incompatible(_)) => true,
            (Self::Compatible(compatibility), Self::Compatible(other_compatibility)) => {
                compatibility > other_compatibility
            }
            (Self::Incompatible(_), Self::Compatible(_)) => false,
            (Self::Incompatible(incompatibility), Self::Incompatible(other_incompatibility)) => {
                incompatibility.is_more_compatible(other_incompatibility)
            }
        }
    }
}

impl IncompatibleSource {
    fn is_more_compatible(&self, other: &Self) -> bool {
        match self {
            Self::ExcludeNewer(timestamp_self) => match other {
                // Smaller timestamps are closer to the cut-off time
                Self::ExcludeNewer(timestamp_other) => timestamp_other < timestamp_self,
                Self::NoBuild
                | Self::RequiresPython(_, _)
                | Self::Yanked(_)
                | Self::NotPep625Filename => true,
            },
            Self::RequiresPython(_, _) => match other {
                Self::ExcludeNewer(_) => false,
                // Version specifiers cannot be reasonably compared
                Self::RequiresPython(_, _) => false,
                Self::NoBuild | Self::Yanked(_) | Self::NotPep625Filename => true,
            },
            Self::Yanked(_) => match other {
                Self::ExcludeNewer(_) | Self::RequiresPython(_, _) | Self::NotPep625Filename => {
                    false
                }
                // Yanks with a reason are more helpful for errors
                Self::Yanked(yanked_other) => matches!(yanked_other, Yanked::Reason(_)),
                Self::NoBuild => true,
            },
            Self::NoBuild | Self::NotPep625Filename => false,
        }
    }
}

impl IncompatibleWheel {
    fn is_more_compatible(&self, other: &Self) -> bool {
        match self {
            Self::ExcludeNewer(timestamp_self) => match other {
                // Smaller timestamps are closer to the cut-off time
                Self::ExcludeNewer(timestamp_other) => match (timestamp_self, timestamp_other) {
                    (None, _) => true,
                    (_, None) => false,
                    (Some(timestamp_self), Some(timestamp_other)) => {
                        timestamp_other < timestamp_self
                    }
                },
                Self::MissingPlatform(_)
                | 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::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::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::ExcludeNewer(_)
                | Self::Tag(_)
                | Self::RequiresPython(_, _)
                | Self::Yanked(_) => false,
                Self::NoBinary => false,
                Self::MissingPlatform(_) => true,
            },
            Self::MissingPlatform(_) => false,
        }
    }
}

/// Given a wheel filename, determine the markers covered by every configured libc baseline.
///
/// A wheel with multiple platform tags can remain eligible without covering every tagged platform.
pub(crate) fn implied_markers(
    filename: &WheelFilename,
    minimum_libc_version: Option<MinimumLibcVersion>,
) -> MarkerTree {
    let python = implied_python_markers(filename);
    let [glibc, musl] = implied_libc_markers(filename, python, minimum_libc_version);
    glibc.and(musl)
}

/// Infer coverage for each libc independently so separate wheels can satisfy each baseline.
fn implied_libc_markers(
    filename: &WheelFilename,
    python: MarkerTree,
    minimum_libc_version: Option<MinimumLibcVersion>,
) -> [MarkerTree; 2] {
    let Some(minimum_libc_version) = minimum_libc_version else {
        return [implied_platform_markers(filename.platform_tags()).and(python); 2];
    };
    let mut markers = [MarkerTree::FALSE; 2];
    for tag in filename.platform_tags() {
        let platform = implied_platform_markers([tag]).and(python);
        for (markers, supported) in markers
            .iter_mut()
            .zip(minimum_libc_version.platform_coverage(tag))
        {
            if supported {
                *markers = markers.or(platform);
            }
        }
    }
    markers
}

/// Infer the environments described by a set of platform tags.
fn implied_platform_markers<'a>(
    platform_tags: impl IntoIterator<Item = &'a PlatformTag>,
) -> MarkerTree {
    let mut marker = MarkerTree::FALSE;
    for platform_tag in platform_tags {
        match platform_tag {
            PlatformTag::Any => {
                return MarkerTree::TRUE;
            }

            // Windows
            PlatformTag::Win32 => {
                let mut tag_marker = MarkerTree::expression(MarkerExpression::String {
                    key: MarkerValueString::SysPlatform,
                    operator: MarkerOperator::Equal,
                    value: arcstr::literal!("win32"),
                });
                tag_marker = tag_marker.and(MarkerTree::expression(MarkerExpression::String {
                    key: MarkerValueString::PlatformMachine,
                    operator: MarkerOperator::Equal,
                    value: arcstr::literal!("x86"),
                }));
                marker = marker.or(tag_marker);
            }
            PlatformTag::WinAmd64 => {
                let mut tag_marker = MarkerTree::expression(MarkerExpression::String {
                    key: MarkerValueString::SysPlatform,
                    operator: MarkerOperator::Equal,
                    value: arcstr::literal!("win32"),
                });
                tag_marker = tag_marker.and(MarkerTree::expression(MarkerExpression::String {
                    key: MarkerValueString::PlatformMachine,
                    operator: MarkerOperator::Equal,
                    value: arcstr::literal!("AMD64"),
                }));
                marker = marker.or(tag_marker);
            }
            PlatformTag::WinArm64 => {
                let mut tag_marker = MarkerTree::expression(MarkerExpression::String {
                    key: MarkerValueString::SysPlatform,
                    operator: MarkerOperator::Equal,
                    value: arcstr::literal!("win32"),
                });
                tag_marker = tag_marker.and(MarkerTree::expression(MarkerExpression::String {
                    key: MarkerValueString::PlatformMachine,
                    operator: MarkerOperator::Equal,
                    value: arcstr::literal!("ARM64"),
                }));
                marker = marker.or(tag_marker);
            }

            // macOS
            PlatformTag::Macos {
                major,
                minor,
                binary_format,
            } => {
                let Some(release) = macos_darwin_release(*major, *minor) else {
                    continue;
                };
                let mut tag_marker = MarkerTree::expression(MarkerExpression::String {
                    key: MarkerValueString::SysPlatform,
                    operator: MarkerOperator::Equal,
                    value: arcstr::literal!("darwin"),
                });

                // Extract the architecture from the end of the tag.
                let mut arch_marker = MarkerTree::FALSE;
                for arch in binary_format.platform_machine() {
                    // A universal2 wheel can target an older macOS on Intel, but its ARM
                    // slice requires macOS 11 (Darwin 20) or later.
                    let release = if *arch == BinaryFormat::Arm64 {
                        release.clone().max(Version::new([20, 0, 0]))
                    } else {
                        release.clone()
                    };
                    let architecture = MarkerTree::expression(MarkerExpression::String {
                        key: MarkerValueString::PlatformMachine,
                        operator: MarkerOperator::Equal,
                        value: ArcStr::from(arch.name()),
                    });
                    let release = MarkerTree::expression(MarkerExpression::String {
                        key: MarkerValueString::PlatformRelease,
                        operator: MarkerOperator::GreaterEqual,
                        value: ArcStr::from(release.to_string()),
                    });
                    arch_marker = arch_marker.or(architecture.and(release));
                }
                tag_marker = tag_marker.and(arch_marker);

                marker = marker.or(tag_marker);
            }

            // Linux
            PlatformTag::Manylinux { arch, .. }
            | PlatformTag::Manylinux1 { arch, .. }
            | PlatformTag::Manylinux2010 { arch, .. }
            | PlatformTag::Manylinux2014 { arch, .. }
            | PlatformTag::Musllinux { arch, .. }
            | PlatformTag::Linux { arch } => {
                let mut tag_marker = MarkerTree::expression(MarkerExpression::String {
                    key: MarkerValueString::SysPlatform,
                    operator: MarkerOperator::Equal,
                    value: arcstr::literal!("linux"),
                });
                tag_marker = tag_marker.and(MarkerTree::expression(MarkerExpression::String {
                    key: MarkerValueString::PlatformMachine,
                    operator: MarkerOperator::Equal,
                    value: ArcStr::from(arch.name()),
                }));
                marker = marker.or(tag_marker);
            }

            // Android
            //
            // The tag's API level is not encoded, since no marker exposes it: `platform_release`
            // reports the Android version.
            PlatformTag::Android { abi, .. } => {
                let mut tag_marker = MarkerTree::expression(MarkerExpression::String {
                    key: MarkerValueString::SysPlatform,
                    operator: MarkerOperator::Equal,
                    value: arcstr::literal!("android"),
                });
                tag_marker = tag_marker.and(MarkerTree::expression(MarkerExpression::String {
                    key: MarkerValueString::PlatformMachine,
                    operator: MarkerOperator::Equal,
                    value: ArcStr::from(abi.arch().name()),
                }));
                marker = marker.or(tag_marker);
            }

            tag => {
                debug!("Unknown platform tag in wheel tag: {tag}");
            }
        }
    }

    marker
}

/// Translate a macOS deployment target into the corresponding
/// [Darwin kernel release](<https://en.wikipedia.org/wiki/Darwin_(operating_system)#Darwin_20_onwards>).
///
/// macOS 10.16 is the compatibility spelling of macOS 11. macOS 26 uses Darwin 25;
/// starting with macOS 27, the major versions match.
fn macos_darwin_release(major: u16, minor: u16) -> Option<Version> {
    let release = match (major, minor) {
        (10, 0) => [1, 3, 0],
        (10, 1) => [1, 4, 1],
        (10, 2..=16) => [u64::from(minor) + 4, 0, 0],
        (11..=15, 0) => [u64::from(major) + 9, 0, 0],
        (26, 0) => [25, 0, 0],
        (27.., 0) => [u64::from(major), 0, 0],
        _ => return None,
    };
    Some(Version::new(release))
}

/// Given a wheel filename, determine the set of supported Python versions, in terms of their markers.
///
/// This is roughly the inverse of Python tag generation: given a tag, we want to infer the
/// supported Python version (rather than generating the supported tags from a given Python version).
fn implied_python_markers(filename: &WheelFilename) -> MarkerTree {
    let mut marker = MarkerTree::FALSE;

    // If any ABI tag is a stable ABI (`abi3` or `abi3t`), the python tag represents a minimum
    // version rather than an exact version. For example, `cp39-abi3` means "compatible with
    // CPython 3.9+".
    let is_abi3 = filename.abi_tags().iter().any(|tag| tag.is_stable_abi());

    for python_tag in filename.python_tags() {
        // First, construct the version marker based on the tag
        let mut tree = match python_tag {
            LanguageTag::None => {
                // No Python tag means no Python version requirement.
                return MarkerTree::TRUE;
            }
            LanguageTag::Python { major, minor: None } | LanguageTag::CPythonMajor { major } => {
                if is_abi3 {
                    MarkerTree::expression(MarkerExpression::Version {
                        key: uv_pep508::MarkerValueVersion::PythonVersion,
                        specifier: VersionSpecifier::greater_than_equal_version(Version::new([
                            u64::from(*major),
                        ])),
                    })
                } else {
                    MarkerTree::expression(MarkerExpression::Version {
                        key: uv_pep508::MarkerValueVersion::PythonVersion,
                        specifier: VersionSpecifier::equals_star_version(Version::new([
                            u64::from(*major),
                        ])),
                    })
                }
            }
            LanguageTag::Python {
                major,
                minor: Some(minor),
            } => {
                // Generic Python tags support later minor versions within the same major version.
                MarkerTree::expression(MarkerExpression::Version {
                    key: uv_pep508::MarkerValueVersion::PythonVersion,
                    specifier: VersionSpecifier::greater_than_equal_version(Version::new([
                        u64::from(*major),
                        u64::from(*minor),
                    ])),
                })
                .and(MarkerTree::expression(MarkerExpression::Version {
                    key: uv_pep508::MarkerValueVersion::PythonVersion,
                    specifier: VersionSpecifier::equals_star_version(Version::new([u64::from(
                        *major,
                    )])),
                }))
            }
            LanguageTag::CPython {
                python_version: (major, minor),
            }
            | LanguageTag::PyPy {
                python_version: (major, minor),
            }
            | LanguageTag::GraalPy {
                python_version: (major, minor),
            }
            | LanguageTag::Pyston {
                python_version: (major, minor),
            } => {
                if is_abi3 {
                    MarkerTree::expression(MarkerExpression::Version {
                        key: uv_pep508::MarkerValueVersion::PythonVersion,
                        specifier: VersionSpecifier::greater_than_equal_version(Version::new([
                            u64::from(*major),
                            u64::from(*minor),
                        ])),
                    })
                } else {
                    MarkerTree::expression(MarkerExpression::Version {
                        key: uv_pep508::MarkerValueVersion::PythonVersion,
                        specifier: VersionSpecifier::equals_star_version(Version::new([
                            u64::from(*major),
                            u64::from(*minor),
                        ])),
                    })
                }
            }
        };

        // Then, add implementation markers for implementation-specific tags
        match python_tag {
            LanguageTag::None | LanguageTag::Python { .. } => {
                // No implementation marker needed
            }
            LanguageTag::CPython { .. } | LanguageTag::CPythonMajor { .. } => {
                tree = tree.and(MarkerTree::expression(MarkerExpression::String {
                    key: MarkerValueString::PlatformPythonImplementation,
                    operator: MarkerOperator::Equal,
                    value: arcstr::literal!("CPython"),
                }));
            }
            LanguageTag::PyPy { .. } => {
                tree = tree.and(MarkerTree::expression(MarkerExpression::String {
                    key: MarkerValueString::PlatformPythonImplementation,
                    operator: MarkerOperator::Equal,
                    value: arcstr::literal!("PyPy"),
                }));
            }
            LanguageTag::GraalPy { .. } => {
                tree = tree.and(MarkerTree::expression(MarkerExpression::String {
                    key: MarkerValueString::PlatformPythonImplementation,
                    operator: MarkerOperator::Equal,
                    value: arcstr::literal!("GraalPy"),
                }));
            }
            LanguageTag::Pyston { .. } => {
                tree = tree.and(MarkerTree::expression(MarkerExpression::String {
                    key: MarkerValueString::PlatformPythonImplementation,
                    operator: MarkerOperator::Equal,
                    value: arcstr::literal!("Pyston"),
                }));
            }
        }

        marker = marker.or(tree);
    }

    marker
}

#[cfg(test)]
mod tests {
    use std::str::FromStr;

    use super::*;

    #[track_caller]
    fn assert_platform_markers(filename: &str, expected: &str) {
        let filename = WheelFilename::from_str(filename).unwrap();
        assert_eq!(
            implied_platform_markers(filename.platform_tags()),
            expected.parse::<MarkerTree>().unwrap()
        );
    }

    #[track_caller]
    fn assert_python_markers(filename: &str, expected: &str) {
        let filename = WheelFilename::from_str(filename).unwrap();
        assert_eq!(
            implied_python_markers(&filename),
            expected.parse::<MarkerTree>().unwrap()
        );
    }

    #[track_caller]
    fn assert_implied_markers(filename: &str, expected: &str) {
        let filename = WheelFilename::from_str(filename).unwrap();
        assert_eq!(
            implied_markers(&filename, None),
            expected.parse::<MarkerTree>().unwrap()
        );
    }

    #[test]
    fn test_implied_platform_markers() {
        let filename = WheelFilename::from_str("example-1.0-py3-none-any.whl").unwrap();
        assert_eq!(
            implied_platform_markers(filename.platform_tags()),
            MarkerTree::TRUE
        );

        assert_platform_markers(
            "example-1.0-cp310-cp310-win32.whl",
            "sys_platform == 'win32' and platform_machine == 'x86'",
        );
        assert_platform_markers(
            "numpy-2.2.1-cp313-cp313t-win_amd64.whl",
            "sys_platform == 'win32' and platform_machine == 'AMD64'",
        );
        assert_platform_markers(
            "numpy-2.2.1-cp313-cp313t-win_arm64.whl",
            "sys_platform == 'win32' and platform_machine == 'ARM64'",
        );
        assert_platform_markers(
            "numpy-2.2.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl",
            "sys_platform == 'linux' and platform_machine == 'aarch64'",
        );
        assert_platform_markers(
            "numpy-2.2.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
            "sys_platform == 'linux' and platform_machine == 'x86_64'",
        );
        assert_platform_markers(
            "numpy-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl",
            "sys_platform == 'linux' and platform_machine == 'aarch64'",
        );
        assert_platform_markers(
            "numpy-2.2.1-cp310-cp310-macosx_14_0_x86_64.whl",
            "sys_platform == 'darwin' and platform_machine == 'x86_64' and platform_release >= '23.0.0'",
        );
        assert_platform_markers(
            "numpy-2.2.1-cp310-cp310-macosx_10_9_x86_64.whl",
            "sys_platform == 'darwin' and platform_machine == 'x86_64' and platform_release >= '13.0.0'",
        );
        assert_platform_markers(
            "numpy-2.2.1-cp310-cp310-macosx_11_0_arm64.whl",
            "sys_platform == 'darwin' and platform_machine == 'arm64' and platform_release >= '20.0.0'",
        );
        assert_platform_markers(
            "example-1.0-py3-none-android_24_arm64_v8a.whl",
            "sys_platform == 'android' and platform_machine == 'aarch64'",
        );
        assert_platform_markers(
            "example-1.0-py3-none-android_24_armeabi_v7a.whl",
            "sys_platform == 'android' and platform_machine == 'armv7l'",
        );
        assert_platform_markers(
            "example-1.0-py3-none-android_24_x86.whl",
            "sys_platform == 'android' and platform_machine == 'i686'",
        );
        assert_platform_markers(
            "example-1.0-py3-none-android_24_x86_64.whl",
            "sys_platform == 'android' and platform_machine == 'x86_64'",
        );
    }

    #[test]
    fn test_implied_python_markers() {
        let filename = WheelFilename::from_str("example-1.0-none-none-any.whl").unwrap();
        assert_eq!(implied_python_markers(&filename), MarkerTree::TRUE);

        assert_python_markers(
            "example-1.0-cp310-cp310-any.whl",
            "python_full_version == '3.10.*' and platform_python_implementation == 'CPython'",
        );
        assert_python_markers(
            "example-1.0-cp311-cp311-any.whl",
            "python_full_version == '3.11.*' and platform_python_implementation == 'CPython'",
        );
        assert_python_markers(
            "example-1.0-cp312-cp312-any.whl",
            "python_full_version == '3.12.*' and platform_python_implementation == 'CPython'",
        );
        assert_python_markers(
            "example-1.0-cp313-cp313-any.whl",
            "python_full_version == '3.13.*' and platform_python_implementation == 'CPython'",
        );
        assert_python_markers(
            "example-1.0-cp313-cp313t-any.whl",
            "python_full_version == '3.13.*' and platform_python_implementation == 'CPython'",
        );
        assert_python_markers(
            "example-1.0-pp310-pypy310_pp73-any.whl",
            "python_full_version == '3.10.*' and platform_python_implementation == 'PyPy'",
        );
        assert_python_markers(
            "example-1.0-py310-none-any.whl",
            "python_full_version >= '3.10' and python_full_version < '4'",
        );
        assert_python_markers(
            "example-1.0-py3-none-any.whl",
            "python_full_version >= '3' and python_full_version < '4'",
        );
        assert_python_markers(
            "example-1.0-py311.py312-none-any.whl",
            "python_full_version >= '3.11' and python_full_version < '4'",
        );

        // abi3 wheels: the python tag represents a minimum version, not an exact version.
        assert_python_markers(
            "example-1.0-cp39-abi3-any.whl",
            "python_full_version >= '3.9' and platform_python_implementation == 'CPython'",
        );
        assert_python_markers(
            "example-1.0-cp312-abi3-any.whl",
            "python_full_version >= '3.12' and platform_python_implementation == 'CPython'",
        );
        assert_python_markers(
            "example-1.0-cp315-abi3t-any.whl",
            "python_full_version >= '3.15' and platform_python_implementation == 'CPython'",
        );
        assert_python_markers(
            "example-1.0-cp3-abi3-any.whl",
            "python_full_version >= '3' and platform_python_implementation == 'CPython'",
        );
    }

    #[test]
    fn test_macos_platform_markers() {
        for (tag, expected) in [
            (
                "macosx_10_5_x86_64",
                "sys_platform == 'darwin' and platform_machine == 'x86_64' and platform_release >= '9.0.0'",
            ),
            (
                "macosx_10_9_universal2",
                "sys_platform == 'darwin' and ((platform_machine == 'x86_64' and platform_release >= '13.0.0') or (platform_machine == 'arm64' and platform_release >= '20.0.0'))",
            ),
            (
                "macosx_10_16_universal2",
                "sys_platform == 'darwin' and (platform_machine == 'arm64' or platform_machine == 'x86_64') and platform_release >= '20.0.0'",
            ),
            (
                "macosx_15_0_arm64",
                "sys_platform == 'darwin' and platform_machine == 'arm64' and platform_release >= '24.0.0'",
            ),
            (
                "macosx_26_0_arm64",
                "sys_platform == 'darwin' and platform_machine == 'arm64' and platform_release >= '25.0.0'",
            ),
            (
                "macosx_27_0_arm64",
                "sys_platform == 'darwin' and platform_machine == 'arm64' and platform_release >= '27.0.0'",
            ),
            (
                "macosx_26_0_arm64.macosx_15_0_x86_64",
                "sys_platform == 'darwin' and ((platform_machine == 'arm64' and platform_release >= '25.0.0') or (platform_machine == 'x86_64' and platform_release >= '24.0.0'))",
            ),
        ] {
            let filename =
                WheelFilename::from_str(&format!("example-1.0-py3-none-{tag}.whl")).unwrap();
            assert_eq!(
                implied_platform_markers(filename.platform_tags()),
                MarkerTree::from_str(expected).unwrap()
            );
        }
    }

    #[test]
    fn test_implied_markers() {
        assert_implied_markers(
            "numpy-1.0-cp310-cp310-win32.whl",
            "python_full_version == '3.10.*' and platform_python_implementation == 'CPython' and sys_platform == 'win32' and platform_machine == 'x86'",
        );
        assert_implied_markers(
            "pywin32-311-cp314-cp314-win_arm64.whl",
            "python_full_version == '3.14.*' and platform_python_implementation == 'CPython' and sys_platform == 'win32' and platform_machine == 'ARM64'",
        );
        assert_implied_markers(
            "numpy-1.0-cp311-cp311-macosx_10_9_x86_64.whl",
            "python_full_version == '3.11.*' and platform_python_implementation == 'CPython' and sys_platform == 'darwin' and platform_machine == 'x86_64' and platform_release >= '13.0.0'",
        );
        assert_implied_markers(
            "numpy-1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl",
            "python_full_version == '3.12.*' and platform_python_implementation == 'CPython' and sys_platform == 'linux' and platform_machine == 'aarch64'",
        );
        assert_implied_markers(
            "example-1.0-py3-none-any.whl",
            "python_full_version >= '3' and python_full_version < '4'",
        );

        // abi3 wheel: cp39-abi3 means CPython >= 3.9, combined with platform markers.
        assert_implied_markers(
            "example-1.0-cp39-abi3-manylinux_2_28_x86_64.whl",
            "python_full_version >= '3.9' and platform_python_implementation == 'CPython' and sys_platform == 'linux' and platform_machine == 'x86_64'",
        );
        assert_implied_markers(
            "example-1.0-cp315-abi3t-manylinux_2_28_x86_64.whl",
            "python_full_version >= '3.15' and platform_python_implementation == 'CPython' and sys_platform == 'linux' and platform_machine == 'x86_64'",
        );
    }
}