refactor(resolver): Pull MSRV handling to VersionPreferences

crates/resolver-tests/src/lib.rs

@@ -190,7 +190,6 @@ pub fn resolve_with_config_raw(
     .unwrap();
     let opts = ResolveOpts::everything();
     let start = Instant::now();
-    let max_rust_version = None;
     let mut version_prefs = VersionPreferences::default();
     if config.cli_unstable().minimal_versions {
         version_prefs.version_ordering(VersionOrdering::MinimumVersionsFirst)
@@ -202,7 +201,6 @@ pub fn resolve_with_config_raw(
         &version_prefs,
         Some(config),
         true,
-        max_rust_version,
     );
 
     // The largest test in our suite takes less then 30 sec.

src/cargo/core/resolver/dep_cache.rs

@@ -20,7 +20,6 @@ use crate::core::{Dependency, FeatureValue, PackageId, PackageIdSpec, Registry,
 use crate::sources::source::QueryKind;
 use crate::util::errors::CargoResult;
 use crate::util::interning::InternedString;
-use crate::util::RustVersion;
 
 use anyhow::Context as _;
 use std::collections::{BTreeSet, HashMap, HashSet};
@@ -32,7 +31,6 @@ pub struct RegistryQueryer<'a> {
     pub registry: &'a mut (dyn Registry + 'a),
     replacements: &'a [(PackageIdSpec, Dependency)],
     version_prefs: &'a VersionPreferences,
-    max_rust_version: Option<RustVersion>,
     /// a cache of `Candidate`s that fulfil a `Dependency` (and whether `first_version`)
     registry_cache: HashMap<(Dependency, Option<VersionOrdering>), Poll<Rc<Vec<Summary>>>>,
     /// a cache of `Dependency`s that are required for a `Summary`
@@ -53,13 +51,11 @@ impl<'a> RegistryQueryer<'a> {
         registry: &'a mut dyn Registry,
         replacements: &'a [(PackageIdSpec, Dependency)],
         version_prefs: &'a VersionPreferences,
-        max_rust_version: Option<&RustVersion>,
     ) -> Self {
         RegistryQueryer {
             registry,
             replacements,
             version_prefs,
-            max_rust_version: max_rust_version.cloned(),
             registry_cache: HashMap::new(),
             summary_cache: HashMap::new(),
             used_replacements: HashMap::new(),
@@ -109,10 +105,7 @@ impl<'a> RegistryQueryer<'a> {
 
         let mut ret = Vec::new();
         let ready = self.registry.query(dep, QueryKind::Exact, &mut |s| {
-            if self.max_rust_version.is_none() || s.rust_version() <= self.max_rust_version.as_ref()
-            {
             ret.push(s);
-            }
         })?;
         if ready.is_pending() {
             self.registry_cache

src/cargo/core/resolver/mod.rs

@@ -71,7 +71,6 @@ use crate::util::config::Config;
 use crate::util::errors::CargoResult;
 use crate::util::network::PollExt;
 use crate::util::profile;
-use crate::util::RustVersion;
 
 use self::context::Context;
 use self::dep_cache::RegistryQueryer;
@@ -139,7 +138,6 @@ pub fn resolve(
     version_prefs: &VersionPreferences,
     config: Option<&Config>,
     check_public_visible_dependencies: bool,
-    mut max_rust_version: Option<&RustVersion>,
 ) -> CargoResult<Resolve> {
     let _p = profile::start("resolving");
     let first_version = match config {
@@ -148,14 +146,7 @@ pub fn resolve(
         }
         _ => None,
     };
-    if !config
+    let mut registry = RegistryQueryer::new(registry, replacements, version_prefs);
-        .map(|c| c.cli_unstable().msrv_policy)
-        .unwrap_or(false)
-    {
-        max_rust_version = None;
-    }
-    let mut registry =
-        RegistryQueryer::new(registry, replacements, version_prefs, max_rust_version);
     let cx = loop {
         let cx = Context::new(check_public_visible_dependencies);
         let cx = activate_deps_loop(cx, &mut registry, summaries, first_version, config)?;

src/cargo/core/resolver/version_prefs.rs

@@ -6,6 +6,7 @@ use std::collections::{HashMap, HashSet};
 
 use crate::core::{Dependency, PackageId, Summary};
 use crate::util::interning::InternedString;
+use crate::util::RustVersion;
 
 /// A collection of preferences for particular package versions.
 ///
@@ -19,6 +20,7 @@ pub struct VersionPreferences {
     try_to_use: HashSet<PackageId>,
     prefer_patch_deps: HashMap<InternedString, HashSet<Dependency>>,
     version_ordering: VersionOrdering,
+    max_rust_version: Option<RustVersion>,
 }
 
 #[derive(Copy, Clone, Default, PartialEq, Eq, Hash, Debug)]
@@ -46,6 +48,10 @@ impl VersionPreferences {
         self.version_ordering = ordering;
     }
 
+    pub fn max_rust_version(&mut self, ver: Option<RustVersion>) {
+        self.max_rust_version = ver;
+    }
+
     /// Sort the given vector of summaries in-place, with all summaries presumed to be for
     /// the same package.  Preferred versions appear first in the result, sorted by
     /// `version_ordering`, followed by non-preferred versions sorted the same way.
@@ -62,6 +68,9 @@ impl VersionPreferences {
                     .map(|deps| deps.iter().any(|d| d.matches_id(*pkg_id)))
                     .unwrap_or(false)
         };
+        if self.max_rust_version.is_some() {
+            summaries.retain(|s| s.rust_version() <= self.max_rust_version.as_ref());
+        }
         summaries.sort_unstable_by(|a, b| {
             let prefer_a = should_prefer(&a.package_id());
             let prefer_b = should_prefer(&b.package_id());

src/cargo/ops/resolve.rs

@@ -324,6 +324,9 @@ pub fn resolve_with_previous<'cfg>(
     if ws.config().cli_unstable().minimal_versions {
         version_prefs.version_ordering(VersionOrdering::MinimumVersionsFirst)
     }
+    if ws.config().cli_unstable().msrv_policy {
+        version_prefs.max_rust_version(max_rust_version.cloned());
+    }
 
     // This is a set of PackageIds of `[patch]` entries, and some related locked PackageIds, for
     // which locking should be avoided (but which will be preferred when searching dependencies,
@@ -512,7 +515,6 @@ pub fn resolve_with_previous<'cfg>(
         ws.unstable_features()
             .require(Feature::public_dependency())
             .is_ok(),
-        max_rust_version,
     )?;
     let patches: Vec<_> = registry
         .patches()