Skip to content

Commit 77ab05f

Browse files
Omit compatible prerelease version constraints (#22068)
## Summary Extend #22004 to omit compatible version constraints when the bound or a locked version is a prerelease. Every locked version must satisfy an omitted constraint. Keep source and index constraints, and constraints that opt a locked registry prerelease into the `explicit` policy. Under `if-necessary`, the resolver can still use an existing locked prerelease as a preference after its constraint is removed.
1 parent 9a04b8f commit 77ab05f

6 files changed

Lines changed: 506 additions & 82 deletions

File tree

‎crates/uv-configuration/src/normalized_requirements.rs‎

Lines changed: 12 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,10 @@ use uv_pep440::{
1616
use uv_pep508::MarkerTree;
1717
use version_ranges::Ranges;
1818

19-
use crate::{ExcludeDependency, Excludes, Override, PackageOverride, PackageOverrideTarget};
19+
use crate::{
20+
ExcludeDependency, Excludes, Override, PackageOverride, PackageOverrideTarget,
21+
specifier_opts_into_prereleases,
22+
};
2023

2124
mod coverage;
2225

@@ -241,7 +244,7 @@ impl RequirementsKey {
241244
let range = if let RequirementSource::Registry { specifier, .. } = &mut requirement.source {
242245
yanked = allows_yanked(specifier.iter());
243246
let ranges = mem::take(specifier).into_iter().map(|specifier| {
244-
prerelease |= allows_prereleases(&specifier);
247+
prerelease |= specifier_opts_into_prereleases(&specifier);
245248
Ranges::from(specifier)
246249
});
247250
intersect_ranges(ranges)
@@ -449,7 +452,7 @@ fn simplify_specifiers(specifiers: VersionSpecifiers) -> VersionSpecifiers {
449452
let mut retained_count = specifiers.len();
450453
let mut prerelease_count = specifiers
451454
.iter()
452-
.filter(|specifier| allows_prereleases(specifier))
455+
.filter(|specifier| specifier_opts_into_prereleases(specifier))
453456
.count();
454457
for (index, specifier) in specifiers.iter().enumerate() {
455458
let remaining = specifiers
@@ -458,14 +461,14 @@ fn simplify_specifiers(specifiers: VersionSpecifiers) -> VersionSpecifiers {
458461
.filter(|(other_index, _)| *other_index != index && retained[*other_index])
459462
.map(|(_, specifier)| specifier);
460463
if (retained_count == 2 && allows_yanked(remaining))
461-
|| (allows_prereleases(specifier) && prerelease_count == 1)
464+
|| (specifier_opts_into_prereleases(specifier) && prerelease_count == 1)
462465
{
463466
continue;
464467
}
465468
if coverage.is_redundant(&exclusions[index]) {
466469
retained[index] = false;
467470
retained_count -= 1;
468-
prerelease_count -= usize::from(allows_prereleases(specifier));
471+
prerelease_count -= usize::from(specifier_opts_into_prereleases(specifier));
469472
coverage.remove(&exclusions[index]);
470473
}
471474
}
@@ -525,22 +528,6 @@ fn normalize_specifier(specifier: VersionSpecifier) -> VersionSpecifier {
525528
}
526529
}
527530

528-
/// Whether this clause opts into prereleases under the explicit prerelease policy.
529-
/// Excluding a prerelease, as in `!=1rc1`, does not opt in.
530-
fn allows_prereleases(specifier: &VersionSpecifier) -> bool {
531-
match specifier.operator() {
532-
Operator::NotEqual | Operator::NotEqualStar => false,
533-
Operator::Equal
534-
| Operator::EqualStar
535-
| Operator::ExactEqual
536-
| Operator::TildeEqual
537-
| Operator::LessThan
538-
| Operator::LessThanEqual
539-
| Operator::GreaterThan
540-
| Operator::GreaterThanEqual => specifier.any_prerelease(),
541-
}
542-
}
543-
544531
#[cfg(test)]
545532
mod tests {
546533
use std::str::FromStr;
@@ -557,8 +544,8 @@ mod tests {
557544
};
558545

559546
use super::{
560-
NormalizedExcludes, NormalizedRequirements, allows_prereleases, allows_yanked,
561-
simplify_specifiers,
547+
NormalizedExcludes, NormalizedRequirements, allows_yanked, simplify_specifiers,
548+
specifier_opts_into_prereleases,
562549
};
563550

564551
fn requirements(inputs: &[&str]) -> Result<Vec<Requirement>> {
@@ -832,8 +819,8 @@ mod tests {
832819
let original = VersionSpecifiers::from_str(&format!("{left},{right}"))?;
833820
let normalized = simplify_specifiers(original.clone());
834821
assert_eq!(
835-
original.iter().any(allows_prereleases),
836-
normalized.iter().any(allows_prereleases),
822+
original.iter().any(specifier_opts_into_prereleases),
823+
normalized.iter().any(specifier_opts_into_prereleases),
837824
"{original} -> {normalized}"
838825
);
839826
assert_eq!(

‎crates/uv-configuration/src/prerelease.rs‎

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,24 @@ use std::str::FromStr;
33

44
use rustc_hash::FxHashMap;
55
use uv_normalize::PackageName;
6+
use uv_pep440::{Operator, VersionSpecifier};
7+
8+
/// Return whether a specifier opts into prereleases under the explicit prerelease policy.
9+
///
10+
/// Excluding a prerelease, as in `!=1.0a1`, does not opt in.
11+
pub fn specifier_opts_into_prereleases(specifier: &VersionSpecifier) -> bool {
12+
match specifier.operator() {
13+
Operator::NotEqual | Operator::NotEqualStar => false,
14+
Operator::Equal
15+
| Operator::EqualStar
16+
| Operator::ExactEqual
17+
| Operator::TildeEqual
18+
| Operator::LessThan
19+
| Operator::LessThanEqual
20+
| Operator::GreaterThan
21+
| Operator::GreaterThanEqual => specifier.any_prerelease(),
22+
}
23+
}
624

725
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
826
#[serde(deny_unknown_fields, rename_all = "kebab-case")]

‎crates/uv-lock/src/lock/inputs.rs‎

Lines changed: 21 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,16 @@
11
use std::collections::BTreeSet;
22
use std::mem;
33

4-
use uv_configuration::{ExcludeDependency, NormalizedConstraints, Override};
4+
use uv_configuration::{
5+
ExcludeDependency, NormalizedConstraints, Override, PrereleaseMode,
6+
specifier_opts_into_prereleases,
7+
};
58
use uv_distribution_types::{Requirement, RequirementSource, ResolutionLookups, StaticMetadata};
69
use uv_normalize::PackageName;
7-
use uv_pep440::VersionSpecifier;
810
use uv_preview::PreviewFeature;
911

1012
use super::requirements::normalize_collection;
11-
use super::{Lock, Package};
13+
use super::{Lock, Package, Source};
1214

1315
impl Lock {
1416
/// Retain settings for locked packages and settings consulted during runtime resolution.
@@ -51,11 +53,11 @@ impl Lock {
5153
self
5254
}
5355

54-
/// Return whether a plain version bound is satisfied by every stable locked version.
56+
/// Return whether a plain version bound is satisfied by every locked version.
5557
///
56-
/// Source declarations and prerelease specifiers can affect candidate eligibility, so their
57-
/// changes must trigger resolution. Bounds on dynamic or prerelease versions also remain
58-
/// recorded. Check every version regardless of markers: an inapplicable bound that does not
58+
/// Source declarations remain recorded because they affect candidate eligibility. Under the
59+
/// explicit prerelease policy, an opt-in also remains recorded when a registry prerelease is
60+
/// locked. Check every version regardless of markers: an inapplicable bound that does not
5961
/// contain a locked version must be retained to avoid resolving unchanged inputs repeatedly.
6062
pub(super) fn can_omit_constraint(&self, constraint: &Requirement) -> bool {
6163
let RequirementSource::Registry {
@@ -69,17 +71,21 @@ impl Lock {
6971
if specifier.is_empty() {
7072
return true;
7173
}
72-
if specifier.iter().any(VersionSpecifier::any_prerelease) {
73-
return false;
74-
}
74+
let prerelease_opt_in = self.options.prerelease.mode(&constraint.name)
75+
== PrereleaseMode::Explicit
76+
&& specifier.iter().any(specifier_opts_into_prereleases);
7577
self.packages_for_name(&constraint.name)
7678
.iter()
7779
.all(|package| {
78-
package
79-
.id
80-
.version
81-
.as_ref()
82-
.is_some_and(|version| !version.any_prerelease() && specifier.contains(version))
80+
package.id.version.as_ref().is_some_and(|version| {
81+
if prerelease_opt_in
82+
&& version.any_prerelease()
83+
&& let Source::Registry(_) = &package.id.source
84+
{
85+
return false;
86+
}
87+
specifier.contains(version)
88+
})
8389
})
8490
}
8591
}

‎crates/uv-resolver/src/prerelease.rs‎

Lines changed: 2 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,9 @@
11
use std::borrow::Cow;
22

33
use rustc_hash::FxHashMap;
4-
use uv_configuration::{Prerelease, PrereleaseMode};
4+
use uv_configuration::{Prerelease, PrereleaseMode, specifier_opts_into_prereleases};
55
use uv_distribution_types::{Requirement, RequirementSource};
66
use uv_normalize::PackageName;
7-
use uv_pep440::{Operator, VersionSpecifiers};
87

98
use crate::resolver::ForkSet;
109
use crate::{DependencyMode, Manifest, ResolverEnvironment};
@@ -83,7 +82,7 @@ impl PrereleaseStrategy {
8382
continue;
8483
};
8584

86-
if contains_prerelease(specifier) {
85+
if specifier.iter().any(specifier_opts_into_prereleases) {
8786
packages.add(&requirement, ());
8887
}
8988
}
@@ -115,22 +114,6 @@ impl PrereleaseStrategy {
115114
}
116115
}
117116

118-
/// Returns `true` if the specifiers explicitly mention a pre-release version.
119-
///
120-
/// Exclusions do not opt a package into pre-releases. For example, `!=1.0a1` should not change
121-
/// which candidate kinds are considered.
122-
fn contains_prerelease(specifiers: &VersionSpecifiers) -> bool {
123-
specifiers
124-
.iter()
125-
.filter(|specifier| {
126-
!matches!(
127-
specifier.operator(),
128-
Operator::NotEqual | Operator::NotEqualStar
129-
)
130-
})
131-
.any(uv_pep440::VersionSpecifier::any_prerelease)
132-
}
133-
134117
/// How pre-release candidates participate in version selection.
135118
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
136119
pub(crate) enum PrereleaseSelection {

0 commit comments

Comments
 (0)