let meta = &attr.node.value;
let metas = match meta.node {
- ast::MetaList(_, ref metas) => metas,
+ ast::MetaItemKind::List(_, ref metas) => metas,
_ => {
out.push(Err(meta.span));
return out;
for meta in metas {
out.push(match meta.node {
- ast::MetaWord(ref lint_name) => Ok((lint_name.clone(), level, meta.span)),
+ ast::MetaItemKind::Word(ref lint_name) => Ok((lint_name.clone(), level, meta.span)),
_ => Err(meta.span),
});
}
PrintRequest::Cfg => {
for cfg in config::build_configuration(sess) {
match cfg.node {
- ast::MetaWord(ref word) => println!("{}", word),
- ast::MetaNameValue(ref name, ref value) => {
+ ast::MetaItemKind::Word(ref word) => println!("{}", word),
+ ast::MetaItemKind::NameValue(ref name, ref value) => {
println!("{}=\"{}\"", name, match value.node {
ast::LitKind::Str(ref s, _) => s,
_ => continue,
});
}
// Right now there are not and should not be any
- // MetaList items in the configuration returned by
+ // MetaItemKind::List items in the configuration returned by
// `build_configuration`.
- ast::MetaList(..) => {
- panic!("MetaList encountered in default cfg")
+ ast::MetaItemKind::List(..) => {
+ panic!("MetaItemKind::List encountered in default cfg")
}
}
}
use hir::*;
use syntax::ast::{Name, NodeId, DUMMY_NODE_ID, Attribute, Attribute_, MetaItem};
-use syntax::ast::{MetaWord, MetaList, MetaNameValue};
+use syntax::ast::MetaItemKind;
use syntax::attr::ThinAttributesExt;
use hir;
use syntax::codemap::{respan, Span, Spanned};
mi.map(|Spanned { node, span }| {
Spanned {
node: match node {
- MetaWord(id) => MetaWord(id),
- MetaList(id, mis) => {
- MetaList(id, mis.move_map(|e| fld.fold_meta_item(e)))
+ MetaItemKind::Word(id) => MetaItemKind::Word(id),
+ MetaItemKind::List(id, mis) => {
+ MetaItemKind::List(id, mis.move_map(|e| fld.fold_meta_item(e)))
}
- MetaNameValue(id, s) => MetaNameValue(id, s),
+ MetaItemKind::NameValue(id, s) => MetaItemKind::NameValue(id, s),
},
span: fld.new_span(span),
}
let has_doc = attrs.iter().any(|a| {
match a.node.value.node {
- ast::MetaNameValue(ref name, _) if *name == "doc" => true,
+ ast::MetaItemKind::NameValue(ref name, _) if *name == "doc" => true,
_ => false
}
});
let vd = reader::get_doc(meta_item_doc, tag_meta_item_value);
let n = token::intern_and_get_ident(nd.as_str_slice());
let v = token::intern_and_get_ident(vd.as_str_slice());
- // FIXME (#623): Should be able to decode MetaNameValue variants,
+ // FIXME (#623): Should be able to decode MetaItemKind::NameValue variants,
// but currently the encoder just drops them
attr::mk_name_value_item_str(n, v)
})).chain(reader::tagged_docs(md, tag_meta_item_list).map(|meta_item_doc| {
fn encode_meta_item(rbml_w: &mut Encoder, mi: &ast::MetaItem) {
match mi.node {
- ast::MetaWord(ref name) => {
+ ast::MetaItemKind::Word(ref name) => {
rbml_w.start_tag(tag_meta_item_word);
rbml_w.wr_tagged_str(tag_meta_item_name, name);
rbml_w.end_tag();
}
- ast::MetaNameValue(ref name, ref value) => {
+ ast::MetaItemKind::NameValue(ref name, ref value) => {
match value.node {
ast::LitKind::Str(ref value, _) => {
rbml_w.start_tag(tag_meta_item_name_value);
_ => {/* FIXME (#623): encode other variants */ }
}
}
- ast::MetaList(ref name, ref items) => {
+ ast::MetaItemKind::List(ref name, ref items) => {
rbml_w.start_tag(tag_meta_item_list);
rbml_w.wr_tagged_str(tag_meta_item_name, name);
for inner_item in items {
}
if let (Some(sel), Some(names)) = (import.as_mut(), names) {
for attr in names {
- if let ast::MetaWord(ref name) = attr.node {
+ if let ast::MetaItemKind::Word(ref name) = attr.node {
sel.insert(name.clone(), attr.span);
} else {
span_err!(self.sess, attr.span, E0466, "bad macro import");
};
for attr in names {
- if let ast::MetaWord(ref name) = attr.node {
+ if let ast::MetaItemKind::Word(ref name) = attr.node {
reexport.insert(name.clone(), attr.span);
} else {
call_bad_macro_reexport(self.sess, attr.span);
let mut id = None;
for meta_item in attr.meta_item_list().unwrap_or_default() {
match meta_item.node {
- ast::MetaWord(ref s) if id.is_none() => id = Some(s.clone()),
+ ast::MetaItemKind::Word(ref s) if id.is_none() => id = Some(s.clone()),
_ => {
self.tcx.sess.span_err(
meta_item.span,
let mut id = None;
for meta_item in attr.meta_item_list().unwrap_or_default() {
match meta_item.node {
- ast::MetaWord(ref s) if dep_node_interned.is_none() =>
+ ast::MetaItemKind::Word(ref s) if dep_node_interned.is_none() =>
dep_node_interned = Some(s.clone()),
- ast::MetaWord(ref s) if id.is_none() =>
+ ast::MetaItemKind::Word(ref s) if id.is_none() =>
id = Some(s.clone()),
_ => {
self.tcx.sess.span_err(
attributes.iter().any(|attr| {
let meta_item: &ast::MetaItem = &*attr.node.value;
match meta_item.node {
- ast::MetaWord(ref value) => &value[..] == "no_debug",
+ ast::MetaItemKind::Word(ref value) => &value[..] == "no_debug",
_ => false
}
})
impl Clean<Attribute> for ast::MetaItem {
fn clean(&self, cx: &DocContext) -> Attribute {
match self.node {
- ast::MetaWord(ref s) => Word(s.to_string()),
- ast::MetaList(ref s, ref l) => {
+ ast::MetaItemKind::Word(ref s) => Word(s.to_string()),
+ ast::MetaItemKind::List(ref s, ref l) => {
List(s.to_string(), l.clean(cx))
}
- ast::MetaNameValue(ref s, ref v) => {
+ ast::MetaItemKind::NameValue(ref s, ref v) => {
NameValue(s.to_string(), lit_to_string(v))
}
}
// The Rust abstract syntax tree.
-pub use self::MetaItem_::*;
pub use self::Mutability::*;
pub use self::Pat_::*;
pub use self::PathListItem_::*;
pub exported_macros: Vec<MacroDef>,
}
-pub type MetaItem = Spanned<MetaItem_>;
+pub type MetaItem = Spanned<MetaItemKind>;
#[derive(Clone, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub enum MetaItem_ {
- MetaWord(InternedString),
- MetaList(InternedString, Vec<P<MetaItem>>),
- MetaNameValue(InternedString, Lit),
+pub enum MetaItemKind {
+ Word(InternedString),
+ List(InternedString, Vec<P<MetaItem>>),
+ NameValue(InternedString, Lit),
}
-// can't be derived because the MetaList requires an unordered comparison
-impl PartialEq for MetaItem_ {
- fn eq(&self, other: &MetaItem_) -> bool {
+// can't be derived because the MetaItemKind::List requires an unordered comparison
+impl PartialEq for MetaItemKind {
+ fn eq(&self, other: &MetaItemKind) -> bool {
+ use self::MetaItemKind::*;
match *self {
- MetaWord(ref ns) => match *other {
- MetaWord(ref no) => (*ns) == (*no),
+ Word(ref ns) => match *other {
+ Word(ref no) => (*ns) == (*no),
_ => false
},
- MetaNameValue(ref ns, ref vs) => match *other {
- MetaNameValue(ref no, ref vo) => {
+ NameValue(ref ns, ref vs) => match *other {
+ NameValue(ref no, ref vo) => {
(*ns) == (*no) && vs.node == vo.node
}
_ => false
},
- MetaList(ref ns, ref miss) => match *other {
- MetaList(ref no, ref miso) => {
+ List(ref ns, ref miss) => match *other {
+ List(ref no, ref miso) => {
ns == no &&
miss.iter().all(|mi| miso.iter().any(|x| x.node == mi.node))
}
pub use self::IntType::*;
use ast;
-use ast::{AttrId, Attribute, Attribute_, MetaItem, MetaWord, MetaNameValue, MetaList};
+use ast::{AttrId, Attribute, Attribute_, MetaItem, MetaItemKind};
use ast::{Stmt, StmtKind, DeclKind};
use ast::{Expr, Item, Local, Decl};
use codemap::{Span, Spanned, spanned, dummy_spanned};
/// `#[foo="bar"]` and `#[foo(bar)]`
fn name(&self) -> InternedString;
- /// Gets the string value if self is a MetaNameValue variant
+ /// Gets the string value if self is a MetaItemKind::NameValue variant
/// containing a string, otherwise None.
fn value_str(&self) -> Option<InternedString>;
/// Gets a list of inner meta items from a list MetaItem type.
impl AttrMetaMethods for MetaItem {
fn name(&self) -> InternedString {
match self.node {
- MetaWord(ref n) => (*n).clone(),
- MetaNameValue(ref n, _) => (*n).clone(),
- MetaList(ref n, _) => (*n).clone(),
+ MetaItemKind::Word(ref n) => (*n).clone(),
+ MetaItemKind::NameValue(ref n, _) => (*n).clone(),
+ MetaItemKind::List(ref n, _) => (*n).clone(),
}
}
fn value_str(&self) -> Option<InternedString> {
match self.node {
- MetaNameValue(_, ref v) => {
+ MetaItemKind::NameValue(_, ref v) => {
match v.node {
ast::LitKind::Str(ref s, _) => Some((*s).clone()),
_ => None,
fn meta_item_list(&self) -> Option<&[P<MetaItem>]> {
match self.node {
- MetaList(_, ref l) => Some(&l[..]),
+ MetaItemKind::List(_, ref l) => Some(&l[..]),
_ => None
}
}
pub fn mk_name_value_item(name: InternedString, value: ast::Lit)
-> P<MetaItem> {
- P(dummy_spanned(MetaNameValue(name, value)))
+ P(dummy_spanned(MetaItemKind::NameValue(name, value)))
}
pub fn mk_list_item(name: InternedString, items: Vec<P<MetaItem>>) -> P<MetaItem> {
- P(dummy_spanned(MetaList(name, items)))
+ P(dummy_spanned(MetaItemKind::List(name, items)))
}
pub fn mk_word_item(name: InternedString) -> P<MetaItem> {
- P(dummy_spanned(MetaWord(name)))
+ P(dummy_spanned(MetaItemKind::Word(name)))
}
thread_local! { static NEXT_ATTR_ID: Cell<usize> = Cell::new(0) }
let attr = Attribute_ {
id: id,
style: style,
- value: P(spanned(lo, hi, MetaNameValue(InternedString::new("doc"),
- lit))),
+ value: P(spanned(lo, hi, MetaItemKind::NameValue(InternedString::new("doc"), lit))),
is_sugared_doc: true
};
spanned(lo, hi, attr)
v.into_iter().map(|(_, m)| m.map(|Spanned {node, span}| {
Spanned {
node: match node {
- MetaList(n, mis) => MetaList(n, sort_meta_items(mis)),
+ MetaItemKind::List(n, mis) => MetaItemKind::List(n, sort_meta_items(mis)),
_ => node
},
span: span
pub fn find_inline_attr(diagnostic: Option<&Handler>, attrs: &[Attribute]) -> InlineAttr {
attrs.iter().fold(InlineAttr::None, |ia,attr| {
match attr.node.value.node {
- MetaWord(ref n) if *n == "inline" => {
+ MetaItemKind::Word(ref n) if *n == "inline" => {
mark_used(attr);
InlineAttr::Hint
}
- MetaList(ref n, ref items) if *n == "inline" => {
+ MetaItemKind::List(ref n, ref items) if *n == "inline" => {
mark_used(attr);
if items.len() != 1 {
diagnostic.map(|d|{ d.span_err(attr.span, "expected one argument"); });
cfg: &ast::MetaItem,
diag: &mut T) -> bool {
match cfg.node {
- ast::MetaList(ref pred, ref mis) if &pred[..] == "any" =>
+ ast::MetaItemKind::List(ref pred, ref mis) if &pred[..] == "any" =>
mis.iter().any(|mi| cfg_matches(cfgs, &**mi, diag)),
- ast::MetaList(ref pred, ref mis) if &pred[..] == "all" =>
+ ast::MetaItemKind::List(ref pred, ref mis) if &pred[..] == "all" =>
mis.iter().all(|mi| cfg_matches(cfgs, &**mi, diag)),
- ast::MetaList(ref pred, ref mis) if &pred[..] == "not" => {
+ ast::MetaItemKind::List(ref pred, ref mis) if &pred[..] == "not" => {
if mis.len() != 1 {
diag.emit_error(|diagnostic| {
diagnostic.span_err(cfg.span, "expected 1 cfg-pattern");
}
!cfg_matches(cfgs, &*mis[0], diag)
}
- ast::MetaList(ref pred, _) => {
+ ast::MetaItemKind::List(ref pred, _) => {
diag.emit_error(|diagnostic| {
diagnostic.span_err(cfg.span,
&format!("invalid predicate `{}`", pred));
});
false
},
- ast::MetaWord(_) | ast::MetaNameValue(..) => {
+ ast::MetaItemKind::Word(_) | ast::MetaItemKind::NameValue(..) => {
diag.flag_gated(|feature_gated_cfgs| {
feature_gated_cfgs.extend(
GatedCfg::gate(cfg).map(GatedCfgAttr::GatedCfg));
pub fn find_repr_attrs(diagnostic: &Handler, attr: &Attribute) -> Vec<ReprAttr> {
let mut acc = Vec::new();
match attr.node.value.node {
- ast::MetaList(ref s, ref items) if *s == "repr" => {
+ ast::MetaItemKind::List(ref s, ref items) if *s == "repr" => {
mark_used(attr);
for item in items {
match item.node {
- ast::MetaWord(ref word) => {
+ ast::MetaItemKind::Word(ref word) => {
let hint = match &word[..] {
// Can't use "extern" because it's not a lexical identifier.
"C" => Some(ReprExtern),
diag: &mut T) -> bool {
attrs.iter().all(|attr| {
let mis = match attr.node.value.node {
- ast::MetaList(_, ref mis) if is_cfg(&attr) => mis,
+ ast::MetaItemKind::List(_, ref mis) if is_cfg(&attr) => mis,
_ => return true
};
}
fn meta_word(&self, sp: Span, w: InternedString) -> P<ast::MetaItem> {
- P(respan(sp, ast::MetaWord(w)))
+ P(respan(sp, ast::MetaItemKind::Word(w)))
}
fn meta_list(&self,
sp: Span,
name: InternedString,
mis: Vec<P<ast::MetaItem>> )
-> P<ast::MetaItem> {
- P(respan(sp, ast::MetaList(name, mis)))
+ P(respan(sp, ast::MetaItemKind::List(name, mis)))
}
fn meta_name_value(&self,
sp: Span,
name: InternedString,
value: ast::LitKind)
-> P<ast::MetaItem> {
- P(respan(sp, ast::MetaNameValue(name, respan(sp, value))))
+ P(respan(sp, ast::MetaItemKind::NameValue(name, respan(sp, value))))
}
fn item_use(&self, sp: Span,
if is_use {
match attr.node.value.node {
- ast::MetaWord(..) => (),
+ ast::MetaItemKind::Word(..) => (),
_ => fld.cx.span_err(attr.span, "arguments to macro_use are not allowed here"),
}
return true;
Some(list) => {
for mi in list {
let name = match mi.node {
- ast::MetaWord(ref word) => (*word).clone(),
+ ast::MetaItemKind::Word(ref word) => (*word).clone(),
_ => {
span_handler.span_err(mi.span,
"malformed feature, expected just \
pub fn noop_fold_meta_item<T: Folder>(mi: P<MetaItem>, fld: &mut T) -> P<MetaItem> {
mi.map(|Spanned {node, span}| Spanned {
node: match node {
- MetaWord(id) => MetaWord(id),
- MetaList(id, mis) => {
- MetaList(id, mis.move_map(|e| fld.fold_meta_item(e)))
+ MetaItemKind::Word(id) => MetaItemKind::Word(id),
+ MetaItemKind::List(id, mis) => {
+ MetaItemKind::List(id, mis.move_map(|e| fld.fold_meta_item(e)))
}
- MetaNameValue(id, s) => MetaNameValue(id, s)
+ MetaItemKind::NameValue(id, s) => MetaItemKind::NameValue(id, s)
},
span: fld.new_span(span)
})
}
}
let hi = self.span.hi;
- Ok(P(spanned(lo, hi, ast::MetaNameValue(name, lit))))
+ Ok(P(spanned(lo, hi, ast::MetaItemKind::NameValue(name, lit))))
}
token::OpenDelim(token::Paren) => {
let inner_items = try!(self.parse_meta_seq());
let hi = self.span.hi;
- Ok(P(spanned(lo, hi, ast::MetaList(name, inner_items))))
+ Ok(P(spanned(lo, hi, ast::MetaItemKind::List(name, inner_items))))
}
_ => {
let hi = self.last_span.hi;
- Ok(P(spanned(lo, hi, ast::MetaWord(name))))
+ Ok(P(spanned(lo, hi, ast::MetaItemKind::Word(name))))
}
}
}
fn print_meta_item(&mut self, item: &ast::MetaItem) -> io::Result<()> {
try!(self.ibox(INDENT_UNIT));
match item.node {
- ast::MetaWord(ref name) => {
+ ast::MetaItemKind::Word(ref name) => {
try!(word(self.writer(), &name));
}
- ast::MetaNameValue(ref name, ref value) => {
+ ast::MetaItemKind::NameValue(ref name, ref value) => {
try!(self.word_space(&name[..]));
try!(self.word_space("="));
try!(self.print_literal(value));
}
- ast::MetaList(ref name, ref items) => {
+ ast::MetaItemKind::List(ref name, ref items) => {
try!(word(self.writer(), &name));
try!(self.popen());
try!(self.commasep(Consistent,
style: ast::AttrStyle::Outer,
value: P(ast::MetaItem {
span: self.span,
- node: ast::MetaWord(special_idents::prelude_import.name.as_str()),
+ node: ast::MetaItemKind::Word(special_idents::prelude_import.name.as_str()),
}),
is_sugared_doc: false,
},
//! FIXME (#2810): hygiene. Search for "__" strings (in other files too). We also assume "extra" is
//! the standard library, and "std" is the core library.
-use syntax::ast::{MetaItem, MetaWord};
+use syntax::ast::{MetaItem, MetaItemKind};
use syntax::attr::AttrMetaMethods;
use syntax::ext::base::{ExtCtxt, SyntaxEnv, Annotatable};
use syntax::ext::base::{MultiDecorator, MultiItemDecorator, MultiModifier};
for titem in traits.iter().rev() {
let tname = match titem.node {
- MetaWord(ref tname) => tname,
+ MetaItemKind::Word(ref tname) => tname,
_ => {
cx.span_err(titem.span, "malformed `derive` entry");
continue;
push: &mut FnMut(Annotatable))
{
let copy_name = match mi.node {
- ast::MetaItem_::MetaList(_, ref xs) => {
- if let ast::MetaItem_::MetaWord(ref w) = xs[0].node {
+ ast::MetaItemKind::List(_, ref xs) => {
+ if let ast::MetaItemKind::Word(ref w) = xs[0].node {
token::str_to_ident(&w)
} else {
cx.span_err(mi.span, "Expected word");