Auto merge of #12560 - epage:msrv, r=🙈eh2406🙈

feat(resolver): **Very** preliminary MSRV resolver support

### What does this PR try to resolve?

A bare bones implementation of an MSRV resolver that is good enough for people running on nightly when they really need it but is not ready for general use.

Current limitations
- Does not honor `--ignore-version`
- Gives terrible error messages
- Nothing is done yet regarding `cargo install`
- Doesn't inform the user when choosing non-latest

These will be  noted in #9930 on merge.

Implementation wise, this is yet another hack (sorry `@Eh2406).`  Our expectation to get this GA is to refactor the resolver to make the cargo/resolver boundary look a little more like the cargo/pubgrub boundary so we can better control policy without any of these hacks which will also make having all of the policy we need for this easier to maintain.

This is a part of #9930

### How should we test and review this PR?

Per commit

Author: bors

benches/benchsuite/benches/resolve.rs

@@ -31,6 +31,7 @@ fn do_resolve<'cfg>(config: &'cfg Config, ws_root: &Path) -> ResolveInfo<'cfg> {
     let specs = pkgs.to_package_id_specs(&ws).unwrap();
     let has_dev_units = HasDevUnits::Yes;
     let force_all_targets = ForceAllTargets::No;
+    let max_rust_version = None;
     // Do an initial run to download anything necessary so that it does
     // not confuse criterion's warmup.
     let ws_resolve = cargo::ops::resolve_ws_with_opts(
@@ -41,6 +42,7 @@ fn do_resolve<'cfg>(config: &'cfg Config, ws_root: &Path) -> ResolveInfo<'cfg> {
         &specs,
         has_dev_units,
         force_all_targets,
+        max_rust_version,
     )
     .unwrap();
     ResolveInfo {
@@ -82,6 +84,7 @@ fn resolve_ws(c: &mut Criterion) {
                 force_all_targets,
                 ..
             } = lazy_info.get_or_insert_with(|| do_resolve(&config, &ws_root));
+            let max_rust_version = None;
             b.iter(|| {
                 cargo::ops::resolve_ws_with_opts(
                     ws,
@@ -91,6 +94,7 @@ fn resolve_ws(c: &mut Criterion) {
                     specs,
                     *has_dev_units,
                     *force_all_targets,
+                    max_rust_version,
                 )
                 .unwrap();
             })

crates/resolver-tests/src/lib.rs

@@ -188,13 +188,15 @@ pub fn resolve_with_config_raw(
     .unwrap();
     let opts = ResolveOpts::everything();
     let start = Instant::now();
+    let max_rust_version = None;
     let resolve = resolver::resolve(
         &[(summary, opts)],
         &[],
         &mut registry,
         &VersionPreferences::default(),
         Some(config),
         true,
+        max_rust_version,
     );
 
     // The largest test in our suite takes less then 30 sec.

src/cargo/core/compiler/standard_lib.rs

@@ -145,6 +145,7 @@ pub fn resolve_std<'cfg>(
     let cli_features = CliFeatures::from_command_line(
         &features, /*all_features*/ false, /*uses_default_features*/ false,
     )?;
+    let max_rust_version = ws.rust_version();
     let resolve = ops::resolve_ws_with_opts(
         &std_ws,
         target_data,
@@ -153,6 +154,7 @@ pub fn resolve_std<'cfg>(
         &specs,
         HasDevUnits::No,
         crate::core::resolver::features::ForceAllTargets::No,
+        max_rust_version,
     )?;
     Ok((
         resolve.pkg_set,

src/cargo/core/resolver/dep_cache.rs

@@ -21,6 +21,7 @@ use crate::core::{
 };
 use crate::util::errors::CargoResult;
 use crate::util::interning::InternedString;
+use crate::util::PartialVersion;
 
 use anyhow::Context as _;
 use std::collections::{BTreeSet, HashMap, HashSet};
@@ -36,6 +37,7 @@ pub struct RegistryQueryer<'a> {
     /// versions first. That allows `cargo update -Z minimal-versions` which will
     /// specify minimum dependency versions to be used.
     minimal_versions: bool,
+    max_rust_version: Option<PartialVersion>,
     /// a cache of `Candidate`s that fulfil a `Dependency` (and whether `first_minimal_version`)
     registry_cache: HashMap<(Dependency, bool), Poll<Rc<Vec<Summary>>>>,
     /// a cache of `Dependency`s that are required for a `Summary`
@@ -57,12 +59,14 @@ impl<'a> RegistryQueryer<'a> {
         replacements: &'a [(PackageIdSpec, Dependency)],
         version_prefs: &'a VersionPreferences,
         minimal_versions: bool,
+        max_rust_version: Option<PartialVersion>,
     ) -> Self {
         RegistryQueryer {
             registry,
             replacements,
             version_prefs,
             minimal_versions,
+            max_rust_version,
             registry_cache: HashMap::new(),
             summary_cache: HashMap::new(),
             used_replacements: HashMap::new(),
@@ -112,7 +116,9 @@ impl<'a> RegistryQueryer<'a> {
 
         let mut ret = Vec::new();
         let ready = self.registry.query(dep, QueryKind::Exact, &mut |s| {
-            ret.push(s);
+            if self.max_rust_version.is_none() || s.rust_version() <= self.max_rust_version {
+                ret.push(s);
+            }
         })?;
         if ready.is_pending() {
             self.registry_cache

src/cargo/core/resolver/mod.rs

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

src/cargo/core/workspace.rs

@@ -23,6 +23,7 @@ use crate::util::edit_distance;
 use crate::util::errors::{CargoResult, ManifestError};
 use crate::util::interning::InternedString;
 use crate::util::toml::{read_manifest, InheritableFields, TomlDependency, TomlProfiles};
+use crate::util::PartialVersion;
 use crate::util::{config::ConfigRelativePath, Config, Filesystem, IntoUrl};
 use cargo_util::paths;
 use cargo_util::paths::normalize_path;
@@ -595,6 +596,12 @@ impl<'cfg> Workspace<'cfg> {
         self
     }
 
+    /// Get the lowest-common denominator `package.rust-version` within the workspace, if specified
+    /// anywhere
+    pub fn rust_version(&self) -> Option<PartialVersion> {
+        self.members().filter_map(|pkg| pkg.rust_version()).min()
+    }
+
     pub fn custom_metadata(&self) -> Option<&toml::Value> {
         self.custom_metadata.as_ref()
     }

src/cargo/ops/cargo_compile/mod.rs

@@ -261,6 +261,7 @@ pub fn create_bcx<'a, 'cfg>(
             HasDevUnits::No
         }
     };
+    let max_rust_version = ws.rust_version();
     let resolve = ops::resolve_ws_with_opts(
         ws,
         &mut target_data,
@@ -269,6 +270,7 @@ pub fn create_bcx<'a, 'cfg>(
         &specs,
         has_dev_units,
         crate::core::resolver::features::ForceAllTargets::No,
+        max_rust_version,
     )?;
     let WorkspaceResolve {
         mut pkg_set,

src/cargo/ops/cargo_generate_lockfile.rs

@@ -21,6 +21,7 @@ pub struct UpdateOptions<'a> {
 
 pub fn generate_lockfile(ws: &Workspace<'_>) -> CargoResult<()> {
     let mut registry = PackageRegistry::new(ws.config())?;
+    let max_rust_version = ws.rust_version();
     let mut resolve = ops::resolve_with_previous(
         &mut registry,
         ws,
@@ -30,6 +31,7 @@ pub fn generate_lockfile(ws: &Workspace<'_>) -> CargoResult<()> {
         None,
         &[],
         true,
+        max_rust_version,
     )?;
     ops::write_pkg_lockfile(ws, &mut resolve)?;
     Ok(())
@@ -48,6 +50,8 @@ pub fn update_lockfile(ws: &Workspace<'_>, opts: &UpdateOptions<'_>) -> CargoRes
     // that we're synchronized against other Cargos.
     let _lock = ws.config().acquire_package_cache_lock()?;
 
+    let max_rust_version = ws.rust_version();
+
     let previous_resolve = match ops::load_pkg_lockfile(ws)? {
         Some(resolve) => resolve,
         None => {
@@ -67,6 +71,7 @@ pub fn update_lockfile(ws: &Workspace<'_>, opts: &UpdateOptions<'_>) -> CargoRes
                         None,
                         &[],
                         true,
+                        max_rust_version,
                     )?
                 }
             }
@@ -125,6 +130,7 @@ pub fn update_lockfile(ws: &Workspace<'_>, opts: &UpdateOptions<'_>) -> CargoRes
         Some(&to_avoid),
         &[],
         true,
+        max_rust_version,
     )?;
 
     // Summarize what is changing for the user.

src/cargo/ops/cargo_output_metadata.rs

@@ -135,6 +135,8 @@ fn build_resolve_graph(
         crate::core::resolver::features::ForceAllTargets::No
     };
 
+    let max_rust_version = ws.rust_version();
+
     // Note that even with --filter-platform we end up downloading host dependencies as well,
     // as that is the behavior of download_accessible.
     let ws_resolve = ops::resolve_ws_with_opts(
@@ -145,6 +147,7 @@ fn build_resolve_graph(
         &specs,
         HasDevUnits::Yes,
         force_all,
+        max_rust_version,
     )?;
 
     let package_map: BTreeMap<PackageId, Package> = ws_resolve

src/cargo/ops/cargo_package.rs

@@ -423,6 +423,8 @@ fn build_lock(ws: &Workspace<'_>, orig_pkg: &Package) -> CargoResult<String> {
         TomlManifest::to_real_manifest(&toml_manifest, false, source_id, package_root, config)?;
     let new_pkg = Package::new(manifest, orig_pkg.manifest_path());
 
+    let max_rust_version = new_pkg.rust_version();
+
     // Regenerate Cargo.lock using the old one as a guide.
     let tmp_ws = Workspace::ephemeral(new_pkg, ws.config(), None, true)?;
     let mut tmp_reg = PackageRegistry::new(ws.config())?;
@@ -435,6 +437,7 @@ fn build_lock(ws: &Workspace<'_>, orig_pkg: &Package) -> CargoResult<String> {
         None,
         &[],
         true,
+        max_rust_version,
     )?;
     let pkg_set = ops::get_resolved_packages(&new_resolve, tmp_reg)?;