WIP: expr: add support for declaring a minimum version

This allows crates to declare the minimum supported version in their
code. Further use of `#[rustc]` attributes will then error if a
tautology is discovered.

Missing:

  - [ ] documentation updates
  - [ ] error impls/messages
  - [ ] test cases

Fixes: dtolnay#4

Author: mathstuf

Cargo.toml

@@ -14,6 +14,7 @@ name = "rustc"
 proc-macro = true
 
 [dependencies]
+lazy_static = "1"
 proc-macro2 = "0.4"
 quote = "0.6.8"
 syn = { version = "0.15.25", features = ["full"] }

src/expr.rs

@@ -1,9 +1,11 @@
 use crate::bound::{Bound, Release};
 use crate::date::Date;
+use crate::time;
 use crate::version::{Channel, Version};
 use syn::parse::{Parse, ParseStream, Result};
 use syn::punctuated::Punctuated;
 use syn::{parenthesized, token, Token};
+use std::sync::RwLock;
 
 pub enum Expr {
     Stable,
@@ -16,33 +18,142 @@ pub enum Expr {
     Not(Box<Expr>),
     Any(Vec<Expr>),
     All(Vec<Expr>),
+    MinVer(Bound),
+}
+
+pub enum ExprError {
+}
+
+impl ExprError {
+    fn nightly_date(mindate: Date, date: Date) -> Self {
+        unimplemented!()
+    }
+
+    fn nightly_channel(channel: Channel) -> Self {
+        unimplemented!()
+    }
+
+    fn nightly_release(release: Release) -> Self {
+        unimplemented!()
+    }
+
+    fn release(minrel: Release, release: Release) -> Self {
+        unimplemented!()
+    }
+
+    fn bad_bound(minver: Bound, bound: Bound) -> Self {
+        unimplemented!()
+    }
+
+    fn duplicate_minver(minver: Bound, new_minver: Bound) -> Self {
+        unimplemented!()
+    }
+}
+
+pub type ExprResult<T> = std::result::Result<T, ExprError>;
+
+lazy_static! {
+    static ref MINVER: RwLock<Option<Bound>> = RwLock::new(None);
+}
+
+fn check_minver_channel(minver: Option<Bound>, channel: Channel) -> ExprResult<()> {
+    match minver {
+        Some(Bound::Nightly(mindate)) => {
+            match channel {
+                Channel::Nightly(checkdate) => if checkdate < mindate {
+                    Err(ExprError::nightly_date(mindate, checkdate))
+                } else {
+                    Ok(())
+                },
+                Channel::Stable | Channel::Beta => Err(ExprError::nightly_channel(channel)),
+                _ => Ok(()),
+            }
+        },
+        _ => Ok(()),
+    }
+}
+
+fn check_minver_bound(minver: Option<Bound>, bound: &Bound) -> ExprResult<()> {
+    match minver {
+        Some(minver) => if bound < &minver {
+            Err(ExprError::bad_bound(minver, *bound))
+        } else {
+            Ok(())
+        },
+        None => Ok(()),
+    }
+}
+
+fn check_minver_release(minver: Option<Bound>, release: &Release) -> ExprResult<()> {
+    match minver {
+        Some(Bound::Nightly(_)) => Err(ExprError::nightly_release(*release)),
+        Some(Bound::Stable(minrel)) => if release < &minrel {
+            Err(ExprError::release(minrel, *release))
+        } else {
+            Ok(())
+        },
+        None => Ok(()),
+    }
 }
 
 impl Expr {
-    pub fn eval(&self, rustc: Version) -> Result<bool> {
+    pub fn eval(&self, rustc: Version) -> ExprResult<bool> {
         use self::Expr::*;
 
+        let minver = {
+            let bound = MINVER.read().expect("minver lock poisoned");
+            *bound
+        };
+
         Ok(match self {
-            Stable => rustc.channel == Channel::Stable,
-            Beta => rustc.channel == Channel::Beta,
-            Nightly => match rustc.channel {
-                Channel::Nightly(_) | Channel::Dev => true,
-                Channel::Stable | Channel::Beta => false,
+            Stable => {
+                check_minver_channel(minver, Channel::Stable)?;
+                rustc.channel == Channel::Stable
+            },
+            Beta => {
+                check_minver_channel(minver, Channel::Beta)?;
+                rustc.channel == Channel::Beta
+            },
+            Nightly => {
+                check_minver_channel(minver, Channel::Nightly(time::today()))?;
+                match rustc.channel {
+                    Channel::Nightly(_) | Channel::Dev => true,
+                    Channel::Stable | Channel::Beta => false,
+                }
             },
-            Date(date) => match rustc.channel {
-                Channel::Nightly(rustc) => rustc == *date,
-                Channel::Stable | Channel::Beta | Channel::Dev => false,
+            Date(date) => {
+                check_minver_channel(minver, Channel::Nightly(*date))?;
+                match rustc.channel {
+                    Channel::Nightly(rustc) => rustc == *date,
+                    Channel::Stable | Channel::Beta | Channel::Dev => false,
+                }
+            },
+            Since(bound) => {
+                check_minver_bound(minver, bound)?;
+                rustc >= *bound
+            },
+            Before(bound) => {
+                check_minver_bound(minver, bound)?;
+                rustc < *bound
             },
-            Since(bound) => rustc >= *bound,
-            Before(bound) => rustc < *bound,
             Release(release) => {
+                check_minver_release(minver, release)?;
                 rustc.channel == Channel::Stable
                     && rustc.minor == release.minor
                     && release.patch.map_or(true, |patch| rustc.patch == patch)
             }
             Not(expr) => !expr.eval(rustc)?,
-            Any(exprs) => exprs.iter().map(|e| e.eval(rustc)).collect::<Result<Vec<_>>>()?.into_iter().any(|b| b),
-            All(exprs) => exprs.iter().map(|e| e.eval(rustc)).collect::<Result<Vec<_>>>()?.into_iter().all(|b| b),
+            Any(exprs) => exprs.iter().map(|e| e.eval(rustc)).collect::<ExprResult<Vec<_>>>()?.into_iter().any(|b| b),
+            All(exprs) => exprs.iter().map(|e| e.eval(rustc)).collect::<ExprResult<Vec<_>>>()?.into_iter().all(|b| b),
+            MinVer(bound) => {
+                if let Some(minver) = minver {
+                    Err(ExprError::duplicate_minver(minver, *bound))?
+                } else {
+                    let mut new_minver = MINVER.write().expect("minver lock poisoned");
+                    *new_minver = Some(*bound);
+                    true
+                }
+            },
         })
     }
 }
@@ -58,6 +169,7 @@ mod keyword {
     syn::custom_keyword!(not);
     syn::custom_keyword!(any);
     syn::custom_keyword!(all);
+    syn::custom_keyword!(minver);
 }
 
 impl Parse for Expr {
@@ -79,6 +191,8 @@ impl Parse for Expr {
             Self::parse_any(input)
         } else if lookahead.peek(keyword::all) {
             Self::parse_all(input)
+        } else if lookahead.peek(keyword::minver) {
+            Self::parse_minver(input)
         } else {
             Err(lookahead.error())
         }
@@ -174,4 +288,15 @@ impl Expr {
 
         Ok(Expr::All(exprs.into_iter().collect()))
     }
+
+    fn parse_minver(input: ParseStream) -> Result<Self> {
+        input.parse::<keyword::minver>()?;
+
+        let paren;
+        parenthesized!(paren in input);
+        let bound: Bound = paren.parse()?;
+        paren.parse::<Option<Token![,]>>()?;
+
+        Ok(Expr::MinVer(bound))
+    }
 }

src/lib.rs

@@ -137,6 +137,7 @@
 //!
 //! <br>
 
+#[macro_use] extern crate lazy_static;
 extern crate proc_macro;
 
 mod attr;
@@ -194,6 +195,11 @@ pub fn all(args: TokenStream, input: TokenStream) -> TokenStream {
     cfg("all", args, input)
 }
 
+#[proc_macro_attribute]
+pub fn minver(args: TokenStream, input: TokenStream) -> TokenStream {
+    cfg("minver", args, input)
+}
+
 fn cfg(top: &str, args: TokenStream, input: TokenStream) -> TokenStream {
     match try_cfg(top, args, input) {
         Ok(tokens) => tokens,
@@ -213,10 +219,10 @@ fn try_cfg(top: &str, args: TokenStream, input: TokenStream) -> Result<TokenStre
     let expr: Expr = syn::parse2(full_args)?;
     let version = rustc::version()?;
 
-    if expr.eval(version)? {
-        Ok(input)
-    } else {
-        Ok(TokenStream::new())
+    match expr.eval(version) {
+        Ok(true) => Ok(input),
+        Ok(false) => Ok(TokenStream::new()),
+        Err(err) => unimplemented!(),
     }
 }
 
@@ -233,9 +239,11 @@ pub fn attr(args: TokenStream, input: TokenStream) -> TokenStream {
 fn try_attr(args: attr::Args, input: TokenStream) -> Result<TokenStream> {
     let version = rustc::version()?;
 
-    if !args.condition.eval(version)? {
-        return Ok(input);
-    }
+    match args.condition.eval(version) {
+        Ok(false) => return Ok(input),
+        Err(err) => unimplemented!(),
+        _ => (),
+    };
 
     match args.then {
         Then::Const(const_token) => {