Implement cfg-based target-specific dependencies

This commit is an implementation of [RFC 1361][rfc] which is an extension of Cargo's `target` section in `Cargo.toml` to allow the use of `#[cfg]`-like expressions for target-specific dependencies. Now that the compiler has been extended with `--print cfg` each invocation of Cargo will scrape this output and learn about the relevant `#[cfg]` directives in play for the target being compiled. Cargo will then use these directives to decide whether a dependency should be activated or not. This should allow definition of dependencies along the lines of: [target.'cfg(unix)'.dependencies] [target.'cfg(target_os = "linux")'.dependencies] [target.'cfg(windows)'.dependencies] Which is much more ergonomic and robust than listing all the triples out!
rust-lang · Jan 26, 2016 · f5d786e05600720ba4671caf5b598624103c8f72 · f5d786e
1 parent 3afc341
commit f5d786e05600720ba4671caf5b598624103c8f72
diff --git a/src/cargo/core/dependency.rs b/src/cargo/core/dependency.rs
@@ -1,12 +1,22 @@
+  
+use std::fmt;
+  
+use std::rc::Rc;
+  
+use std::str::FromStr;
+  
+
 use semver::VersionReq;
 use rustc_serialize::{Encoder, Encodable};
 use core::{SourceId, Summary, PackageId};
-  
-use std::rc::Rc;
-  
-use util::CargoResult;
+  
+use util::{CargoError, CargoResult, Cfg, CfgExpr, ChainError, human};
+  
+
+  
+/// Information about a dependency requested by a Cargo manifest.
+  
+/// Cheap to copy.
+  
+#[derive(PartialEq, Clone ,Debug)]
+  
+pub struct Dependency {
+  
+    inner: Rc<DependencyInner>,
+  
+}
 /// The data underlying a Dependency.
-  
-#[derive(PartialEq,Clone,Debug)]
+  
+#[derive(PartialEq, Clone, Debug)]
 pub struct DependencyInner {
    name: String,
    source_id: SourceId,
@@ -21,17 +31,15 @@ pub struct DependencyInner {
    // This dependency should be used only for this platform.
    // `None` means *all platforms*.
-  
-    only_for_platform: Option<String>,
+  
+    platform: Option<Platform>,
 }
-  
-/// Information about a dependency requested by a Cargo manifest.
-  
-/// Cheap to copy.
-  
-#[derive(PartialEq,Clone,Debug)]
-  
-pub struct Dependency {
-  
-    inner: Rc<DependencyInner>,
+  
+#[derive(Clone, Debug, PartialEq)]
+  
+pub enum Platform {
+  
+    Name(String),
+  
+    Cfg(CfgExpr),
 }
-  
-
 #[derive(RustcEncodable)]
 struct SerializedDependency<'a> {
    name: &'a str,
@@ -42,7 +50,7 @@ struct SerializedDependency<'a> {
    optional: bool,
    uses_default_features: bool,
    features: &'a [String],
-  
-    target: &'a Option<&'a str>,
+  
+    target: Option<&'a Platform>,
 }
 impl Encodable for Dependency {
@@ -55,7 +63,7 @@ impl Encodable for Dependency {
            optional: self.is_optional(),
            uses_default_features: self.uses_default_features(),
            features: self.features(),
-  
-            target: &self.only_for_platform(),
+  
+            target: self.platform(),
        }.encode(s)
    }
 }
@@ -106,7 +114,7 @@ impl DependencyInner {
            features: Vec::new(),
            default_features: true,
            specified_req: None,
-  
-            only_for_platform: None,
+  
+            platform: None,
        }
    }
@@ -118,10 +126,10 @@ impl DependencyInner {
        self.specified_req.as_ref().map(|s| &s[..])
    }
-  
-    /// If none, this dependencies must be built for all platforms.
-  
-    /// If some, it must only be built for the specified platform.
-  
-    pub fn only_for_platform(&self) -> Option<&str> {
-  
-        self.only_for_platform.as_ref().map(|s| &s[..])
+  
+    /// If none, this dependency must be built for all platforms.
+  
+    /// If some, it must only be built for matching platforms.
+  
+    pub fn platform(&self) -> Option<&Platform> {
+  
+        self.platform.as_ref()
    }
    pub fn set_kind(mut self, kind: Kind) -> DependencyInner {
@@ -159,9 +167,9 @@ impl DependencyInner {
        self
    }
-  
-    pub fn set_only_for_platform(mut self, platform: Option<String>)
-  
-                                 -> DependencyInner {
-  
-        self.only_for_platform = platform;
+  
+    pub fn set_platform(mut self, platform: Option<Platform>)
+  
+                        -> DependencyInner {
+  
+        self.platform = platform;
        self
    }
@@ -230,8 +238,8 @@ impl Dependency {
    /// If none, this dependencies must be built for all platforms.
    /// If some, it must only be built for the specified platform.
-  
-    pub fn only_for_platform(&self) -> Option<&str> {
-  
-        self.inner.only_for_platform()
+  
+    pub fn platform(&self) -> Option<&Platform> {
+  
+        self.inner.platform()
    }
    /// Lock this dependency to depending on the specified package id
@@ -258,3 +266,47 @@ impl Dependency {
        self.inner.matches_id(id)
    }
 }
+  
+
+  
+impl Platform {
+  
+    pub fn matches(&self, name: &str, cfg: Option<&[Cfg]>) -> bool {
+  
+        match *self {
+  
+            Platform::Name(ref p) => p == name,
+  
+            Platform::Cfg(ref p) => {
+  
+                match cfg {
+  
+                    Some(cfg) => p.matches(cfg),
+  
+                    None => false,
+  
+                }
+  
+            }
+  
+        }
+  
+    }
+  
+}
+  
+
+  
+impl Encodable for Platform {
+  
+    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
+  
+        self.to_string().encode(s)
+  
+    }
+  
+}
+  
+
+  
+impl FromStr for Platform {
+  
+    type Err = Box<CargoError>;
+  
+
+  
+    fn from_str(s: &str) -> CargoResult<Platform> {
+  
+        if s.starts_with("cfg(") && s.ends_with(")") {
+  
+            let s = &s[4..s.len()-1];
+  
+            s.parse().map(Platform::Cfg).chain_error(|| {
+  
+                human(format!("failed to parse `{}` as a cfg expression", s))
+  
+            })
+  
+        } else {
+  
+            Ok(Platform::Name(s.to_string()))
+  
+        }
+  
+    }
+  
+}
+  
+
+  
+impl fmt::Display for Platform {
+  
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+  
+        match *self {
+  
+            Platform::Name(ref n) => n.fmt(f),
+  
+            Platform::Cfg(ref e) => write!(f, "cfg({})", e),
+  
+        }
+  
+    }
+  
+}
diff --git a/src/cargo/ops/cargo_rustc/context.rs b/src/cargo/ops/cargo_rustc/context.rs
@@ -1,14 +1,14 @@
 use std::collections::{HashSet, HashMap};
 use std::path::{Path, PathBuf};
-  
-use std::str;
+  
+use std::str::{self, FromStr};
 use std::sync::Arc;
 use regex::Regex;
 use core::{SourceMap, Package, PackageId, PackageSet, Resolve, Target, Profile};
 use core::{TargetKind, LibKind, Profiles, Metadata, Dependency};
 use core::dependency::Kind as DepKind;
-  
-use util::{self, CargoResult, ChainError, internal, Config, profile};
+  
+use util::{self, CargoResult, ChainError, internal, Config, profile, Cfg, human};
 use super::TargetConfig;
 use super::custom_build::{BuildState, BuildScripts};
@@ -41,16 +41,20 @@ pub struct Context<'a, 'cfg: 'a> {
    host: Layout,
    target: Option<Layout>,
    target_triple: String,
-  
-    host_dylib: Option<(String, String)>,
-  
-    host_staticlib: Option<(String, String)>,
-  
-    host_exe: String,
+  
+    target_info: TargetInfo,
+  
+    host_info: TargetInfo,
    package_set: &'a PackageSet,
-  
-    target_dylib: Option<(String, String)>,
-  
-    target_staticlib: Option<(String, String)>,
-  
-    target_exe: String,
    profiles: &'a Profiles,
 }
+  
+#[derive(Clone)]
+  
+struct TargetInfo {
+  
+    dylib: Option<(String, String)>,
+  
+    staticlib: Option<(String, String)>,
+  
+    exe: String,
+  
+    cfg: Option<Vec<Cfg>>,
+  
+}
+  
+
 impl<'a, 'cfg> Context<'a, 'cfg> {
    pub fn new(resolve: &'a Resolve,
               sources: &'a SourceMap<'cfg>,
@@ -62,12 +66,11 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
               profiles: &'a Profiles) -> CargoResult<Context<'a, 'cfg>> {
        let target = build_config.requested_target.clone();
        let target = target.as_ref().map(|s| &s[..]);
-  
-        let (target_dylib, target_staticlib, target_exe) = try!(Context::filename_parts(target,
-  
-                                                                      config));
-  
-        let (host_dylib, host_staticlib, host_exe) = if build_config.requested_target.is_none() {
-  
-            (target_dylib.clone(), target_staticlib.clone(), target_exe.clone())
+  
+        let target_info = try!(Context::target_info(target, config));
+  
+        let host_info = if build_config.requested_target.is_none() {
+  
+            target_info.clone()
        } else {
-  
-            try!(Context::filename_parts(None, config))
+  
+            try!(Context::target_info(None, config))
        };
        let target_triple = target.unwrap_or_else(|| {
            &config.rustc_info().host[..]
@@ -83,12 +86,8 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
            sources: sources,
            package_set: deps,
            config: config,
-  
-            target_dylib: target_dylib,
-  
-            target_staticlib: target_staticlib,
-  
-            target_exe: target_exe,
-  
-            host_dylib: host_dylib,
-  
-            host_staticlib: host_staticlib,
-  
-            host_exe: host_exe,
+  
+            target_info: target_info,
+  
+            host_info: host_info,
            compilation: Compilation::new(config),
            build_state: Arc::new(BuildState::new(&build_config, deps)),
            build_config: build_config,
@@ -103,8 +102,8 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
    /// Run `rustc` to discover the dylib prefix/suffix for the target
    /// specified as well as the exe suffix
-  
-    fn filename_parts(target: Option<&str>, cfg: &Config)
-  
-                      -> CargoResult<(Option<(String, String)>, Option<(String, String)>, String)> {
+  
+    fn target_info(target: Option<&str>, cfg: &Config)
+  
+                   -> CargoResult<TargetInfo> {
        let mut process = util::process(cfg.rustc());
        process.arg("-")
               .arg("--crate-name").arg("_")
@@ -116,7 +115,18 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
        if let Some(s) = target {
            process.arg("--target").arg(s);
        };
-  
-        let output = try!(process.exec_with_output());
+  
+
+  
+        let mut with_cfg = process.clone();
+  
+        with_cfg.arg("--print=cfg");
+  
+
+  
+        let mut has_cfg = true;
+  
+        let output = try!(with_cfg.exec_with_output().or_else(|_| {
+  
+            has_cfg = false;
+  
+            process.exec_with_output()
+  
+        }).chain_error(|| {
+  
+            human(format!("failed to run `rustc` to learn about \
+  
+                           target-specific information"))
+  
+        }));
        let error = str::from_utf8(&output.stderr).unwrap();
        let output = str::from_utf8(&output.stdout).unwrap();
@@ -143,13 +153,25 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
            Some((staticlib_parts[0].to_string(), staticlib_parts[1].to_string()))
        };
-  
-        let exe_suffix = if nobin.is_match(error) {
+  
+        let exe = if nobin.is_match(error) {
            String::new()
        } else {
            lines.next().unwrap().trim()
                 .split('_').skip(1).next().unwrap().to_string()
        };
-  
-        Ok((dylib, staticlib, exe_suffix))
+  
+
+  
+        let cfg = if has_cfg {
+  
+            Some(try!(lines.map(Cfg::from_str).collect()))
+  
+        } else {
+  
+            None
+  
+        };
+  
+
+  
+        Ok(TargetInfo {
+  
+            dylib: dylib,
+  
+            staticlib: staticlib,
+  
+            exe: exe,
+  
+            cfg: cfg,
+  
+        })
    }
    /// Prepare this context, ensuring that all filesystem directories are in
@@ -207,9 +229,9 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
    /// otherwise it corresponds to the target platform.
    fn dylib(&self, kind: Kind) -> CargoResult<(&str, &str)> {
        let (triple, pair) = if kind == Kind::Host {
-  
-            (&self.config.rustc_info().host, &self.host_dylib)
+  
+            (&self.config.rustc_info().host, &self.host_info.dylib)
        } else {
-  
-            (&self.target_triple, &self.target_dylib)
+  
+            (&self.target_triple, &self.target_info.dylib)
        };
        match *pair {
            None => bail!("dylib outputs are not supported for {}", triple),
@@ -223,9 +245,9 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
    /// otherwise it corresponds to the target platform.
    pub fn staticlib(&self, kind: Kind) -> CargoResult<(&str, &str)> {
        let (triple, pair) = if kind == Kind::Host {
-  
-            (&self.config.rustc_info().host, &self.host_staticlib)
+  
+            (&self.config.rustc_info().host, &self.host_info.staticlib)
        } else {
-  
-            (&self.target_triple, &self.target_staticlib)
+  
+            (&self.target_triple, &self.target_info.staticlib)
        };
        match *pair {
            None => bail!("staticlib outputs are not supported for {}", triple),
@@ -284,9 +306,9 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
    pub fn target_filenames(&self, unit: &Unit) -> CargoResult<Vec<String>> {
        let stem = self.file_stem(unit);
        let suffix = if unit.target.for_host() {
-  
-            &self.host_exe
+  
+            &self.host_info.exe
        } else {
-  
-            &self.target_exe
+  
+            &self.target_info.exe
        };
        let mut ret = Vec::new();
@@ -532,15 +554,15 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
    fn dep_platform_activated(&self, dep: &Dependency, kind: Kind) -> bool {
        // If this dependency is only available for certain platforms,
        // make sure we're only enabling it for that platform.
-  
-        match (dep.only_for_platform(), kind) {
-  
-            (Some(ref platform), Kind::Host) => {
-  
-                *platform == self.config.rustc_info().host
-  
-            },
-  
-            (Some(ref platform), Kind::Target) => {
-  
-                *platform == self.target_triple
-  
-            },
-  
-            (None, _) => true
-  
-        }
+  
+        let platform = match dep.platform() {
+  
+            Some(p) => p,
+  
+            None => return true,
+  
+        };
+  
+        let (name, info) = match kind {
+  
+            Kind::Host => (&self.config.rustc_info().host, &self.host_info),
+  
+            Kind::Target => (&self.target_triple, &self.target_info),
+  
+        };
+  
+        platform.matches(name, info.cfg.as_ref().map(|cfg| &cfg[..]))
    }
    /// Gets a package for the given package id.

diff --git a/src/cargo/ops/registry.rs b/src/cargo/ops/registry.rs
@@ -81,7 +81,7 @@ fn transmit(pkg: &Package, tarball: &Path, registry: &mut Registry)
            name: dep.name().to_string(),
            features: dep.features().to_vec(),
            version_req: dep.version_req().to_string(),
-  
-            target: dep.only_for_platform().map(|s| s.to_string()),
+  
+            target: dep.platform().map(|s| s.to_string()),
            kind: match dep.kind() {
                Kind::Normal => "normal",
                Kind::Build => "build",

diff --git a/src/cargo/sources/registry.rs b/src/cargo/sources/registry.rs
@@ -435,6 +435,11 @@ impl<'cfg> RegistrySource<'cfg> {
            _ => Kind::Normal,
        };
+  
+        let platform = match target {
+  
+            Some(target) => Some(try!(target.parse())),
+  
+            None => None,
+  
+        };
+  
+
        // Unfortunately older versions of cargo and/or the registry ended up
        // publishing lots of entries where the features array contained the
        // empty feature, "", inside. This confuses the resolution process much
@@ -445,7 +450,7 @@ impl<'cfg> RegistrySource<'cfg> {
        Ok(dep.set_optional(optional)
              .set_default_features(default_features)
              .set_features(features)
-  
-              .set_only_for_platform(target)
+  
+              .set_platform(platform)
              .set_kind(kind)
              .into_dependency())
    }