Allow artifact target set for build-std

Adds unstable flag `build-std-targets`.

The intended use is for projects that mix a Tier 1/2 target as a host
with a Tier 3 target in an artifact dependency, which is then deployed
at runtime. For instance, x86-64-*-linux and bpfeb-unknown-none, or a
supported host with a custom hardware profile given by json.

In these cases it is unlikely that all std libraries should be built
from scratch. Additionally, the list of std builds are not only those
given as direct targets on the command line but rather discovered by
target specifications on artifact dependencies that are embedded to a
host loader etc.

The previous state discovered the set of std-builds through the target
list of the CLI but never dynamically within the crate graph. The unit
graph would then try to access the std build for kinds that were not
generated, resulting in panics in unit dependency planning.

Author: 197g

src/cargo/core/compiler/unit_dependencies.rs

@@ -174,24 +174,27 @@ fn attach_std_deps(
     std_unit_deps: UnitGraph,
 ) {
     // Attach the standard library as a dependency of every target unit.
-    let mut found = false;
+    let mut found = HashSet::new();
     for (unit, deps) in state.unit_dependencies.iter_mut() {
         if !unit.kind.is_host() && !unit.mode.is_run_custom_build() {
-            deps.extend(std_roots[&unit.kind].iter().map(|unit| UnitDep {
-                unit: unit.clone(),
-                unit_for: UnitFor::new_normal(unit.kind),
-                extern_crate_name: unit.pkg.name(),
-                dep_name: None,
-                // TODO: Does this `public` make sense?
-                public: true,
-                noprelude: true,
-            }));
-            found = true;
+            if let Some(std_build) = std_roots.get(&unit.kind) {
+                deps.extend(std_build.iter().map(|unit| UnitDep {
+                    unit: unit.clone(),
+                    unit_for: UnitFor::new_normal(unit.kind),
+                    extern_crate_name: unit.pkg.name(),
+                    dep_name: None,
+                    // TODO: Does this `public` make sense?
+                    public: true,
+                    noprelude: true,
+                }));
+
+                found.insert(unit.kind);
+            }
         }
     }
     // And also include the dependencies of the standard library itself. Don't
     // include these if no units actually needed the standard library.
-    if found {
+    if !found.is_empty() {
         for (unit, deps) in std_unit_deps.into_iter() {
             if let Some(other_unit) = state.unit_dependencies.insert(unit, deps) {
                 panic!("std unit collision with existing unit: {:?}", other_unit);

src/cargo/core/features.rs

@@ -129,6 +129,7 @@ use cargo_util::ProcessBuilder;
 use serde::{Deserialize, Serialize};
 
 use crate::GlobalContext;
+use crate::core::compiler::CompileTarget;
 use crate::core::resolver::ResolveBehavior;
 use crate::util::errors::CargoResult;
 use crate::util::indented_lines;
@@ -824,6 +825,8 @@ unstable_cli_options!(
     build_std: Option<Vec<String>>  = ("Enable Cargo to compile the standard library itself as part of a crate graph compilation"),
     #[serde(deserialize_with = "deserialize_comma_separated_list")]
     build_std_features: Option<Vec<String>>  = ("Configure features enabled for the standard library itself when building the standard library"),
+    #[serde(deserialize_with = "deserialize_target_list")]
+    build_std_targets: Option<Vec<CompileTarget>>  = ("Configure a list of targets that cargo should compile the standard library for"),
     cargo_lints: bool = ("Enable the `[lints.cargo]` table"),
     checksum_freshness: bool = ("Use a checksum to determine if output is fresh rather than filesystem mtime"),
     codegen_backend: bool = ("Enable the `codegen-backend` option in profiles in .cargo/config.toml file"),
@@ -1176,6 +1179,32 @@ fn parse_gitoxide(
     Ok(Some(out))
 }
 
+fn deserialize_target_list<'de, D>(deserializer: D) -> Result<Option<Vec<CompileTarget>>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    use serde::de::Error as _;
+
+    let targets = deserialize_comma_separated_list(deserializer)?;
+
+    let Some(targets) = targets else {
+        return Ok(None);
+    };
+
+    let targets = targets
+        .into_iter()
+        .map(|s| match CompileTarget::new(&s) {
+            Ok(target) => Ok(target),
+            Err(err) => Err(D::Error::custom(err)),
+        })
+        // Dedup
+        .collect::<Result<BTreeSet<_>, D::Error>>()?
+        .into_iter()
+        .collect::<Vec<_>>();
+
+    Ok(Some(targets))
+}
+
 impl CliUnstable {
     /// Parses `-Z` flags from the command line, and returns messages that warn
     /// if any flag has alreardy been stabilized.
@@ -1336,6 +1365,16 @@ impl CliUnstable {
             "bindeps" => self.bindeps = parse_empty(k, v)?,
             "build-dir" => self.build_dir = parse_empty(k, v)?,
             "build-std" => self.build_std = Some(parse_list(v)),
+            "build-std-targets" => {
+                self.build_std_targets = Some(
+                    parse_list(v)
+                        .into_iter()
+                        .map(|s| CompileTarget::new(&s))
+                        .collect::<CargoResult<BTreeSet<_>>>()?
+                        .into_iter()
+                        .collect(),
+                )
+            }
             "build-std-features" => self.build_std_features = Some(parse_list(v)),
             "cargo-lints" => self.cargo_lints = parse_empty(k, v)?,
             "codegen-backend" => self.codegen_backend = parse_empty(k, v)?,

src/cargo/ops/cargo_compile/mod.rs

@@ -46,6 +46,7 @@ use crate::core::compiler::{BuildConfig, BuildContext, BuildRunner, Compilation}
 use crate::core::compiler::{CompileKind, CompileTarget, RustcTargetData, Unit};
 use crate::core::compiler::{CrateType, TargetInfo, apply_env_config, standard_lib};
 use crate::core::compiler::{DefaultExecutor, Executor, UnitInterner};
+use crate::core::dependency::ArtifactTarget;
 use crate::core::profiles::Profiles;
 use crate::core::resolver::features::{self, CliFeatures, FeaturesFor};
 use crate::core::resolver::{HasDevUnits, Resolve};
@@ -288,15 +289,37 @@ pub fn create_bcx<'a, 'gctx>(
     } = resolve;
 
     let std_resolve_features = if let Some(crates) = &gctx.cli_unstable().build_std {
-        let (std_package_set, std_resolve, std_features) = standard_lib::resolve_std(
-            ws,
-            &mut target_data,
-            &build_config,
-            crates,
-            &build_config.requested_kinds,
-        )?;
-        pkg_set.add_set(std_package_set);
-        Some((std_resolve, std_features))
+        let mut required_kinds = build_config.requested_kinds.to_vec();
+
+        required_kinds.extend(pkg_set.packages().flat_map(|pkg| {
+            let manifest = pkg.manifest();
+            manifest.forced_kind()
+        }));
+
+        if let Some(requested_std) = gctx.cli_unstable().build_std_targets.as_ref() {
+            required_kinds.retain(|n| match n {
+                CompileKind::Host => false,
+                CompileKind::Target(n) => requested_std.contains(n),
+            });
+        }
+
+        if required_kinds.is_empty() {
+            tracing::trace!("No host targets requested with build-std");
+            None
+        } else {
+            tracing::trace!("Host targets requested with build-std: {required_kinds:#?}");
+
+            let (std_package_set, std_resolve, std_features) = standard_lib::resolve_std(
+                ws,
+                &mut target_data,
+                &build_config,
+                crates,
+                &required_kinds,
+            )?;
+
+            pkg_set.add_set(std_package_set);
+            Some((std_resolve, std_features))
+        }
     } else {
         None
     };
@@ -415,18 +438,70 @@ pub fn create_bcx<'a, 'gctx>(
         };
 
         let std_roots = if let Some(crates) = gctx.cli_unstable().build_std.as_ref() {
-            let (std_resolve, std_features) = std_resolve_features.as_ref().unwrap();
-            standard_lib::generate_std_roots(
-                &crates,
-                &targeted_root_units,
-                std_resolve,
-                std_features,
-                &explicit_host_kinds,
-                &pkg_set,
-                interner,
-                &profiles,
-                &target_data,
-            )?
+            // Force kinds that require a std build were not collected previously. They must be
+            // present within `build_unit_dependencies` which then attaches std-deps and their
+            // std-roots, by target definition.
+            let mut required_kinds: Vec<_> = packages
+                .iter()
+                .flat_map(|pkg| {
+                    let tr = resolve.transitive_deps_not_replaced(pkg.package_id());
+                    tr.filter_map(|(_, dependency)| match dependency.artifact()?.target()? {
+                        ArtifactTarget::BuildDependencyAssumeTarget => None,
+                        ArtifactTarget::Force(target) => Some(target),
+                    })
+                })
+                .map(CompileKind::Target)
+                .collect();
+
+            if let Some(requested_std) = gctx.cli_unstable().build_std_targets.as_ref() {
+                required_kinds.retain(|n| match n {
+                    CompileKind::Host => true,
+                    CompileKind::Target(n) => requested_std.contains(n),
+                });
+            }
+
+            let custom_targets;
+            let std_build = if !required_kinds.is_empty() {
+                let (_std_package_set, std_resolve, std_features) = standard_lib::resolve_std(
+                    ws,
+                    &mut target_data,
+                    &build_config,
+                    crates,
+                    &required_kinds,
+                )?;
+
+                custom_targets = (std_resolve, std_features);
+                // to_builds.extend(std_package_set.packages());
+                Some(&custom_targets)
+            } else {
+                std_resolve_features.as_ref()
+            };
+
+            let target_kinds = if !required_kinds.is_empty() {
+                tracing::trace!("Build-std artifact targets for {specs:?}: {required_kinds:#?}");
+                &required_kinds
+            } else {
+                tracing::trace!("Build-std host for {specs:?}: {explicit_host_kinds:#?}");
+                &explicit_host_kinds
+            };
+
+            if let Some((std_resolve, std_features)) = std_build {
+                tracing::trace!("Build std targets for {specs:?}: {required_kinds:?}");
+
+                standard_lib::generate_std_roots(
+                    &crates,
+                    &targeted_root_units,
+                    std_resolve,
+                    std_features,
+                    target_kinds,
+                    &pkg_set,
+                    interner,
+                    &profiles,
+                    &target_data,
+                )?
+            } else {
+                Default::default()
+            }
         } else {
             Default::default()
         };