Add new feature resolver.

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

@@ -1,19 +1,17 @@
 use crate::core::compiler::unit::UnitInterner;
-use crate::core::compiler::CompileTarget;
 use crate::core::compiler::{BuildConfig, BuildOutput, CompileKind, Unit};
 use crate::core::profiles::Profiles;
-use crate::core::{Dependency, InternedString, Workspace};
+use crate::core::{InternedString, Workspace};
 use crate::core::{PackageId, PackageSet};
-use crate::util::config::{Config, TargetConfig};
+use crate::util::config::Config;
 use crate::util::errors::CargoResult;
 use crate::util::Rustc;
-use cargo_platform::Cfg;
 use std::collections::HashMap;
 use std::path::PathBuf;
 use std::str;
 
 mod target_info;
-pub use self::target_info::{FileFlavor, TargetInfo};
+pub use self::target_info::{FileFlavor, RustcTargetData, TargetInfo};
 
 /// The build context, containing all information about a build task.
 ///
@@ -30,26 +28,14 @@ pub struct BuildContext<'a, 'cfg> {
  pub build_config: &'a BuildConfig,
  /// Extra compiler args for either `rustc` or `rustdoc`.
  pub extra_compiler_args: HashMap<Unit<'a>, Vec<String>>,
+ /// Package downloader.
  pub packages: &'a PackageSet<'cfg>,
 
  /// Source of interning new units as they're created.
  pub units: &'a UnitInterner<'a>,
 
- /// Information about the compiler that we've detected on the local system.
- pub rustc: Rustc,
-
- /// Build information for the "host", which is information about when
- /// `rustc` is invoked without a `--target` flag. This is used for
- /// procedural macros, build scripts, etc.
- host_config: TargetConfig,
- host_info: TargetInfo,
-
- /// Build information for targets that we're building for. This will be
- /// empty if the `--target` flag is not passed, and currently also only ever
- /// has at most one entry, but eventually we'd like to support multi-target
- /// builds with Cargo.
- target_config: HashMap<CompileTarget, TargetConfig>,
- target_info: HashMap<CompileTarget, TargetInfo>,
+ /// Information about rustc and the target platform.
+ pub target_data: RustcTargetData,
 }
 
 impl<'a, 'cfg> BuildContext<'a, 'cfg> {
@@ -61,90 +47,41 @@ impl<'a, 'cfg> BuildContext<'a, 'cfg> {
  profiles: Profiles,
  units: &'a UnitInterner<'a>,
  extra_compiler_args: HashMap<Unit<'a>, Vec<String>>,
+ target_data: RustcTargetData,
  ) -> CargoResult<BuildContext<'a, 'cfg>> {
- let rustc = config.load_global_rustc(Some(ws))?;
-
- let host_config = config.target_cfg_triple(&rustc.host)?;
- let host_info = TargetInfo::new(
- config,
- build_config.requested_kind,
- &rustc,
- CompileKind::Host,
- )?;
- let mut target_config = HashMap::new();
- let mut target_info = HashMap::new();
- if let CompileKind::Target(target) = build_config.requested_kind {
- let tcfg = config.target_cfg_triple(target.short_name())?;
- target_config.insert(target, tcfg);
- target_info.insert(
- target,
- TargetInfo::new(
- config,
- build_config.requested_kind,
- &rustc,
- CompileKind::Target(target),
- )?,
- );
- }
-
  Ok(BuildContext {
  ws,
  packages,
  config,
- rustc,
- target_config,
- target_info,
- host_config,
- host_info,
  build_config,
  profiles,
  extra_compiler_args,
  units,
+ target_data,
  })
  }
 
- /// Whether a dependency should be compiled for the host or target platform,
- /// specified by `CompileKind`.
- pub fn dep_platform_activated(&self, dep: &Dependency, kind: CompileKind) -> bool {
- // If this dependency is only available for certain platforms,
- // make sure we're only enabling it for that platform.
- let platform = match dep.platform() {
- Some(p) => p,
- None => return true,
- };
- let name = kind.short_name(self);
- platform.matches(name, self.cfg(kind))
+ pub fn rustc(&self) -> &Rustc {
+ &self.target_data.rustc
  }
 
  /// Gets the user-specified linker for a particular host or target.
  pub fn linker(&self, kind: CompileKind) -> Option<PathBuf> {
- self.target_config(kind)
+ self.target_data
+ .target_config(kind)
  .linker
  .as_ref()
  .map(|l| l.val.clone().resolve_program(self.config))
  }
 
- /// Gets the list of `cfg`s printed out from the compiler for the specified kind.
- pub fn cfg(&self, kind: CompileKind) -> &[Cfg] {
- self.info(kind).cfg()
- }
-
  /// Gets the host architecture triple.
  ///
  /// For example, x86_64-unknown-linux-gnu, would be
  /// - machine: x86_64,
  /// - hardware-platform: unknown,
  /// - operating system: linux-gnu.
  pub fn host_triple(&self) -> InternedString {
- self.rustc.host
- }
-
- /// Gets the target configuration for a particular host or target.
- pub fn target_config(&self, kind: CompileKind) -> &TargetConfig {
- match kind {
- CompileKind::Host => &self.host_config,
- CompileKind::Target(s) => &self.target_config[&s],
- }
+ self.target_data.rustc.host
  }
 
  /// Gets the number of jobs specified for this build.
@@ -153,24 +90,17 @@ impl<'a, 'cfg> BuildContext<'a, 'cfg> {
  }
 
  pub fn rustflags_args(&self, unit: &Unit<'_>) -> &[String] {
- &self.info(unit.kind).rustflags
+ &self.target_data.info(unit.kind).rustflags
  }
 
  pub fn rustdocflags_args(&self, unit: &Unit<'_>) -> &[String] {
- &self.info(unit.kind).rustdocflags
+ &self.target_data.info(unit.kind).rustdocflags
  }
 
  pub fn show_warnings(&self, pkg: PackageId) -> bool {
  pkg.source_id().is_path() || self.config.extra_verbose()
  }
 
- pub fn info(&self, kind: CompileKind) -> &TargetInfo {
- match kind {
- CompileKind::Host => &self.host_info,
- CompileKind::Target(s) => &self.target_info[&s],
- }
- }
-
  pub fn extra_args_for(&self, unit: &Unit<'a>) -> Option<&Vec<String>> {
  self.extra_compiler_args.get(unit)
  }
@@ -180,6 +110,9 @@ 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: CompileKind) -> Option<&BuildOutput> {
- self.target_config(kind).links_overrides.get(lib_name)
+ self.target_data
+ .target_config(kind)
+ .links_overrides
+ .get(lib_name)
  }
 }

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

@@ -1,18 +1,18 @@
+use crate::core::compiler::CompileKind;
+use crate::core::compiler::CompileTarget;
+use crate::core::{Dependency, TargetKind, Workspace};
+use crate::util::config::{Config, StringList, TargetConfig};
+use crate::util::{CargoResult, CargoResultExt, ProcessBuilder, Rustc};
+use cargo_platform::{Cfg, CfgExpr};
 use std::cell::RefCell;
 use std::collections::hash_map::{Entry, HashMap};
 use std::env;
 use std::path::PathBuf;
 use std::str::{self, FromStr};
 
-use crate::core::compiler::CompileKind;
-use crate::core::TargetKind;
-use crate::util::config::StringList;
-use crate::util::{CargoResult, CargoResultExt, Config, ProcessBuilder, Rustc};
-use cargo_platform::{Cfg, CfgExpr};
-
 /// Information about the platform target gleaned from querying rustc.
 ///
-/// The `BuildContext` keeps two of these, one for the host and one for the
+/// `RustcTargetData` keeps two of these, one for the host and one for the
 /// target. If no target is specified, it uses a clone from the host.
 #[derive(Clone)]
 pub struct TargetInfo {
@@ -468,3 +468,91 @@ fn env_args(
 
  Ok(Vec::new())
 }
+
+/// Collection of information about `rustc` and the host and target.
+pub struct RustcTargetData {
+ /// Information about `rustc` itself.
+ pub rustc: Rustc,
+ /// Build information for the "host", which is information about when
+ /// `rustc` is invoked without a `--target` flag. This is used for
+ /// procedural macros, build scripts, etc.
+ host_config: TargetConfig,
+ host_info: TargetInfo,
+
+ /// Build information for targets that we're building for. This will be
+ /// empty if the `--target` flag is not passed, and currently also only ever
+ /// has at most one entry, but eventually we'd like to support multi-target
+ /// builds with Cargo.
+ target_config: HashMap<CompileTarget, TargetConfig>,
+ target_info: HashMap<CompileTarget, TargetInfo>,
+}
+
+impl RustcTargetData {
+ pub fn new(ws: &Workspace<'_>, requested_kind: CompileKind) -> CargoResult<RustcTargetData> {
+ let config = ws.config();
+ let rustc = config.load_global_rustc(Some(ws))?;
+ let host_config = config.target_cfg_triple(&rustc.host)?;
+ let host_info = TargetInfo::new(config, requested_kind, &rustc, CompileKind::Host)?;
+ let mut target_config = HashMap::new();
+ let mut target_info = HashMap::new();
+ if let CompileKind::Target(target) = requested_kind {
+ let tcfg = config.target_cfg_triple(target.short_name())?;
+ target_config.insert(target, tcfg);
+ target_info.insert(
+ target,
+ TargetInfo::new(config, requested_kind, &rustc, CompileKind::Target(target))?,
+ );
+ }
+
+ Ok(RustcTargetData {
+ rustc,
+ target_config,
+ target_info,
+ host_config,
+ host_info,
+ })
+ }
+
+ /// Returns a "short" name for the given kind, suitable for keying off
+ /// configuration in Cargo or presenting to users.
+ pub fn short_name<'a>(&'a self, kind: &'a CompileKind) -> &'a str {
+ match kind {
+ CompileKind::Host => &self.rustc.host,
+ CompileKind::Target(target) => target.short_name(),
+ }
+ }
+
+ /// Whether a dependency should be compiled for the host or target platform,
+ /// specified by `CompileKind`.
+ pub fn dep_platform_activated(&self, dep: &Dependency, kind: CompileKind) -> bool {
+ // If this dependency is only available for certain platforms,
+ // make sure we're only enabling it for that platform.
+ let platform = match dep.platform() {
+ Some(p) => p,
+ None => return true,
+ };
+ let name = self.short_name(&kind);
+ platform.matches(name, self.cfg(kind))
+ }
+
+ /// Gets the list of `cfg`s printed out from the compiler for the specified kind.
+ pub fn cfg(&self, kind: CompileKind) -> &[Cfg] {
+ self.info(kind).cfg()
+ }
+
+ /// Information about the given target platform, learned by querying rustc.
+ pub fn info(&self, kind: CompileKind) -> &TargetInfo {
+ match kind {
+ CompileKind::Host => &self.host_info,
+ CompileKind::Target(s) => &self.target_info[&s],
+ }
+ }
+
+ /// Gets the target configuration for a particular host or target.
+ pub fn target_config(&self, kind: CompileKind) -> &TargetConfig {
+ match kind {
+ CompileKind::Host => &self.host_config,
+ CompileKind::Target(s) => &self.target_config[&s],
+ }
+ }
+}

src/cargo/core/compiler/compilation.rs

@@ -84,7 +84,7 @@ impl<'cfg> Compilation<'cfg> {
  bcx: &BuildContext<'a, 'cfg>,
  default_kind: CompileKind,
  ) -> CargoResult<Compilation<'cfg>> {
- let mut rustc = bcx.rustc.process();
+ let mut rustc = bcx.rustc().process();
 
  let mut primary_unit_rustc_process = bcx.build_config.primary_unit_rustc.clone();
 
@@ -102,8 +102,16 @@ impl<'cfg> Compilation<'cfg> {
  root_output: PathBuf::from("/"),
  deps_output: PathBuf::from("/"),
  host_deps_output: PathBuf::from("/"),
- host_dylib_path: bcx.info(CompileKind::Host).sysroot_host_libdir.clone(),
- target_dylib_path: bcx.info(default_kind).sysroot_target_libdir.clone(),
+ host_dylib_path: bcx
+ .target_data
+ .info(CompileKind::Host)
+ .sysroot_host_libdir
+ .clone(),
+ target_dylib_path: bcx
+ .target_data
+ .info(default_kind)
+ .sysroot_target_libdir
+ .clone(),
  tests: Vec::new(),
  binaries: Vec::new(),
  extra_env: HashMap::new(),
@@ -114,7 +122,7 @@ impl<'cfg> Compilation<'cfg> {
  rustc_process: rustc,
  primary_unit_rustc_process,
  host: bcx.host_triple().to_string(),
- target: default_kind.short_name(bcx).to_string(),
+ target: bcx.target_data.short_name(&default_kind).to_string(),
  target_runner: target_runner(bcx, default_kind)?,
  })
  }
@@ -286,7 +294,7 @@ fn target_runner(
  bcx: &BuildContext<'_, '_>,
  kind: CompileKind,
 ) -> CargoResult<Option<(PathBuf, Vec<String>)>> {
- let target = kind.short_name(bcx);
+ let target = bcx.target_data.short_name(&kind);
 
  // try target.{}.runner
  let key = format!("target.{}.runner", target);
@@ -296,7 +304,7 @@ fn target_runner(
  }
 
  // try target.'cfg(...)'.runner
- let target_cfg = bcx.info(kind).cfg();
+ let target_cfg = bcx.target_data.info(kind).cfg();
  let mut cfgs = bcx
  .config
  .target_cfgs()?

src/cargo/core/compiler/compile_kind.rs

@@ -1,4 +1,3 @@
-use crate::core::compiler::BuildContext;
 use crate::core::{InternedString, Target};
 use crate::util::errors::{CargoResult, CargoResultExt};
 use serde::Serialize;
@@ -40,15 +39,6 @@ impl CompileKind {
  CompileKind::Target(n) => CompileKind::Target(n),
  }
  }
-
- /// Returns a "short" name for this kind, suitable for keying off
- /// configuration in Cargo or presenting to users.
- pub fn short_name(&self, bcx: &BuildContext<'_, '_>) -> &str {
- match self {
- CompileKind::Host => bcx.host_triple().as_str(),
- CompileKind::Target(target) => target.short_name(),
- }
- }
 }
 
 /// Abstraction for the representation of a compilation target that Cargo has.