From e486eb86b7b95c0d26ebcbdb14f66b18bcced81c Mon Sep 17 00:00:00 2001
From: konsti <konstin@mailbox.org>
Date: Tue, 18 Jun 2024 18:47:06 +0200
Subject: [PATCH] Log when we fork (#4386)

We currently don't log if or when we split the resolution graphs into
forks. I ran into this when trying to debug missing forking.
---
 crates/uv-resolver/src/resolver/mod.rs | 28 ++++++++++++++++++++++----
 1 file changed, 24 insertions(+), 4 deletions(-)

diff --git a/crates/uv-resolver/src/resolver/mod.rs b/crates/uv-resolver/src/resolver/mod.rs
index f8278a86d..c136ca1c5 100644
--- a/crates/uv-resolver/src/resolver/mod.rs
+++ b/crates/uv-resolver/src/resolver/mod.rs
@@ -544,7 +544,18 @@ impl<InstalledPackages: InstalledPackagesProvider> ResolverState<InstalledPackag
                             );
                             forked_states.push(state);
                         }
-                        ForkedDependencies::Forked(forks) => {
+                        ForkedDependencies::Forked {
+                            forks,
+                            diverging_packages,
+                        } => {
+                            debug!(
+                                "Splitting resolution on {} over {}",
+                                state.next,
+                                diverging_packages
+                                    .iter()
+                                    .map(ToString::to_string)
+                                    .join(", ")
+                            );
                             assert!(forks.len() >= 2);
                             // This is a somewhat tortured technique to ensure
                             // that our resolver state is only cloned as much
@@ -1996,7 +2007,8 @@ impl Dependencies {
             dependencies: vec![],
             markers: MarkerTree::And(vec![]),
         }];
-        for (_, possible_forks) in by_name {
+        let mut diverging_packages = Vec::new();
+        for (name, possible_forks) in by_name {
             let fork_groups = match possible_forks {
                 PossibleForks::PossiblyForking(fork_groups) => fork_groups,
                 PossibleForks::NoForkPossible(indices) => {
@@ -2028,8 +2040,12 @@ impl Dependencies {
                 new_forks.extend(new_forks_for_group);
             }
             forks = new_forks;
+            diverging_packages.push(name.clone());
+        }
+        ForkedDependencies::Forked {
+            forks,
+            diverging_packages,
         }
-        ForkedDependencies::Forked(forks)
     }
 }
 
@@ -2052,7 +2068,11 @@ enum ForkedDependencies {
     /// Note that there is always at least two forks. If there would
     /// be fewer than 2 forks, then there is no fork at all and the
     /// `Unforked` variant is used instead.
-    Forked(Vec<Fork>),
+    Forked {
+        forks: Vec<Fork>,
+        /// The package(s) with different requirements for disjoint markers.
+        diverging_packages: Vec<PackageName>,
+    },
 }
 
 /// A single fork in a list of dependencies.