.

crates/pypi-types/src/requirement.rs

@@ -8,7 +8,9 @@ use pep508_rs::{MarkerEnvironment, MarkerTree, RequirementOrigin, VerbatimUrl, V
 use uv_git::{GitReference, GitSha};
 use uv_normalize::{ExtraName, PackageName};
 
-use crate::{ParsedUrl, VerbatimParsedUrl};
+use crate::{
+    ParsedArchiveUrl, ParsedDirectoryUrl, ParsedGitUrl, ParsedPathUrl, ParsedUrl, VerbatimParsedUrl,
+};
 
 /// A representation of dependency on a package, an extension over a PEP 508's requirement.
 ///
@@ -251,6 +253,66 @@ impl RequirementSource {
         }
     }
 
+    pub fn to_verbatim_parsed_url(&self) -> Option<VerbatimParsedUrl> {
+        Some(match &self {
+            Self::Registry { .. } => {
+                return None;
+            }
+            Self::Url {
+                subdirectory,
+                location,
+                url,
+            } => VerbatimParsedUrl {
+                parsed_url: ParsedUrl::Archive(ParsedArchiveUrl::from_source(
+                    location.clone(),
+                    subdirectory.clone(),
+                )),
+                verbatim: url.clone(),
+            },
+            Self::Path {
+                install_path,
+                lock_path,
+                url,
+            } => VerbatimParsedUrl {
+                parsed_url: ParsedUrl::Path(ParsedPathUrl::from_source(
+                    install_path.clone(),
+                    lock_path.clone(),
+                    url.to_url(),
+                )),
+                verbatim: url.clone(),
+            },
+            Self::Directory {
+                install_path,
+                lock_path,
+                editable,
+                url,
+            } => VerbatimParsedUrl {
+                parsed_url: ParsedUrl::Directory(ParsedDirectoryUrl::from_source(
+                    install_path.clone(),
+                    lock_path.clone(),
+                    *editable,
+                    url.to_url(),
+                )),
+                verbatim: url.clone(),
+            },
+            Self::Git {
+                repository,
+                reference,
+                precise,
+                subdirectory,
+                url,
+            } => VerbatimParsedUrl {
+                parsed_url: ParsedUrl::Git(ParsedGitUrl::from_source(
+                    repository.clone(),
+                    reference.clone(),
+                    *precise,
+                    subdirectory.clone(),
+                )),
+                verbatim: url.clone(),
+            },
+        })
+    }
+
     /// Returns `true` if the source is editable.
     pub fn is_editable(&self) -> bool {
         matches!(self, Self::Directory { editable: true, .. })

crates/uv-resolver/src/error.rs

@@ -9,11 +9,12 @@ use rustc_hash::{FxHashMap, FxHashSet};
 
 use distribution_types::{BuiltDist, IndexLocations, InstalledDist, SourceDist};
 use pep440_rs::Version;
-use pep508_rs::Requirement;
+use pep508_rs::{MarkerTree, Requirement};
 use uv_normalize::PackageName;
 
 use crate::candidate_selector::CandidateSelector;
 use crate::dependency_provider::UvDependencyProvider;
+use crate::fork_urls::ForkUrls;
 use crate::pubgrub::{
     PubGrubPackage, PubGrubPackageInner, PubGrubReportFormatter, PubGrubSpecifierError,
 };
@@ -48,11 +49,18 @@ pub enum ResolveError {
     #[error(transparent)]
     PubGrubSpecifier(#[from] PubGrubSpecifierError),
 
-    #[error("Requirements contain conflicting URLs for package `{0}`:\n- {1}\n- {2}")]
-    ConflictingUrlsDirect(PackageName, String, String),
+    #[error("Overrides contain conflicting URLs for package `{0}`:\n- {1}\n- {2}")]
+    ConflictingOverrideUrls(PackageName, String, String),
 
-    #[error("There are conflicting URLs for package `{0}`:\n- {1}\n- {2}")]
-    ConflictingUrlsTransitive(PackageName, String, String),
+    #[error("Requirements contain conflicting URLs for package `{0}`:\n- {}", _1.join("\n- "))]
+    ConflictingUrls(PackageName, Vec<String>),
+
+    #[error("Requirements contain conflicting URLs for package `{package_name}` in split `{fork_markers}`:\n- {}", urls.join("\n- "))]
+    ConflictingUrlsInFork {
+        package_name: PackageName,
+        urls: Vec<String>,
+        fork_markers: MarkerTree,
+    },
 
     #[error("Package `{0}` attempted to resolve via URL: {1}. URL dependencies must be expressed as direct requirements or constraints. Consider adding `{0} @ {1}` to your dependencies or constraints file.")]
     DisallowedUrl(PackageName, String),
@@ -178,6 +186,7 @@ impl From<pubgrub::error::PubGrubError<UvDependencyProvider>> for ResolveError {
                     index_locations: None,
                     unavailable_packages: FxHashMap::default(),
                     incomplete_packages: FxHashMap::default(),
+                    fork_urls: ForkUrls::default(),
                 })
             }
             pubgrub::error::PubGrubError::SelfDependency { package, version } => {
@@ -200,6 +209,7 @@ pub struct NoSolutionError {
     index_locations: Option<IndexLocations>,
     unavailable_packages: FxHashMap<PackageName, UnavailablePackage>,
     incomplete_packages: FxHashMap<PackageName, BTreeMap<Version, IncompletePackage>>,
+    fork_urls: ForkUrls,
 }
 
 impl std::error::Error for NoSolutionError {}
@@ -222,6 +232,7 @@ impl std::fmt::Display for NoSolutionError {
             &self.index_locations,
             &self.unavailable_packages,
             &self.incomplete_packages,
+            &self.fork_urls,
         ) {
             write!(f, "\n\n{hint}")?;
         }

crates/uv-resolver/src/fork_urls.rs

@@ -0,0 +1,57 @@
+use std::collections::hash_map::Entry;
+
+use rustc_hash::FxHashMap;
+
+use distribution_types::Verbatim;
+use pep508_rs::MarkerTree;
+use pypi_types::VerbatimParsedUrl;
+use uv_normalize::PackageName;
+
+use crate::ResolveError;
+
+/// See [`crate::resolver::SolveState`].
+#[derive(Default, Debug, Clone)]
+pub(crate) struct ForkUrls(FxHashMap<PackageName, VerbatimParsedUrl>);
+
+impl ForkUrls {
+    /// Get the URL previously used for a package in this fork.
+    pub(crate) fn get(&self, package_name: &PackageName) -> Option<&VerbatimParsedUrl> {
+        self.0.get(package_name)
+    }
+
+    /// Check that this is the only URL used for this package in this fork.
+    pub(crate) fn insert(
+        &mut self,
+        package_name: &PackageName,
+        url: &VerbatimParsedUrl,
+        fork_markers: &MarkerTree,
+    ) -> Result<(), ResolveError> {
+        match self.0.entry(package_name.clone()) {
+            Entry::Occupied(previous) => {
+                if previous.get() != url {
+                    let mut conflicting_url = vec![
+                        previous.get().verbatim.verbatim().to_string(),
+                        url.to_string(),
+                    ];
+                    conflicting_url.sort();
+                    return if fork_markers == &MarkerTree::And(Vec::new()) {
+                        Err(ResolveError::ConflictingUrls(
+                            package_name.clone(),
+                            conflicting_url,
+                        ))
+                    } else {
+                        Err(ResolveError::ConflictingUrlsInFork {
+                            package_name: package_name.clone(),
+                            urls: conflicting_url,
+                            fork_markers: fork_markers.clone(),
+                        })
+                    };
+                }
+            }
+            Entry::Vacant(vacant) => {
+                vacant.insert(url.clone());
+            }
+        }
+        Ok(())
+    }
+}

crates/uv-resolver/src/lib.rs

@@ -30,6 +30,7 @@ mod error;
 mod exclude_newer;
 mod exclusions;
 mod flat_index;
+mod fork_urls;
 mod lock;
 mod manifest;
 mod marker;

crates/uv-resolver/src/manifest.rs

@@ -97,6 +97,16 @@ impl Manifest {
         &'a self,
         markers: Option<&'a MarkerEnvironment>,
         mode: DependencyMode,
+    ) -> impl Iterator<Item = &Requirement> + 'a {
+        self.requirements_no_overrides(markers, mode)
+            .chain(self.overrides(markers, mode))
+    }
+
+    /// Like [`Self::requirements`], but without the overrides.
+    pub fn requirements_no_overrides<'a>(
+        &'a self,
+        markers: Option<&'a MarkerEnvironment>,
+        mode: DependencyMode,
     ) -> impl Iterator<Item = &Requirement> + 'a {
         match mode {
             // Include all direct and transitive requirements, with constraints and overrides applied.
@@ -119,19 +129,35 @@ impl Manifest {
                         self.constraints
                             .requirements()
                             .filter(move |requirement| requirement.evaluate_markers(markers, &[])),
-                    )
-                    .chain(
-                        self.overrides
-                            .requirements()
-                            .filter(move |requirement| requirement.evaluate_markers(markers, &[])),
                     ),
             ),
             // Include direct requirements, with constraints and overrides applied.
             DependencyMode::Direct => Either::Right(
                 self.overrides
                     .apply(&self.requirements)
                     .chain(self.constraints.requirements())
-                    .chain(self.overrides.requirements())
+                    .filter(move |requirement| requirement.evaluate_markers(markers, &[])),
+            ),
+        }
+    }
+
+    /// Only the overrides from [`Self::requirements`].
+    pub fn overrides<'a>(
+        &'a self,
+        markers: Option<&'a MarkerEnvironment>,
+        mode: DependencyMode,
+    ) -> impl Iterator<Item = &Requirement> + 'a {
+        match mode {
+            // Include all direct and transitive requirements, with constraints and overrides applied.
+            DependencyMode::Transitive => Either::Left(
+                self.overrides
+                    .requirements()
+                    .filter(move |requirement| requirement.evaluate_markers(markers, &[])),
+            ),
+            // Include direct requirements, with constraints and overrides applied.
+            DependencyMode::Direct => Either::Right(
+                self.overrides
+                    .requirements()
                     .filter(move |requirement| requirement.evaluate_markers(markers, &[])),
             ),
         }