Check build target supports std when building with -Zbuild-std=std

Running cargo with "-Zbuild-std=std" should check whether the build
target supports building the standard library. This information can be
obtained from rustc with the target-spec-json "--print" option. When
'std' is false for the build target, cargo should not attempt to build
the standard library.

This avoids the "use of unstable library" errors, as this check is
performed before Cargo starts trying to build restricted_std code.

Cargo will now emit a warning if the requested target does not support
building the standard library, or if there was an issue when collecting
the necessary information via rustc

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

@@ -43,6 +43,8 @@ pub struct TargetInfo {
     crate_types: RefCell<HashMap<CrateType, Option<(String, String)>>>,
     /// `cfg` information extracted from `rustc --print=cfg`.
     cfg: Vec<Cfg>,
+    /// `supports_std` information extracted from `rustc --print=target-spec-json`
+    pub supports_std: Option<bool>,
     /// Supported values for `-Csplit-debuginfo=` flag, queried from rustc
     support_split_debuginfo: Vec<String>,
     /// Path to the sysroot.
@@ -294,6 +296,44 @@ impl TargetInfo {
                 gctx.shell().warn("non-trivial mutual dependency between target-specific configuration and RUSTFLAGS")?;
             }
 
+            let mut supports_std: Option<bool> = None;
+
+            // The '--print=target-spec-json' is an unstable option of rustc, therefore only
+            // try to fetch this information if rustc allows nightly features. Additionally,
+            // to avoid making two rustc queries when not required, only try to fetch the
+            // target-spec when the '-Zbuild-std' option is passed.
+            if gctx.cli_unstable().build_std.is_some() {
+                let mut target_spec_process = rustc.workspace_process();
+                apply_env_config(gctx, &mut target_spec_process)?;
+                target_spec_process
+                    .arg("--print=target-spec-json")
+                    .arg("-Zunstable-options")
+                    .args(&rustflags)
+                    .env_remove("RUSTC_LOG");
+
+                if let CompileKind::Target(target) = kind {
+                    target_spec_process
+                        .arg("--target")
+                        .arg(target.rustc_target());
+                }
+
+                #[derive(Deserialize)]
+                struct Metadata {
+                    pub std: Option<bool>,
+                }
+
+                #[derive(Deserialize)]
+                struct TargetSpec {
+                    pub metadata: Metadata,
+                }
+
+                if let Ok(output) = target_spec_process.output() {
+                    if let Ok(spec) = serde_json::from_slice::<TargetSpec>(&output.stdout) {
+                        supports_std = spec.metadata.std;
+                    }
+                }
+            }
+
             return Ok(TargetInfo {
                 crate_type_process,
                 crate_types: RefCell::new(map),
@@ -310,6 +350,7 @@ impl TargetInfo {
                 )?
                 .into(),
                 cfg,
+                supports_std,
                 support_split_debuginfo,
             });
         }
@@ -1026,6 +1067,16 @@ impl<'gctx> RustcTargetData<'gctx> {
             CompileKind::Target(s) => &self.target_config[&s],
         }
     }
+
+    pub fn get_unsupported_std_targets(&self) -> Vec<&str> {
+        let mut unsupported = Vec::new();
+        for (target, target_info) in &self.target_info {
+            if target_info.supports_std == Some(false) {
+                unsupported.push(target.short_name());
+            }
+        }
+        unsupported
+    }
 }
 
 /// Structure used to deal with Rustdoc fingerprinting

src/cargo/core/compiler/standard_lib.rs

@@ -72,6 +72,17 @@ pub fn resolve_std<'gctx>(
             .warn("-Zbuild-std does not currently fully support --build-plan")?;
     }
 
+    // check that targets support building std
+    if crates.contains(&"std".to_string()) {
+        let unsupported_targets = target_data.get_unsupported_std_targets();
+        if !unsupported_targets.is_empty() {
+            anyhow::bail!(
+                "building std is not supported on the following targets: {}",
+                unsupported_targets.join(", ")
+            )
+        }
+    }
+
     let src_path = detect_sysroot_src_path(target_data)?;
     let std_ws_manifest_path = src_path.join("Cargo.toml");
     let gctx = ws.gctx();