publish: report failing crate and remaining unpublished on workspace failure

- Keep single-crate error format unchanged
- Add test for workspace failure messaging

Author: ojuschugh1

src/cargo/ops/registry/publish.rs

@@ -197,6 +197,8 @@ pub fn publish(ws: &Workspace<'_>, opts: &PublishOpts<'_>) -> CargoResult<()> {
     )?;
 
     let mut plan = PublishPlan::new(&pkg_dep_graph.graph);
+    // Store the original list of packages to be published for error reporting
+    let original_packages: BTreeSet<_> = plan.iter().collect();
     // May contains packages from previous rounds as `wait_for_any_publish_confirmation` returns
     // after it confirms any packages, not all packages, requiring us to handle the rest in the next
     // iteration.
@@ -236,47 +238,67 @@ pub fn publish(ws: &Workspace<'_>, opts: &PublishOpts<'_>) -> CargoResult<()> {
                 )?));
             }
 
-            // Always wrap transmit with context for enhanced error reporting
-            let transmit_result = transmit(
-                opts.gctx,
-                ws,
-                pkg,
-                tarball.file(),
-                &mut registry,
-                source_ids.original,
-                opts.dry_run,
-            ).map_err(|e| {
-                // Collect remaining packages that have not been published yet
-                let mut remaining: Vec<_> = plan
-                    .iter()
-                    .filter(|id| *id != pkg_id)
-                    .map(|id| {
+            let transmit_result = if original_packages.len() > 1 {
+                // For workspace publishes, wrap transmit with enhanced error reporting
+                transmit(
+                    opts.gctx,
+                    ws,
+                    pkg,
+                    tarball.file(),
+                    &mut registry,
+                    source_ids.original,
+                    opts.dry_run,
+                ).map_err(|e| {
+                    // Collect remaining packages that have not been published yet
+                    let mut remaining: Vec<_> = original_packages
+                        .iter()
+                        .filter(|id| **id != pkg_id)
+                        .map(|id| {
+                            let pkg = &pkg_dep_graph.packages[&id].0;
+                            format!("{} v{}", pkg.name(), pkg.version())
+                        })
+                        .collect();
+                    // Also include any packages that are still waiting for confirmation
+                    for id in to_confirm.iter().filter(|id| **id != pkg_id) {
                         let pkg = &pkg_dep_graph.packages[&id].0;
-                        format!("{} v{}", pkg.name(), pkg.version())
-                    })
-                    .collect();
-                // Also include any packages that are still waiting for confirmation
-                for id in to_confirm.iter().filter(|id| **id != pkg_id) {
-                    let pkg = &pkg_dep_graph.packages[&id].0;
-                    let entry = format!("{} v{}", pkg.name(), pkg.version());
-                    if !remaining.contains(&entry) {
-                        remaining.push(entry);
+                        let entry = format!("{} v{}", pkg.name(), pkg.version());
+                        if !remaining.contains(&entry) {
+                            remaining.push(entry);
+                        }
                     }
-                }
 
-                let message = if !remaining.is_empty() {
-                    format!(
-                        "failed to publish `{}` v{}; the following crates have not been published yet: {}",
+                    let message = if !remaining.is_empty() {
+                        format!(
+                            "failed to publish `{}` v{}; the following crates have not been published yet: {}",
+                            pkg.name(),
+                            pkg.version(),
+                            remaining.join(", ")
+                        )
+                    } else {
+                        format!("failed to publish `{}` v{}", pkg.name(), pkg.version())
+                    };
+
+                    e.context(message)
+                })
+            } else {
+                // For single package publishes, preserve original top-level error message with package name
+                transmit(
+                    opts.gctx,
+                    ws,
+                    pkg,
+                    tarball.file(),
+                    &mut registry,
+                    source_ids.original,
+                    opts.dry_run,
+                )
+                .map_err(|e| {
+                    e.context(format!(
+                        "failed to publish `{}` v{}",
                         pkg.name(),
-                        pkg.version(),
-                        remaining.join(", ")
-                    )
-                } else {
-                    format!("failed to publish `{}` v{}", pkg.name(), pkg.version())
-                };
-
-                e.context(message)
-            });
+                        pkg.version()
+                    ))
+                })
+            };
 
             if let Err(e) = transmit_result {
                 return Err(e);

tests/testsuite/publish.rs

@@ -4351,6 +4351,38 @@ fn all_unpublishable_packages() {
 #[cargo_test]
 fn workspace_publish_failure_reports_remaining_packages() {
     use cargo_test_support::project;
+    use cargo_test_support::registry::RegistryBuilder;
+
+    // Create a registry that will fail for package 'a' but succeed for others
+    let _registry = RegistryBuilder::new()
+        .alternative()
+        .http_api()
+        .add_responder("/api/v1/crates/new", |req, _| {
+            if let Some(body) = &req.body {
+                let body_str = String::from_utf8_lossy(body);
+                if body_str.contains("\"name\":\"a\"") {
+                    Response {
+                        body: b"{\"errors\":[{\"detail\":\"crate [email protected] already exists on crates.io index\"}]}".to_vec(),
+                        code: 400,
+                        headers: vec!["Content-Type: application/json".to_string()],
+                    }
+                } else {
+                    Response {
+                        body: b"{\"ok\":true}".to_vec(),
+                        code: 200,
+                        headers: vec!["Content-Type: application/json".to_string()],
+                    }
+                }
+            } else {
+                Response {
+                    body: b"{\"ok\":true}".to_vec(),
+                    code: 200,
+                    headers: vec!["Content-Type: application/json".to_string()],
+                }
+            }
+        })
+        .build();
+
     let p = project()
         .file(
             "Cargo.toml",
@@ -4366,6 +4398,9 @@ fn workspace_publish_failure_reports_remaining_packages() {
             name = "a"
             version = "0.1.0"
             edition = "2021"
+            authors = []
+            license = "MIT"
+            description = "Package A"
         "#,
         )
         .file("a/src/lib.rs", "")
@@ -4376,6 +4411,9 @@ fn workspace_publish_failure_reports_remaining_packages() {
             name = "b"
             version = "0.1.0"
             edition = "2021"
+            authors = []
+            license = "MIT"
+            description = "Package B"
         "#,
         )
         .file("b/src/lib.rs", "")
@@ -4386,17 +4424,55 @@ fn workspace_publish_failure_reports_remaining_packages() {
             name = "c"
             version = "0.1.0"
             edition = "2021"
+            authors = []
+            license = "MIT"
+            description = "Package C"
         "#,
         )
         .file("c/src/lib.rs", "")
         .build();
 
-    // Simulate a publish failure for package 'a' (e.g., already published)
-    // The error message should match the actual output from the verify step
-    p.cargo("publish --workspace")
-        .env("CARGO_REGISTRY_TOKEN", "dummy-token")
+    // Test that when package 'a' fails to publish, the error message includes
+    // information about which packages remain unpublished
+    p.cargo("publish --workspace --registry alternative")
         .with_status(101)
-        .with_stderr_contains("[ERROR] crate [email protected] already exists on crates.io index")
+        .with_stderr_data(str![[r#"
+[WARNING] virtual workspace defaulting to `resolver = "1"` despite one or more workspace members being on edition 2021 which implies `resolver = "2"`
+[NOTE] to keep the current resolver, specify `workspace.resolver = "1"` in the workspace root's manifest
+[NOTE] to use the edition 2021 resolver, specify `workspace.resolver = "2"` in the workspace root's manifest
+[NOTE] for more details see https://doc.rust-lang.org/cargo/reference/resolver.html#resolver-versions
+[UPDATING] `alternative` index
+[WARNING] manifest has no documentation, homepage or repository.
+See https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info.
+[PACKAGING] a v0.1.0 ([ROOT]/foo/a)
+[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
+[WARNING] manifest has no documentation, homepage or repository.
+See https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info.
+[PACKAGING] b v0.1.0 ([ROOT]/foo/b)
+[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
+[WARNING] manifest has no documentation, homepage or repository.
+See https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info.
+[PACKAGING] c v0.1.0 ([ROOT]/foo/c)
+[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
+[VERIFYING] a v0.1.0 ([ROOT]/foo/a)
+[COMPILING] a v0.1.0 ([ROOT]/foo/target/package/a-0.1.0)
+[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
+[VERIFYING] b v0.1.0 ([ROOT]/foo/b)
+[COMPILING] b v0.1.0 ([ROOT]/foo/target/package/b-0.1.0)
+[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
+[VERIFYING] c v0.1.0 ([ROOT]/foo/c)
+[COMPILING] c v0.1.0 ([ROOT]/foo/target/package/c-0.1.0)
+[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
+[UPLOADING] a v0.1.0 ([ROOT]/foo/a)
+[ERROR] failed to publish `a` v0.1.0; the following crates have not been published yet: b v0.1.0, c v0.1.0
+
+Caused by:
+  failed to publish to registry at http://127.0.0.1:[..]/
+
+Caused by:
+  the remote server responded with an error (status 400 Bad Request): crate [email protected] already exists on crates.io index
+
+"#]])
         .run();
 }