Add -Z json-target-spec

This adds the `-Z json-target-spec` CLI flag to assist with using custom
`.json` target spec files. `rustc` recently switched so that it requires
`-Z unstable-options` when using custom spec files
(rust-lang/rust#151534). This can make it rather
awkward to use spec files with cargo because it then requires setting
RUSTFLAGS and RUSTDOCFLAGS to pass `-Zunstable-options`. It also ends up
causing some confusing error messages.

Now, using `--target` with `.json` extension files generates an error
that explains you need `-Zjson-target-spec`. The only thing this flag
does is disable that error, and automatically passes
`-Zunstable-options` with the `--target` flag.

This does not 100% cover json target spec files, because they can be
placed in RUST_TARGET_PATH or the sysroot, and `rustc` will
automatically search for them (without the `.json` extension in the
`--target` arg). The user will just need to use RUSTFLAGS/RUSTDOCFLAGS
in that situation (but I expect that to be rare).

The majority of this change is changing `CompileTarget::new` to take a
flag if `-Zjson-target-spec` is enabled, and then threading through all
the places that call it. `CompileTarget::new` is responsible for
generating an error if json is used without the Z flag.

Author: ehuss

src/cargo/core/compiler/build_context/target_info.rs

@@ -959,7 +959,7 @@ impl<'gctx> RustcTargetData<'gctx> {
         let mut target_config = HashMap::new();
         let mut target_info = HashMap::new();
         let target_applies_to_host = gctx.target_applies_to_host()?;
-        let host_target = CompileTarget::new(&rustc.host)?;
+        let host_target = CompileTarget::new(&rustc.host, gctx.cli_unstable().json_target_spec)?;
         let host_info = TargetInfo::new(gctx, requested_kinds, &rustc, CompileKind::Host)?;
 
         // This config is used for link overrides and choosing a linker.

src/cargo/core/compiler/compile_kind.rs

@@ -94,9 +94,15 @@ impl CompileKind {
 
                     if value.as_str() == "host-tuple" {
                         let host_triple = env!("RUST_HOST_TARGET");
-                        Ok(CompileKind::Target(CompileTarget::new(host_triple)?))
+                        Ok(CompileKind::Target(CompileTarget::new(
+                            host_triple,
+                            gctx.cli_unstable().json_target_spec,
+                        )?))
                     } else {
-                        Ok(CompileKind::Target(CompileTarget::new(value.as_str())?))
+                        Ok(CompileKind::Target(CompileTarget::new(
+                            value.as_str(),
+                            gctx.cli_unstable().json_target_spec,
+                        )?))
                     }
                 })
                 // First collect into a set to deduplicate any `--target` passed
@@ -186,7 +192,7 @@ pub enum CompileTarget {
 }
 
 impl CompileTarget {
-    pub fn new(name: &str) -> CargoResult<CompileTarget> {
+    pub fn new(name: &str, unstable_json: bool) -> CargoResult<CompileTarget> {
         let name = name.trim();
         if name.is_empty() {
             bail!("target was empty");
@@ -195,6 +201,10 @@ impl CompileTarget {
             return Ok(CompileTarget::Tuple(name.into()));
         }
 
+        if !unstable_json {
+            bail!("`.json` target specs require -Zjson-target-spec");
+        }
+
         // If `name` ends in `.json` then it's likely a custom target
         // specification. Canonicalize the path to ensure that different builds
         // with different paths always produce the same result.

src/cargo/core/dependency.rs

@@ -496,6 +496,7 @@ impl Artifact {
         artifacts: &[impl AsRef<str>],
         is_lib: bool,
         target: Option<&str>,
+        unstable_json: bool,
     ) -> CargoResult<Self> {
         let kinds = ArtifactKind::validate(
             artifacts
@@ -506,7 +507,9 @@ impl Artifact {
         Ok(Artifact {
             inner: Arc::new(kinds),
             is_lib,
-            target: target.map(ArtifactTarget::parse).transpose()?,
+            target: target
+                .map(|name| ArtifactTarget::parse(name, unstable_json))
+                .transpose()?,
         })
     }
 
@@ -536,10 +539,10 @@ pub enum ArtifactTarget {
 }
 
 impl ArtifactTarget {
-    pub fn parse(target: &str) -> CargoResult<ArtifactTarget> {
+    pub fn parse(target: &str, unstable_json: bool) -> CargoResult<ArtifactTarget> {
         Ok(match target {
             "target" => ArtifactTarget::BuildDependencyAssumeTarget,
-            name => ArtifactTarget::Force(CompileTarget::new(name)?),
+            name => ArtifactTarget::Force(CompileTarget::new(name, unstable_json)?),
         })
     }
 

src/cargo/core/features.rs

@@ -870,6 +870,7 @@ unstable_cli_options!(
     #[serde(deserialize_with = "deserialize_gitoxide_features")]
     gitoxide: Option<GitoxideFeatures> = ("Use gitoxide for the given git interactions, or all of them if no argument is given"),
     host_config: bool = ("Enable the `[host]` section in the .cargo/config.toml file"),
+    json_target_spec: bool = ("Enable `.json` target spec files"),
     lockfile_path: bool = ("Enable the `resolver.lockfile-path` config option"),
     minimal_versions: bool = ("Resolve minimal dependency versions instead of maximum"),
     msrv_policy: bool = ("Enable rust-version aware policy within cargo"),
@@ -1409,6 +1410,7 @@ impl CliUnstable {
                 )?
             }
             "host-config" => self.host_config = parse_empty(k, v)?,
+            "json-target-spec" => self.json_target_spec = parse_empty(k, v)?,
             "lockfile-path" => self.lockfile_path = parse_empty(k, v)?,
             "next-lockfile-bump" => self.next_lockfile_bump = parse_empty(k, v)?,
             "minimal-versions" => self.minimal_versions = parse_empty(k, v)?,

src/cargo/core/resolver/features.rs

@@ -811,6 +811,7 @@ impl<'a, 'gctx> FeatureResolver<'a, 'gctx> {
             pkg_id: PackageId,
             dep: &Dependency,
             lib_fk: FeaturesFor,
+            unstable_json_spec: bool,
         ) -> CargoResult<Vec<FeaturesFor>> {
             let Some(artifact) = dep.artifact() else {
                 return Ok(vec![lib_fk]);
@@ -844,7 +845,9 @@ impl<'a, 'gctx> FeatureResolver<'a, 'gctx> {
                     ArtifactTarget::BuildDependencyAssumeTarget => {
                         for kind in this.requested_targets {
                             let target = match kind {
-                                CompileKind::Host => CompileTarget::new(&host_triple).unwrap(),
+                                CompileKind::Host => {
+                                    CompileTarget::new(&host_triple, unstable_json_spec).unwrap()
+                                }
                                 CompileKind::Target(target) => *target,
                             };
                             activate_target(target)?;
@@ -859,6 +862,7 @@ impl<'a, 'gctx> FeatureResolver<'a, 'gctx> {
             Ok(result)
         }
 
+        let unstable_json_spec = self.ws.gctx().cli_unstable().json_target_spec;
         self.resolve
             .deps(pkg_id)
             .map(|(dep_id, deps)| {
@@ -915,7 +919,8 @@ impl<'a, 'gctx> FeatureResolver<'a, 'gctx> {
                             fk
                         };
 
-                        let dep_fks = artifact_features_for(self, pkg_id, dep, lib_fk)?;
+                        let dep_fks =
+                            artifact_features_for(self, pkg_id, dep, lib_fk, unstable_json_spec)?;
                         Ok(dep_fks.into_iter().map(move |dep_fk| (dep, dep_fk)))
                     })
                     .flatten_ok()

src/cargo/ops/cargo_compile/mod.rs

@@ -398,7 +398,10 @@ pub fn create_bcx<'a, 'gctx>(
     // If `--target` has not been specified, then the unit graph is built
     // assuming `--target $HOST` was specified. See
     // `rebuild_unit_graph_shared` for more on why this is done.
-    let explicit_host_kind = CompileKind::Target(CompileTarget::new(&target_data.rustc.host)?);
+    let explicit_host_kind = CompileKind::Target(CompileTarget::new(
+        &target_data.rustc.host,
+        gctx.cli_unstable().json_target_spec,
+    )?);
     let explicit_host_kinds: Vec<_> = build_config
         .requested_kinds
         .iter()

src/cargo/sources/registry/index/mod.rs

@@ -195,14 +195,18 @@ impl IndexSummary {
     }
 }
 
-fn index_package_to_summary(pkg: &IndexPackage<'_>, source_id: SourceId) -> CargoResult<Summary> {
+fn index_package_to_summary(
+    pkg: &IndexPackage<'_>,
+    source_id: SourceId,
+    cli_unstable: &CliUnstable,
+) -> CargoResult<Summary> {
     // ****CAUTION**** Please be extremely careful with returning errors, see
     // `IndexSummary::parse` for details
     let pkgid = PackageId::new(pkg.name.as_ref().into(), pkg.vers.clone(), source_id);
     let deps = pkg
         .deps
         .iter()
-        .map(|dep| registry_dependency_into_dep(dep.clone(), source_id))
+        .map(|dep| registry_dependency_into_dep(dep.clone(), source_id, cli_unstable))
         .collect::<CargoResult<Vec<_>>>()?;
     let mut features = pkg.features.clone();
     if let Some(features2) = pkg.features2.clone() {
@@ -651,7 +655,7 @@ impl IndexSummary {
         // values carefully when making changes here.
         let index_summary = (|| {
             let index = serde_json::from_slice::<IndexPackage<'_>>(line)?;
-            let summary = index_package_to_summary(&index, source_id)?;
+            let summary = index_package_to_summary(&index, source_id, cli_unstable)?;
             Ok((index, summary))
         })();
         let (index, summary, valid) = match index_summary {
@@ -683,7 +687,7 @@ impl IndexSummary {
                     links: Default::default(),
                     pubtime: Default::default(),
                 };
-                let summary = index_package_to_summary(&index, source_id)?;
+                let summary = index_package_to_summary(&index, source_id, cli_unstable)?;
                 (index, summary, false)
             }
         };
@@ -712,6 +716,7 @@ impl IndexSummary {
 fn registry_dependency_into_dep(
     dep: RegistryDependency<'_>,
     default: SourceId,
+    cli_unstable: &CliUnstable,
 ) -> CargoResult<Dependency> {
     let RegistryDependency {
         name,
@@ -768,7 +773,12 @@ fn registry_dependency_into_dep(
     }
 
     if let Some(artifacts) = artifact {
-        let artifact = Artifact::parse(&artifacts, lib, bindep_target.as_deref())?;
+        let artifact = Artifact::parse(
+            &artifacts,
+            lib,
+            bindep_target.as_deref(),
+            cli_unstable.json_target_spec,
+        )?;
         dep.set_artifact(artifact);
     }
 

src/cargo/util/toml/mod.rs

@@ -1792,13 +1792,13 @@ note: only a feature named `default` will be enabled by default"
     let default_kind = normalized_package
         .default_target
         .as_ref()
-        .map(|t| CompileTarget::new(&*t))
+        .map(|t| CompileTarget::new(&*t, gctx.cli_unstable().json_target_spec))
         .transpose()?
         .map(CompileKind::Target);
     let forced_kind = normalized_package
         .forced_target
         .as_ref()
-        .map(|t| CompileTarget::new(&*t))
+        .map(|t| CompileTarget::new(&*t, gctx.cli_unstable().json_target_spec))
         .transpose()?
         .map(CompileKind::Target);
     let include = normalized_package
@@ -2311,7 +2311,12 @@ fn dep_to_dependency<P: ResolveToPath + Clone>(
         orig.target.as_deref(),
     ) {
         if manifest_ctx.gctx.cli_unstable().bindeps {
-            let artifact = Artifact::parse(&artifact.0, is_lib, target)?;
+            let artifact = Artifact::parse(
+                &artifact.0,
+                is_lib,
+                target,
+                manifest_ctx.gctx.cli_unstable().json_target_spec,
+            )?;
             if dep.kind() != DepKind::Build
                 && artifact.target() == Some(ArtifactTarget::BuildDependencyAssumeTarget)
             {

src/doc/src/reference/unstable.md

@@ -100,6 +100,7 @@ Each new feature described below should explain how to use it.
     * [panic-immediate-abort](#panic-immediate-abort) --- Passes `-Cpanic=immediate-abort` to the compiler.
     * [compile-time-deps](#compile-time-deps) --- Perma-unstable feature for rust-analyzer
     * [fine-grain-locking](#fine-grain-locking) --- Use fine grain locking instead of locking the entire build cache
+    * [target-spec-json](#target-spec-json) --- Allows the use of `.json` custom target specs.
 * rustdoc
     * [rustdoc-map](#rustdoc-map) --- Provides mappings for documentation to link to external sites like [docs.rs](https://docs.rs/).
     * [scrape-examples](#scrape-examples) --- Shows examples within documentation.
@@ -2028,7 +2029,7 @@ cargo +nightly build --compile-time-deps -Z unstable-options
 cargo +nightly check --compile-time-deps --all-targets -Z unstable-options
 ```
 
-# `rustc-unicode`
+## `rustc-unicode`
 * Tracking Issue: [rust#148607](https://github.com/rust-lang/rust/issues/148607)
 
 Enable `rustc`'s unicode error format in Cargo's error messages
@@ -2045,6 +2046,17 @@ so that `cargo doc` can merge cross-crate information
 from separate output directories,
 and run `rustdoc` in parallel.
 
+## target-spec-json
+* Tracking Issue: [rust-lang/rust#151528](https://github.com/rust-lang/rust/issues/151528)
+
+The `-Z target-spec-json` CLI flag enables the ability to use [custom target spec JSON files](https://doc.rust-lang.org/nightly/rustc/targets/custom.html) as a target.
+
+```console
+cargo +nightly build --target my-target.json -Z target-spec-json
+```
+
+This usually must be combined with [build-std](#build-std).
+
 # Stabilized and removed features
 
 ## Compile progress

tests/build-std/main.rs

@@ -312,7 +312,8 @@ fn cross_custom() {
         .file("custom-target.json", target_spec_json())
         .build();
 
-    p.cargo("build --target custom-target.json -v")
+    p.cargo("build --target custom-target.json -v -Zjson-target-spec")
+        .masquerade_as_nightly_cargo(&["json_target_spec"])
         .build_std_arg("core")
         .run();
 }
@@ -352,7 +353,8 @@ fn custom_test_framework() {
     paths.insert(0, sysroot_bin);
     let new_path = env::join_paths(paths).unwrap();
 
-    p.cargo("test --target target.json --no-run -v")
+    p.cargo("test --target target.json --no-run -v -Zjson-target-spec")
+        .masquerade_as_nightly_cargo(&["json_target_spec"])
         .env("PATH", new_path)
         .build_std_arg("core")
         .run();