From 8771230eb89f1ec6a8ed38a8296997db99613b26 Mon Sep 17 00:00:00 2001
From: Joe Neeman <joe.neeman@tweag.io>
Date: Thu, 13 Jun 2024 15:10:50 -0500
Subject: [PATCH 1/3] Factor out a function for building a NewCrate.

Co-Authored-By: Tor Hovland <55164+torhovland@users.noreply.github.com>
---
 src/cargo/ops/registry/publish.rs | 75 +++++++++++++++++--------------
 1 file changed, 41 insertions(+), 34 deletions(-)

diff --git a/src/cargo/ops/registry/publish.rs b/src/cargo/ops/registry/publish.rs
index 4ce5e36a50a..ff7653acff3 100644
--- a/src/cargo/ops/registry/publish.rs
+++ b/src/cargo/ops/registry/publish.rs
@@ -321,14 +321,11 @@ fn verify_dependencies(
     Ok(())
 }
 
-fn transmit(
+pub(crate) fn prepare_transmit(
     gctx: &GlobalContext,
     pkg: &Package,
-    tarball: &File,
-    registry: &mut Registry,
     registry_id: SourceId,
-    dry_run: bool,
-) -> CargoResult<()> {
+) -> CargoResult<NewCrate> {
     let deps = pkg
         .dependencies()
         .iter()
@@ -410,12 +407,6 @@ fn transmit(
         }
     }
 
-    // Do not upload if performing a dry run
-    if dry_run {
-        gctx.shell().warn("aborting upload due to dry run")?;
-        return Ok(());
-    }
-
     let deps_set = deps
         .iter()
         .map(|dep| dep.name.clone())
@@ -447,30 +438,46 @@ fn transmit(
         None => BTreeMap::new(),
     };
 
+    Ok(NewCrate {
+        name: pkg.name().to_string(),
+        vers: pkg.version().to_string(),
+        deps,
+        features: string_features,
+        authors: authors.clone(),
+        description: description.clone(),
+        homepage: homepage.clone(),
+        documentation: documentation.clone(),
+        keywords: keywords.clone(),
+        categories: categories.clone(),
+        readme: readme_content,
+        readme_file: readme.clone(),
+        repository: repository.clone(),
+        license: license.clone(),
+        license_file: license_file.clone(),
+        badges: badges.clone(),
+        links: links.clone(),
+        rust_version,
+    })
+}
+
+fn transmit(
+    gctx: &GlobalContext,
+    pkg: &Package,
+    tarball: &File,
+    registry: &mut Registry,
+    registry_id: SourceId,
+    dry_run: bool,
+) -> CargoResult<()> {
+    let new_crate = prepare_transmit(gctx, pkg, registry_id)?;
+
+    // Do not upload if performing a dry run
+    if dry_run {
+        gctx.shell().warn("aborting upload due to dry run")?;
+        return Ok(());
+    }
+
     let warnings = registry
-        .publish(
-            &NewCrate {
-                name: pkg.name().to_string(),
-                vers: pkg.version().to_string(),
-                deps,
-                features: string_features,
-                authors: authors.clone(),
-                description: description.clone(),
-                homepage: homepage.clone(),
-                documentation: documentation.clone(),
-                keywords: keywords.clone(),
-                categories: categories.clone(),
-                readme: readme_content,
-                readme_file: readme.clone(),
-                repository: repository.clone(),
-                license: license.clone(),
-                license_file: license_file.clone(),
-                badges: badges.clone(),
-                links: links.clone(),
-                rust_version,
-            },
-            tarball,
-        )
+        .publish(&new_crate, tarball)
         .with_context(|| format!("failed to publish to registry at {}", registry.host()))?;
 
     if !warnings.invalid_categories.is_empty() {

From cbc836d4b0f6a4fa3b0165970acb5d88a67108aa Mon Sep 17 00:00:00 2001
From: Joe Neeman <joe.neeman@tweag.io>
Date: Thu, 13 Jun 2024 14:30:54 -0500
Subject: [PATCH 2/3] Add tests showing incorrect workspace packaging.

Co-Authored-By: Tor Hovland <55164+torhovland@users.noreply.github.com>
---
 tests/testsuite/package.rs | 632 +++++++++++++++++++++++++++++++++++++
 1 file changed, 632 insertions(+)

diff --git a/tests/testsuite/package.rs b/tests/testsuite/package.rs
index 3ed3c0e2ed9..33731f91599 100644
--- a/tests/testsuite/package.rs
+++ b/tests/testsuite/package.rs
@@ -5076,3 +5076,635 @@ path = "examples/z.rs"
         )],
     );
 }
+
+// A workspace with three projects that depend on one another (level1 -> level2 -> level3).
+// level1 is a binary package, to test lockfile generation.
+#[cargo_test]
+fn workspace_with_local_deps() {
+    let crates_io = registry::init();
+    let p =
+        project()
+            .file(
+                "Cargo.toml",
+                r#"
+            [workspace]
+            members = ["level1", "level2", "level3"]
+
+            [workspace.dependencies]
+            level2 = { path = "level2", version = "0.0.1" }
+        "#
+            )
+            .file(
+                "level1/Cargo.toml",
+                r#"
+            [package]
+            name = "level1"
+            version = "0.0.1"
+            edition = "2015"
+            authors = []
+            license = "MIT"
+            description = "level1"
+            repository = "bar"
+
+            [dependencies]
+            # Let one dependency also specify features, for the added test coverage when generating package files.
+            level2 = { workspace = true, features = ["foo"] }
+        "#,
+            )
+            .file("level1/src/main.rs", "fn main() {}")
+            .file(
+                "level2/Cargo.toml",
+                r#"
+            [package]
+            name = "level2"
+            version = "0.0.1"
+            edition = "2015"
+            authors = []
+            license = "MIT"
+            description = "level2"
+            repository = "bar"
+
+            [features]
+            foo = []
+
+            [dependencies]
+            level3 = { path = "../level3", version = "0.0.1" }
+        "#
+            )
+            .file("level2/src/lib.rs", "")
+            .file(
+                "level3/Cargo.toml",
+                r#"
+            [package]
+            name = "level3"
+            version = "0.0.1"
+            edition = "2015"
+            authors = []
+            license = "MIT"
+            description = "level3"
+            repository = "bar"
+        "#,
+            )
+            .file("level3/src/lib.rs", "")
+            .build();
+
+    p.cargo("package")
+        .replace_crates_io(crates_io.index_url())
+        .with_status(101)
+        .with_stdout_data("")
+        .with_stderr_data(str![[r#"
+[PACKAGING] level1 v0.0.1 ([ROOT]/foo/level1)
+[UPDATING] crates.io index
+[ERROR] failed to prepare local package for uploading
+
+Caused by:
+  no matching package named `level2` found
+  location searched: registry `crates-io`
+  required by package `level1 v0.0.1 ([ROOT]/foo/level1)`
+
+"#]])
+        .run();
+}
+
+#[cargo_test]
+fn workspace_with_local_deps_packaging_one_fails() {
+    let crates_io = registry::init();
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [workspace]
+            members = ["level1", "level2"]
+        "#,
+        )
+        .file(
+            "level1/Cargo.toml",
+            r#"
+            [package]
+            name = "level1"
+            version = "0.0.1"
+            edition = "2015"
+            authors = []
+            license = "MIT"
+            description = "level1"
+            repository = "bar"
+
+            [dependencies]
+            level2 = { path = "../level2", version = "0.0.1" }
+        "#,
+        )
+        .file("level1/src/lib.rs", "")
+        .file(
+            "level2/Cargo.toml",
+            r#"
+            [package]
+            name = "level2"
+            version = "0.0.1"
+            edition = "2015"
+            authors = []
+            license = "MIT"
+            description = "level2"
+            repository = "bar"
+        "#,
+        )
+        .file("level2/src/lib.rs", "")
+        .build();
+
+    // We can't package just level1, because there's a dependency on level2.
+    p.cargo("package -p level1")
+        .replace_crates_io(crates_io.index_url())
+        .with_status(101)
+        .with_stdout_data("")
+        .with_stderr_data(str![[r#"
+[PACKAGING] level1 v0.0.1 ([ROOT]/foo/level1)
+[PACKAGED] 3 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
+[VERIFYING] level1 v0.0.1 ([ROOT]/foo/level1)
+[UPDATING] crates.io index
+[ERROR] failed to verify package tarball
+
+Caused by:
+  no matching package named `level2` found
+  location searched: registry `crates-io`
+  required by package `level1 v0.0.1 ([ROOT]/foo/target/package/level1-0.0.1)`
+
+"#]])
+        .run();
+}
+
+// Same as workspace_with_local_deps_packaging_one_fails except that we're
+// packaging a bin. This fails during lock-file generation instead of during verification.
+#[cargo_test]
+fn workspace_with_local_deps_packaging_one_bin_fails() {
+    let crates_io = registry::init();
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [workspace]
+            members = ["level1", "level2"]
+        "#,
+        )
+        .file(
+            "level1/Cargo.toml",
+            r#"
+            [package]
+            name = "level1"
+            version = "0.0.1"
+            edition = "2015"
+            authors = []
+            license = "MIT"
+            description = "level1"
+            repository = "bar"
+
+            [dependencies]
+            level2 = { path = "../level2", version = "0.0.1" }
+        "#,
+        )
+        .file("level1/src/main.rs", "fn main() {}")
+        .file(
+            "level2/Cargo.toml",
+            r#"
+            [package]
+            name = "level2"
+            version = "0.0.1"
+            edition = "2015"
+            authors = []
+            license = "MIT"
+            description = "level2"
+            repository = "bar"
+        "#,
+        )
+        .file("level2/src/lib.rs", "")
+        .build();
+
+    // We can't package just level1, because there's a dependency on level2.
+    p.cargo("package -p level1")
+        .replace_crates_io(crates_io.index_url())
+        .with_status(101)
+        .with_stdout_data("")
+        .with_stderr_data(str![[r#"
+[PACKAGING] level1 v0.0.1 ([ROOT]/foo/level1)
+[UPDATING] crates.io index
+[ERROR] failed to prepare local package for uploading
+
+Caused by:
+  no matching package named `level2` found
+  location searched: registry `crates-io`
+  required by package `level1 v0.0.1 ([ROOT]/foo/level1)`
+
+"#]])
+        .run();
+}
+
+// Here we don't package the whole workspace, but it succeeds because we package a
+// dependency-closed subset.
+#[cargo_test]
+fn workspace_with_local_deps_packaging_one_with_needed_deps() {
+    let crates_io = registry::init();
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [workspace]
+            members = ["level1", "level2", "level3"]
+        "#,
+        )
+        .file(
+            "level1/Cargo.toml",
+            r#"
+            [package]
+            name = "level1"
+            version = "0.0.1"
+            edition = "2015"
+            authors = []
+            license = "MIT"
+            description = "level1"
+            repository = "bar"
+
+            [dependencies]
+            level2 = { path = "../level2", version = "0.0.1" }
+        "#,
+        )
+        .file("level1/src/main.rs", "fn main() {}")
+        .file(
+            "level2/Cargo.toml",
+            r#"
+            [package]
+            name = "level2"
+            version = "0.0.1"
+            edition = "2015"
+            authors = []
+            license = "MIT"
+            description = "level2"
+            repository = "bar"
+
+            [dependencies]
+            level3 = { path = "../level3", version = "0.0.1" }
+        "#,
+        )
+        .file("level2/src/lib.rs", "")
+        .file(
+            "level3/Cargo.toml",
+            r#"
+            [package]
+            name = "level3"
+            version = "0.0.1"
+            edition = "2015"
+            authors = []
+            license = "MIT"
+            description = "level3"
+            repository = "bar"
+        "#,
+        )
+        .file("level3/src/lib.rs", "")
+        .build();
+
+    p.cargo("package -p level2 -p level3")
+        .replace_crates_io(crates_io.index_url())
+        .with_status(101)
+        .with_stdout_data("")
+        .with_stderr_data(str![[r#"
+[PACKAGING] level2 v0.0.1 ([ROOT]/foo/level2)
+[PACKAGED] 3 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
+[VERIFYING] level2 v0.0.1 ([ROOT]/foo/level2)
+[UPDATING] crates.io index
+[ERROR] failed to verify package tarball
+
+Caused by:
+  no matching package named `level3` found
+  location searched: registry `crates-io`
+  required by package `level2 v0.0.1 ([ROOT]/foo/target/package/level2-0.0.1)`
+
+"#]])
+        .run();
+}
+
+// package --list in a workspace lists all the files in all the packages.
+// The output is not very good, though. See https://github.com/rust-lang/cargo/issues/13953
+#[cargo_test]
+fn workspace_with_local_deps_list() {
+    let crates_io = registry::init();
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [workspace]
+            members = ["level1", "level2"]
+        "#,
+        )
+        .file(
+            "level1/Cargo.toml",
+            r#"
+            [package]
+            name = "level1"
+            version = "0.0.1"
+            edition = "2015"
+            authors = []
+            license = "MIT"
+            description = "level1"
+            repository = "bar"
+
+            [dependencies]
+            level2 = { path = "../level2", version = "0.0.1" }
+        "#,
+        )
+        .file("level1/src/main.rs", "fn main() {}")
+        .file(
+            "level2/Cargo.toml",
+            r#"
+            [package]
+            name = "level2"
+            version = "0.0.1"
+            edition = "2015"
+            authors = []
+            license = "MIT"
+            description = "level2"
+            repository = "bar"
+        "#,
+        )
+        .file("level2/src/lib.rs", "")
+        .build();
+
+    p.cargo("package --list")
+        .replace_crates_io(crates_io.index_url())
+        .with_stdout_data(str![[r#"
+Cargo.lock
+Cargo.toml
+Cargo.toml.orig
+src/main.rs
+Cargo.toml
+Cargo.toml.orig
+src/lib.rs
+
+"#]])
+        .with_stderr_data("")
+        .run();
+}
+
+#[cargo_test]
+fn workspace_with_local_deps_index_mismatch() {
+    let alt_reg = registry::RegistryBuilder::new()
+        .http_api()
+        .http_index()
+        .alternative()
+        .build();
+    // We're publishing to an alternate index, but the manifests don't specify it.
+    // The intra-workspace deps won't be found.
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [workspace]
+            members = ["level1", "level2"]
+        "#,
+        )
+        .file(
+            "level1/Cargo.toml",
+            r#"
+            [package]
+            name = "level1"
+            version = "0.0.1"
+            edition = "2015"
+            authors = []
+            license = "MIT"
+            description = "level1"
+            repository = "bar"
+
+            [dependencies]
+            level2 = { path = "../level2", version = "0.0.1" }
+        "#,
+        )
+        .file("level1/src/main.rs", "fn main() {}")
+        .file(
+            "level2/Cargo.toml",
+            r#"
+            [package]
+            name = "level2"
+            version = "0.0.1"
+            edition = "2015"
+            authors = []
+            license = "MIT"
+            description = "level2"
+            repository = "bar"
+        "#,
+        )
+        .file("level2/src/lib.rs", "")
+        .build();
+    p.cargo(&format!("package --index {}", alt_reg.index_url()))
+        .with_status(1)
+        .with_stdout_data("")
+        .with_stderr_data(str![[r#"
+[ERROR] unexpected argument '--index' found
+
+Usage: cargo package [OPTIONS]
+
+For more information, try '--help'.
+
+"#]])
+        .run();
+}
+
+#[cargo_test]
+fn workspace_with_local_deps_alternative_index() {
+    let alt_reg = registry::RegistryBuilder::new()
+        .http_api()
+        .http_index()
+        .alternative()
+        .build();
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [workspace]
+            members = ["level1", "level2"]
+        "#,
+        )
+        .file(
+            "level1/Cargo.toml",
+            r#"
+            [package]
+            name = "level1"
+            version = "0.0.1"
+            edition = "2015"
+            authors = []
+            license = "MIT"
+            description = "level1"
+            repository = "bar"
+
+            [dependencies]
+            level2 = { path = "../level2", version = "0.0.1", registry = "alternative" }
+        "#,
+        )
+        .file("level1/src/main.rs", "fn main() {}")
+        .file(
+            "level2/Cargo.toml",
+            r#"
+            [package]
+            name = "level2"
+            version = "0.0.1"
+            edition = "2015"
+            authors = []
+            license = "MIT"
+            description = "level2"
+            repository = "bar"
+        "#,
+        )
+        .file("level2/src/lib.rs", "")
+        .build();
+
+    p.cargo(&format!("package --index {}", alt_reg.index_url()))
+        .with_status(1)
+        .with_stdout_data("")
+        .with_stderr_data(str![[r#"
+[ERROR] unexpected argument '--index' found
+
+Usage: cargo package [OPTIONS]
+
+For more information, try '--help'.
+
+"#]])
+        .run();
+}
+
+#[cargo_test]
+fn workspace_with_local_dep_already_published() {
+    let reg = registry::init();
+
+    Package::new("dep", "0.1.0").publish();
+
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [workspace]
+            members = ["dep", "main"]
+            "#,
+        )
+        .file(
+            "main/Cargo.toml",
+            r#"
+            [package]
+            name = "main"
+            version = "0.0.1"
+            edition = "2015"
+            authors = []
+            license = "MIT"
+            description = "main"
+            repository = "bar"
+
+            [dependencies]
+            dep = { path = "../dep", version = "0.1.0" }
+        "#,
+        )
+        .file("main/src/main.rs", "fn main() {}")
+        .file(
+            "dep/Cargo.toml",
+            r#"
+            [package]
+            name = "dep"
+            version = "0.1.0"
+            edition = "2015"
+            authors = []
+            license = "MIT"
+            description = "dep"
+            repository = "bar"
+        "#,
+        )
+        .file("dep/src/lib.rs", "")
+        .build();
+
+    p.cargo("package")
+        .replace_crates_io(reg.index_url())
+        .with_stderr_data(
+            str![[r#"
+[PACKAGING] dep v0.1.0 ([ROOT]/foo/dep)
+[PACKAGED] 3 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
+[PACKAGING] main v0.0.1 ([ROOT]/foo/main)
+[UPDATING] crates.io index
+[VERIFYING] dep v0.1.0 ([ROOT]/foo/dep)
+[COMPILING] dep v0.1.0 ([ROOT]/foo/target/package/dep-0.1.0)
+[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
+[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
+[VERIFYING] main v0.0.1 ([ROOT]/foo/main)
+[DOWNLOADING] crates ...
+[DOWNLOADED] dep v0.1.0
+[COMPILING] dep v0.1.0
+[COMPILING] main v0.0.1 ([ROOT]/foo/target/package/main-0.0.1)
+[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
+
+"#]]
+            .unordered(),
+        )
+        .run();
+}
+
+#[cargo_test]
+fn workspace_with_local_and_remote_deps() {
+    let reg = registry::init();
+
+    Package::new("dep", "0.0.1").publish();
+
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [workspace]
+            members = ["dep", "main"]
+            "#,
+        )
+        .file(
+            "main/Cargo.toml",
+            r#"
+            [package]
+            name = "main"
+            version = "0.0.1"
+            edition = "2015"
+            authors = []
+            license = "MIT"
+            description = "main"
+            repository = "bar"
+
+            [dependencies]
+            dep = { path = "../dep", version = "0.1.0" }
+            old_dep = { package = "dep", version = "0.0.1" }
+        "#,
+        )
+        .file("main/src/main.rs", "fn main() {}")
+        .file(
+            "dep/Cargo.toml",
+            r#"
+            [package]
+            name = "dep"
+            version = "0.1.0"
+            edition = "2015"
+            authors = []
+            license = "MIT"
+            description = "dep"
+            repository = "bar"
+        "#,
+        )
+        .file("dep/src/lib.rs", "")
+        .build();
+
+    p.cargo("package")
+        .replace_crates_io(reg.index_url())
+        .with_status(101)
+        .with_stderr_data(str![[r#"
+[PACKAGING] dep v0.1.0 ([ROOT]/foo/dep)
+[PACKAGED] 3 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
+[VERIFYING] dep v0.1.0 ([ROOT]/foo/dep)
+[COMPILING] dep v0.1.0 ([ROOT]/foo/target/package/dep-0.1.0)
+[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
+[PACKAGING] main v0.0.1 ([ROOT]/foo/main)
+[UPDATING] crates.io index
+[ERROR] failed to prepare local package for uploading
+
+Caused by:
+  failed to select a version for the requirement `dep = "^0.1.0"`
+  candidate versions found which didn't match: 0.0.1
+  location searched: crates.io index
+  required by package `main v0.0.1 ([ROOT]/foo/main)`
+
+"#]])
+        .run();
+}

From a2f0a9e7d62da5c3eb11d4e7a085d70c53f21272 Mon Sep 17 00:00:00 2001
From: Joe Neeman <joe.neeman@tweag.io>
Date: Sun, 23 Jun 2024 18:11:58 -0500
Subject: [PATCH 3/3] Adds support for packaging workspaces.

Takes local dependencies into account when packaging a workspace. Builds
a temporary package registry to provide local dependencies, and overlays
it on the upstream registry.

This adds `--registry` and `--index` flags to `cargo package`. They act
much like the same arguments to `cargo publish`, except that of course
we are not actually publishing to the specified registry. Instead, these
arguments affect lock-file generation for intra-workspace dependencies:
when simultaneously packaging a crate and one of its dependencies, the
lock-file will be generated under the assumption that the dependency
will be published to the specified registry.

Co-Authored-By: Tor Hovland <55164+torhovland@users.noreply.github.com>
---
 src/bin/cargo/commands/package.rs             |  20 +
 src/cargo/core/features.rs                    |   2 +
 src/cargo/ops/cargo_package.rs                | 333 ++++++++++++++--
 src/cargo/ops/registry/mod.rs                 |   8 +-
 src/cargo/ops/registry/publish.rs             |   1 +
 src/cargo/sources/registry/index/mod.rs       |  54 +--
 src/cargo/sources/registry/mod.rs             |   2 +-
 src/doc/man/cargo-package.md                  |  15 +-
 src/doc/man/generated_txt/cargo-package.txt   |  10 +
 src/doc/src/commands/cargo-package.md         |  17 +-
 src/etc/_cargo                                |   3 +-
 src/etc/cargo.bashcomp.sh                     |   2 +-
 src/etc/man/cargo-package.1                   |  19 +-
 tests/testsuite/cargo/z_help/stdout.term.svg  |  34 +-
 .../cargo_package/help/stdout.term.svg        |  74 ++--
 tests/testsuite/package.rs                    | 361 +++++++++++++++---
 tests/testsuite/publish_lockfile.rs           |   8 +-
 17 files changed, 775 insertions(+), 188 deletions(-)

diff --git a/src/bin/cargo/commands/package.rs b/src/bin/cargo/commands/package.rs
index 27b48097c6a..42b3ac3d03d 100644
--- a/src/bin/cargo/commands/package.rs
+++ b/src/bin/cargo/commands/package.rs
@@ -5,6 +5,8 @@ use cargo::ops::{self, PackageOpts};
 pub fn cli() -> Command {
     subcommand("package")
         .about("Assemble the local package into a distributable tarball")
+        .arg_index("Registry index URL to prepare the package for (unstable)")
+        .arg_registry("Registry to prepare the package for (unstable)")
         .arg(
             flag(
                 "list",
@@ -41,6 +43,23 @@ pub fn cli() -> Command {
 }
 
 pub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {
+    if args._value_of("registry").is_some() {
+        gctx.cli_unstable().fail_if_stable_opt_custom_z(
+            "--registry",
+            13947,
+            "package-workspace",
+            gctx.cli_unstable().package_workspace,
+        )?;
+    }
+    if args._value_of("index").is_some() {
+        gctx.cli_unstable().fail_if_stable_opt_custom_z(
+            "--index",
+            13947,
+            "package-workspace",
+            gctx.cli_unstable().package_workspace,
+        )?;
+    }
+    let reg_or_index = args.registry_or_index(gctx)?;
     let ws = args.workspace(gctx)?;
     if ws.root_maybe().is_embedded() {
         return Err(anyhow::format_err!(
@@ -64,6 +83,7 @@ pub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {
             jobs: args.jobs()?,
             keep_going: args.keep_going(),
             cli_features: args.cli_features()?,
+            reg_or_index,
         },
     )?;
 
diff --git a/src/cargo/core/features.rs b/src/cargo/core/features.rs
index f613bdf9094..c44b8d51eb4 100644
--- a/src/cargo/core/features.rs
+++ b/src/cargo/core/features.rs
@@ -774,6 +774,7 @@ unstable_cli_options!(
     mtime_on_use: bool = ("Configure Cargo to update the mtime of used files"),
     next_lockfile_bump: bool,
     no_index_update: bool = ("Do not update the registry index even if the cache is outdated"),
+    package_workspace: bool = ("Handle intra-workspace dependencies when packaging"),
     panic_abort_tests: bool = ("Enable support to run tests with -Cpanic=abort"),
     profile_rustflags: bool = ("Enable the `rustflags` option in profiles in .cargo/config.toml file"),
     public_dependency: bool = ("Respect a dependency's `public` field in Cargo.toml to control public/private dependencies"),
@@ -1276,6 +1277,7 @@ impl CliUnstable {
             // can also be set in .cargo/config or with and ENV
             "mtime-on-use" => self.mtime_on_use = parse_empty(k, v)?,
             "no-index-update" => self.no_index_update = parse_empty(k, v)?,
+            "package-workspace" => self.package_workspace= parse_empty(k, v)?,
             "panic-abort-tests" => self.panic_abort_tests = parse_empty(k, v)?,
             "public-dependency" => self.public_dependency = parse_empty(k, v)?,
             "profile-rustflags" => self.profile_rustflags = parse_empty(k, v)?,
diff --git a/src/cargo/ops/cargo_package.rs b/src/cargo/ops/cargo_package.rs
index b32f2ed20d0..a83df435b2d 100644
--- a/src/cargo/ops/cargo_package.rs
+++ b/src/cargo/ops/cargo_package.rs
@@ -1,4 +1,4 @@
-use std::collections::{BTreeSet, HashMap};
+use std::collections::{BTreeSet, HashMap, HashSet};
 use std::fs::{self, File};
 use std::io::prelude::*;
 use std::io::SeekFrom;
@@ -7,19 +7,23 @@ use std::sync::Arc;
 use std::task::Poll;
 
 use crate::core::compiler::{BuildConfig, CompileMode, DefaultExecutor, Executor};
+use crate::core::dependency::DepKind;
 use crate::core::manifest::Target;
 use crate::core::resolver::CliFeatures;
 use crate::core::resolver::HasDevUnits;
 use crate::core::{Feature, PackageIdSpecQuery, Shell, Verbosity, Workspace};
 use crate::core::{Package, PackageId, PackageSet, Resolve, SourceId};
-use crate::sources::PathSource;
+use crate::sources::registry::index::{IndexPackage, RegistryDependency};
+use crate::sources::{PathSource, SourceConfigMap, CRATES_IO_REGISTRY};
 use crate::util::cache_lock::CacheLockMode;
 use crate::util::context::JobsConfig;
 use crate::util::errors::CargoResult;
 use crate::util::toml::prepare_for_publish;
-use crate::util::{self, human_readable_bytes, restricted_names, FileLock, GlobalContext};
+use crate::util::{
+    self, human_readable_bytes, restricted_names, FileLock, Filesystem, GlobalContext, Graph,
+};
 use crate::{drop_println, ops};
-use anyhow::Context as _;
+use anyhow::{bail, Context as _};
 use cargo_util::paths;
 use flate2::read::GzDecoder;
 use flate2::{Compression, GzBuilder};
@@ -28,6 +32,8 @@ use tar::{Archive, Builder, EntryType, Header, HeaderMode};
 use tracing::debug;
 use unicase::Ascii as UncasedAscii;
 
+use super::RegistryOrIndex;
+
 #[derive(Clone)]
 pub struct PackageOpts<'gctx> {
     pub gctx: &'gctx GlobalContext,
@@ -40,6 +46,7 @@ pub struct PackageOpts<'gctx> {
     pub to_package: ops::Packages,
     pub targets: Vec<String>,
     pub cli_features: CliFeatures,
+    pub reg_or_index: Option<ops::RegistryOrIndex>,
 }
 
 const ORIGINAL_MANIFEST_FILE: &str = "Cargo.toml.orig";
@@ -101,10 +108,10 @@ pub fn package_one(
     assert!(!opts.list);
 
     let ar_files = prepare_archive(ws, pkg, opts)?;
-    let tarball = create_package(ws, pkg, ar_files)?;
+    let tarball = create_package(ws, pkg, ar_files, None)?;
 
     if opts.verify {
-        run_verify(ws, pkg, &tarball, opts)?;
+        run_verify(ws, pkg, &tarball, None, opts)?;
     }
 
     Ok(tarball)
@@ -115,6 +122,7 @@ fn create_package(
     ws: &Workspace<'_>,
     pkg: &Package,
     ar_files: Vec<ArchiveFile>,
+    local_reg: Option<&TmpRegistry<'_>>,
 ) -> CargoResult<FileLock> {
     let gctx = ws.gctx();
     let filecount = ar_files.len();
@@ -138,7 +146,7 @@ fn create_package(
     gctx.shell()
         .status("Packaging", pkg.package_id().to_string())?;
     dst.file().set_len(0)?;
-    let uncompressed_size = tar(ws, pkg, ar_files, dst.file(), &filename)
+    let uncompressed_size = tar(ws, pkg, local_reg, ar_files, dst.file(), &filename)
         .with_context(|| "failed to prepare local package for uploading")?;
 
     dst.seek(SeekFrom::Start(0))?;
@@ -166,7 +174,70 @@ fn create_package(
     return Ok(dst);
 }
 
-pub fn package(ws: &Workspace<'_>, opts: &PackageOpts<'_>) -> CargoResult<Option<Vec<FileLock>>> {
+/// Determine which registry the packages are for.
+///
+/// The registry only affects the built packages if there are dependencies within the
+/// packages that we're packaging: if we're packaging foo-bin and foo-lib, and foo-bin
+/// depends on foo-lib, then the foo-lib entry in foo-bin's lockfile will depend on the
+/// registry that we're building packages for.
+fn infer_registry(
+    gctx: &GlobalContext,
+    pkgs: &[&Package],
+    reg_or_index: Option<RegistryOrIndex>,
+) -> CargoResult<SourceId> {
+    let publish_registry = if let Some(RegistryOrIndex::Registry(registry)) = reg_or_index.as_ref()
+    {
+        Some(registry.clone())
+    } else if let Some([first_pkg_reg]) = pkgs[0].publish().as_deref() {
+        // If no registry is specified in the command, but all of the packages
+        // to publish have the same, unique allowed registry, push to that one.
+        if pkgs[1..].iter().all(|p| p.publish() == pkgs[0].publish()) {
+            Some(first_pkg_reg.clone())
+        } else {
+            None
+        }
+    } else {
+        None
+    };
+
+    // Validate the registry against the packages' allow-lists. For backwards compatibility, we
+    // skip this if only a single package is being published (because in that case the registry
+    // doesn't affect the packaging step).
+    if pkgs.len() > 1 {
+        let reg_name = publish_registry.as_deref().unwrap_or(CRATES_IO_REGISTRY);
+        for pkg in pkgs {
+            if let Some(allowed) = pkg.publish().as_ref() {
+                if !allowed.iter().any(|a| a == reg_name) {
+                    bail!(
+                        "`{}` cannot be packaged.\n\
+                         The registry `{}` is not listed in the `package.publish` value in Cargo.toml.",
+                        pkg.name(),
+                        reg_name
+                    );
+                }
+            }
+        }
+    }
+
+    let sid = match reg_or_index {
+        None => SourceId::crates_io(gctx)?,
+        Some(RegistryOrIndex::Registry(r)) => SourceId::alt_registry(gctx, &r)?,
+        Some(RegistryOrIndex::Index(url)) => SourceId::for_registry(&url)?,
+    };
+
+    // Load source replacements that are built-in to Cargo.
+    let sid = SourceConfigMap::empty(gctx)?
+        .load(sid, &HashSet::new())?
+        .replaced_source_id();
+
+    Ok(sid)
+}
+
+/// Packages an entire workspace.
+///
+/// Returns the generated package files. If `opts.list` is true, skips
+/// generating package files and returns an empty list.
+pub fn package(ws: &Workspace<'_>, opts: &PackageOpts<'_>) -> CargoResult<Vec<FileLock>> {
     let specs = &opts.to_package.to_package_id_specs(ws)?;
     // If -p is used, we should check spec is matched with the members (See #13719)
     if let ops::Packages::Packages(_) = opts.to_package {
@@ -176,7 +247,6 @@ pub fn package(ws: &Workspace<'_>, opts: &PackageOpts<'_>) -> CargoResult<Option
         }
     }
     let pkgs = ws.members_with_features(specs, &opts.cli_features)?;
-    let mut dsts = Vec::with_capacity(pkgs.len());
 
     if ws.root().join("Cargo.lock").exists() {
         // Make sure the Cargo.lock is up-to-date and valid.
@@ -186,34 +256,108 @@ pub fn package(ws: &Workspace<'_>, opts: &PackageOpts<'_>) -> CargoResult<Option
         // below, and will be validated during the verification step.
     }
 
-    for (pkg, cli_features) in pkgs {
+    let just_pkgs: Vec<_> = pkgs.iter().map(|p| p.0).collect();
+    let publish_reg = infer_registry(ws.gctx(), &just_pkgs, opts.reg_or_index.clone())?;
+    debug!("packaging for registry {publish_reg}");
+
+    let mut local_reg = if ws.gctx().cli_unstable().package_workspace {
+        let reg_dir = ws.target_dir().join("package").join("tmp-registry");
+        Some(TmpRegistry::new(ws.gctx(), reg_dir, publish_reg)?)
+    } else {
+        None
+    };
+
+    let deps = local_deps(pkgs.iter().map(|(p, f)| ((*p).clone(), f.clone())));
+
+    // Packages need to be created in dependency order, because dependencies must
+    // be added to our local overlay before we can create lockfiles that depend on them.
+    let sorted_pkgs = deps.sort();
+    let mut outputs: Vec<(Package, PackageOpts<'_>, FileLock)> = Vec::new();
+    for (pkg, cli_features) in sorted_pkgs {
         let opts = PackageOpts {
+            cli_features: cli_features.clone(),
             to_package: ops::Packages::Default,
-            cli_features,
             ..opts.clone()
         };
-        let ar_files = prepare_archive(ws, pkg, &opts)?;
+        let ar_files = prepare_archive(ws, &pkg, &opts)?;
 
         if opts.list {
-            for ar_file in ar_files {
+            for ar_file in &ar_files {
                 drop_println!(ws.gctx(), "{}", ar_file.rel_str);
             }
         } else {
-            let tarball = create_package(ws, pkg, ar_files)?;
-            if opts.verify {
-                run_verify(ws, pkg, &tarball, &opts)
-                    .with_context(|| "failed to verify package tarball")?;
+            let tarball = create_package(ws, &pkg, ar_files, local_reg.as_ref())?;
+            if let Some(local_reg) = local_reg.as_mut() {
+                local_reg.add_package(&pkg, &tarball)?;
             }
-            dsts.push(tarball);
+            outputs.push((pkg, opts, tarball));
         }
     }
 
-    if opts.list {
-        // We're just listing, so there's no file output
-        Ok(None)
-    } else {
-        Ok(Some(dsts))
+    // Verify all packages in the workspace. This can be done in any order, since the dependencies
+    // are already all in the local registry overlay.
+    if opts.verify {
+        for (pkg, opts, tarball) in &outputs {
+            run_verify(ws, pkg, tarball, local_reg.as_ref(), opts)
+                .with_context(|| "failed to verify package tarball")?
+        }
     }
+
+    Ok(outputs.into_iter().map(|x| x.2).collect())
+}
+
+/// Just the part of the dependency graph that's between the packages we're packaging.
+/// (Is the package name a good key? Does it uniquely identify packages?)
+#[derive(Clone, Debug, Default)]
+struct LocalDependencies {
+    packages: HashMap<PackageId, (Package, CliFeatures)>,
+    graph: Graph<PackageId, ()>,
+}
+
+impl LocalDependencies {
+    fn sort(&self) -> Vec<(Package, CliFeatures)> {
+        self.graph
+            .sort()
+            .into_iter()
+            .map(|name| self.packages[&name].clone())
+            .collect()
+    }
+}
+
+/// Build just the part of the dependency graph that's between the given packages,
+/// ignoring dev dependencies.
+///
+/// We assume that the packages all belong to this workspace.
+fn local_deps(packages: impl Iterator<Item = (Package, CliFeatures)>) -> LocalDependencies {
+    let packages: HashMap<PackageId, (Package, CliFeatures)> =
+        packages.map(|pkg| (pkg.0.package_id(), pkg)).collect();
+
+    // Dependencies have source ids but not package ids. We draw an edge
+    // whenever a dependency's source id matches one of our packages. This is
+    // wrong in general because it doesn't require (e.g.) versions to match. But
+    // since we're working only with path dependencies here, it should be fine.
+    let source_to_pkg: HashMap<_, _> = packages
+        .keys()
+        .map(|pkg_id| (pkg_id.source_id(), *pkg_id))
+        .collect();
+
+    let mut graph = Graph::new();
+    for (pkg, _features) in packages.values() {
+        graph.add(pkg.package_id());
+        for dep in pkg.dependencies() {
+            // Ignore local dev-dependencies because they aren't needed for intra-workspace
+            // lockfile generation or verification as they get stripped on publish.
+            if dep.kind() == DepKind::Development || !dep.source_id().is_path() {
+                continue;
+            };
+
+            if let Some(dep_pkg) = source_to_pkg.get(&dep.source_id()) {
+                graph.link(pkg.package_id(), *dep_pkg);
+            }
+        }
+    }
+
+    LocalDependencies { packages, graph }
 }
 
 /// Performs pre-archiving checks and builds a list of files to archive.
@@ -483,12 +627,27 @@ fn error_custom_build_file_not_in_package(
 }
 
 /// Construct `Cargo.lock` for the package to be published.
-fn build_lock(ws: &Workspace<'_>, publish_pkg: &Package) -> CargoResult<String> {
+fn build_lock(
+    ws: &Workspace<'_>,
+    publish_pkg: &Package,
+    local_reg: Option<&TmpRegistry<'_>>,
+) -> CargoResult<String> {
     let gctx = ws.gctx();
     let orig_resolve = ops::load_pkg_lockfile(ws)?;
 
-    let tmp_ws = Workspace::ephemeral(publish_pkg.clone(), ws.gctx(), None, true)?;
-    let mut tmp_reg = ws.package_registry()?;
+    let mut tmp_ws = Workspace::ephemeral(publish_pkg.clone(), ws.gctx(), None, true)?;
+
+    // The local registry is an overlay used for simulating workspace packages
+    // that are supposed to be in the published registry, but that aren't there
+    // yet.
+    if let Some(local_reg) = local_reg {
+        tmp_ws.add_local_overlay(
+            local_reg.upstream,
+            local_reg.root.as_path_unlocked().to_owned(),
+        );
+    }
+    let mut tmp_reg = tmp_ws.package_registry()?;
+
     let mut new_resolve = ops::resolve_with_previous(
         &mut tmp_reg,
         &tmp_ws,
@@ -499,6 +658,7 @@ fn build_lock(ws: &Workspace<'_>, publish_pkg: &Package) -> CargoResult<String>
         &[],
         true,
     )?;
+
     let pkg_set = ops::get_resolved_packages(&new_resolve, tmp_reg)?;
 
     if let Some(orig_resolve) = orig_resolve {
@@ -712,6 +872,7 @@ fn check_repo_state(
 fn tar(
     ws: &Workspace<'_>,
     pkg: &Package,
+    local_reg: Option<&TmpRegistry<'_>>,
     ar_files: Vec<ArchiveFile>,
     dst: &File,
     filename: &str,
@@ -764,7 +925,7 @@ fn tar(
             FileContents::Generated(generated_kind) => {
                 let contents = match generated_kind {
                     GeneratedFile::Manifest => publish_pkg.manifest().to_resolved_contents()?,
-                    GeneratedFile::Lockfile => build_lock(ws, &publish_pkg)?,
+                    GeneratedFile::Lockfile => build_lock(ws, &publish_pkg, local_reg)?,
                     GeneratedFile::VcsInfo(ref s) => serde_json::to_string_pretty(s)?,
                 };
                 header.set_entry_type(EntryType::file());
@@ -920,12 +1081,14 @@ fn run_verify(
     ws: &Workspace<'_>,
     pkg: &Package,
     tar: &FileLock,
+    local_reg: Option<&TmpRegistry<'_>>,
     opts: &PackageOpts<'_>,
 ) -> CargoResult<()> {
     let gctx = ws.gctx();
 
     gctx.shell().status("Verifying", pkg)?;
 
+    tar.file().seek(SeekFrom::Start(0))?;
     let f = GzDecoder::new(tar.file());
     let dst = tar
         .parent()
@@ -945,7 +1108,13 @@ fn run_verify(
     let mut src = PathSource::new(&dst, id, ws.gctx());
     let new_pkg = src.root_package()?;
     let pkg_fingerprint = hash_all(&dst)?;
-    let ws = Workspace::ephemeral(new_pkg, gctx, None, true)?;
+    let mut ws = Workspace::ephemeral(new_pkg, gctx, None, true)?;
+    if let Some(local_reg) = local_reg {
+        ws.add_local_overlay(
+            local_reg.upstream,
+            local_reg.root.as_path_unlocked().to_owned(),
+        );
+    }
 
     let rustc_args = if pkg
         .manifest()
@@ -1096,3 +1265,111 @@ fn check_filename(file: &Path, shell: &mut Shell) -> CargoResult<()> {
     }
     Ok(())
 }
+
+/// Manages a temporary local registry that we use to overlay our new packages on the
+/// upstream registry. This way we can build lockfiles that depend on the new packages even
+/// before they're published.
+struct TmpRegistry<'a> {
+    gctx: &'a GlobalContext,
+    upstream: SourceId,
+    root: Filesystem,
+    _lock: FileLock,
+}
+
+impl<'a> TmpRegistry<'a> {
+    fn new(gctx: &'a GlobalContext, root: Filesystem, upstream: SourceId) -> CargoResult<Self> {
+        root.create_dir()?;
+        let _lock = root.open_rw_exclusive_create(".cargo-lock", gctx, "temporary registry")?;
+        let slf = Self {
+            gctx,
+            root,
+            upstream,
+            _lock,
+        };
+        // If there's an old temporary registry, delete it.
+        let index_path = slf.index_path().into_path_unlocked();
+        if index_path.exists() {
+            paths::remove_dir_all(index_path)?;
+        }
+        slf.index_path().create_dir()?;
+        Ok(slf)
+    }
+
+    fn index_path(&self) -> Filesystem {
+        self.root.join("index")
+    }
+
+    fn add_package(&mut self, package: &Package, tar: &FileLock) -> CargoResult<()> {
+        debug!(
+            "adding package {}@{} to local overlay at {}",
+            package.name(),
+            package.version(),
+            self.root.as_path_unlocked().display()
+        );
+        {
+            let mut tar_copy = self.root.open_rw_exclusive_create(
+                package.package_id().tarball_name(),
+                self.gctx,
+                "temporary package registry",
+            )?;
+            tar.file().seek(SeekFrom::Start(0))?;
+            std::io::copy(&mut tar.file(), &mut tar_copy)?;
+            tar_copy.flush()?;
+        }
+
+        let new_crate = super::registry::prepare_transmit(self.gctx, package, self.upstream)?;
+
+        tar.file().seek(SeekFrom::Start(0))?;
+        let cksum = cargo_util::Sha256::new()
+            .update_file(tar.file())?
+            .finish_hex();
+
+        let deps: Vec<_> = new_crate
+            .deps
+            .into_iter()
+            .map(|dep| RegistryDependency {
+                name: dep.name.into(),
+                req: dep.version_req.into(),
+                features: dep.features.into_iter().map(|x| x.into()).collect(),
+                optional: dep.optional,
+                default_features: dep.default_features,
+                target: dep.target.map(|x| x.into()),
+                kind: Some(dep.kind.into()),
+                registry: dep.registry.map(|x| x.into()),
+                package: None,
+                public: None,
+                artifact: dep
+                    .artifact
+                    .map(|xs| xs.into_iter().map(|x| x.into()).collect()),
+                bindep_target: dep.bindep_target.map(|x| x.into()),
+                lib: dep.lib,
+            })
+            .collect();
+
+        let index_line = serde_json::to_string(&IndexPackage {
+            name: new_crate.name.into(),
+            vers: package.version().clone(),
+            deps,
+            features: new_crate
+                .features
+                .into_iter()
+                .map(|(k, v)| (k.into(), v.into_iter().map(|x| x.into()).collect()))
+                .collect(),
+            features2: None,
+            cksum,
+            yanked: None,
+            links: new_crate.links.map(|x| x.into()),
+            rust_version: None,
+            v: Some(2),
+        })?;
+
+        let file = cargo_util::registry::make_dep_path(package.name().as_str(), false);
+        let mut dst = self.index_path().open_rw_exclusive_create(
+            file,
+            self.gctx,
+            "temporary package registry",
+        )?;
+        dst.write_all(index_line.as_bytes())?;
+        Ok(())
+    }
+}
diff --git a/src/cargo/ops/registry/mod.rs b/src/cargo/ops/registry/mod.rs
index 0ce7269d8ee..f45947566b7 100644
--- a/src/cargo/ops/registry/mod.rs
+++ b/src/cargo/ops/registry/mod.rs
@@ -36,6 +36,8 @@ pub use self::publish::PublishOpts;
 pub use self::search::search;
 pub use self::yank::yank;
 
+pub(crate) use self::publish::prepare_transmit;
+
 /// Represents either `--registry` or `--index` argument, which is mutually exclusive.
 #[derive(Debug, Clone)]
 pub enum RegistryOrIndex {
@@ -254,9 +256,9 @@ fn gen_replacement_error(replacement_sid: SourceId) -> String {
     error_message
 }
 
-struct RegistrySourceIds {
+pub(crate) struct RegistrySourceIds {
     /// Use when looking up the auth token, or writing out `Cargo.lock`
-    original: SourceId,
+    pub(crate) original: SourceId,
     /// Use when interacting with the source (querying / publishing , etc)
     ///
     /// The source for crates.io may be replaced by a built-in source for accessing crates.io with
@@ -264,5 +266,5 @@ struct RegistrySourceIds {
     /// function is used)
     ///
     /// User-defined source replacement is not applied.
-    replacement: SourceId,
+    pub(crate) replacement: SourceId,
 }
diff --git a/src/cargo/ops/registry/publish.rs b/src/cargo/ops/registry/publish.rs
index ff7653acff3..f0a72bda404 100644
--- a/src/cargo/ops/registry/publish.rs
+++ b/src/cargo/ops/registry/publish.rs
@@ -157,6 +157,7 @@ pub fn publish(ws: &Workspace<'_>, opts: &PublishOpts<'_>) -> CargoResult<()> {
             jobs: opts.jobs.clone(),
             keep_going: opts.keep_going,
             cli_features,
+            reg_or_index,
         },
     )?;
 
diff --git a/src/cargo/sources/registry/index/mod.rs b/src/cargo/sources/registry/index/mod.rs
index 0bc6196fad5..e0fd92c279c 100644
--- a/src/cargo/sources/registry/index/mod.rs
+++ b/src/cargo/sources/registry/index/mod.rs
@@ -30,7 +30,7 @@ use crate::util::{internal, CargoResult, Filesystem, GlobalContext, OptVersionRe
 use cargo_util::registry::make_dep_path;
 use cargo_util_schemas::manifest::RustVersion;
 use semver::Version;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use std::borrow::Cow;
 use std::collections::BTreeMap;
 use std::collections::HashMap;
@@ -195,44 +195,44 @@ impl IndexSummary {
 }
 
 /// A single line in the index representing a single version of a package.
-#[derive(Deserialize)]
+#[derive(Deserialize, Serialize)]
 pub struct IndexPackage<'a> {
     /// Name of the package.
-    name: InternedString,
+    pub name: InternedString,
     /// The version of this dependency.
-    vers: Version,
+    pub vers: Version,
     /// All kinds of direct dependencies of the package, including dev and
     /// build dependencies.
     #[serde(borrow)]
-    deps: Vec<RegistryDependency<'a>>,
+    pub deps: Vec<RegistryDependency<'a>>,
     /// Set of features defined for the package, i.e., `[features]` table.
-    features: BTreeMap<InternedString, Vec<InternedString>>,
+    pub features: BTreeMap<InternedString, Vec<InternedString>>,
     /// This field contains features with new, extended syntax. Specifically,
     /// namespaced features (`dep:`) and weak dependencies (`pkg?/feat`).
     ///
     /// This is separated from `features` because versions older than 1.19
     /// will fail to load due to not being able to parse the new syntax, even
     /// with a `Cargo.lock` file.
-    features2: Option<BTreeMap<InternedString, Vec<InternedString>>>,
+    pub features2: Option<BTreeMap<InternedString, Vec<InternedString>>>,
     /// Checksum for verifying the integrity of the corresponding downloaded package.
-    cksum: String,
+    pub cksum: String,
     /// If `true`, Cargo will skip this version when resolving.
     ///
     /// This was added in 2014. Everything in the crates.io index has this set
     /// now, so this probably doesn't need to be an option anymore.
-    yanked: Option<bool>,
+    pub yanked: Option<bool>,
     /// Native library name this package links to.
     ///
     /// Added early 2018 (see <https://github.com/rust-lang/cargo/pull/4978>),
     /// can be `None` if published before then.
-    links: Option<InternedString>,
+    pub links: Option<InternedString>,
     /// Required version of rust
     ///
     /// Corresponds to `package.rust-version`.
     ///
     /// Added in 2023 (see <https://github.com/rust-lang/crates.io/pull/6267>),
     /// can be `None` if published before then or if not set in the manifest.
-    rust_version: Option<RustVersion>,
+    pub rust_version: Option<RustVersion>,
     /// The schema version for this entry.
     ///
     /// If this is None, it defaults to version `1`. Entries with unknown
@@ -255,41 +255,41 @@ pub struct IndexPackage<'a> {
     /// incorrectly select a new package that uses a new index schema. A
     /// workaround is to downgrade any packages that are incompatible with the
     /// `--precise` flag of `cargo update`.
-    v: Option<u32>,
+    pub v: Option<u32>,
 }
 
 /// A dependency as encoded in the [`IndexPackage`] index JSON.
-#[derive(Deserialize)]
-struct RegistryDependency<'a> {
+#[derive(Deserialize, Serialize)]
+pub struct RegistryDependency<'a> {
     /// Name of the dependency. If the dependency is renamed, the original
     /// would be stored in [`RegistryDependency::package`].
-    name: InternedString,
+    pub name: InternedString,
     /// The SemVer requirement for this dependency.
     #[serde(borrow)]
-    req: Cow<'a, str>,
+    pub req: Cow<'a, str>,
     /// Set of features enabled for this dependency.
-    features: Vec<InternedString>,
+    pub features: Vec<InternedString>,
     /// Whether or not this is an optional dependency.
-    optional: bool,
+    pub optional: bool,
     /// Whether or not default features are enabled.
-    default_features: bool,
+    pub default_features: bool,
     /// The target platform for this dependency.
-    target: Option<Cow<'a, str>>,
+    pub target: Option<Cow<'a, str>>,
     /// The dependency kind. "dev", "build", and "normal".
-    kind: Option<Cow<'a, str>>,
+    pub kind: Option<Cow<'a, str>>,
     // The URL of the index of the registry where this dependency is from.
     // `None` if it is from the same index.
-    registry: Option<Cow<'a, str>>,
+    pub registry: Option<Cow<'a, str>>,
     /// The original name if the dependency is renamed.
-    package: Option<InternedString>,
+    pub package: Option<InternedString>,
     /// Whether or not this is a public dependency. Unstable. See [RFC 1977].
     ///
     /// [RFC 1977]: https://rust-lang.github.io/rfcs/1977-public-private-dependencies.html
-    public: Option<bool>,
-    artifact: Option<Vec<Cow<'a, str>>>,
-    bindep_target: Option<Cow<'a, str>>,
+    pub public: Option<bool>,
+    pub artifact: Option<Vec<Cow<'a, str>>>,
+    pub bindep_target: Option<Cow<'a, str>>,
     #[serde(default)]
-    lib: bool,
+    pub lib: bool,
 }
 
 impl<'gctx> RegistryIndex<'gctx> {
diff --git a/src/cargo/sources/registry/mod.rs b/src/cargo/sources/registry/mod.rs
index 6ef6f70be22..31ebc48ae31 100644
--- a/src/cargo/sources/registry/mod.rs
+++ b/src/cargo/sources/registry/mod.rs
@@ -445,7 +445,7 @@ pub enum MaybeLock {
 
 mod download;
 mod http_remote;
-mod index;
+pub(crate) mod index;
 pub use index::IndexSummary;
 mod local;
 mod remote;
diff --git a/src/doc/man/cargo-package.md b/src/doc/man/cargo-package.md
index 42fa2366b83..7443c20fd0c 100644
--- a/src/doc/man/cargo-package.md
+++ b/src/doc/man/cargo-package.md
@@ -15,9 +15,8 @@ cargo-package --- Assemble the local package into a distributable tarball
 ## DESCRIPTION
 
 This command will create a distributable, compressed `.crate` file with the
-source code of the package in the current directory. The resulting file will
-be stored in the `target/package` directory. This performs the following
-steps:
+source code of the package in the current directory. The resulting file will be
+stored in the `target/package` directory. This performs the following steps:
 
 1. Load and check the current workspace, performing some basic checks.
     - Path dependencies are not allowed unless they have a version key. Cargo
@@ -95,6 +94,16 @@ or the license).
 Allow working directories with uncommitted VCS changes to be packaged.
 {{/option}}
 
+{{> options-index }}
+
+{{#option "`--registry` _registry_"}}
+Name of the registry to package for; see `cargo publish --help` for more details
+about configuration of registry names. The packages will not be published
+to this registry, but if we are packaging multiple inter-dependent crates,
+lock-files will be generated under the assumption that dependencies will be
+published to this registry.
+{{/option}}
+
 {{/options}}
 
 {{> section-package-selection }}
diff --git a/src/doc/man/generated_txt/cargo-package.txt b/src/doc/man/generated_txt/cargo-package.txt
index 0e474d17ff8..39c317c63e2 100644
--- a/src/doc/man/generated_txt/cargo-package.txt
+++ b/src/doc/man/generated_txt/cargo-package.txt
@@ -87,6 +87,16 @@ OPTIONS
            Allow working directories with uncommitted VCS changes to be
            packaged.
 
+       --index index
+           The URL of the registry index to use.
+
+       --registry registry
+           Name of the registry to package for; see cargo publish --help for
+           more details about configuration of registry names. The packages
+           will not be published to this registry, but if we are packaging
+           multiple inter-dependent crates, lock-files will be generated under
+           the assumption that dependencies will be published to this registry.
+
    Package Selection
        By default, when no package selection options are given, the packages
        selected depend on the selected manifest file (based on the current
diff --git a/src/doc/src/commands/cargo-package.md b/src/doc/src/commands/cargo-package.md
index bb3324fdb74..765281f479c 100644
--- a/src/doc/src/commands/cargo-package.md
+++ b/src/doc/src/commands/cargo-package.md
@@ -10,9 +10,8 @@ cargo-package --- Assemble the local package into a distributable tarball
 ## DESCRIPTION
 
 This command will create a distributable, compressed `.crate` file with the
-source code of the package in the current directory. The resulting file will
-be stored in the `target/package` directory. This performs the following
-steps:
+source code of the package in the current directory. The resulting file will be
+stored in the `target/package` directory. This performs the following steps:
 
 1. Load and check the current workspace, performing some basic checks.
     - Path dependencies are not allowed unless they have a version key. Cargo
@@ -91,6 +90,18 @@ or the license).</dd>
 <dd class="option-desc">Allow working directories with uncommitted VCS changes to be packaged.</dd>
 
 
+<dt class="option-term" id="option-cargo-package---index"><a class="option-anchor" href="#option-cargo-package---index"></a><code>--index</code> <em>index</em></dt>
+<dd class="option-desc">The URL of the registry index to use.</dd>
+
+
+<dt class="option-term" id="option-cargo-package---registry"><a class="option-anchor" href="#option-cargo-package---registry"></a><code>--registry</code> <em>registry</em></dt>
+<dd class="option-desc">Name of the registry to package for; see <code>cargo publish --help</code> for more details
+about configuration of registry names. The packages will not be published
+to this registry, but if we are packaging multiple inter-dependent crates,
+lock-files will be generated under the assumption that dependencies will be
+published to this registry.</dd>
+
+
 </dl>
 
 ### Package Selection
diff --git a/src/etc/_cargo b/src/etc/_cargo
index aab5c98d958..0158f6bd85c 100644
--- a/src/etc/_cargo
+++ b/src/etc/_cargo
@@ -226,7 +226,8 @@ _cargo() {
                         ;;
 
                 package)
-                    _arguments -s -S $common $parallel $features $triple $target $manifest \
+                    _arguments -s -S $common $parallel $features $triple $target $manifest $registry \
+                        '--index=[specify registry index]:index' \
                         '(-l --list)'{-l,--list}'[print files included in a package without making one]' \
                         '--no-metadata[ignore warnings about a lack of human-usable metadata]' \
                         '--allow-dirty[allow dirty working directories to be packaged]' \
diff --git a/src/etc/cargo.bashcomp.sh b/src/etc/cargo.bashcomp.sh
index 398fc6f9fad..5219b8b66ea 100644
--- a/src/etc/cargo.bashcomp.sh
+++ b/src/etc/cargo.bashcomp.sh
@@ -70,7 +70,7 @@ _cargo()
 	local opt__metadata="$opt_common $opt_feat $opt_mani $opt_lock --format-version=1 --no-deps --filter-platform"
 	local opt__new="$opt_common $opt_lock --vcs --bin --lib --name --edition --registry"
 	local opt__owner="$opt_common $opt_lock -a --add -r --remove -l --list --index --token --registry"
-	local opt__package="$opt_common $opt_mani $opt_feat $opt_lock $opt_parallel --allow-dirty -l --list --no-verify --no-metadata --target --target-dir"
+	local opt__package="$opt_common $opt_mani $opt_feat $opt_lock $opt_parallel --allow-dirty -l --list --no-verify --no-metadata --index --registry --target --target-dir"
 	local opt__pkgid="$opt_common $opt_mani $opt_lock $opt_pkg"
 	local opt__publish="$opt_common $opt_mani $opt_feat $opt_lock $opt_parallel --allow-dirty --dry-run --token --no-verify --index --registry --target --target-dir"
 	local opt__read_manifest="$opt_help $opt_quiet $opt_verbose $opt_mani $opt_color $opt_lock --no-deps"
diff --git a/src/etc/man/cargo-package.1 b/src/etc/man/cargo-package.1
index 9a7986014a4..8530e5454ca 100644
--- a/src/etc/man/cargo-package.1
+++ b/src/etc/man/cargo-package.1
@@ -9,9 +9,8 @@ cargo\-package \[em] Assemble the local package into a distributable tarball
 \fBcargo package\fR [\fIoptions\fR]
 .SH "DESCRIPTION"
 This command will create a distributable, compressed \fB\&.crate\fR file with the
-source code of the package in the current directory. The resulting file will
-be stored in the \fBtarget/package\fR directory. This performs the following
-steps:
+source code of the package in the current directory. The resulting file will be
+stored in the \fBtarget/package\fR directory. This performs the following steps:
 .sp
 .RS 4
 \h'-04' 1.\h'+01'Load and check the current workspace, performing some basic checks.
@@ -118,6 +117,20 @@ or the license).
 .RS 4
 Allow working directories with uncommitted VCS changes to be packaged.
 .RE
+.sp
+\fB\-\-index\fR \fIindex\fR
+.RS 4
+The URL of the registry index to use.
+.RE
+.sp
+\fB\-\-registry\fR \fIregistry\fR
+.RS 4
+Name of the registry to package for; see \fBcargo publish \-\-help\fR for more details
+about configuration of registry names. The packages will not be published
+to this registry, but if we are packaging multiple inter\-dependent crates,
+lock\-files will be generated under the assumption that dependencies will be
+published to this registry.
+.RE
 .SS "Package Selection"
 By default, when no package selection options are given, the packages selected
 depend on the selected manifest file (based on the current working directory if
diff --git a/tests/testsuite/cargo/z_help/stdout.term.svg b/tests/testsuite/cargo/z_help/stdout.term.svg
index a4c8e579b4d..e5386620e46 100644
--- a/tests/testsuite/cargo/z_help/stdout.term.svg
+++ b/tests/testsuite/cargo/z_help/stdout.term.svg
@@ -1,4 +1,4 @@
-<svg width="1230px" height="704px" xmlns="http://www.w3.org/2000/svg">
+<svg width="1230px" height="722px" xmlns="http://www.w3.org/2000/svg">
   <style>
     .fg { fill: #AAAAAA }
     .bg { background: #000000 }
@@ -62,35 +62,37 @@
 </tspan>
     <tspan x="10px" y="424px"><tspan>    -Z no-index-update          Do not update the registry index even if the cache is outdated</tspan>
 </tspan>
-    <tspan x="10px" y="442px"><tspan>    -Z panic-abort-tests        Enable support to run tests with -Cpanic=abort</tspan>
+    <tspan x="10px" y="442px"><tspan>    -Z package-workspace        Handle intra-workspace dependencies when packaging</tspan>
 </tspan>
-    <tspan x="10px" y="460px"><tspan>    -Z profile-rustflags        Enable the `rustflags` option in profiles in .cargo/config.toml file</tspan>
+    <tspan x="10px" y="460px"><tspan>    -Z panic-abort-tests        Enable support to run tests with -Cpanic=abort</tspan>
 </tspan>
-    <tspan x="10px" y="478px"><tspan>    -Z public-dependency        Respect a dependency's `public` field in Cargo.toml to control public/private dependencies</tspan>
+    <tspan x="10px" y="478px"><tspan>    -Z profile-rustflags        Enable the `rustflags` option in profiles in .cargo/config.toml file</tspan>
 </tspan>
-    <tspan x="10px" y="496px"><tspan>    -Z publish-timeout          Enable the `publish.timeout` key in .cargo/config.toml file</tspan>
+    <tspan x="10px" y="496px"><tspan>    -Z public-dependency        Respect a dependency's `public` field in Cargo.toml to control public/private dependencies</tspan>
 </tspan>
-    <tspan x="10px" y="514px"><tspan>    -Z rustdoc-map              Allow passing external documentation mappings to rustdoc</tspan>
+    <tspan x="10px" y="514px"><tspan>    -Z publish-timeout          Enable the `publish.timeout` key in .cargo/config.toml file</tspan>
 </tspan>
-    <tspan x="10px" y="532px"><tspan>    -Z rustdoc-scrape-examples  Allows Rustdoc to scrape code examples from reverse-dependencies</tspan>
+    <tspan x="10px" y="532px"><tspan>    -Z rustdoc-map              Allow passing external documentation mappings to rustdoc</tspan>
 </tspan>
-    <tspan x="10px" y="550px"><tspan>    -Z script                   Enable support for single-file, `.rs` packages</tspan>
+    <tspan x="10px" y="550px"><tspan>    -Z rustdoc-scrape-examples  Allows Rustdoc to scrape code examples from reverse-dependencies</tspan>
 </tspan>
-    <tspan x="10px" y="568px"><tspan>    -Z target-applies-to-host   Enable the `target-applies-to-host` key in the .cargo/config.toml file</tspan>
+    <tspan x="10px" y="568px"><tspan>    -Z script                   Enable support for single-file, `.rs` packages</tspan>
 </tspan>
-    <tspan x="10px" y="586px"><tspan>    -Z trim-paths               Enable the `trim-paths` option in profiles</tspan>
+    <tspan x="10px" y="586px"><tspan>    -Z target-applies-to-host   Enable the `target-applies-to-host` key in the .cargo/config.toml file</tspan>
 </tspan>
-    <tspan x="10px" y="604px"><tspan>    -Z unstable-options         Allow the usage of unstable options</tspan>
+    <tspan x="10px" y="604px"><tspan>    -Z trim-paths               Enable the `trim-paths` option in profiles</tspan>
 </tspan>
-    <tspan x="10px" y="622px">
+    <tspan x="10px" y="622px"><tspan>    -Z unstable-options         Allow the usage of unstable options</tspan>
 </tspan>
-    <tspan x="10px" y="640px"><tspan>Run with `cargo -Z [FLAG] [COMMAND]`</tspan>
+    <tspan x="10px" y="640px">
 </tspan>
-    <tspan x="10px" y="658px">
+    <tspan x="10px" y="658px"><tspan>Run with `cargo -Z [FLAG] [COMMAND]`</tspan>
 </tspan>
-    <tspan x="10px" y="676px"><tspan>See https://doc.rust-lang.org/nightly/cargo/reference/unstable.html for more information about these flags.</tspan>
+    <tspan x="10px" y="676px">
 </tspan>
-    <tspan x="10px" y="694px">
+    <tspan x="10px" y="694px"><tspan>See https://doc.rust-lang.org/nightly/cargo/reference/unstable.html for more information about these flags.</tspan>
+</tspan>
+    <tspan x="10px" y="712px">
 </tspan>
   </text>
 
diff --git a/tests/testsuite/cargo_package/help/stdout.term.svg b/tests/testsuite/cargo_package/help/stdout.term.svg
index 0b341bc2243..8f285119794 100644
--- a/tests/testsuite/cargo_package/help/stdout.term.svg
+++ b/tests/testsuite/cargo_package/help/stdout.term.svg
@@ -1,4 +1,4 @@
-<svg width="852px" height="740px" xmlns="http://www.w3.org/2000/svg">
+<svg width="860px" height="776px" xmlns="http://www.w3.org/2000/svg">
   <style>
     .fg { fill: #AAAAAA }
     .bg { background: #000000 }
@@ -29,75 +29,79 @@
 </tspan>
     <tspan x="10px" y="100px"><tspan class="fg-green bold">Options:</tspan>
 </tspan>
-    <tspan x="10px" y="118px"><tspan>  </tspan><tspan class="fg-cyan bold">-l</tspan><tspan>, </tspan><tspan class="fg-cyan bold">--list</tspan><tspan>                Print files included in a package without making one</tspan>
+    <tspan x="10px" y="118px"><tspan>      </tspan><tspan class="fg-cyan bold">--index</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;INDEX&gt;</tspan><tspan>        Registry index URL to prepare the package for (unstable)</tspan>
 </tspan>
-    <tspan x="10px" y="136px"><tspan>      </tspan><tspan class="fg-cyan bold">--no-verify</tspan><tspan>           Don't verify the contents by building them</tspan>
+    <tspan x="10px" y="136px"><tspan>      </tspan><tspan class="fg-cyan bold">--registry</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;REGISTRY&gt;</tspan><tspan>  Registry to prepare the package for (unstable)</tspan>
 </tspan>
-    <tspan x="10px" y="154px"><tspan>      </tspan><tspan class="fg-cyan bold">--no-metadata</tspan><tspan>         Ignore warnings about a lack of human-usable metadata</tspan>
+    <tspan x="10px" y="154px"><tspan>  </tspan><tspan class="fg-cyan bold">-l</tspan><tspan>, </tspan><tspan class="fg-cyan bold">--list</tspan><tspan>                 Print files included in a package without making one</tspan>
 </tspan>
-    <tspan x="10px" y="172px"><tspan>      </tspan><tspan class="fg-cyan bold">--allow-dirty</tspan><tspan>         Allow dirty working directories to be packaged</tspan>
+    <tspan x="10px" y="172px"><tspan>      </tspan><tspan class="fg-cyan bold">--no-verify</tspan><tspan>            Don't verify the contents by building them</tspan>
 </tspan>
-    <tspan x="10px" y="190px"><tspan>  </tspan><tspan class="fg-cyan bold">-v</tspan><tspan>, </tspan><tspan class="fg-cyan bold">--verbose</tspan><tspan class="fg-cyan">...</tspan><tspan>          Use verbose output (-vv very verbose/build.rs output)</tspan>
+    <tspan x="10px" y="190px"><tspan>      </tspan><tspan class="fg-cyan bold">--no-metadata</tspan><tspan>          Ignore warnings about a lack of human-usable metadata</tspan>
 </tspan>
-    <tspan x="10px" y="208px"><tspan>  </tspan><tspan class="fg-cyan bold">-q</tspan><tspan>, </tspan><tspan class="fg-cyan bold">--quiet</tspan><tspan>               Do not print cargo log messages</tspan>
+    <tspan x="10px" y="208px"><tspan>      </tspan><tspan class="fg-cyan bold">--allow-dirty</tspan><tspan>          Allow dirty working directories to be packaged</tspan>
 </tspan>
-    <tspan x="10px" y="226px"><tspan>      </tspan><tspan class="fg-cyan bold">--color</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;WHEN&gt;</tspan><tspan>        Coloring: auto, always, never</tspan>
+    <tspan x="10px" y="226px"><tspan>  </tspan><tspan class="fg-cyan bold">-v</tspan><tspan>, </tspan><tspan class="fg-cyan bold">--verbose</tspan><tspan class="fg-cyan">...</tspan><tspan>           Use verbose output (-vv very verbose/build.rs output)</tspan>
 </tspan>
-    <tspan x="10px" y="244px"><tspan>      </tspan><tspan class="fg-cyan bold">--config</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;KEY=VALUE&gt;</tspan><tspan>  Override a configuration value</tspan>
+    <tspan x="10px" y="244px"><tspan>  </tspan><tspan class="fg-cyan bold">-q</tspan><tspan>, </tspan><tspan class="fg-cyan bold">--quiet</tspan><tspan>                Do not print cargo log messages</tspan>
 </tspan>
-    <tspan x="10px" y="262px"><tspan>  </tspan><tspan class="fg-cyan bold">-Z</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FLAG&gt;</tspan><tspan>                 Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details</tspan>
+    <tspan x="10px" y="262px"><tspan>      </tspan><tspan class="fg-cyan bold">--color</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;WHEN&gt;</tspan><tspan>         Coloring: auto, always, never</tspan>
 </tspan>
-    <tspan x="10px" y="280px"><tspan>  </tspan><tspan class="fg-cyan bold">-h</tspan><tspan>, </tspan><tspan class="fg-cyan bold">--help</tspan><tspan>                Print help</tspan>
+    <tspan x="10px" y="280px"><tspan>      </tspan><tspan class="fg-cyan bold">--config</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;KEY=VALUE&gt;</tspan><tspan>   Override a configuration value</tspan>
 </tspan>
-    <tspan x="10px" y="298px">
+    <tspan x="10px" y="298px"><tspan>  </tspan><tspan class="fg-cyan bold">-Z</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FLAG&gt;</tspan><tspan>                  Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details</tspan>
 </tspan>
-    <tspan x="10px" y="316px"><tspan class="fg-green bold">Package Selection:</tspan>
+    <tspan x="10px" y="316px"><tspan>  </tspan><tspan class="fg-cyan bold">-h</tspan><tspan>, </tspan><tspan class="fg-cyan bold">--help</tspan><tspan>                 Print help</tspan>
 </tspan>
-    <tspan x="10px" y="334px"><tspan>  </tspan><tspan class="fg-cyan bold">-p</tspan><tspan>, </tspan><tspan class="fg-cyan bold">--package</tspan><tspan class="fg-cyan"> [</tspan><tspan class="fg-cyan">&lt;SPEC&gt;</tspan><tspan class="fg-cyan">]</tspan><tspan>  Package(s) to assemble</tspan>
+    <tspan x="10px" y="334px">
 </tspan>
-    <tspan x="10px" y="352px"><tspan>      </tspan><tspan class="fg-cyan bold">--workspace</tspan><tspan>         Assemble all packages in the workspace</tspan>
+    <tspan x="10px" y="352px"><tspan class="fg-green bold">Package Selection:</tspan>
 </tspan>
-    <tspan x="10px" y="370px"><tspan>      </tspan><tspan class="fg-cyan bold">--exclude</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;SPEC&gt;</tspan><tspan>    Don't assemble specified packages</tspan>
+    <tspan x="10px" y="370px"><tspan>  </tspan><tspan class="fg-cyan bold">-p</tspan><tspan>, </tspan><tspan class="fg-cyan bold">--package</tspan><tspan class="fg-cyan"> [</tspan><tspan class="fg-cyan">&lt;SPEC&gt;</tspan><tspan class="fg-cyan">]</tspan><tspan>  Package(s) to assemble</tspan>
 </tspan>
-    <tspan x="10px" y="388px">
+    <tspan x="10px" y="388px"><tspan>      </tspan><tspan class="fg-cyan bold">--workspace</tspan><tspan>         Assemble all packages in the workspace</tspan>
 </tspan>
-    <tspan x="10px" y="406px"><tspan class="fg-green bold">Feature Selection:</tspan>
+    <tspan x="10px" y="406px"><tspan>      </tspan><tspan class="fg-cyan bold">--exclude</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;SPEC&gt;</tspan><tspan>    Don't assemble specified packages</tspan>
 </tspan>
-    <tspan x="10px" y="424px"><tspan>  </tspan><tspan class="fg-cyan bold">-F</tspan><tspan>, </tspan><tspan class="fg-cyan bold">--features</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FEATURES&gt;</tspan><tspan>  Space or comma separated list of features to activate</tspan>
+    <tspan x="10px" y="424px">
 </tspan>
-    <tspan x="10px" y="442px"><tspan>      </tspan><tspan class="fg-cyan bold">--all-features</tspan><tspan>         Activate all available features</tspan>
+    <tspan x="10px" y="442px"><tspan class="fg-green bold">Feature Selection:</tspan>
 </tspan>
-    <tspan x="10px" y="460px"><tspan>      </tspan><tspan class="fg-cyan bold">--no-default-features</tspan><tspan>  Do not activate the `default` feature</tspan>
+    <tspan x="10px" y="460px"><tspan>  </tspan><tspan class="fg-cyan bold">-F</tspan><tspan>, </tspan><tspan class="fg-cyan bold">--features</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;FEATURES&gt;</tspan><tspan>  Space or comma separated list of features to activate</tspan>
 </tspan>
-    <tspan x="10px" y="478px">
+    <tspan x="10px" y="478px"><tspan>      </tspan><tspan class="fg-cyan bold">--all-features</tspan><tspan>         Activate all available features</tspan>
 </tspan>
-    <tspan x="10px" y="496px"><tspan class="fg-green bold">Compilation Options:</tspan>
+    <tspan x="10px" y="496px"><tspan>      </tspan><tspan class="fg-cyan bold">--no-default-features</tspan><tspan>  Do not activate the `default` feature</tspan>
 </tspan>
-    <tspan x="10px" y="514px"><tspan>      </tspan><tspan class="fg-cyan bold">--target</tspan><tspan class="fg-cyan"> [</tspan><tspan class="fg-cyan">&lt;TRIPLE&gt;</tspan><tspan class="fg-cyan">]</tspan><tspan>       Build for the target triple</tspan>
+    <tspan x="10px" y="514px">
 </tspan>
-    <tspan x="10px" y="532px"><tspan>      </tspan><tspan class="fg-cyan bold">--target-dir</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;DIRECTORY&gt;</tspan><tspan>  Directory for all generated artifacts</tspan>
+    <tspan x="10px" y="532px"><tspan class="fg-green bold">Compilation Options:</tspan>
 </tspan>
-    <tspan x="10px" y="550px"><tspan>  </tspan><tspan class="fg-cyan bold">-j</tspan><tspan>, </tspan><tspan class="fg-cyan bold">--jobs</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;N&gt;</tspan><tspan>                Number of parallel jobs, defaults to # of CPUs.</tspan>
+    <tspan x="10px" y="550px"><tspan>      </tspan><tspan class="fg-cyan bold">--target</tspan><tspan class="fg-cyan"> [</tspan><tspan class="fg-cyan">&lt;TRIPLE&gt;</tspan><tspan class="fg-cyan">]</tspan><tspan>       Build for the target triple</tspan>
 </tspan>
-    <tspan x="10px" y="568px"><tspan>      </tspan><tspan class="fg-cyan bold">--keep-going</tspan><tspan>              Do not abort the build as soon as there is an error</tspan>
+    <tspan x="10px" y="568px"><tspan>      </tspan><tspan class="fg-cyan bold">--target-dir</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;DIRECTORY&gt;</tspan><tspan>  Directory for all generated artifacts</tspan>
 </tspan>
-    <tspan x="10px" y="586px">
+    <tspan x="10px" y="586px"><tspan>  </tspan><tspan class="fg-cyan bold">-j</tspan><tspan>, </tspan><tspan class="fg-cyan bold">--jobs</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;N&gt;</tspan><tspan>                Number of parallel jobs, defaults to # of CPUs.</tspan>
 </tspan>
-    <tspan x="10px" y="604px"><tspan class="fg-green bold">Manifest Options:</tspan>
+    <tspan x="10px" y="604px"><tspan>      </tspan><tspan class="fg-cyan bold">--keep-going</tspan><tspan>              Do not abort the build as soon as there is an error</tspan>
 </tspan>
-    <tspan x="10px" y="622px"><tspan>      </tspan><tspan class="fg-cyan bold">--manifest-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;PATH&gt;</tspan><tspan>  Path to Cargo.toml</tspan>
+    <tspan x="10px" y="622px">
 </tspan>
-    <tspan x="10px" y="640px"><tspan>      </tspan><tspan class="fg-cyan bold">--locked</tspan><tspan>                Assert that `Cargo.lock` will remain unchanged</tspan>
+    <tspan x="10px" y="640px"><tspan class="fg-green bold">Manifest Options:</tspan>
 </tspan>
-    <tspan x="10px" y="658px"><tspan>      </tspan><tspan class="fg-cyan bold">--offline</tspan><tspan>               Run without accessing the network</tspan>
+    <tspan x="10px" y="658px"><tspan>      </tspan><tspan class="fg-cyan bold">--manifest-path</tspan><tspan class="fg-cyan"> </tspan><tspan class="fg-cyan">&lt;PATH&gt;</tspan><tspan>  Path to Cargo.toml</tspan>
 </tspan>
-    <tspan x="10px" y="676px"><tspan>      </tspan><tspan class="fg-cyan bold">--frozen</tspan><tspan>                Equivalent to specifying both --locked and --offline</tspan>
+    <tspan x="10px" y="676px"><tspan>      </tspan><tspan class="fg-cyan bold">--locked</tspan><tspan>                Assert that `Cargo.lock` will remain unchanged</tspan>
 </tspan>
-    <tspan x="10px" y="694px">
+    <tspan x="10px" y="694px"><tspan>      </tspan><tspan class="fg-cyan bold">--offline</tspan><tspan>               Run without accessing the network</tspan>
 </tspan>
-    <tspan x="10px" y="712px"><tspan>Run `</tspan><tspan class="fg-cyan bold">cargo help package</tspan><tspan class="bold">` for more detailed information.</tspan>
+    <tspan x="10px" y="712px"><tspan>      </tspan><tspan class="fg-cyan bold">--frozen</tspan><tspan>                Equivalent to specifying both --locked and --offline</tspan>
 </tspan>
     <tspan x="10px" y="730px">
+</tspan>
+    <tspan x="10px" y="748px"><tspan>Run `</tspan><tspan class="fg-cyan bold">cargo help package</tspan><tspan class="bold">` for more detailed information.</tspan>
+</tspan>
+    <tspan x="10px" y="766px">
 </tspan>
   </text>
 
diff --git a/tests/testsuite/package.rs b/tests/testsuite/package.rs
index 33731f91599..92a91d41732 100644
--- a/tests/testsuite/package.rs
+++ b/tests/testsuite/package.rs
@@ -8,7 +8,7 @@ use cargo_test_support::publish::validate_crate_contents;
 use cargo_test_support::registry::{self, Package};
 use cargo_test_support::{
     basic_manifest, cargo_process, git, paths, project, rustc_host, str, symlink_supported, t,
-    ProjectBuilder,
+    Project, ProjectBuilder,
 };
 use flate2::read::GzDecoder;
 use tar::Archive;
@@ -2813,13 +2813,13 @@ fn in_workspace() {
 See https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info.
 [PACKAGING] bar v0.0.1 ([ROOT]/foo/bar)
 [PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
-[VERIFYING] bar v0.0.1 ([ROOT]/foo/bar)
-[COMPILING] bar v0.0.1 ([ROOT]/foo/target/package/bar-0.0.1)
-[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
 [WARNING] manifest has no documentation, homepage or repository.
 See https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info.
 [PACKAGING] foo v0.0.1 ([ROOT]/foo)
 [PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
+[VERIFYING] bar v0.0.1 ([ROOT]/foo/bar)
+[COMPILING] bar v0.0.1 ([ROOT]/foo/target/package/bar-0.0.1)
+[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
 [VERIFYING] foo v0.0.1 ([ROOT]/foo)
 [COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)
 [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
@@ -5079,11 +5079,8 @@ path = "examples/z.rs"
 
 // A workspace with three projects that depend on one another (level1 -> level2 -> level3).
 // level1 is a binary package, to test lockfile generation.
-#[cargo_test]
-fn workspace_with_local_deps() {
-    let crates_io = registry::init();
-    let p =
-        project()
+fn workspace_with_local_deps_project() -> Project {
+    project()
             .file(
                 "Cargo.toml",
                 r#"
@@ -5146,13 +5143,23 @@ fn workspace_with_local_deps() {
         "#,
             )
             .file("level3/src/lib.rs", "")
-            .build();
+            .build()
+}
+
+#[cargo_test]
+fn workspace_with_local_deps() {
+    let crates_io = registry::init();
+    let p = workspace_with_local_deps_project();
 
     p.cargo("package")
         .replace_crates_io(crates_io.index_url())
         .with_status(101)
         .with_stdout_data("")
         .with_stderr_data(str![[r#"
+[PACKAGING] level3 v0.0.1 ([ROOT]/foo/level3)
+[PACKAGED] 3 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
+[PACKAGING] level2 v0.0.1 ([ROOT]/foo/level2)
+[PACKAGED] 3 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
 [PACKAGING] level1 v0.0.1 ([ROOT]/foo/level1)
 [UPDATING] crates.io index
 [ERROR] failed to prepare local package for uploading
@@ -5167,9 +5174,112 @@ Caused by:
 }
 
 #[cargo_test]
-fn workspace_with_local_deps_packaging_one_fails() {
+fn workspace_with_local_deps_nightly() {
     let crates_io = registry::init();
-    let p = project()
+    let p = workspace_with_local_deps_project();
+
+    p.cargo("package -Zpackage-workspace")
+        .masquerade_as_nightly_cargo(&["package-workspace"])
+        .replace_crates_io(crates_io.index_url())
+        .with_stdout_data("")
+        .with_stderr_data(str![[r#"
+[PACKAGING] level3 v0.0.1 ([ROOT]/foo/level3)
+[PACKAGED] 3 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
+[PACKAGING] level2 v0.0.1 ([ROOT]/foo/level2)
+[PACKAGED] 3 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
+[PACKAGING] level1 v0.0.1 ([ROOT]/foo/level1)
+[UPDATING] crates.io index
+[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
+[VERIFYING] level3 v0.0.1 ([ROOT]/foo/level3)
+[COMPILING] level3 v0.0.1 ([ROOT]/foo/target/package/level3-0.0.1)
+[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
+[VERIFYING] level2 v0.0.1 ([ROOT]/foo/level2)
+[UNPACKING] level3 v0.0.1 (registry `[ROOT]/foo/target/package/tmp-registry`)
+[COMPILING] level3 v0.0.1
+[COMPILING] level2 v0.0.1 ([ROOT]/foo/target/package/level2-0.0.1)
+[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
+[VERIFYING] level1 v0.0.1 ([ROOT]/foo/level1)
+[UNPACKING] level2 v0.0.1 (registry `[ROOT]/foo/target/package/tmp-registry`)
+[COMPILING] level3 v0.0.1
+[COMPILING] level2 v0.0.1
+[COMPILING] level1 v0.0.1 ([ROOT]/foo/target/package/level1-0.0.1)
+[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
+
+"#]])
+        .run();
+
+    let generated_lock = format!(
+        r#"# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "level1"
+version = "0.0.1"
+dependencies = [
+ "level2",
+]
+
+[[package]]
+name = "level2"
+version = "0.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = [..]
+dependencies = [
+ "level3",
+]
+
+[[package]]
+name = "level3"
+version = "0.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = [..]
+"#
+    );
+
+    let generated_manifest = format!(
+        r#"{}
+[package]
+edition = "2015"
+name = "level1"
+version = "0.0.1"
+authors = []
+build = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "level1"
+readme = false
+license = "MIT"
+repository = "bar"
+
+[[bin]]
+name = "level1"
+path = "src/main.rs"
+
+[dependencies.level2]
+version = "0.0.1"
+features = ["foo"]
+"#,
+        cargo::core::manifest::MANIFEST_PREAMBLE,
+    );
+
+    let mut f = File::open(&p.root().join("target/package/level1-0.0.1.crate")).unwrap();
+
+    validate_crate_contents(
+        &mut f,
+        "level1-0.0.1.crate",
+        &["Cargo.lock", "Cargo.toml", "Cargo.toml.orig", "src/main.rs"],
+        &[
+            ("Cargo.lock", &generated_lock),
+            ("Cargo.toml", &generated_manifest),
+        ],
+    );
+}
+
+fn workspace_with_local_deps_packaging_one_fails_project() -> Project {
+    project()
         .file(
             "Cargo.toml",
             r#"
@@ -5208,7 +5318,13 @@ fn workspace_with_local_deps_packaging_one_fails() {
         "#,
         )
         .file("level2/src/lib.rs", "")
-        .build();
+        .build()
+}
+
+#[cargo_test]
+fn workspace_with_local_deps_packaging_one_fails() {
+    let crates_io = registry::init();
+    let p = workspace_with_local_deps_packaging_one_fails_project();
 
     // We can't package just level1, because there's a dependency on level2.
     p.cargo("package -p level1")
@@ -5231,6 +5347,33 @@ Caused by:
         .run();
 }
 
+#[cargo_test]
+fn workspace_with_local_deps_packaging_one_fails_nightly() {
+    let crates_io = registry::init();
+    let p = workspace_with_local_deps_packaging_one_fails_project();
+
+    // We can't package just level1, because there's a dependency on level2.
+    p.cargo("package -p level1 -Zpackage-workspace")
+        .masquerade_as_nightly_cargo(&["package-workspace"])
+        .replace_crates_io(crates_io.index_url())
+        .with_status(101)
+        .with_stdout_data("")
+        .with_stderr_data(str![[r#"
+[PACKAGING] level1 v0.0.1 ([ROOT]/foo/level1)
+[PACKAGED] 3 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
+[VERIFYING] level1 v0.0.1 ([ROOT]/foo/level1)
+[UPDATING] crates.io index
+[ERROR] failed to verify package tarball
+
+Caused by:
+  no matching package named `level2` found
+  location searched: registry `crates-io`
+  required by package `level1 v0.0.1 ([ROOT]/foo/target/package/level1-0.0.1)`
+
+"#]])
+        .run();
+}
+
 // Same as workspace_with_local_deps_packaging_one_fails except that we're
 // packaging a bin. This fails during lock-file generation instead of during verification.
 #[cargo_test]
@@ -5278,7 +5421,8 @@ fn workspace_with_local_deps_packaging_one_bin_fails() {
         .build();
 
     // We can't package just level1, because there's a dependency on level2.
-    p.cargo("package -p level1")
+    p.cargo("package -p level1 -Zpackage-workspace")
+        .masquerade_as_nightly_cargo(&["package-workspace"])
         .replace_crates_io(crates_io.index_url())
         .with_status(101)
         .with_stdout_data("")
@@ -5359,21 +5503,24 @@ fn workspace_with_local_deps_packaging_one_with_needed_deps() {
         .file("level3/src/lib.rs", "")
         .build();
 
-    p.cargo("package -p level2 -p level3")
+    p.cargo("package -p level2 -p level3 -Zpackage-workspace")
+        .masquerade_as_nightly_cargo(&["package-workspace"])
         .replace_crates_io(crates_io.index_url())
-        .with_status(101)
         .with_stdout_data("")
         .with_stderr_data(str![[r#"
+[PACKAGING] level3 v0.0.1 ([ROOT]/foo/level3)
+[PACKAGED] 3 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
 [PACKAGING] level2 v0.0.1 ([ROOT]/foo/level2)
 [PACKAGED] 3 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
+[VERIFYING] level3 v0.0.1 ([ROOT]/foo/level3)
+[COMPILING] level3 v0.0.1 ([ROOT]/foo/target/package/level3-0.0.1)
+[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
 [VERIFYING] level2 v0.0.1 ([ROOT]/foo/level2)
 [UPDATING] crates.io index
-[ERROR] failed to verify package tarball
-
-Caused by:
-  no matching package named `level3` found
-  location searched: registry `crates-io`
-  required by package `level2 v0.0.1 ([ROOT]/foo/target/package/level2-0.0.1)`
+[UNPACKING] level3 v0.0.1 (registry `[ROOT]/foo/target/package/tmp-registry`)
+[COMPILING] level3 v0.0.1
+[COMPILING] level2 v0.0.1 ([ROOT]/foo/target/package/level2-0.0.1)
+[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
 
 "#]])
         .run();
@@ -5428,13 +5575,13 @@ fn workspace_with_local_deps_list() {
     p.cargo("package --list")
         .replace_crates_io(crates_io.index_url())
         .with_stdout_data(str![[r#"
-Cargo.lock
 Cargo.toml
 Cargo.toml.orig
-src/main.rs
+src/lib.rs
+Cargo.lock
 Cargo.toml
 Cargo.toml.orig
-src/lib.rs
+src/main.rs
 
 "#]])
         .with_stderr_data("")
@@ -5490,18 +5637,27 @@ fn workspace_with_local_deps_index_mismatch() {
         )
         .file("level2/src/lib.rs", "")
         .build();
-    p.cargo(&format!("package --index {}", alt_reg.index_url()))
-        .with_status(1)
-        .with_stdout_data("")
-        .with_stderr_data(str![[r#"
-[ERROR] unexpected argument '--index' found
-
-Usage: cargo package [OPTIONS]
+    p.cargo(&format!(
+        "package --index {} -Zpackage-workspace",
+        alt_reg.index_url()
+    ))
+    .masquerade_as_nightly_cargo(&["package-workspace"])
+    .with_status(101)
+    .with_stdout_data("")
+    .with_stderr_data(str![[r#"
+[PACKAGING] level2 v0.0.1 ([ROOT]/foo/level2)
+[PACKAGED] 3 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
+[PACKAGING] level1 v0.0.1 ([ROOT]/foo/level1)
+[UPDATING] crates.io index
+[ERROR] failed to prepare local package for uploading
 
-For more information, try '--help'.
+Caused by:
+  no matching package named `level2` found
+  location searched: registry `crates-io`
+  required by package `level1 v0.0.1 ([ROOT]/foo/level1)`
 
 "#]])
-        .run();
+    .run();
 }
 
 #[cargo_test]
@@ -5552,27 +5708,66 @@ fn workspace_with_local_deps_alternative_index() {
         .file("level2/src/lib.rs", "")
         .build();
 
-    p.cargo(&format!("package --index {}", alt_reg.index_url()))
-        .with_status(1)
-        .with_stdout_data("")
-        .with_stderr_data(str![[r#"
-[ERROR] unexpected argument '--index' found
+    p.cargo(&format!(
+        "package --index {} -Zpackage-workspace",
+        alt_reg.index_url()
+    ))
+    .masquerade_as_nightly_cargo(&["package-workspace"])
+    .with_stdout_data("")
+    .with_stderr_data(str![[r#"
+[PACKAGING] level2 v0.0.1 ([ROOT]/foo/level2)
+[PACKAGED] 3 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
+[PACKAGING] level1 v0.0.1 ([ROOT]/foo/level1)
+[UPDATING] `alternative` index
+[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
+[VERIFYING] level2 v0.0.1 ([ROOT]/foo/level2)
+[COMPILING] level2 v0.0.1 ([ROOT]/foo/target/package/level2-0.0.1)
+[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
+[VERIFYING] level1 v0.0.1 ([ROOT]/foo/level1)
+[UPDATING] `alternative` index
+[UNPACKING] level2 v0.0.1 (registry `[ROOT]/foo/target/package/tmp-registry`)
+[COMPILING] level2 v0.0.1 (registry `alternative`)
+[COMPILING] level1 v0.0.1 ([ROOT]/foo/target/package/level1-0.0.1)
+[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
 
-Usage: cargo package [OPTIONS]
+"#]])
+    .run();
 
-For more information, try '--help'.
+    let index = alt_reg.index_url();
+    let generated_lock = format!(
+        r#"# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
 
-"#]])
-        .run();
-}
+[[package]]
+name = "level1"
+version = "0.0.1"
+dependencies = [
+ "level2",
+]
 
-#[cargo_test]
-fn workspace_with_local_dep_already_published() {
-    let reg = registry::init();
+[[package]]
+name = "level2"
+version = "0.0.1"
+source = "{index}"
+checksum = [..]
+"#
+    );
+
+    let mut f = File::open(&p.root().join("target/package/level1-0.0.1.crate")).unwrap();
+
+    validate_crate_contents(
+        &mut f,
+        "level1-0.0.1.crate",
+        &["Cargo.lock", "Cargo.toml", "Cargo.toml.orig", "src/main.rs"],
+        &[("Cargo.lock", &generated_lock)],
+    );
+}
 
+fn workspace_with_local_dep_already_published_project() -> Project {
     Package::new("dep", "0.1.0").publish();
 
-    let p = project()
+    project()
         .file(
             "Cargo.toml",
             r#"
@@ -5611,7 +5806,13 @@ fn workspace_with_local_dep_already_published() {
         "#,
         )
         .file("dep/src/lib.rs", "")
-        .build();
+        .build()
+}
+
+#[cargo_test]
+fn workspace_with_local_dep_already_published() {
+    let reg = registry::init();
+    let p = workspace_with_local_dep_already_published_project();
 
     p.cargo("package")
         .replace_crates_io(reg.index_url())
@@ -5621,10 +5822,10 @@ fn workspace_with_local_dep_already_published() {
 [PACKAGED] 3 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
 [PACKAGING] main v0.0.1 ([ROOT]/foo/main)
 [UPDATING] crates.io index
+[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
 [VERIFYING] dep v0.1.0 ([ROOT]/foo/dep)
 [COMPILING] dep v0.1.0 ([ROOT]/foo/target/package/dep-0.1.0)
 [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
-[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
 [VERIFYING] main v0.0.1 ([ROOT]/foo/main)
 [DOWNLOADING] crates ...
 [DOWNLOADED] dep v0.1.0
@@ -5638,6 +5839,35 @@ fn workspace_with_local_dep_already_published() {
         .run();
 }
 
+#[cargo_test]
+fn workspace_with_local_dep_already_published_nightly() {
+    let reg = registry::init();
+    let p = workspace_with_local_dep_already_published_project();
+
+    p.cargo("package -Zpackage-workspace")
+        .masquerade_as_nightly_cargo(&["package-workspace"])
+        .replace_crates_io(reg.index_url())
+        .with_status(101)
+        .with_stderr_data(
+            str![[r#"
+[PACKAGING] dep v0.1.0 ([ROOT]/foo/dep)
+[PACKAGED] 3 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
+[PACKAGING] main v0.0.1 ([ROOT]/foo/main)
+[UPDATING] crates.io index
+[ERROR] failed to prepare local package for uploading
+
+Caused by:
+  failed to get `dep` as a dependency of package `main v0.0.1 ([ROOT]/foo/main)`
+
+Caused by:
+  found a package in the remote registry and the local overlay: dep@0.1.0
+
+"#]]
+            .unordered(),
+        )
+        .run();
+}
+
 #[cargo_test]
 fn workspace_with_local_and_remote_deps() {
     let reg = registry::init();
@@ -5686,25 +5916,30 @@ fn workspace_with_local_and_remote_deps() {
         .file("dep/src/lib.rs", "")
         .build();
 
-    p.cargo("package")
+    p.cargo("package -Zpackage-workspace")
+        .masquerade_as_nightly_cargo(&["package-workspace"])
         .replace_crates_io(reg.index_url())
-        .with_status(101)
-        .with_stderr_data(str![[r#"
+        .with_stderr_data(
+            str![[r#"
 [PACKAGING] dep v0.1.0 ([ROOT]/foo/dep)
 [PACKAGED] 3 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
+[PACKAGING] main v0.0.1 ([ROOT]/foo/main)
+[UPDATING] crates.io index
+[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
 [VERIFYING] dep v0.1.0 ([ROOT]/foo/dep)
 [COMPILING] dep v0.1.0 ([ROOT]/foo/target/package/dep-0.1.0)
 [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
-[PACKAGING] main v0.0.1 ([ROOT]/foo/main)
-[UPDATING] crates.io index
-[ERROR] failed to prepare local package for uploading
-
-Caused by:
-  failed to select a version for the requirement `dep = "^0.1.0"`
-  candidate versions found which didn't match: 0.0.1
-  location searched: crates.io index
-  required by package `main v0.0.1 ([ROOT]/foo/main)`
+[VERIFYING] main v0.0.1 ([ROOT]/foo/main)
+[DOWNLOADING] crates ...
+[UNPACKING] dep v0.1.0 (registry `[ROOT]/foo/target/package/tmp-registry`)
+[DOWNLOADED] dep v0.0.1
+[COMPILING] dep v0.0.1
+[COMPILING] dep v0.1.0
+[COMPILING] main v0.0.1 ([ROOT]/foo/target/package/main-0.0.1)
+[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
 
-"#]])
+"#]]
+            .unordered(),
+        )
         .run();
 }
diff --git a/tests/testsuite/publish_lockfile.rs b/tests/testsuite/publish_lockfile.rs
index eaeb057964d..5f86b6e9f8f 100644
--- a/tests/testsuite/publish_lockfile.rs
+++ b/tests/testsuite/publish_lockfile.rs
@@ -553,16 +553,16 @@ See https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for
 [PACKAGING] bar v0.0.1 ([ROOT]/foo/bar)
 [UPDATING] `dummy-registry` index
 [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] foo v0.0.1 ([ROOT]/foo)
+[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
 [VERIFYING] bar v0.0.1 ([ROOT]/foo/bar)
 [DOWNLOADING] crates ...
 [DOWNLOADED] serde v0.2.0 (registry `dummy-registry`)
 [COMPILING] serde v0.2.0
 [COMPILING] bar v0.0.1 ([ROOT]/foo/target/package/bar-0.0.1)
 [FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
-[WARNING] manifest has no documentation, homepage or repository.
-See https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata for more info.
-[PACKAGING] foo v0.0.1 ([ROOT]/foo)
-[PACKAGED] 4 files, [FILE_SIZE]B ([FILE_SIZE]B compressed)
 [VERIFYING] foo v0.0.1 ([ROOT]/foo)
 [COMPILING] serde v0.2.0
 [COMPILING] foo v0.0.1 ([ROOT]/foo/target/package/foo-0.0.1)