refactor(embedded): Integrate cargo-script logic into main parser (#15168)

### What does this PR try to resolve?

This is a part of #12207

Now that the experiment is over and we can be intrusive, this merges all
of the permanent cargo-script manifest logic into the regular manifest
loading code path with the goal of reducing the number of places people
need to be aware to check to know how things work so we're less likely
to overlook them (e.g. `package.name`s being optional). This should also
make error reporting better as we will eventually only use the real
manifest users specify, instead of one with a lot of edits by us.

This comes at the cost of some uglier code needed to check some of these
cases.

### How should we test and review this PR?

### Additional information

Author: ehuss

Diff for: crates/cargo-util-schemas/manifest.schema.json

@@ -241,7 +241,10 @@
           ]
         },
         "name": {
-          "type": "string"
+          "type": [
+            "string",
+            "null"
+          ]
         },
         "version": {
           "anyOf": [
@@ -475,10 +478,7 @@
             }
           ]
         }
-      },
-      "required": [
-        "name"
-      ]
+      }
     },
     "InheritableField_for_string": {
       "description": "An enum that allows for inheriting keys from a workspace in a Cargo.toml.",

Diff for: crates/cargo-util-schemas/src/manifest/mod.rs

@@ -171,15 +171,15 @@ pub struct InheritablePackage {
 /// are serialized to a TOML file. For example, you cannot have values after
 /// the field `metadata`, since it is a table and values cannot appear after
 /// tables.
-#[derive(Deserialize, Serialize, Clone, Debug)]
+#[derive(Deserialize, Serialize, Clone, Debug, Default)]
 #[serde(rename_all = "kebab-case")]
 #[cfg_attr(feature = "unstable-schema", derive(schemars::JsonSchema))]
 pub struct TomlPackage {
     pub edition: Option<InheritableString>,
     #[cfg_attr(feature = "unstable-schema", schemars(with = "Option<String>"))]
     pub rust_version: Option<InheritableRustVersion>,
-    #[cfg_attr(feature = "unstable-schema", schemars(with = "String"))]
-    pub name: PackageName,
+    #[cfg_attr(feature = "unstable-schema", schemars(with = "Option<String>"))]
+    pub name: Option<PackageName>,
     pub version: Option<InheritableSemverVersion>,
     pub authors: Option<InheritableVecString>,
     pub build: Option<StringOrBool>,
@@ -226,43 +226,15 @@ pub struct TomlPackage {
 impl TomlPackage {
     pub fn new(name: PackageName) -> Self {
         Self {
-            name,
-
-            edition: None,
-            rust_version: None,
-            version: None,
-            authors: None,
-            build: None,
-            metabuild: None,
-            default_target: None,
-            forced_target: None,
-            links: None,
-            exclude: None,
-            include: None,
-            publish: None,
-            workspace: None,
-            im_a_teapot: None,
-            autolib: None,
-            autobins: None,
-            autoexamples: None,
-            autotests: None,
-            autobenches: None,
-            default_run: None,
-            description: None,
-            homepage: None,
-            documentation: None,
-            readme: None,
-            keywords: None,
-            categories: None,
-            license: None,
-            license_file: None,
-            repository: None,
-            resolver: None,
-            metadata: None,
-            _invalid_cargo_features: None,
+            name: Some(name),
+            ..Default::default()
         }
     }
 
+    pub fn normalized_name(&self) -> Result<&PackageName, UnresolvedError> {
+        self.name.as_ref().ok_or(UnresolvedError)
+    }
+
     pub fn normalized_edition(&self) -> Result<Option<&String>, UnresolvedError> {
         self.edition.as_ref().map(|v| v.normalized()).transpose()
     }

Diff for: src/cargo/ops/vendor.rs

@@ -434,6 +434,7 @@ fn prepare_for_vendor(
         workspace_config,
         source_id,
         me.manifest_path(),
+        me.manifest().is_embedded(),
         gctx,
         &mut warnings,
         &mut errors,

Diff for: src/cargo/util/toml/embedded.rs

@@ -6,16 +6,6 @@ use crate::util::restricted_names;
 use crate::CargoResult;
 use crate::GlobalContext;
 
-const DEFAULT_EDITION: crate::core::features::Edition =
-    crate::core::features::Edition::LATEST_STABLE;
-const AUTO_FIELDS: &[&str] = &[
-    "autolib",
-    "autobins",
-    "autoexamples",
-    "autotests",
-    "autobenches",
-];
-
 pub(super) fn expand_manifest(
     content: &str,
     path: &std::path::Path,
@@ -64,88 +54,46 @@ pub(super) fn expand_manifest(
         }
         cargo_util::paths::write_if_changed(&hacked_path, hacked_source)?;
 
-        let manifest = expand_manifest_(&frontmatter, &hacked_path, gctx)
-            .with_context(|| format!("failed to parse manifest at {}", path.display()))?;
+        let manifest = inject_bin_path(&frontmatter, &hacked_path)
+            .with_context(|| format!("failed to parse manifest at `{}`", path.display()))?;
         let manifest = toml::to_string_pretty(&manifest)?;
         Ok(manifest)
     } else {
         let frontmatter = "";
-        let manifest = expand_manifest_(frontmatter, path, gctx)
-            .with_context(|| format!("failed to parse manifest at {}", path.display()))?;
+        let manifest = inject_bin_path(frontmatter, path)
+            .with_context(|| format!("failed to parse manifest at `{}`", path.display()))?;
         let manifest = toml::to_string_pretty(&manifest)?;
         Ok(manifest)
     }
 }
 
-fn expand_manifest_(
-    manifest: &str,
-    path: &std::path::Path,
-    gctx: &GlobalContext,
-) -> CargoResult<toml::Table> {
+/// HACK: Add a `[[bin]]` table to the `original_toml`
+fn inject_bin_path(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")
-        }
-    }
-
-    // Prevent looking for a workspace by `read_manifest_from_str`
-    manifest.insert("workspace".to_owned(), toml::Table::new().into());
-
-    let package = manifest
-        .entry("package".to_owned())
-        .or_insert_with(|| toml::Table::new().into())
-        .as_table_mut()
-        .ok_or_else(|| anyhow::format_err!("`package` must be a 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
         .file_stem()
         .ok_or_else(|| anyhow::format_err!("no file name"))?
         .to_string_lossy();
     let name = sanitize_name(file_stem.as_ref());
     let bin_name = name.clone();
-    package
-        .entry("name".to_owned())
-        .or_insert(toml::Value::String(name));
-    package.entry("edition".to_owned()).or_insert_with(|| {
-        let _ = gctx.shell().warn(format_args!(
-            "`package.edition` is unspecified, defaulting to `{}`",
-            DEFAULT_EDITION
-        ));
-        toml::Value::String(DEFAULT_EDITION.to_string())
-    });
-    package
-        .entry("build".to_owned())
-        .or_insert_with(|| toml::Value::Boolean(false));
-    for field in AUTO_FIELDS {
-        package
-            .entry(field.to_owned())
-            .or_insert_with(|| toml::Value::Boolean(false));
-    }
 
     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)
 }
 
 /// Ensure the package name matches the validation from `ops::cargo_new::check_name`
-fn sanitize_name(name: &str) -> String {
+pub fn sanitize_name(name: &str) -> String {
     let placeholder = if name.contains('_') {
         '_'
     } else {
@@ -565,18 +513,6 @@ fn main() {}
 name = "test-"
 path = "/home/me/test.rs"
 
-[package]
-autobenches = false
-autobins = false
-autoexamples = false
-autolib = false
-autotests = false
-build = false
-edition = "2024"
-name = "test-"
-
-[workspace]
-
 "#]]
         );
     }
@@ -600,18 +536,6 @@ path = [..]
 [dependencies]
 time = "0.1.25"
 
-[package]
-autobenches = false
-autobins = false
-autoexamples = false
-autolib = false
-autotests = false
-build = false
-edition = "2024"
-name = "test-"
-
-[workspace]
-
 "#]]
         );
     }