feat(resolver): Add CLI option to resolve minimal version dependencies

src/cargo/core/features.rs

@@ -285,6 +285,7 @@ pub struct CliUnstable {
     pub offline: bool,
     pub no_index_update: bool,
     pub avoid_dev_deps: bool,
+    pub minimal_versions: bool,
 }
 
 impl CliUnstable {
@@ -317,6 +318,7 @@ impl CliUnstable {
             "offline" => self.offline = true,
             "no-index-update" => self.no_index_update = true,
             "avoid-dev-deps" => self.avoid_dev_deps = true,
+            "minimal-versions" => self.minimal_versions = true,
             _ => bail!("unknown `-Z` flag specified: {}", k),
         }
 

src/cargo/core/resolver/mod.rs

@@ -430,7 +430,11 @@ pub fn resolve(
         warnings: RcList::new(),
     };
     let _p = profile::start("resolving");
-    let mut registry = RegistryQueryer::new(registry, replacements, try_to_use);
+    let minimal_versions = match config {
+        Some(config) => config.cli_unstable().minimal_versions,
+        None => false,
+    };
+    let mut registry = RegistryQueryer::new(registry, replacements, try_to_use, minimal_versions);
     let cx = activate_deps_loop(cx, &mut registry, summaries, config)?;
 
     let mut resolve = Resolve {
@@ -683,19 +687,25 @@ struct RegistryQueryer<'a> {
     try_to_use: &'a HashSet<&'a PackageId>,
     // TODO: with nll the Rc can be removed
     cache: HashMap<Dependency, Rc<Vec<Candidate>>>,
+    // If set the list of dependency candidates will be sorted by minimal
+    // versions first. That allows `cargo update -Z minimal-versions` which will
+    // specify minimum depedency versions to be used.
+    minimal_versions: bool,
 }
 
 impl<'a> RegistryQueryer<'a> {
     fn new(
         registry: &'a mut Registry,
         replacements: &'a [(PackageIdSpec, Dependency)],
         try_to_use: &'a HashSet<&'a PackageId>,
+        minimal_versions: bool,
     ) -> Self {
         RegistryQueryer {
             registry,
             replacements,
             cache: HashMap::new(),
             try_to_use,
+            minimal_versions,
         }
     }
 
@@ -797,7 +807,10 @@ impl<'a> RegistryQueryer<'a> {
             let b_in_previous = self.try_to_use.contains(b.summary.package_id());
             let a = (a_in_previous, a.summary.version());
             let b = (b_in_previous, b.summary.version());
-            a.cmp(&b).reverse()
+            match self.minimal_versions {
+                true => a.cmp(&b),
+                false => a.cmp(&b).reverse(),
+            }
         });
 
         let out = Rc::new(ret);

tests/testsuite/resolve.rs

@@ -5,7 +5,7 @@ use hamcrest::{assert_that, contains, is_not};
 use cargo::core::source::{GitReference, SourceId};
 use cargo::core::dependency::Kind::{self, Development};
 use cargo::core::{Dependency, PackageId, Registry, Summary};
-use cargo::util::{CargoResult, ToUrl};
+use cargo::util::{CargoResult, Config, ToUrl};
 use cargo::core::resolver::{self, Method};
 
 fn resolve(
@@ -45,6 +45,45 @@ fn resolve(
     Ok(res)
 }
 
+// Clone of resolve() from above that also passes down a Config instance.
+fn resolve_with_config(
+    pkg: &PackageId,
+    deps: Vec<Dependency>,
+    registry: &[Summary],
+    config: &Config,
+) -> CargoResult<Vec<PackageId>> {
+    struct MyRegistry<'a>(&'a [Summary]);
+    impl<'a> Registry for MyRegistry<'a> {
+        fn query(&mut self, dep: &Dependency, f: &mut FnMut(Summary)) -> CargoResult<()> {
+            for summary in self.0.iter() {
+                if dep.matches(summary) {
+                    f(summary.clone());
+                }
+            }
+            Ok(())
+        }
+        fn supports_checksums(&self) -> bool {
+            false
+        }
+        fn requires_precise(&self) -> bool {
+            false
+        }
+    }
+    let mut registry = MyRegistry(registry);
+    let summary = Summary::new(pkg.clone(), deps, BTreeMap::new(), None).unwrap();
+    let method = Method::Everything;
+    let resolve = resolver::resolve(
+        &[(summary, method)],
+        &[],
+        &mut registry,
+        &HashSet::new(),
+        Some(config),
+        false,
+    )?;
+    let res = resolve.iter().cloned().collect();
+    Ok(res)
+}
+
 trait ToDep {
     fn to_dep(self) -> Dependency;
 }
@@ -320,6 +359,48 @@ fn test_resolving_maximum_version_with_transitive_deps() {
     assert_that(&res, is_not(contains(names(&[("util", "1.1.1")]))));
 }
 
+#[test]
+fn test_resolving_minimum_version_with_transitive_deps() {
+    let reg = registry(vec![
+        pkg!(("util", "1.2.2")),
+        pkg!(("util", "1.0.0")),
+        pkg!(("util", "1.1.1")),
+        pkg!("foo" => [dep_req("util", "1.0.0")]),
+        pkg!("bar" => [dep_req("util", ">=1.0.1")]),
+    ]);
+
+    let mut config = Config::default().unwrap();
+    config
+        .configure(
+            1,
+            None,
+            &None,
+            false,
+            false,
+            &["minimal-versions".to_string()],
+        )
+        .unwrap();
+
+    let res = resolve_with_config(
+        &pkg_id("root"),
+        vec![dep_req("foo", "1.0.0"), dep_req("bar", "1.0.0")],
+        &reg,
+        &config,
+    ).unwrap();
+
+    assert_that(
+        &res,
+        contains(names(&[
+            ("root", "1.0.0"),
+            ("foo", "1.0.0"),
+            ("bar", "1.0.0"),
+            ("util", "1.1.1"),
+        ])),
+    );
+    assert_that(&res, is_not(contains(names(&[("util", "1.2.2")]))));
+    assert_that(&res, is_not(contains(names(&[("util", "1.0.0")]))));
+}
+
 #[test]
 fn resolving_incompat_versions() {
     let reg = registry(vec![