/// Tests if a cfg-pattern matches the cfg set
pub fn cfg_matches(cfg: &ast::MetaItem, sess: &ParseSess, features: Option<&Features>) -> bool {
+ eval_condition(cfg, sess, &mut |cfg| {
+ if let (Some(feats), Some(gated_cfg)) = (features, GatedCfg::gate(cfg)) {
+ gated_cfg.check_and_emit(sess, feats);
+ }
+ sess.config.contains(&(cfg.name(), cfg.value_str()))
+ })
+}
+
+/// Evaluate a cfg-like condition (with `any` and `all`), using `eval` to
+/// evaluate individual items.
+pub fn eval_condition<F>(cfg: &ast::MetaItem, sess: &ParseSess, eval: &mut F)
+ -> bool
+ where F: FnMut(&ast::MetaItem) -> bool
+{
match cfg.node {
ast::MetaItemKind::List(ref mis) => {
for mi in mis.iter() {
// that they won't fail with the loop above.
match &*cfg.name.as_str() {
"any" => mis.iter().any(|mi| {
- cfg_matches(mi.meta_item().unwrap(), sess, features)
+ eval_condition(mi.meta_item().unwrap(), sess, eval)
}),
"all" => mis.iter().all(|mi| {
- cfg_matches(mi.meta_item().unwrap(), sess, features)
+ eval_condition(mi.meta_item().unwrap(), sess, eval)
}),
"not" => {
if mis.len() != 1 {
return false;
}
- !cfg_matches(mis[0].meta_item().unwrap(), sess, features)
+ !eval_condition(mis[0].meta_item().unwrap(), sess, eval)
},
p => {
span_err!(sess.span_diagnostic, cfg.span, E0537, "invalid predicate `{}`", p);
}
},
ast::MetaItemKind::Word | ast::MetaItemKind::NameValue(..) => {
- if let (Some(feats), Some(gated_cfg)) = (features, GatedCfg::gate(cfg)) {
- gated_cfg.check_and_emit(sess, feats);
- }
- sess.config.contains(&(cfg.name(), cfg.value_str()))
+ eval(cfg)
}
}
}
-/// Represents the #[stable], #[unstable] and #[rustc_deprecated] attributes.
+/// Represents the #[stable], #[unstable], #[rustc_{deprecated,const_unstable}] attributes.
#[derive(RustcEncodable, RustcDecodable, Clone, Debug, PartialEq, Eq, Hash)]
pub struct Stability {
pub level: StabilityLevel,
pub feature: Symbol,
pub rustc_depr: Option<RustcDeprecation>,
+ pub rustc_const_unstable: Option<RustcConstUnstable>,
}
/// The available stability levels.
pub reason: Symbol,
}
+#[derive(RustcEncodable, RustcDecodable, PartialEq, PartialOrd, Clone, Debug, Eq, Hash)]
+pub struct RustcConstUnstable {
+ pub feature: Symbol,
+}
+
#[derive(RustcEncodable, RustcDecodable, PartialEq, PartialOrd, Clone, Debug, Eq, Hash)]
pub struct Deprecation {
pub since: Option<Symbol>,
{
let mut stab: Option<Stability> = None;
let mut rustc_depr: Option<RustcDeprecation> = None;
+ let mut rustc_const_unstable: Option<RustcConstUnstable> = None;
'outer: for attr in attrs_iter {
- if attr.path != "rustc_deprecated" && attr.path != "unstable" && attr.path != "stable" {
+ if ![
+ "rustc_deprecated",
+ "rustc_const_unstable",
+ "unstable",
+ "stable",
+ ].iter().any(|&s| attr.path == s) {
continue // not a stability level
}
}
};
- match &*meta.name.as_str() {
- "rustc_deprecated" => {
- if rustc_depr.is_some() {
- span_err!(diagnostic, item_sp, E0540,
- "multiple rustc_deprecated attributes");
- break
- }
-
- let mut since = None;
- let mut reason = None;
+ macro_rules! get_meta {
+ ($($name:ident),+) => {
+ $(
+ let mut $name = None;
+ )+
for meta in metas {
if let Some(mi) = meta.meta_item() {
match &*mi.name().as_str() {
- "since" => if !get(mi, &mut since) { continue 'outer },
- "reason" => if !get(mi, &mut reason) { continue 'outer },
+ $(
+ stringify!($name)
+ => if !get(mi, &mut $name) { continue 'outer },
+ )+
_ => {
handle_errors(diagnostic, mi.span,
AttrError::UnknownMetaItem(mi.name()));
continue 'outer
}
}
+ }
+ }
+
+ match &*meta.name.as_str() {
+ "rustc_deprecated" => {
+ if rustc_depr.is_some() {
+ span_err!(diagnostic, item_sp, E0540,
+ "multiple rustc_deprecated attributes");
+ continue 'outer
+ }
+
+ get_meta!(since, reason);
match (since, reason) {
(Some(since), Some(reason)) => {
}
}
}
+ "rustc_const_unstable" => {
+ if rustc_const_unstable.is_some() {
+ span_err!(diagnostic, item_sp, E0553,
+ "multiple rustc_const_unstable attributes");
+ continue 'outer
+ }
+
+ get_meta!(feature);
+ if let Some(feature) = feature {
+ rustc_const_unstable = Some(RustcConstUnstable {
+ feature
+ });
+ } else {
+ span_err!(diagnostic, attr.span(), E0629, "missing 'feature'");
+ continue
+ }
+ }
"unstable" => {
if stab.is_some() {
handle_errors(diagnostic, attr.span(), AttrError::MultipleStabilityLevels);
},
feature,
rustc_depr: None,
+ rustc_const_unstable: None,
})
}
(None, _, _) => {
},
feature,
rustc_depr: None,
+ rustc_const_unstable: None,
})
}
(None, _) => {
}
}
+ // Merge the const-unstable info into the stability info
+ if let Some(rustc_const_unstable) = rustc_const_unstable {
+ if let Some(ref mut stab) = stab {
+ stab.rustc_const_unstable = Some(rustc_const_unstable);
+ } else {
+ span_err!(diagnostic, item_sp, E0630,
+ "rustc_const_unstable attribute must be paired with \
+ either stable or unstable attribute");
+ }
+ }
+
stab
}
fn from_tokens<I>(tokens: &mut iter::Peekable<I>) -> Option<MetaItem>
where I: Iterator<Item = TokenTree>,
{
- let (mut span, name) = match tokens.next() {
+ let (span, name) = match tokens.next() {
Some(TokenTree::Token(span, Token::Ident(ident))) => (span, ident.name),
Some(TokenTree::Token(_, Token::Interpolated(ref nt))) => match nt.0 {
token::Nonterminal::NtIdent(ident) => (ident.span, ident.node.name),
},
_ => return None,
};
- let list_closing_paren_pos = tokens.peek().map(|tt| tt.span().hi);
+ let list_closing_paren_pos = tokens.peek().map(|tt| tt.span().hi());
let node = match MetaItemKind::from_tokens(tokens) {
Some(node) => node,
_ => return None,
};
- span.hi = match node {
- MetaItemKind::NameValue(ref lit) => lit.span.hi,
- MetaItemKind::List(..) => list_closing_paren_pos.unwrap_or(span.hi),
- _ => span.hi,
+ let hi = match node {
+ MetaItemKind::NameValue(ref lit) => lit.span.hi(),
+ MetaItemKind::List(..) => list_closing_paren_pos.unwrap_or(span.hi()),
+ _ => span.hi(),
};
- Some(MetaItem { name: name, span: span, node: node })
+ Some(MetaItem { name, node, span: span.with_hi(hi) })
}
}
projects / rust.git / blobdiff