Move infer_registry into a more public spot

Author: jneem

src/cargo/ops/cargo_package.rs

@@ -14,7 +14,7 @@ use crate::core::resolver::HasDevUnits;
 use crate::core::{Feature, PackageIdSpecQuery, Shell, Verbosity, Workspace};
 use crate::core::{Package, PackageId, PackageSet, Resolve, SourceId};
 use crate::ops::lockfile::LOCKFILE_NAME;
-use crate::ops::registry::RegistryOrIndex;
+use crate::ops::registry::{infer_registry, RegistryOrIndex};
 use crate::sources::registry::index::{IndexPackage, RegistryDependency};
 use crate::sources::{PathSource, SourceConfigMap, CRATES_IO_REGISTRY};
 use crate::util::cache_lock::CacheLockMode;
@@ -174,45 +174,6 @@ fn create_package(
     return Ok(dst);
 }
 
-/// If this set of packages has an unambiguous publish registry, find it.
-pub(crate) fn infer_registry(pkgs: &[&Package]) -> CargoResult<Option<RegistryOrIndex>> {
-    if pkgs[1..].iter().all(|p| p.publish() == pkgs[0].publish()) {
-        // If all packages have the same publish settings, we take that as the default.
-        match pkgs[0].publish().as_deref() {
-            Some([unique_pkg_reg]) => {
-                Ok(Some(RegistryOrIndex::Registry(unique_pkg_reg.to_owned())))
-            }
-            None | Some([]) => Ok(None),
-            Some(regs) => {
-                let mut regs: Vec<_> = regs.iter().map(|s| format!("\"{}\"", s)).collect();
-                regs.sort();
-                regs.dedup();
-                // unwrap: the match block ensures that there's more than one reg.
-                let (last_reg, regs) = regs.split_last().unwrap();
-                bail!(
-                    "--registry is required to disambiguate between {} or {} registries",
-                    regs.join(", "),
-                    last_reg
-                )
-            }
-        }
-    } else {
-        let common_regs = pkgs
-            .iter()
-            // `None` means "all registries", so drop them instead of including them
-            // in the intersection.
-            .filter_map(|p| p.publish().as_deref())
-            .map(|p| p.iter().collect::<HashSet<_>>())
-            .reduce(|xs, ys| xs.intersection(&ys).cloned().collect())
-            .unwrap_or_default();
-        if common_regs.is_empty() {
-            bail!("conflicts between `package.publish` fields in the selected packages");
-        } else {
-            bail!("--registry is required because not all `package.publish` settings agree",);
-        }
-    }
-}
-
 /// Packages an entire workspace.
 ///
 /// Returns the generated package files. If `opts.list` is true, skips

src/cargo/ops/registry/mod.rs

@@ -19,7 +19,7 @@ use cargo_credential::{Operation, Secret};
 use crates_io::Registry;
 use url::Url;
 
-use crate::core::{PackageId, SourceId};
+use crate::core::{Package, PackageId, SourceId};
 use crate::sources::source::Source;
 use crate::sources::{RegistrySource, SourceConfigMap};
 use crate::util::auth;
@@ -322,3 +322,42 @@ pub(crate) struct RegistrySourceIds {
     /// User-defined source replacement is not applied.
     pub(crate) replacement: SourceId,
 }
+
+/// If this set of packages has an unambiguous publish registry, find it.
+pub(crate) fn infer_registry(pkgs: &[&Package]) -> CargoResult<Option<RegistryOrIndex>> {
+    if pkgs[1..].iter().all(|p| p.publish() == pkgs[0].publish()) {
+        // If all packages have the same publish settings, we take that as the default.
+        match pkgs[0].publish().as_deref() {
+            Some([unique_pkg_reg]) => {
+                Ok(Some(RegistryOrIndex::Registry(unique_pkg_reg.to_owned())))
+            }
+            None | Some([]) => Ok(None),
+            Some(regs) => {
+                let mut regs: Vec<_> = regs.iter().map(|s| format!("\"{}\"", s)).collect();
+                regs.sort();
+                regs.dedup();
+                // unwrap: the match block ensures that there's more than one reg.
+                let (last_reg, regs) = regs.split_last().unwrap();
+                bail!(
+                    "--registry is required to disambiguate between {} or {} registries",
+                    regs.join(", "),
+                    last_reg
+                )
+            }
+        }
+    } else {
+        let common_regs = pkgs
+            .iter()
+            // `None` means "all registries", so drop them instead of including them
+            // in the intersection.
+            .filter_map(|p| p.publish().as_deref())
+            .map(|p| p.iter().collect::<HashSet<_>>())
+            .reduce(|xs, ys| xs.intersection(&ys).cloned().collect())
+            .unwrap_or_default();
+        if common_regs.is_empty() {
+            bail!("conflicts between `package.publish` fields in the selected packages");
+        } else {
+            bail!("--registry is required because not all `package.publish` settings agree",);
+        }
+    }
+}