feat(platform)!: Require the rust version to do matching

Co-authored-by: Ed Page <[email protected]>

Author: mo8it

Cargo.lock

@@ -10,6 +10,7 @@ documentation = "https://docs.rs/cargo-platform"
 description = "Cargo's representation of a target platform."
 
 [dependencies]
+semver.workspace = true
 serde.workspace = true
 
 [dev-dependencies]

crates/cargo-platform/Cargo.toml

@@ -26,7 +26,11 @@ fn main() {
     examples.push(target.as_str());
     for example in examples {
         let p = Platform::from_str(example).unwrap();
-        println!("{:?} matches: {:?}", example, p.matches(&target, &cfgs));
+        println!(
+            "{:?} matches: {:?}",
+            example,
+            p.matches(&target, &cfgs, &semver::Version::new(0, 0, 0))
+        );
     }
 }
 

crates/cargo-platform/examples/matches.rs

@@ -130,24 +130,24 @@ impl fmt::Display for Cfg {
 
 impl CfgExpr {
     /// Utility function to check if the key, "cfg(..)" matches the `target_cfg`
-    pub fn matches_key(key: &str, target_cfg: &[Cfg]) -> bool {
+    pub fn matches_key(key: &str, target_cfg: &[Cfg], rustc_version: &semver::Version) -> bool {
         if key.starts_with("cfg(") && key.ends_with(')') {
             let cfg = &key[4..key.len() - 1];
 
             CfgExpr::from_str(cfg)
                 .ok()
-                .map(|ce| ce.matches(target_cfg))
+                .map(|ce| ce.matches(target_cfg, rustc_version))
                 .unwrap_or(false)
         } else {
             false
         }
     }
 
-    pub fn matches(&self, cfg: &[Cfg]) -> bool {
+    pub fn matches(&self, cfg: &[Cfg], rustc_version: &semver::Version) -> bool {
         match *self {
-            CfgExpr::Not(ref e) => !e.matches(cfg),
-            CfgExpr::All(ref e) => e.iter().all(|e| e.matches(cfg)),
-            CfgExpr::Any(ref e) => e.iter().any(|e| e.matches(cfg)),
+            CfgExpr::Not(ref e) => !e.matches(cfg, rustc_version),
+            CfgExpr::All(ref e) => e.iter().all(|e| e.matches(cfg, rustc_version)),
+            CfgExpr::Any(ref e) => e.iter().any(|e| e.matches(cfg, rustc_version)),
             CfgExpr::Value(ref e) => cfg.contains(e),
             CfgExpr::True => true,
             CfgExpr::False => false,

crates/cargo-platform/src/cfg.rs

@@ -34,10 +34,10 @@ impl Platform {
     /// Returns whether the Platform matches the given target and cfg.
     ///
     /// The named target and cfg values should be obtained from `rustc`.
-    pub fn matches(&self, name: &str, cfg: &[Cfg]) -> bool {
+    pub fn matches(&self, name: &str, cfg: &[Cfg], rustc_version: &semver::Version) -> bool {
         match *self {
             Platform::Name(ref p) => p == name,
-            Platform::Cfg(ref p) => p.matches(cfg),
+            Platform::Cfg(ref p) => p.matches(cfg, rustc_version),
         }
     }
 

crates/cargo-platform/src/lib.rs

@@ -251,33 +251,34 @@ fn cfg_expr_bad() {
 
 #[test]
 fn cfg_matches() {
-    assert!(e!(foo).matches(&[c!(bar), c!(foo), c!(baz)]));
-    assert!(e!(any(foo)).matches(&[c!(bar), c!(foo), c!(baz)]));
-    assert!(e!(any(foo, bar)).matches(&[c!(bar)]));
-    assert!(e!(any(foo, bar)).matches(&[c!(foo)]));
-    assert!(e!(all(foo, bar)).matches(&[c!(foo), c!(bar)]));
-    assert!(e!(all(foo, bar)).matches(&[c!(foo), c!(bar)]));
-    assert!(e!(not(foo)).matches(&[c!(bar)]));
-    assert!(e!(not(foo)).matches(&[]));
-    assert!(e!(any((not(foo)), (all(foo, bar)))).matches(&[c!(bar)]));
-    assert!(e!(any((not(foo)), (all(foo, bar)))).matches(&[c!(foo), c!(bar)]));
-    assert!(e!(foo).matches(&[c!(r # foo)]));
-    assert!(e!(r # foo).matches(&[c!(foo)]));
-    assert!(e!(r # foo).matches(&[c!(r # foo)]));
+    let v87 = semver::Version::new(1, 87, 0);
+    assert!(e!(foo).matches(&[c!(bar), c!(foo), c!(baz)], &v87));
+    assert!(e!(any(foo)).matches(&[c!(bar), c!(foo), c!(baz)], &v87));
+    assert!(e!(any(foo, bar)).matches(&[c!(bar)], &v87));
+    assert!(e!(any(foo, bar)).matches(&[c!(foo)], &v87));
+    assert!(e!(all(foo, bar)).matches(&[c!(foo), c!(bar)], &v87));
+    assert!(e!(all(foo, bar)).matches(&[c!(foo), c!(bar)], &v87));
+    assert!(e!(not(foo)).matches(&[c!(bar)], &v87));
+    assert!(e!(not(foo)).matches(&[], &v87));
+    assert!(e!(any((not(foo)), (all(foo, bar)))).matches(&[c!(bar)], &v87));
+    assert!(e!(any((not(foo)), (all(foo, bar)))).matches(&[c!(foo), c!(bar)], &v87));
+    assert!(e!(foo).matches(&[c!(r # foo)], &v87));
+    assert!(e!(r # foo).matches(&[c!(foo)], &v87));
+    assert!(e!(r # foo).matches(&[c!(r # foo)], &v87));
 
-    assert!(!e!(foo).matches(&[]));
-    assert!(!e!(foo).matches(&[c!(bar)]));
-    assert!(!e!(foo).matches(&[c!(fo)]));
-    assert!(!e!(any(foo)).matches(&[]));
-    assert!(!e!(any(foo)).matches(&[c!(bar)]));
-    assert!(!e!(any(foo)).matches(&[c!(bar), c!(baz)]));
-    assert!(!e!(all(foo)).matches(&[c!(bar), c!(baz)]));
-    assert!(!e!(all(foo, bar)).matches(&[c!(bar)]));
-    assert!(!e!(all(foo, bar)).matches(&[c!(foo)]));
-    assert!(!e!(all(foo, bar)).matches(&[]));
-    assert!(!e!(not(bar)).matches(&[c!(bar)]));
-    assert!(!e!(not(bar)).matches(&[c!(baz), c!(bar)]));
-    assert!(!e!(any((not(foo)), (all(foo, bar)))).matches(&[c!(foo)]));
+    assert!(!e!(foo).matches(&[], &v87));
+    assert!(!e!(foo).matches(&[c!(bar)], &v87));
+    assert!(!e!(foo).matches(&[c!(fo)], &v87));
+    assert!(!e!(any(foo)).matches(&[], &v87));
+    assert!(!e!(any(foo)).matches(&[c!(bar)], &v87));
+    assert!(!e!(any(foo)).matches(&[c!(bar), c!(baz)], &v87));
+    assert!(!e!(all(foo)).matches(&[c!(bar), c!(baz)], &v87));
+    assert!(!e!(all(foo, bar)).matches(&[c!(bar)], &v87));
+    assert!(!e!(all(foo, bar)).matches(&[c!(foo)], &v87));
+    assert!(!e!(all(foo, bar)).matches(&[], &v87));
+    assert!(!e!(not(bar)).matches(&[c!(bar)], &v87));
+    assert!(!e!(not(bar)).matches(&[c!(baz), c!(bar)], &v87));
+    assert!(!e!(any((not(foo)), (all(foo, bar)))).matches(&[c!(foo)], &v87));
 }
 
 #[test]