Adopt std roots generations to use explicit_kinds method

Author: fee1-dead

src/cargo/core/compiler/standard_lib.rs

@@ -8,6 +8,7 @@ use crate::core::resolver::HasDevUnits;
 use crate::core::{Dependency, PackageId, PackageSet, Resolve, SourceId, Workspace};
 use crate::ops::{self, Packages};
 use crate::util::errors::CargoResult;
+use std::collections::hash_map::Entry;
 use std::collections::{HashMap, HashSet};
 use std::env;
 use std::path::PathBuf;
@@ -133,7 +134,8 @@ pub fn generate_std_roots(
     crates: &[String],
     std_resolve: &Resolve,
     std_features: &ResolvedFeatures,
-    kinds: &[CompileKind],
+    requested_kinds: &[CompileKind],
+    explicit_host_kind: CompileKind,
     package_set: &PackageSet<'_>,
     interner: &UnitInterner,
     profiles: &Profiles,
@@ -147,41 +149,51 @@ pub fn generate_std_roots(
     let std_pkgs = package_set.get_many(std_ids)?;
     // Generate a map of Units for each kind requested.
     let mut ret = HashMap::new();
-    for pkg in std_pkgs {
+
+    let std_pkg_infos: Vec<_> = std_pkgs.iter().map(|pkg| {
         let lib = pkg
             .targets()
             .iter()
             .find(|t| t.is_lib())
             .expect("std has a lib");
         let unit_for = UnitFor::new_normal();
-        // I don't think we need to bother with Check here, the difference
-        // in time is minimal, and the difference in caching is
-        // significant.
-        let mode = CompileMode::Build;
         let features = std_features.activated_features(pkg.package_id(), FeaturesFor::NormalOrDev);
+        (pkg, lib, unit_for, features)
+    }).collect();
 
+    for kinds in package_set.packages().map(|pkg| pkg.explicit_kinds(requested_kinds, explicit_host_kind)) {
         for kind in kinds {
-            let list = ret.entry(*kind).or_insert_with(Vec::new);
-            let profile = profiles.get_profile(
-                pkg.package_id(),
-                /*is_member*/ false,
-                /*is_local*/ false,
-                unit_for,
-                mode,
-                *kind,
-            );
-            list.push(interner.intern(
-                pkg,
-                lib,
-                profile,
-                *kind,
-                mode,
-                features.clone(),
-                /*is_std*/ true,
-                /*dep_hash*/ 0,
-            ));
+            if let Entry::Vacant(e) = ret.entry(kind) {
+                let units = std_pkg_infos.iter().map(|(pkg, lib, unit_for, features)| {
+                    // I don't think we need to bother with Check here, the difference
+                    // in time is minimal, and the difference in caching is
+                    // significant.
+                    let mode = CompileMode::Build;
+                    let profile = profiles.get_profile(
+                        pkg.package_id(),
+                        /*is_member*/ false,
+                        /*is_local*/ false,
+                        *unit_for,
+                        mode,
+                        kind,
+                    );
+                    interner.intern(
+                        pkg,
+                        lib,
+                        profile,
+                        kind,
+                        mode,
+                        features.clone(),
+                        /*is_std*/ true,
+                        /*dep_hash*/ 0,
+                    )
+                });
+
+                e.insert(units.collect());
+            }
         }
     }
+
     Ok(ret)
 }
 

src/cargo/ops/cargo_compile.rs

@@ -562,7 +562,8 @@ pub fn create_bcx<'a, 'cfg>(
             &crates,
             std_resolve,
             std_features,
-            &explicit_host_kinds,
+            &build_config.requested_kinds,
+            explicit_host_kind,
             &pkg_set,
             interner,
             &profiles,