Pubgrub experiment for fun

Cargo.toml

@@ -85,6 +85,7 @@ pathdiff = "0.2.3"
 portable-atomic = "1.13.1"
 percent-encoding = "2.3.2"
 proptest = "1.11.0"
+pubgrub = "0.4.0"
 pulldown-cmark = { version = "0.13.3", default-features = false, features = ["html"] }
 rand = "0.10.1"
 regex = "1.12.3"
@@ -203,6 +204,7 @@ os_info.workspace = true
 pasetors.workspace = true
 pathdiff.workspace = true
 portable-atomic.workspace = true
+pubgrub.workspace = true
 rand.workspace = true
 regex.workspace = true
 rusqlite = { workspace = true, features = ["fallible_uint"] }

crates/cargo-test-support/src/lib.rs

@@ -1439,6 +1439,10 @@ pub trait TestEnvCommandExt: Sized {
             .env("CARGO_INCREMENTAL", "0")
             // Don't read the system git config which is out of our control.
             .env("GIT_CONFIG_NOSYSTEM", "1")
+            // See: https://github.com/rust-lang/rust/pull/159857#issuecomment-5119325932
+            // This should be removed once the new build-dir layout is stabilized and the old layout
+            // is removed.
+            .env("__CARGO_TEMPORARY_BUILD_DIR_NEW_LAYOUT_OPT_OUT", "1")
             .env_remove("CI")
             .env_remove("__CARGO_DEFAULT_LIB_METADATA")
             .env_remove("ALL_PROXY")

crates/cargo-util-terminal/Cargo.toml

@@ -14,6 +14,7 @@ anstyle.workspace = true
 anstyle-hyperlink = { workspace = true, features = ["file"] }
 anstyle-progress.workspace = true
 anyhow.workspace = true
+cargo-util.workspace = true
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true, features = ["raw_value"] }
 supports-hyperlinks.workspace = true

crates/cargo-util-terminal/src/shell.rs

@@ -363,6 +363,21 @@ impl Shell {
         url.map(|u| self.err_hyperlink(u)).unwrap_or_default()
     }
 
+    /// Query terminal capability, independent of user configuration
+    pub fn progress_supported(&self) -> bool {
+        // report no progress when -q (for quiet) or TERM=dumb are set
+        // or if running on Continuous Integration service like Travis where the
+        // output logs get mangled.
+        if self.verbosity == Verbosity::Quiet
+            || std::env::var("TERM").as_deref() == Ok("dumb")
+            || cargo_util::is_ci()
+        {
+            false
+        } else {
+            true
+        }
+    }
+
     fn unstable_flags_rustc_unicode(&self) -> bool {
         match &self.output {
             ShellOut::Write(_) => false,

crates/cargo-util/src/paths.rs

@@ -57,6 +57,8 @@ pub fn dylib_path_envvar() -> &'static str {
         "DYLD_FALLBACK_LIBRARY_PATH"
     } else if cfg!(target_os = "aix") {
         "LIBPATH"
+    } else if cfg!(target_os = "haiku") {
+        "LIBRARY_PATH"
     } else {
         "LD_LIBRARY_PATH"
     }

crates/resolver-tests/src/lib.rs

@@ -33,9 +33,38 @@ use proptest::prelude::*;
 use proptest::sample::Index;
 use proptest::string::string_regex;
 
+/// Builds the [`GlobalContext`] used by the convenience resolve helpers.
+///
+/// When the `__CARGO_TEST_PUBGRUB` environment variable is set, the experimental
+/// `-Zpubgrub-resolver` is enabled, so the entire curated resolver test suite
+/// can be re-run against the PubGrub resolver for differential validation:
+///
+/// ```sh
+/// __CARGO_TEST_PUBGRUB=1 cargo test -p resolver-tests
+/// ```
+pub fn test_global_context() -> GlobalContext {
+    let mut gctx = GlobalContext::default().unwrap();
+    if gctx.get_env_os("__CARGO_TEST_PUBGRUB").is_some() {
+        gctx.nightly_features_allowed = true;
+        gctx.configure(
+            0,
+            false,
+            None,
+            false,
+            false,
+            false,
+            &None,
+            &["pubgrub-resolver".to_string()],
+            &[],
+        )
+        .unwrap();
+    }
+    gctx
+}
+
 pub fn resolve(deps: Vec<Dependency>, registry: &[Summary]) -> CargoResult<Vec<PackageId>> {
     Ok(
-        resolve_with_global_context(deps, registry, &GlobalContext::default().unwrap())?
+        resolve_with_global_context(deps, registry, &test_global_context())?
             .into_iter()
             .map(|(pkg, _)| pkg)
             .collect(),
@@ -61,7 +90,7 @@ pub fn resolve_and_validated_raw(
         deps.clone(),
         registry,
         root_pkg_id,
-        &GlobalContext::default().unwrap(),
+        &test_global_context(),
     );
 
     match resolve {
@@ -129,6 +158,31 @@ pub fn resolve_with_global_context_raw(
     registry: &[Summary],
     root_pkg_id: PackageId,
     gctx: &GlobalContext,
+) -> CargoResult<Resolve> {
+    resolve_with_prefs_raw(
+        deps,
+        registry,
+        root_pkg_id,
+        gctx,
+        VersionPreferences::default(),
+    )
+}
+
+/// Like [`resolve_with_global_context_raw`], but lets the caller seed the
+/// [`VersionPreferences`].
+///
+/// This is how the conservative-update paths are exercised offline: an existing
+/// lockfile (and `cargo update -p <crate>`) is modeled by preferring the
+/// previously selected [`PackageId`]s (see [`prefs_from_lock`]), and `--precise`
+/// is modeled by preferring an exact [`Dependency`]. The production glue in
+/// `ops::resolve` builds the same [`VersionPreferences`] before handing off to
+/// the resolver, so this is the faithful resolver-level slice of those flows.
+pub fn resolve_with_prefs_raw(
+    deps: Vec<Dependency>,
+    registry: &[Summary],
+    root_pkg_id: PackageId,
+    gctx: &GlobalContext,
+    mut version_prefs: VersionPreferences,
 ) -> CargoResult<Resolve> {
     struct MyRegistry<'a> {
         list: &'a [Summary],
@@ -193,7 +247,6 @@ pub fn resolve_with_global_context_raw(
     let opts = ResolveOpts::everything();
 
     let start = Instant::now();
-    let mut version_prefs = VersionPreferences::default();
     if gctx.cli_unstable().minimal_versions {
         version_prefs.version_ordering(VersionOrdering::MinimumVersionsFirst)
     }
@@ -213,6 +266,26 @@ pub fn resolve_with_global_context_raw(
     resolve
 }
 
+/// Build [`VersionPreferences`] that reproduce a previous resolution, modeling
+/// an existing `Cargo.lock` (and `cargo update -p <crate>`) at the resolver
+/// level.
+///
+/// Every previously selected package is preferred via
+/// [`VersionPreferences::prefer_package_id`], *except* those whose name is in
+/// `unlock`. Passing an empty `unlock` models building against an untouched lock
+/// (everything kept); passing a single name models `cargo update -p <name>`
+/// (that crate is free to move, the rest are pinned).
+pub fn prefs_from_lock(resolve: &Resolve, unlock: &[&str]) -> VersionPreferences {
+    let mut prefs = VersionPreferences::default();
+    for id in resolve.iter() {
+        if unlock.contains(&id.name().as_str()) {
+            continue;
+        }
+        prefs.prefer_package_id(id);
+    }
+    prefs
+}
+
 /// By default `Summary` and `Dependency` have a very verbose `Debug` representation.
 /// This replaces with a representation that uses constructors from this file.
 ///

crates/resolver-tests/tests/pubgrub_graph.rs

@@ -0,0 +1,114 @@
+//! Compares the full resolved dependency *graph* (edges, not just the package
+//! set) produced by the pubgrub resolver against the default resolver.
+
+use std::collections::BTreeSet;
+
+use cargo::resolver::Resolve;
+use cargo::workspace::{Dependency, Summary};
+use cargo::util::GlobalContext;
+
+use resolver_tests::{
+    helpers::{ToDep, dep, pkg, pkg_dep, pkg_dep_with, pkg_id, registry},
+    resolve_with_global_context_raw,
+};
+
+fn pubgrub_gctx() -> GlobalContext {
+    let mut gctx = GlobalContext::default().unwrap();
+    gctx.nightly_features_allowed = true;
+    gctx.configure(
+        0,
+        false,
+        None,
+        false,
+        false,
+        false,
+        &None,
+        &["pubgrub-resolver".to_string()],
+        &[],
+    )
+    .unwrap();
+    gctx
+}
+
+fn edges(r: &Resolve) -> BTreeSet<(String, String)> {
+    let mut e = BTreeSet::new();
+    for p in r.iter() {
+        for (dp, _) in r.deps(p) {
+            e.insert((
+                format!("{}/{}", p.name(), p.version()),
+                format!("{}/{}", dp.name(), dp.version()),
+            ));
+        }
+    }
+    e
+}
+
+#[track_caller]
+fn assert_same_graph(deps: Vec<Dependency>, reg: &[Summary]) {
+    let default = resolve_with_global_context_raw(
+        deps.clone(),
+        reg,
+        pkg_id("root"),
+        &GlobalContext::default().unwrap(),
+    );
+    let pubgrub = resolve_with_global_context_raw(deps, reg, pkg_id("root"), &pubgrub_gctx());
+    match (default, pubgrub) {
+        (Ok(d), Ok(p)) => {
+            let de = edges(&d);
+            let pe = edges(&p);
+            let missing: Vec<_> = de.difference(&pe).collect();
+            let extra: Vec<_> = pe.difference(&de).collect();
+            assert!(
+                missing.is_empty() && extra.is_empty(),
+                "graph mismatch:\n  missing in pubgrub: {missing:?}\n  extra in pubgrub: {extra:?}",
+            );
+        }
+        (Err(_), Err(_)) => {}
+        (d, p) => panic!(
+            "resolvers disagree on solvability: default={:?} pubgrub={:?}",
+            d.is_ok(),
+            p.is_ok()
+        ),
+    }
+}
+
+/// An optional dependency that IS activated (via `features = [..]` on the dep)
+/// must appear as an edge.
+#[test]
+fn activated_optional_edge_present() {
+    let reg = registry(vec![
+        pkg(("serde", "1.0.0")),
+        pkg_dep_with("bstr", vec!["serde".opt()], &[]),
+        pkg_dep(("consumer", "1.0.0"), vec!["bstr".with(&["serde"])]),
+    ]);
+    assert_same_graph(vec![dep("consumer")], &reg);
+}
+
+/// A weak dependency feature (`dep?/feat`) on an enabled feature still records
+/// the optional dependency as an edge in the lock graph (mirrors bstr's
+/// `std = ["serde?/std"]`), matching Cargo's v1 lock resolver.
+#[test]
+fn weak_dep_feature_records_edge() {
+    let reg = registry(vec![
+        pkg_dep_with("serde", vec![], &[("std", &[])]),
+        pkg_dep_with("bstr", vec!["serde".opt()], &[("std", &["serde?/std"])]),
+        pkg_dep(("consumer", "1.0.0"), vec!["bstr".with(&["std"])]),
+    ]);
+    assert_same_graph(vec![dep("consumer")], &reg);
+}
+
+/// An optional dependency that is NOT activated must NOT create an edge, even
+/// if its target is otherwise present in the lock (regression for the
+/// schemars->url cycle).
+#[test]
+fn unactivated_optional_edge_absent() {
+    let reg = registry(vec![
+        // b optionally depends on a, but that optional dep is never enabled.
+        pkg_dep_with("b", vec!["a".opt()], &[]),
+        // a depends on b normally; a is also independently in the graph.
+        pkg_dep(("a", "1.0.0"), vec![dep("b")]),
+    ]);
+    // Resolving `a` pulls in b; b's optional `a` is not enabled, so there must
+    // be no b->a edge (which would be a cycle).
+    assert_same_graph(vec![dep("a")], &reg);
+}