refactor(embedded): Move embedded validation to to_real_manifest

This is where a lot of the other logic like it is

Author: epage

src/cargo/util/toml/embedded.rs

@@ -6,14 +6,6 @@ use crate::util::restricted_names;
 use crate::CargoResult;
 use crate::GlobalContext;
 
-const AUTO_FIELDS: &[&str] = &[
-    "autolib",
-    "autobins",
-    "autoexamples",
-    "autotests",
-    "autobenches",
-];
-
 pub(super) fn expand_manifest(
     content: &str,
     path: &std::path::Path,
@@ -78,23 +70,6 @@ pub(super) fn expand_manifest(
 fn expand_manifest_(manifest: &str, path: &std::path::Path) -> CargoResult<toml::Table> {
     let mut manifest: toml::Table = toml::from_str(&manifest)?;
 
-    for key in ["workspace", "lib", "bin", "example", "test", "bench"] {
-        if manifest.contains_key(key) {
-            anyhow::bail!("`{key}` is not allowed in embedded manifests")
-        }
-    }
-
-    if let Some(package) = manifest.get("package").and_then(|v| v.as_table()) {
-        for key in ["workspace", "build", "links"]
-            .iter()
-            .chain(AUTO_FIELDS.iter())
-        {
-            if package.contains_key(*key) {
-                anyhow::bail!("`package.{key}` is not allowed in embedded manifests")
-            }
-        }
-    }
-
     // HACK: Using an absolute path while `hacked_path` is in use
     let bin_path = path.to_string_lossy().into_owned();
     let file_stem = path
@@ -107,10 +82,12 @@ fn expand_manifest_(manifest: &str, path: &std::path::Path) -> CargoResult<toml:
     let mut bin = toml::Table::new();
     bin.insert("name".to_owned(), toml::Value::String(bin_name));
     bin.insert("path".to_owned(), toml::Value::String(bin_path));
-    manifest.insert(
-        "bin".to_owned(),
-        toml::Value::Array(vec![toml::Value::Table(bin)]),
-    );
+    manifest
+        .entry("bin")
+        .or_insert_with(|| Vec::<toml::Value>::new().into())
+        .as_array_mut()
+        .ok_or_else(|| anyhow::format_err!("`bin` must be an array"))?
+        .push(toml::Value::Table(bin));
 
     Ok(manifest)
 }

src/cargo/util/toml/mod.rs

@@ -1333,6 +1333,89 @@ pub fn to_real_manifest(
         features.require(Feature::metabuild())?;
     }
 
+    if is_embedded {
+        let invalid_fields = [
+            ("`workspace`", original_toml.workspace.is_some()),
+            ("`lib`", original_toml.lib.is_some()),
+            (
+                "`bin`",
+                original_toml.bin.as_ref().map(|b| b.len()).unwrap_or(0) != 1,
+            ),
+            ("`example`", original_toml.example.is_some()),
+            ("`test`", original_toml.test.is_some()),
+            ("`bench`", original_toml.bench.is_some()),
+            (
+                "`package.workspace`",
+                original_toml
+                    .package()
+                    .map(|p| p.workspace.is_some())
+                    .unwrap_or(false),
+            ),
+            (
+                "`package.build`",
+                original_toml
+                    .package()
+                    .map(|p| p.build.is_some())
+                    .unwrap_or(false),
+            ),
+            (
+                "`package.links`",
+                original_toml
+                    .package()
+                    .map(|p| p.links.is_some())
+                    .unwrap_or(false),
+            ),
+            (
+                "`package.autolib`",
+                original_toml
+                    .package()
+                    .map(|p| p.autolib.is_some())
+                    .unwrap_or(false),
+            ),
+            (
+                "`package.autobins`",
+                original_toml
+                    .package()
+                    .map(|p| p.autobins.is_some())
+                    .unwrap_or(false),
+            ),
+            (
+                "`package.autoexamples`",
+                original_toml
+                    .package()
+                    .map(|p| p.autoexamples.is_some())
+                    .unwrap_or(false),
+            ),
+            (
+                "`package.autotests`",
+                original_toml
+                    .package()
+                    .map(|p| p.autotests.is_some())
+                    .unwrap_or(false),
+            ),
+            (
+                "`package.autobenches`",
+                original_toml
+                    .package()
+                    .map(|p| p.autobenches.is_some())
+                    .unwrap_or(false),
+            ),
+        ];
+        let invalid_fields = invalid_fields
+            .into_iter()
+            .filter_map(|(name, invalid)| invalid.then_some(name))
+            .collect::<Vec<_>>();
+        if !invalid_fields.is_empty() {
+            let fields = invalid_fields.join(", ");
+            let are = if invalid_fields.len() == 1 {
+                "is"
+            } else {
+                "are"
+            };
+            anyhow::bail!("{fields} {are} not allowed in embedded manifests")
+        }
+    }
+
     let resolve_behavior = match (
         normalized_package.resolver.as_ref(),
         normalized_toml