Refactor Kind to carry target name in Target

This commit is an internal refactoring of Cargo's compilation backend to
eventually support compiling multiple target simultaneously. The
original motivation for this came up in discussion of #7297 and this has
long been something I've intended to update Cargo for. Nothing in the
backend currently exposes the ability to actually build multiple target
simultaneously, but this should have no function change with respect to
all current consumers. Eventually we'll need to refactor APIs of how you
enter the compilation backend to compile for multiple targets.

Author: alexcrichton

crates/cargo-test-support/src/lib.rs

@@ -1680,7 +1680,7 @@ pub static RUSTC: Rustc = Rustc::new(
 
 /// The rustc host such as `x86_64-unknown-linux-gnu`.
 pub fn rustc_host() -> String {
-    RUSTC.with(|r| r.host.clone())
+    RUSTC.with(|r| r.host.to_string())
 }
 
 pub fn is_nightly() -> bool {

src/cargo/core/compiler/build_config.rs

@@ -3,6 +3,7 @@ use std::path::Path;
 
 use serde::ser;
 
+use crate::core::InternedString;
 use crate::util::ProcessBuilder;
 use crate::util::{CargoResult, CargoResultExt, Config, RustfixDiagnosticServer};
 
@@ -11,7 +12,7 @@ use crate::util::{CargoResult, CargoResultExt, Config, RustfixDiagnosticServer};
 pub struct BuildConfig {
     /// The target arch triple.
     /// Default: host arch.
-    pub requested_target: Option<String>,
+    pub requested_target: Option<InternedString>,
     /// Number of rustc jobs to run in parallel.
     pub jobs: u32,
     /// `true` if we are building for release.
@@ -91,7 +92,7 @@ impl BuildConfig {
         let jobs = jobs.or(cfg_jobs).unwrap_or(::num_cpus::get() as u32);
 
         Ok(BuildConfig {
-            requested_target: target,
+            requested_target: target.as_ref().map(|s| s.into()),
             jobs,
             release: false,
             mode,

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

@@ -1,17 +1,14 @@
-use std::collections::HashMap;
-use std::path::{Path, PathBuf};
-use std::str;
-
-use cargo_platform::Cfg;
-use log::debug;
-
 use crate::core::compiler::unit::UnitInterner;
 use crate::core::compiler::{BuildConfig, BuildOutput, Kind, Unit};
 use crate::core::profiles::Profiles;
-use crate::core::{Dependency, Workspace};
+use crate::core::{Dependency, InternedString, Workspace};
 use crate::core::{PackageId, PackageSet};
 use crate::util::errors::CargoResult;
-use crate::util::{profile, Config, Rustc};
+use crate::util::{Config, Rustc};
+use cargo_platform::Cfg;
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::str;
 
 mod target_info;
 pub use self::target_info::{FileFlavor, TargetInfo};
@@ -36,11 +33,11 @@ pub struct BuildContext<'a, 'cfg> {
     /// Information about the compiler.
     pub rustc: Rustc,
     /// Build information for the host arch.
-    pub host_config: TargetConfig,
+    host_config: TargetConfig,
     /// Build information for the target.
-    pub target_config: TargetConfig,
-    pub target_info: TargetInfo,
-    pub host_info: TargetInfo,
+    target_config: HashMap<InternedString, TargetConfig>,
+    target_info: HashMap<InternedString, TargetInfo>,
+    host_info: TargetInfo,
     pub units: &'a UnitInterner<'a>,
 }
 
@@ -57,19 +54,16 @@ impl<'a, 'cfg> BuildContext<'a, 'cfg> {
         let rustc = config.load_global_rustc(Some(ws))?;
 
         let host_config = TargetConfig::new(config, &rustc.host)?;
-        let target_config = match build_config.requested_target.as_ref() {
-            Some(triple) => TargetConfig::new(config, triple)?,
-            None => host_config.clone(),
-        };
-        let (host_info, target_info) = {
-            let _p = profile::start("BuildContext::probe_target_info");
-            debug!("probe_target_info");
-            let host_info =
-                TargetInfo::new(config, &build_config.requested_target, &rustc, Kind::Host)?;
-            let target_info =
-                TargetInfo::new(config, &build_config.requested_target, &rustc, Kind::Target)?;
-            (host_info, target_info)
-        };
+        let host_info = TargetInfo::new(config, build_config.requested_target, &rustc, Kind::Host)?;
+        let mut target_config = HashMap::new();
+        let mut target_info = HashMap::new();
+        if let Some(target) = build_config.requested_target {
+            target_config.insert(target, TargetConfig::new(config, &target)?);
+            target_info.insert(
+                target,
+                TargetInfo::new(config, Some(target), &rustc, Kind::Target(target))?,
+            );
+        }
 
         Ok(BuildContext {
             ws,
@@ -96,11 +90,8 @@ impl<'a, 'cfg> BuildContext<'a, 'cfg> {
             Some(p) => p,
             None => return true,
         };
-        let (name, info) = match kind {
-            Kind::Host => (self.host_triple(), &self.host_info),
-            Kind::Target => (self.target_triple(), &self.target_info),
-        };
-        platform.matches(name, info.cfg())
+        let name = self.target_triple(kind);
+        platform.matches(&name, self.cfg(kind))
     }
 
     /// Gets the user-specified linker for a particular host or target.
@@ -115,11 +106,7 @@ impl<'a, 'cfg> BuildContext<'a, 'cfg> {
 
     /// Gets the list of `cfg`s printed out from the compiler for the specified kind.
     pub fn cfg(&self, kind: Kind) -> &[Cfg] {
-        let info = match kind {
-            Kind::Host => &self.host_info,
-            Kind::Target => &self.target_info,
-        };
-        info.cfg()
+        self.info(kind).cfg()
     }
 
     /// Gets the host architecture triple.
@@ -128,23 +115,23 @@ impl<'a, 'cfg> BuildContext<'a, 'cfg> {
     /// - machine: x86_64,
     /// - hardware-platform: unknown,
     /// - operating system: linux-gnu.
-    pub fn host_triple(&self) -> &str {
-        &self.rustc.host
+    pub fn host_triple(&self) -> InternedString {
+        self.rustc.host
     }
 
-    pub fn target_triple(&self) -> &str {
-        self.build_config
-            .requested_target
-            .as_ref()
-            .map(|s| s.as_str())
-            .unwrap_or_else(|| self.host_triple())
+    /// Returns the target triple associated with a `Kind`
+    pub fn target_triple(&self, kind: Kind) -> InternedString {
+        match kind {
+            Kind::Host => self.host_triple(),
+            Kind::Target(name) => name,
+        }
     }
 
     /// Gets the target configuration for a particular host or target.
-    fn target_config(&self, kind: Kind) -> &TargetConfig {
+    pub fn target_config(&self, kind: Kind) -> &TargetConfig {
         match kind {
             Kind::Host => &self.host_config,
-            Kind::Target => &self.target_config,
+            Kind::Target(s) => &self.target_config[&s],
         }
     }
 
@@ -165,10 +152,10 @@ impl<'a, 'cfg> BuildContext<'a, 'cfg> {
         pkg.source_id().is_path() || self.config.extra_verbose()
     }
 
-    fn info(&self, kind: Kind) -> &TargetInfo {
+    pub fn info(&self, kind: Kind) -> &TargetInfo {
         match kind {
             Kind::Host => &self.host_info,
-            Kind::Target => &self.target_info,
+            Kind::Target(s) => &self.target_info[&s],
         }
     }
 
@@ -181,10 +168,7 @@ impl<'a, 'cfg> BuildContext<'a, 'cfg> {
     /// `lib_name` is the `links` library name and `kind` is whether it is for
     /// Host or Target.
     pub fn script_override(&self, lib_name: &str, kind: Kind) -> Option<&BuildOutput> {
-        match kind {
-            Kind::Host => self.host_config.overrides.get(lib_name),
-            Kind::Target => self.target_config.overrides.get(lib_name),
-        }
+        self.target_config(kind).overrides.get(lib_name)
     }
 }
 

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

@@ -5,6 +5,7 @@ use std::path::PathBuf;
 use std::str::{self, FromStr};
 
 use crate::core::compiler::Kind;
+use crate::core::InternedString;
 use crate::core::TargetKind;
 use crate::util::{CargoResult, CargoResultExt, Config, ProcessBuilder, Rustc};
 use cargo_platform::{Cfg, CfgExpr};
@@ -80,7 +81,7 @@ impl FileType {
 impl TargetInfo {
     pub fn new(
         config: &Config,
-        requested_target: &Option<String>,
+        requested_target: Option<InternedString>,
         rustc: &Rustc,
         kind: Kind,
     ) -> CargoResult<TargetInfo> {
@@ -101,12 +102,8 @@ impl TargetInfo {
             .args(&rustflags)
             .env_remove("RUSTC_LOG");
 
-        let target_triple = requested_target
-            .as_ref()
-            .map(|s| s.as_str())
-            .unwrap_or(&rustc.host);
-        if kind == Kind::Target {
-            process.arg("--target").arg(target_triple);
+        if let Kind::Target(target) = kind {
+            process.arg("--target").arg(target);
         }
 
         let crate_type_process = process.clone();
@@ -148,10 +145,10 @@ impl TargetInfo {
                 }
                 rustlib
             }
-            Kind::Target => {
+            Kind::Target(target) => {
                 rustlib.push("lib");
                 rustlib.push("rustlib");
-                rustlib.push(target_triple);
+                rustlib.push(target);
                 rustlib.push("lib");
                 rustlib
             }
@@ -381,7 +378,7 @@ fn output_err_info(cmd: &ProcessBuilder, stdout: &str, stderr: &str) -> String {
 /// scripts, ...), even if it is the same as the target.
 fn env_args(
     config: &Config,
-    requested_target: &Option<String>,
+    requested_target: Option<InternedString>,
     host_triple: &str,
     target_cfg: Option<&[Cfg]>,
     kind: Kind,
@@ -407,9 +404,7 @@ fn env_args(
     // same as the host, build scripts in plugins won't get
     // RUSTFLAGS.
     let compiling_with_target = requested_target.is_some();
-    let is_target_kind = kind == Kind::Target;
-
-    if compiling_with_target && !is_target_kind {
+    if compiling_with_target && kind.is_host() {
         // This is probably a build script or plugin and we're
         // compiling with --target. In this scenario there are
         // no rustflags we can apply.

src/cargo/core/compiler/compilation.rs

@@ -7,6 +7,7 @@ use cargo_platform::CfgExpr;
 use semver::Version;
 
 use super::BuildContext;
+use crate::core::compiler::Kind;
 use crate::core::{Edition, InternedString, Package, PackageId, Target};
 use crate::util::{self, join_paths, process, rustc::Rustc, CargoResult, Config, ProcessBuilder};
 
@@ -78,7 +79,10 @@ pub struct Compilation<'cfg> {
 }
 
 impl<'cfg> Compilation<'cfg> {
-    pub fn new<'a>(bcx: &BuildContext<'a, 'cfg>) -> CargoResult<Compilation<'cfg>> {
+    pub fn new<'a>(
+        bcx: &BuildContext<'a, 'cfg>,
+        default_kind: Kind,
+    ) -> CargoResult<Compilation<'cfg>> {
         let mut rustc = bcx.rustc.process();
 
         let mut primary_unit_rustc_process = bcx.build_config.primary_unit_rustc.clone();
@@ -97,8 +101,8 @@ impl<'cfg> Compilation<'cfg> {
             root_output: PathBuf::from("/"),
             deps_output: PathBuf::from("/"),
             host_deps_output: PathBuf::from("/"),
-            host_dylib_path: bcx.host_info.sysroot_libdir.clone(),
-            target_dylib_path: bcx.target_info.sysroot_libdir.clone(),
+            host_dylib_path: bcx.info(Kind::Host).sysroot_libdir.clone(),
+            target_dylib_path: bcx.info(default_kind).sysroot_libdir.clone(),
             tests: Vec::new(),
             binaries: Vec::new(),
             extra_env: HashMap::new(),
@@ -109,8 +113,8 @@ impl<'cfg> Compilation<'cfg> {
             rustc_process: rustc,
             primary_unit_rustc_process,
             host: bcx.host_triple().to_string(),
-            target: bcx.target_triple().to_string(),
-            target_runner: target_runner(bcx)?,
+            target: bcx.target_triple(default_kind).to_string(),
+            target_runner: target_runner(bcx, default_kind)?,
             supports_rustdoc_crate_type: supports_rustdoc_crate_type(bcx.config, &bcx.rustc)?,
         })
     }
@@ -289,8 +293,11 @@ fn pre_version_component(v: &Version) -> String {
     ret
 }
 
-fn target_runner(bcx: &BuildContext<'_, '_>) -> CargoResult<Option<(PathBuf, Vec<String>)>> {
-    let target = bcx.target_triple();
+fn target_runner(
+    bcx: &BuildContext<'_, '_>,
+    kind: Kind,
+) -> CargoResult<Option<(PathBuf, Vec<String>)>> {
+    let target = bcx.target_triple(kind);
 
     // try target.{}.runner
     let key = format!("target.{}.runner", target);
@@ -303,7 +310,7 @@ fn target_runner(bcx: &BuildContext<'_, '_>) -> CargoResult<Option<(PathBuf, Vec
         let mut matching_runner = None;
 
         for key in table.val.keys() {
-            if CfgExpr::matches_key(key, bcx.target_info.cfg()) {
+            if CfgExpr::matches_key(key, bcx.info(kind).cfg()) {
                 let key = format!("target.{}.runner", key);
                 if let Some(runner) = bcx.config.get_path_and_args(&key)? {
                     // more than one match, error out