fix(embedded): Don't create an intermediate manifest

Cargo.toml

@@ -13,7 +13,6 @@ exclude = [
 [workspace.dependencies]
 anyhow = "1.0.47"
 base64 = "0.21.0"
-blake3 = "1.3.3"
 bytesize = "1.0"
 cargo = { path = "" }
 cargo-credential = { version = "0.2.0", path = "credential/cargo-credential" }
@@ -115,7 +114,6 @@ path = "src/cargo/lib.rs"
 [dependencies]
 anyhow.workspace = true
 base64.workspace = true
-blake3.workspace = true
 bytesize.workspace = true
 cargo-platform.workspace = true
 cargo-util.workspace = true

deny.toml

@@ -106,7 +106,6 @@ allow = [
     "MIT-0",
     "Apache-2.0",
     "BSD-3-Clause",
-    "BSD-2-Clause",
     "MPL-2.0",
     "Unicode-DFS-2016",
     "CC0-1.0",

src/bin/cargo/commands/run.rs

@@ -5,6 +5,7 @@ use std::path::Path;
 use crate::command_prelude::*;
 use crate::util::restricted_names::is_glob_pattern;
 use cargo::core::Verbosity;
+use cargo::core::Workspace;
 use cargo::ops::{self, CompileFilter, Packages};
 use cargo_util::ProcessError;
 
@@ -95,14 +96,19 @@ pub fn exec_manifest_command(config: &Config, cmd: &str, args: &[OsString]) -> C
     }
 
     let manifest_path = Path::new(cmd);
+    let manifest_path = config.cwd().join(manifest_path);
+    let manifest_path = cargo_util::paths::normalize_path(&manifest_path);
     if !manifest_path.exists() {
-        return Err(
-            anyhow::anyhow!("manifest `{}` does not exist", manifest_path.display()).into(),
-        );
+        return Err(anyhow::format_err!(
+            "manifest path `{}` does not exist",
+            manifest_path.display()
+        )
+        .into());
+    }
+    let mut ws = Workspace::new(&manifest_path, config)?;
+    if config.cli_unstable().avoid_dev_deps {
+        ws.set_require_optional_deps(false);
     }
-    let manifest_path = crate::util::try_canonicalize(manifest_path)?;
-    let script = cargo::util::toml::embedded::parse_from(&manifest_path)?;
-    let ws = cargo::util::toml::embedded::to_workspace(&script, config)?;
 
     let mut compile_opts =
         cargo::ops::CompileOptions::new(config, cargo::core::compiler::CompileMode::Build)?;

src/cargo/core/manifest.rs

@@ -64,6 +64,7 @@ pub struct Manifest {
     metabuild: Option<Vec<String>>,
     resolve_behavior: Option<ResolveBehavior>,
     lint_rustflags: Vec<String>,
+    embedded: bool,
 }
 
 /// When parsing `Cargo.toml`, some warnings should silenced
@@ -407,6 +408,7 @@ impl Manifest {
         metabuild: Option<Vec<String>>,
         resolve_behavior: Option<ResolveBehavior>,
         lint_rustflags: Vec<String>,
+        embedded: bool,
     ) -> Manifest {
         Manifest {
             summary,
@@ -433,6 +435,7 @@ impl Manifest {
             metabuild,
             resolve_behavior,
             lint_rustflags,
+            embedded,
         }
     }
 
@@ -500,6 +503,9 @@ impl Manifest {
     pub fn links(&self) -> Option<&str> {
         self.links.as_deref()
     }
+    pub fn is_embedded(&self) -> bool {
+        self.embedded
+    }
 
     pub fn workspace_config(&self) -> &WorkspaceConfig {
         &self.workspace

src/cargo/core/workspace.rs

@@ -726,6 +726,10 @@ impl<'cfg> Workspace<'cfg> {
         if self.members.contains(&manifest_path) {
             return Ok(());
         }
+        if is_path_dep && self.root_maybe().is_embedded() {
+            // Embedded manifests cannot have workspace members
+            return Ok(());
+        }
         if is_path_dep
             && !manifest_path.parent().unwrap().starts_with(self.root())
             && self.find_root(&manifest_path)? != self.root_manifest
@@ -1580,6 +1584,13 @@ impl MaybePackage {
             MaybePackage::Virtual(ref vm) => vm.workspace_config(),
         }
     }
+
+    fn is_embedded(&self) -> bool {
+        match self {
+            MaybePackage::Package(p) => p.manifest().is_embedded(),
+            MaybePackage::Virtual(_) => false,
+        }
+    }
 }
 
 impl WorkspaceRootConfig {

src/cargo/ops/cargo_package.rs

@@ -393,7 +393,7 @@ fn build_lock(ws: &Workspace<'_>, orig_pkg: &Package) -> CargoResult<String> {
     let package_root = orig_pkg.root();
     let source_id = orig_pkg.package_id().source_id();
     let (manifest, _nested_paths) =
-        TomlManifest::to_real_manifest(&toml_manifest, source_id, package_root, config)?;
+        TomlManifest::to_real_manifest(&toml_manifest, false, source_id, package_root, config)?;
     let new_pkg = Package::new(manifest, orig_pkg.manifest_path());
 
     // Regenerate Cargo.lock using the old one as a guide.