feat: emit a warning when both package.publish and --index are specified

Author: motorailgun

src/cargo/ops/registry/publish.rs

@@ -126,26 +126,7 @@ pub fn publish(ws: &Workspace<'_>, opts: &PublishOpts<'_>) -> CargoResult<()> {
     }
 
     let just_pkgs: Vec<_> = pkgs.iter().map(|p| p.0).collect();
-    let reg_or_index = match opts.reg_or_index.clone() {
-        Some(r) => {
-            validate_registry(&just_pkgs, Some(&r))?;
-            Some(r)
-        }
-        None => {
-            let reg = super::infer_registry(&just_pkgs)?;
-            validate_registry(&just_pkgs, reg.as_ref())?;
-            if let Some(RegistryOrIndex::Registry(registry)) = &reg {
-                if registry != CRATES_IO_REGISTRY {
-                    // Don't warn for crates.io.
-                    opts.gctx.shell().note(&format!(
-                        "found `{}` as only allowed registry. Publishing to it automatically.",
-                        registry
-                    ))?;
-                }
-            }
-            reg
-        }
-    };
+    let reg_or_index = resolve_registory_or_index(opts, &just_pkgs)?;
 
     // This is only used to confirm that we can create a token before we build the package.
     // This causes the credential provider to be called an extra time, but keeps the same order of errors.
@@ -814,6 +795,55 @@ fn package_list(pkgs: impl IntoIterator<Item = PackageId>, final_sep: &str) -> S
     }
 }
 
+fn resolve_registory_or_index(
+    opts: &PublishOpts<'_>,
+    pkgs: &[&Package],
+) -> CargoResult<Option<RegistryOrIndex>> {
+    let opt_index_or_registry = opts.reg_or_index.clone();
+    let registry_is_specified_by_any_package = pkgs
+        .iter()
+        .any(|pkg| pkg.publish().as_ref().map(|v| v.len()).unwrap_or(0) > 0);
+
+    let res = match (opt_index_or_registry, registry_is_specified_by_any_package) {
+        // both `package.publish` and `--index` or `--registry` are specified
+        (Some(opt_reg_or_index), true) => {
+            validate_registry(pkgs, Some(&opt_reg_or_index))?;
+
+            match opt_reg_or_index {
+                r @ RegistryOrIndex::Registry(_) => Some(r),
+                r @ RegistryOrIndex::Index(_) => {
+                    opts.gctx.shell().warn(r#"`--index` will ignore registries set by `package.publish` in Cargo.toml, and may cause unexpected push to prohibited registry
+help: use `--registry` instead or set `publish = true` in Cargo.toml to suppress this warning"#)?;
+
+                    Some(r)
+                }
+            }
+        }
+        // only `package.publish` section
+        (None, true) => {
+            let registry_or_index = super::infer_registry(pkgs)?;
+            if let Some(RegistryOrIndex::Registry(ref registry)) = registry_or_index
+                && registry != CRATES_IO_REGISTRY
+            {
+                // Don't warn for crates.io.
+                opts.gctx.shell().note(&format!(
+                    "found `{}` as only allowed registry. Publishing to it automatically.",
+                    registry
+                ))?;
+            }
+
+            registry_or_index
+        }
+        (Some(opt_reg), false) => {
+            validate_registry(pkgs, Some(&opt_reg))?;
+            Some(opt_reg)
+        }
+        (None, false) => None,
+    };
+
+    Ok(res)
+}
+
 fn validate_registry(pkgs: &[&Package], reg_or_index: Option<&RegistryOrIndex>) -> CargoResult<()> {
     let reg_name = match reg_or_index {
         Some(RegistryOrIndex::Registry(r)) => Some(r.as_str()),

tests/testsuite/publish.rs

@@ -979,6 +979,51 @@ fn publish_implicitly_to_only_allowed_registry() {
     );
 }
 
+#[cargo_test]
+fn publish_warn_when_both_publish_and_index_specified() {
+    let registry = RegistryBuilder::new()
+        .http_api()
+        .http_index()
+        .alternative()
+        .build();
+
+    let p = project().build();
+
+    let _ = repo(&paths::root().join("foo"))
+        .file(
+            "Cargo.toml",
+            r#"
+                [package]
+                name = "foo"
+                version = "0.0.1"
+                edition = "2015"
+                authors = []
+                license = "MIT"
+                description = "foo"
+                documentation = "foo"
+                homepage = "foo"
+                repository = "foo"
+                publish = ["registry"]
+            "#,
+        )
+        .file("src/main.rs", "fn main() {}")
+        .build();
+
+    p.cargo("publish")
+        .arg("--index")
+        .arg(registry.index_url().as_str())
+        .arg("--token")
+        .arg(registry.token())
+        .with_stderr_data(str![[r#"
+...
+[WARNING] `--index` will ignore registries set by `package.publish` in Cargo.toml, and may cause unexpected push to prohibited registry
+[HELP] use `--registry` instead or set `publish = true` in Cargo.toml to suppress this warning
+...
+[PUBLISHED] foo v0.0.1 at registry [..]
+"#]])
+        .run();
+}
+
 #[cargo_test]
 fn publish_failed_with_index_and_only_allowed_registry() {
     let registry = RegistryBuilder::new()
@@ -1014,6 +1059,7 @@ fn publish_failed_with_index_and_only_allowed_registry() {
         .arg(registry.index_url().as_str())
         .with_status(101)
         .with_stderr_data(str![[r#"
+...
 [ERROR] command-line argument --index requires --token to be specified
 
 "#]])