A dep is equivalent to one of the things it can resolve to.

Thus, if all the things it can resolve to have already ben determined
to be conflicting, then we can just say that we conflict with the parent.

Author: Eh2406

src/cargo/core/resolver/conflict_cache.rs

@@ -102,6 +102,28 @@ impl ConflictStoreTrie {
             *self = ConflictStoreTrie::Leaf(con)
         }
     }
+
+    fn contains(&self, mut iter: impl Iterator<Item = PackageId>, con: &ConflictMap) -> bool {
+        match (self, iter.next()) {
+            (ConflictStoreTrie::Leaf(c), None) => {
+                if cfg!(debug_assertions) {
+                    let a: Vec<_> = con.keys().collect();
+                    let b: Vec<_> = c.keys().collect();
+                    assert_eq!(a, b);
+                }
+                true
+            }
+            (ConflictStoreTrie::Leaf(_), Some(_)) => false,
+            (ConflictStoreTrie::Node(_), None) => false,
+            (ConflictStoreTrie::Node(m), Some(n)) => {
+                if let Some(next) = m.get(&n) {
+                    next.contains(iter, con)
+                } else {
+                    false
+                }
+            }
+        }
+    }
 }
 
 pub(super) struct ConflictCache {
@@ -206,6 +228,18 @@ impl ConflictCache {
                 .insert(dep.clone());
         }
     }
+
+    /// Check if a conflict was previously added of the form:
+    /// `dep` is known to be unresolvable if
+    /// all the `PackageId` entries are activated.
+    pub fn contains(&self, dep: &Dependency, con: &ConflictMap) -> bool {
+        if let Some(cst) = self.con_from_dep.get(dep) {
+            cst.contains(con.keys().cloned(), &con)
+        } else {
+            false
+        }
+    }
+
     pub fn dependencies_conflicting_with(&self, pid: PackageId) -> Option<&HashSet<Dependency>> {
         self.dep_from_pid.get(&pid)
     }

src/cargo/core/resolver/mod.rs

@@ -299,6 +299,15 @@ fn activate_deps_loop(
                 // not be right, so we can't push into our global cache.
                 if !just_here_for_the_error_messages && !backtracked {
                     past_conflicting_activations.insert(&dep, &conflicting_activations);
+                    if let Some(c) = generalize_conflicting(
+                        &cx,
+                        registry,
+                        &mut past_conflicting_activations,
+                        &dep,
+                        &conflicting_activations,
+                    ) {
+                        conflicting_activations = c;
+                    }
                 }
 
                 match find_candidate(
@@ -842,6 +851,62 @@ impl RemainingCandidates {
     }
 }
 
+/// Attempts to find a new conflict that allows a bigger backjump then the input one.
+/// It will add the new conflict to the cache if one is found.
+///
+/// Panics if the input conflict is not all active in `cx`.
+fn generalize_conflicting(
+    cx: &Context,
+    registry: &mut RegistryQueryer<'_>,
+    past_conflicting_activations: &mut conflict_cache::ConflictCache,
+    dep: &Dependency,
+    conflicting_activations: &ConflictMap,
+) -> Option<ConflictMap> {
+    if conflicting_activations.is_empty() {
+        return None;
+    }
+    // We need to determine the "age" that this `conflicting_activations` will jump to, and why.
+    let (jumpback_critical_age, jumpback_critical_id) = conflicting_activations
+        .keys()
+        .map(|&c| (cx.is_active(c).expect("not currently active!?"), c))
+        .max()
+        .unwrap();
+    let jumpback_critical_reason: ConflictReason =
+        conflicting_activations[&jumpback_critical_id].clone();
+    // What parents dose that critical activation have
+    for (critical_parent, critical_parents_deps) in
+        cx.parents.edges(&jumpback_critical_id).filter(|(p, _)| {
+            // it will only help backjump further if it is older then the critical_age
+            cx.is_active(*p).expect("parent not currently active!?") < jumpback_critical_age
+        })
+    {
+        for critical_parents_dep in critical_parents_deps.iter() {
+            // A dep is equivalent to one of the things it can resolve to.
+            // Thus, if all the things it can resolve to have already ben determined
+            // to be conflicting, then we can just say that we conflict with the parent.
+            if registry
+                .query(&critical_parents_dep)
+                .expect("an already used dep now error!?")
+                .iter()
+                .rev() // the last one to be tried is the least likely to be in the cache, so start with that.
+                .all(|other| {
+                    let mut con = conflicting_activations.clone();
+                    con.remove(&jumpback_critical_id);
+                    con.insert(other.summary.package_id(), jumpback_critical_reason.clone());
+                    past_conflicting_activations.contains(&dep, &con)
+                })
+            {
+                let mut con = conflicting_activations.clone();
+                con.remove(&jumpback_critical_id);
+                con.insert(*critical_parent, jumpback_critical_reason);
+                past_conflicting_activations.insert(&dep, &con);
+                return Some(con);
+            }
+        }
+    }
+    None
+}
+
 /// Looks through the states in `backtrack_stack` for dependencies with
 /// remaining candidates. For each one, also checks if rolling back
 /// could change the outcome of the failed resolution that caused backtracking

tests/testsuite/resolve.rs

@@ -1345,7 +1345,7 @@ fn large_conflict_cache() {
         pkg!(("last", "0.0.0") => [dep("bad")]), // just to make sure last is less constrained
     ];
     let mut root_deps = vec![dep("last")];
-    const NUM_VERSIONS: u8 = 3;
+    const NUM_VERSIONS: u8 = 20;
     for name in 0..=NUM_VERSIONS {
         // a large number of conflicts can easily be generated by a sys crate.
         let sys_name = format!("{}-sys", (b'a' + name) as char);