}
fn check_attribute(&self, attr: &ast::Attribute, target: Target) {
- let name: &str = &attr.name().as_str();
- match name {
- "inline" => self.check_inline(attr, target),
- "repr" => self.check_repr(attr, target),
- _ => (),
+ if let Some(name) = attr.name() {
+ match &*name.as_str() {
+ "inline" => self.check_inline(attr, target),
+ "repr" => self.check_repr(attr, target),
+ _ => (),
+ }
}
}
}
let attrs = self.lower_attrs(&i.attrs);
let mut vis = self.lower_visibility(&i.vis);
if let ItemKind::MacroDef(ref tts) = i.node {
- if i.attrs.iter().any(|attr| attr.name() == "macro_export") {
+ if i.attrs.iter().any(|attr| attr.path == "macro_export") {
self.exported_macros.push(hir::MacroDef {
name: name, attrs: attrs, id: i.id, span: i.span, body: tts.clone().into(),
});
pub fn gather_attr(attr: &ast::Attribute) -> Vec<Result<(ast::Name, Level, Span), Span>> {
let mut out = vec![];
- let level = match Level::from_str(&attr.name().as_str()) {
+ let level = match attr.name().and_then(|name| Level::from_str(&name.as_str())) {
None => return out,
Some(lvl) => lvl,
};
+ let meta = unwrap_or!(attr.meta(), return out);
attr::mark_used(attr);
- let meta = &attr.value;
let metas = if let Some(metas) = meta.meta_item_list() {
metas
} else {
} else {
// Emit errors for non-staged-api crates.
for attr in attrs {
- let tag = attr.name();
+ let tag = unwrap_or!(attr.name(), continue);
if tag == "unstable" || tag == "stable" || tag == "rustc_deprecated" {
attr::mark_used(attr);
self.tcx.sess.span_err(attr.span(), "stability attributes may not be used \
let mut is_staged_api = false;
for attr in &krate.attrs {
- if attr.name() == "stable" || attr.name() == "unstable" {
+ if attr.path == "stable" || attr.path == "unstable" {
is_staged_api = true;
break
}
.filter(|a| a.check_name("rustc_on_unimplemented"))
.next()
{
- let err_sp = item.meta().span.substitute_dummy(span);
+ let err_sp = item.span.substitute_dummy(span);
let trait_str = self.tcx.item_path_str(trait_ref.def_id);
if let Some(istring) = item.value_str() {
let istring = &*istring.as_str();
use syntax::ast::{self, Name, NodeId};
use syntax::attr;
use syntax::parse::token;
-use syntax::symbol::{Symbol, InternedString};
+use syntax::symbol::InternedString;
use syntax_pos::{Span, NO_EXPANSION, COMMAND_LINE_EXPN, BytePos};
use syntax::tokenstream;
use rustc::hir;
use rustc::hir::*;
use rustc::hir::def::Def;
use rustc::hir::def_id::DefId;
-use rustc::hir::intravisit as visit;
+use rustc::hir::intravisit::{self as visit, Visitor};
use rustc::ty::TyCtxt;
-use rustc_data_structures::fnv;
use std::hash::{Hash, Hasher};
use super::def_path_hash::DefPathHashes;
});
}
-impl<'a, 'hash, 'tcx> visit::Visitor<'tcx> for StrictVersionHashVisitor<'a, 'hash, 'tcx> {
+impl<'a, 'hash, 'tcx> Visitor<'tcx> for StrictVersionHashVisitor<'a, 'hash, 'tcx> {
fn nested_visit_map<'this>(&'this mut self) -> visit::NestedVisitorMap<'this, 'tcx> {
if self.hash_bodies {
visit::NestedVisitorMap::OnlyBodies(&self.tcx.hir)
}
}
- fn hash_meta_item(&mut self, meta_item: &ast::MetaItem) {
- debug!("hash_meta_item: st={:?}", self.st);
-
- // ignoring span information, it doesn't matter here
- self.hash_discriminant(&meta_item.node);
- meta_item.name.as_str().len().hash(self.st);
- meta_item.name.as_str().hash(self.st);
-
- match meta_item.node {
- ast::MetaItemKind::Word => {}
- ast::MetaItemKind::NameValue(ref lit) => saw_lit(lit).hash(self.st),
- ast::MetaItemKind::List(ref items) => {
- // Sort subitems so the hash does not depend on their order
- let indices = self.indices_sorted_by(&items, |p| {
- (p.name().map(Symbol::as_str), fnv::hash(&p.literal().map(saw_lit)))
- });
- items.len().hash(self.st);
- for (index, &item_index) in indices.iter().enumerate() {
- index.hash(self.st);
- let nested_meta_item: &ast::NestedMetaItemKind = &items[item_index].node;
- self.hash_discriminant(nested_meta_item);
- match *nested_meta_item {
- ast::NestedMetaItemKind::MetaItem(ref meta_item) => {
- self.hash_meta_item(meta_item);
- }
- ast::NestedMetaItemKind::Literal(ref lit) => {
- saw_lit(lit).hash(self.st);
- }
- }
- }
- }
- }
- }
-
pub fn hash_attributes(&mut self, attributes: &[ast::Attribute]) {
debug!("hash_attributes: st={:?}", self.st);
let indices = self.indices_sorted_by(attributes, |attr| attr.name());
for i in indices {
let attr = &attributes[i];
- if !attr.is_sugared_doc &&
- !IGNORED_ATTRIBUTES.contains(&&*attr.value.name().as_str()) {
+ match attr.name() {
+ Some(name) if IGNORED_ATTRIBUTES.contains(&&*name.as_str()) => continue,
+ _ => {}
+ };
+ if !attr.is_sugared_doc {
SawAttribute(attr.style).hash(self.st);
- self.hash_meta_item(&attr.value);
+ for segment in &attr.path.segments {
+ SawIdent(segment.identifier.name.as_str()).hash(self.st);
+ }
+ for tt in attr.tokens.trees() {
+ self.hash_token_tree(&tt);
+ }
}
}
}
impl<'a, 'tcx> DirtyCleanVisitor<'a, 'tcx> {
fn dep_node(&self, attr: &Attribute, def_id: DefId) -> DepNode<DefId> {
- for item in attr.meta_item_list().unwrap_or(&[]) {
+ for item in attr.meta_item_list().unwrap_or_else(Vec::new) {
if item.check_name(LABEL) {
- let value = expect_associated_value(self.tcx, item);
+ let value = expect_associated_value(self.tcx, &item);
match DepNode::from_label_string(&value.as_str(), def_id) {
Ok(def_id) => return def_id,
Err(()) => {
debug!("check_config(attr={:?})", attr);
let config = &tcx.sess.parse_sess.config;
debug!("check_config: config={:?}", config);
- for item in attr.meta_item_list().unwrap_or(&[]) {
+ for item in attr.meta_item_list().unwrap_or_else(Vec::new) {
if item.check_name(CFG) {
- let value = expect_associated_value(tcx, item);
+ let value = expect_associated_value(tcx, &item);
debug!("check_config: searching for cfg {:?}", value);
return config.contains(&(value, None));
}
}
}
- let has_doc = attrs.iter().any(|a| a.is_value_str() && a.name() == "doc");
+ let has_doc = attrs.iter().any(|a| a.is_value_str() && a.check_name("doc"));
if !has_doc {
cx.span_lint(MISSING_DOCS,
sp,
impl EarlyLintPass for DeprecatedAttr {
fn check_attribute(&mut self, cx: &EarlyContext, attr: &ast::Attribute) {
- let name = attr.name();
+ let name = unwrap_or!(attr.name(), return);
for &&(n, _, ref g) in &self.depr_attrs {
if name == n {
if let &AttributeGate::Gated(Stability::Deprecated(link),
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnstableFeatures {
fn check_attribute(&mut self, ctx: &LateContext, attr: &ast::Attribute) {
- if attr.meta().check_name("feature") {
- if let Some(items) = attr.meta().meta_item_list() {
+ if attr.check_name("feature") {
+ if let Some(items) = attr.meta_item_list() {
for item in items {
ctx.span_lint(UNSTABLE_FEATURES, item.span(), "unstable feature");
}
#![feature(slice_patterns)]
#![feature(staged_api)]
+#[macro_use]
extern crate syntax;
#[macro_use]
extern crate rustc;
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedAttributes {
fn check_attribute(&mut self, cx: &LateContext, attr: &ast::Attribute) {
debug!("checking attribute: {:?}", attr);
+ let name = unwrap_or!(attr.name(), return);
// Note that check_name() marks the attribute as used if it matches.
for &(ref name, ty, _) in BUILTIN_ATTRIBUTES {
cx.span_lint(UNUSED_ATTRIBUTES, attr.span, "unused attribute");
// Is it a builtin attribute that must be used at the crate level?
let known_crate = BUILTIN_ATTRIBUTES.iter()
- .find(|&&(name, ty, _)| attr.name() == name && ty == AttributeType::CrateLevel)
+ .find(|&&(builtin, ty, _)| name == builtin && ty == AttributeType::CrateLevel)
.is_some();
// Has a plugin registered this attribute as one which must be used at
// the crate level?
let plugin_crate = plugin_attributes.iter()
- .find(|&&(ref x, t)| attr.name() == &**x && AttributeType::CrateLevel == t)
+ .find(|&&(ref x, t)| name == &**x && AttributeType::CrateLevel == t)
.is_some();
if known_crate || plugin_crate {
let msg = match attr.style {
impl<'a> CrateLoader<'a> {
pub fn preprocess(&mut self, krate: &ast::Crate) {
- for attr in krate.attrs.iter().filter(|m| m.name() == "link_args") {
- if let Some(linkarg) = attr.value_str() {
- self.cstore.add_used_link_args(&linkarg.as_str());
+ for attr in &krate.attrs {
+ if attr.path == "link_args" {
+ if let Some(linkarg) = attr.value_str() {
+ self.cstore.add_used_link_args(&linkarg.as_str());
+ }
}
}
}
}
pub fn is_staged_api(&self) -> bool {
- self.get_item_attrs(CRATE_DEF_INDEX)
- .iter()
- .any(|attr| attr.name() == "stable" || attr.name() == "unstable")
+ for attr in self.get_item_attrs(CRATE_DEF_INDEX) {
+ if attr.path == "stable" || attr.path == "unstable" {
+ return true;
+ }
+ }
+ false
}
pub fn is_allocator(&self) -> bool {
ItemKind::Mod(_) => {
// Ensure that `path` attributes on modules are recorded as used (c.f. #35584).
attr::first_attr_value_str_by_name(&item.attrs, "path");
- if let Some(attr) =
- item.attrs.iter().find(|attr| attr.name() == "warn_directory_ownership") {
+ if item.attrs.iter().any(|attr| attr.check_name("warn_directory_ownership")) {
let lint = lint::builtin::LEGACY_DIRECTORY_OWNERSHIP;
let msg = "cannot declare a new module at this location";
self.session.add_lint(lint, item.id, item.span, msg.to_string());
- attr::mark_used(attr);
}
}
ItemKind::Union(ref vdata, _) => {
if self.proc_macro_enabled { return; }
for attr in attrs {
- let maybe_binding = self.builtin_macros.get(&attr.name()).cloned().or_else(|| {
- let ident = Ident::with_empty_ctxt(attr.name());
+ let name = unwrap_or!(attr.name(), continue);
+ let maybe_binding = self.builtin_macros.get(&name).cloned().or_else(|| {
+ let ident = Ident::with_empty_ctxt(name);
self.resolve_lexical_macro_path_segment(ident, MacroNS, None).ok()
});
use syntax::fold::{self, Folder};
use syntax::ptr::P;
use syntax::symbol::{Symbol, keywords};
+use syntax::tokenstream::TokenStream;
use syntax::util::lev_distance::find_best_match_for_name;
use syntax_pos::{Span, DUMMY_SP};
fn find_legacy_attr_invoc(&mut self, attrs: &mut Vec<ast::Attribute>)
-> Option<ast::Attribute> {
for i in 0..attrs.len() {
+ let name = unwrap_or!(attrs[i].name(), continue);
+
if self.session.plugin_attributes.borrow().iter()
- .any(|&(ref attr_nm, _)| attrs[i].name() == &**attr_nm) {
+ .any(|&(ref attr_nm, _)| name == &**attr_nm) {
attr::mark_known(&attrs[i]);
}
- match self.builtin_macros.get(&attrs[i].name()).cloned() {
+ match self.builtin_macros.get(&name).cloned() {
Some(binding) => match *binding.get_macro(self) {
MultiModifier(..) | MultiDecorator(..) | SyntaxExtension::AttrProcMacro(..) => {
return Some(attrs.remove(i))
// Check for legacy derives
for i in 0..attrs.len() {
- if attrs[i].name() == "derive" {
+ let name = unwrap_or!(attrs[i].name(), continue);
+
+ if name == "derive" {
let mut traits = match attrs[i].meta_item_list() {
- Some(traits) if !traits.is_empty() => traits.to_owned(),
+ Some(traits) => traits,
_ => continue,
};
if traits.is_empty() {
attrs.remove(i);
} else {
- attrs[i].value = ast::MetaItem {
- name: attrs[i].name(),
- span: attrs[i].span,
- node: ast::MetaItemKind::List(traits),
- };
+ attrs[i].tokens = ast::MetaItemKind::List(traits).tokens(attrs[i].span);
}
return Some(ast::Attribute {
- value: ast::MetaItem {
- name: legacy_name,
- span: span,
- node: ast::MetaItemKind::Word,
- },
+ path: ast::Path::from_ident(span, Ident::with_empty_ctxt(legacy_name)),
+ tokens: TokenStream::empty(),
id: attr::mk_attr_id(),
style: ast::AttrStyle::Outer,
is_sugared_doc: false,
}
};
- let (attr_name, path) = {
- let attr = attr.as_ref().unwrap();
- (attr.name(), ast::Path::from_ident(attr.span, Ident::with_empty_ctxt(attr.name())))
- };
- let mut determined = true;
+ let path = attr.as_ref().unwrap().path.clone();
+ let mut determinacy = Determinacy::Determined;
match self.resolve_macro_to_def(scope, &path, MacroKind::Attr, force) {
Ok(def) => return Ok(def),
- Err(Determinacy::Undetermined) => determined = false,
+ Err(Determinacy::Undetermined) => determinacy = Determinacy::Undetermined,
Err(Determinacy::Determined) if force => return Err(Determinacy::Determined),
Err(Determinacy::Determined) => {}
}
+ let attr_name = match path.segments.len() {
+ 1 => path.segments[0].identifier.name,
+ _ => return Err(determinacy),
+ };
for &(name, span) in traits {
let path = ast::Path::from_ident(span, Ident::with_empty_ctxt(name));
match self.resolve_macro(scope, &path, MacroKind::Derive, force) {
}
return Err(Determinacy::Undetermined);
},
- Err(Determinacy::Undetermined) => determined = false,
+ Err(Determinacy::Undetermined) => determinacy = Determinacy::Undetermined,
Err(Determinacy::Determined) => {}
}
}
- Err(if determined { Determinacy::Determined } else { Determinacy::Undetermined })
+ Err(determinacy)
}
fn resolve_macro_to_def(&mut self, scope: Mark, path: &ast::Path, kind: MacroKind, force: bool)
use syntax::ast::{self, NodeId};
use syntax::codemap::CodeMap;
use syntax::print::pprust;
-use syntax::symbol::Symbol;
use syntax_pos::Span;
use data::{self, Visibility, SigElement};
type Target = Vec<Attribute>;
fn lower(self, tcx: TyCtxt) -> Vec<Attribute> {
- let doc = Symbol::intern("doc");
self.into_iter()
// Only retain real attributes. Doc comments are lowered separately.
- .filter(|attr| attr.name() != doc)
+ .filter(|attr| attr.path != "doc")
.map(|mut attr| {
// Remove the surrounding '#[..]' or '#![..]' of the pretty printed
// attribute. First normalize all inner attribute (#![..]) to outer
use syntax::ast::{self, NodeId, PatKind, Attribute, CRATE_NODE_ID};
use syntax::parse::lexer::comments::strip_doc_comment_decoration;
use syntax::parse::token;
-use syntax::symbol::{Symbol, keywords};
+use syntax::symbol::keywords;
use syntax::visit::{self, Visitor};
use syntax::print::pprust::{ty_to_string, arg_to_string};
use syntax::codemap::MacroAttribute;
}
fn docs_for_attrs(attrs: &[Attribute]) -> String {
- let doc = Symbol::intern("doc");
let mut result = String::new();
for attr in attrs {
- if attr.name() == doc {
+ if attr.check_name("doc") {
if let Some(val) = attr.value_str() {
if attr.is_sugared_doc {
result.push_str(&strip_doc_comment_decoration(&val.as_str()));
}
fn field(&self, attr: &ast::Attribute, name: &str) -> ast::Name {
- for item in attr.meta_item_list().unwrap_or(&[]) {
+ for item in attr.meta_item_list().unwrap_or_else(Vec::new) {
if item.check_name(name) {
if let Some(value) = item.value_str() {
return value;
use rustc::hir;
+use std::{mem, slice, vec};
use std::path::PathBuf;
use std::rc::Rc;
-use std::slice;
use std::sync::Arc;
use std::u32;
-use std::mem;
use core::DocContext;
use doctree;
pub struct ListAttributesIter<'a> {
attrs: slice::Iter<'a, ast::Attribute>,
- current_list: slice::Iter<'a, ast::NestedMetaItem>,
+ current_list: vec::IntoIter<ast::NestedMetaItem>,
name: &'a str
}
impl<'a> Iterator for ListAttributesIter<'a> {
- type Item = &'a ast::NestedMetaItem;
+ type Item = ast::NestedMetaItem;
fn next(&mut self) -> Option<Self::Item> {
if let Some(nested) = self.current_list.next() {
}
for attr in &mut self.attrs {
- if let Some(ref list) = attr.meta_item_list() {
+ if let Some(list) = attr.meta_item_list() {
if attr.check_name(self.name) {
- self.current_list = list.iter();
+ self.current_list = list.into_iter();
if let Some(nested) = self.current_list.next() {
return Some(nested);
}
fn lists<'a>(&'a self, name: &'a str) -> ListAttributesIter<'a> {
ListAttributesIter {
attrs: self.iter(),
- current_list: [].iter(),
+ current_list: Vec::new().into_iter(),
name: name
}
}
fn has_word(self, &str) -> bool;
}
-impl<'a, I: IntoIterator<Item=&'a ast::NestedMetaItem>> NestedAttributesExt for I {
+impl<I: IntoIterator<Item=ast::NestedMetaItem>> NestedAttributesExt for I {
fn has_word(self, word: &str) -> bool {
self.into_iter().any(|attr| attr.is_word() && attr.check_name(word))
}
// #[doc(no_inline)] attribute is present.
// Don't inline doc(hidden) imports so they can be stripped at a later stage.
let denied = self.vis != hir::Public || self.attrs.iter().any(|a| {
- a.name() == "doc" && match a.meta_item_list() {
- Some(l) => attr::list_contains_name(l, "no_inline") ||
- attr::list_contains_name(l, "hidden"),
+ a.name().unwrap() == "doc" && match a.meta_item_list() {
+ Some(l) => attr::list_contains_name(&l, "no_inline") ||
+ attr::list_contains_name(&l, "hidden"),
None => false,
}
});
let mut attrs = String::new();
for attr in &it.attrs.other_attrs {
- let name = attr.name();
+ let name = attr.name().unwrap();
if !ATTRIBUTE_WHITELIST.contains(&&name.as_str()[..]) {
continue;
}
- if let Some(s) = render_attribute(attr.meta()) {
+ if let Some(s) = render_attribute(&attr.meta().unwrap()) {
attrs.push_str(&format!("#[{}]\n", s));
}
}
attrs: Vec::new(),
};
- let attrs = krate.attrs.iter()
- .filter(|a| a.check_name("doc"))
- .filter_map(|a| a.meta_item_list())
- .flat_map(|l| l)
- .filter(|a| a.check_name("test"))
- .filter_map(|a| a.meta_item_list())
- .flat_map(|l| l);
+ let test_attrs: Vec<_> = krate.attrs.iter()
+ .filter(|a| a.check_name("doc"))
+ .flat_map(|a| a.meta_item_list().unwrap_or_else(Vec::new))
+ .filter(|a| a.check_name("test"))
+ .collect();
+ let attrs = test_attrs.iter().flat_map(|a| a.meta_item_list().unwrap_or(&[]));
+
for attr in attrs {
if attr.check_name("no_crate_inject") {
opts.no_crate_inject = true;
if item.vis == hir::Public && self.inside_public_path {
let please_inline = item.attrs.iter().any(|item| {
match item.meta_item_list() {
- Some(list) if item.check_name("doc") => {
+ Some(ref list) if item.check_name("doc") => {
list.iter().any(|i| i.check_name("inline"))
}
_ => false,
pub segments: Vec<PathSegment>,
}
+impl<'a> PartialEq<&'a str> for Path {
+ fn eq(&self, string: &&'a str) -> bool {
+ self.segments.len() == 1 && self.segments[0].identifier.name == *string
+ }
+}
+
impl fmt::Debug for Path {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "path({})", pprust::path_to_string(self))
pub struct Attribute {
pub id: AttrId,
pub style: AttrStyle,
- pub value: MetaItem,
+ pub path: Path,
+ pub tokens: TokenStream,
pub is_sugared_doc: bool,
pub span: Span,
}
pub use self::IntType::*;
use ast;
-use ast::{AttrId, Attribute, Name};
+use ast::{AttrId, Attribute, Name, Ident};
use ast::{MetaItem, MetaItemKind, NestedMetaItem, NestedMetaItemKind};
-use ast::{Lit, Expr, Item, Local, Stmt, StmtKind};
+use ast::{Lit, LitKind, Expr, Item, Local, Stmt, StmtKind};
use codemap::{Spanned, spanned, dummy_spanned, mk_sp};
use syntax_pos::{Span, BytePos, DUMMY_SP};
use errors::Handler;
use feature_gate::{Features, GatedCfg};
use parse::lexer::comments::{doc_comment_style, strip_doc_comment_decoration};
-use parse::ParseSess;
+use parse::parser::Parser;
+use parse::{self, ParseSess, PResult};
+use parse::token::{self, Token};
use ptr::P;
use symbol::Symbol;
+use tokenstream::{TokenStream, TokenTree, Delimited};
use util::ThinVec;
use std::cell::{RefCell, Cell};
+use std::iter;
thread_local! {
static USED_ATTRS: RefCell<Vec<u64>> = RefCell::new(Vec::new());
impl Attribute {
pub fn check_name(&self, name: &str) -> bool {
- let matches = self.name() == name;
+ let matches = self.path == name;
if matches {
mark_used(self);
}
matches
}
- pub fn name(&self) -> Name { self.meta().name() }
+ pub fn name(&self) -> Option<Name> {
+ match self.path.segments.len() {
+ 1 => Some(self.path.segments[0].identifier.name),
+ _ => None,
+ }
+ }
pub fn value_str(&self) -> Option<Symbol> {
- self.meta().value_str()
+ self.meta().and_then(|meta| meta.value_str())
}
- pub fn meta_item_list(&self) -> Option<&[NestedMetaItem]> {
- self.meta().meta_item_list()
+ pub fn meta_item_list(&self) -> Option<Vec<NestedMetaItem>> {
+ match self.meta() {
+ Some(MetaItem { node: MetaItemKind::List(list), .. }) => Some(list),
+ _ => None
+ }
}
- pub fn is_word(&self) -> bool { self.meta().is_word() }
+ pub fn is_word(&self) -> bool {
+ self.path.segments.len() == 1 && self.tokens.is_empty()
+ }
- pub fn span(&self) -> Span { self.meta().span }
+ pub fn span(&self) -> Span {
+ self.span
+ }
pub fn is_meta_item_list(&self) -> bool {
self.meta_item_list().is_some()
match self.node {
MetaItemKind::NameValue(ref v) => {
match v.node {
- ast::LitKind::Str(ref s, _) => Some((*s).clone()),
+ LitKind::Str(ref s, _) => Some((*s).clone()),
_ => None,
}
},
impl Attribute {
/// Extract the MetaItem from inside this Attribute.
- pub fn meta(&self) -> &MetaItem {
- &self.value
+ pub fn meta(&self) -> Option<MetaItem> {
+ let mut tokens = self.tokens.trees().peekable();
+ Some(MetaItem {
+ name: match self.path.segments.len() {
+ 1 => self.path.segments[0].identifier.name,
+ _ => return None,
+ },
+ node: if let Some(node) = MetaItemKind::from_tokens(&mut tokens) {
+ if tokens.peek().is_some() {
+ return None;
+ }
+ node
+ } else {
+ return None;
+ },
+ span: self.span,
+ })
+ }
+
+ pub fn parse_meta<'a>(&self, sess: &'a ParseSess) -> PResult<'a, MetaItem> {
+ if self.path.segments.len() > 1 {
+ sess.span_diagnostic.span_err(self.path.span, "expected ident, found path");
+ }
+
+ Ok(MetaItem {
+ name: self.path.segments.last().unwrap().identifier.name,
+ node: Parser::new(sess, self.tokens.clone(), None, false).parse_meta_item_kind()?,
+ span: self.span,
+ })
}
/// Convert self to a normal #[doc="foo"] comment, if it is a
/* Constructors */
pub fn mk_name_value_item_str(name: Name, value: Symbol) -> MetaItem {
- let value_lit = dummy_spanned(ast::LitKind::Str(value, ast::StrStyle::Cooked));
+ let value_lit = dummy_spanned(LitKind::Str(value, ast::StrStyle::Cooked));
mk_spanned_name_value_item(DUMMY_SP, name, value_lit)
}
Attribute {
id: id,
style: ast::AttrStyle::Inner,
- value: item,
+ path: ast::Path::from_ident(item.span, ast::Ident::with_empty_ctxt(item.name)),
+ tokens: item.node.tokens(item.span),
is_sugared_doc: false,
span: sp,
}
Attribute {
id: id,
style: ast::AttrStyle::Outer,
- value: item,
+ path: ast::Path::from_ident(item.span, ast::Ident::with_empty_ctxt(item.name)),
+ tokens: item.node.tokens(item.span),
is_sugared_doc: false,
span: sp,
}
pub fn mk_sugared_doc_attr(id: AttrId, text: Symbol, lo: BytePos, hi: BytePos)
-> Attribute {
let style = doc_comment_style(&text.as_str());
- let lit = spanned(lo, hi, ast::LitKind::Str(text, ast::StrStyle::Cooked));
+ let lit = spanned(lo, hi, LitKind::Str(text, ast::StrStyle::Cooked));
Attribute {
id: id,
style: style,
- value: MetaItem {
- span: mk_sp(lo, hi),
- name: Symbol::intern("doc"),
- node: MetaItemKind::NameValue(lit),
- },
+ path: ast::Path::from_ident(mk_sp(lo, hi), ast::Ident::from_str("doc")),
+ tokens: MetaItemKind::NameValue(lit).tokens(mk_sp(lo, hi)),
is_sugared_doc: true,
span: mk_sp(lo, hi),
}
}
pub fn list_contains_name(items: &[NestedMetaItem], name: &str) -> bool {
- debug!("attr::list_contains_name (name={})", name);
items.iter().any(|item| {
- debug!(" testing: {:?}", item.name());
item.check_name(name)
})
}
pub fn contains_name(attrs: &[Attribute], name: &str) -> bool {
- debug!("attr::contains_name (name={})", name);
attrs.iter().any(|item| {
- debug!(" testing: {}", item.name());
item.check_name(name)
})
}
/// Determine what `#[inline]` attribute is present in `attrs`, if any.
pub fn find_inline_attr(diagnostic: Option<&Handler>, attrs: &[Attribute]) -> InlineAttr {
attrs.iter().fold(InlineAttr::None, |ia, attr| {
- match attr.value.node {
- _ if attr.value.name != "inline" => ia,
+ if attr.path != "inline" {
+ return ia;
+ }
+ let meta = match attr.meta() {
+ Some(meta) => meta.node,
+ None => return ia,
+ };
+ match meta {
MetaItemKind::Word => {
mark_used(attr);
InlineAttr::Hint
let mut rustc_depr: Option<RustcDeprecation> = None;
'outer: for attr in attrs_iter {
- let tag = attr.name();
- if tag != "rustc_deprecated" && tag != "unstable" && tag != "stable" {
+ if attr.path != "rustc_deprecated" && attr.path != "unstable" && attr.path != "stable" {
continue // not a stability level
}
mark_used(attr);
- if let Some(metas) = attr.meta_item_list() {
+ let meta = attr.meta();
+ if let Some(MetaItem { node: MetaItemKind::List(ref metas), .. }) = meta {
+ let meta = meta.as_ref().unwrap();
let get = |meta: &MetaItem, item: &mut Option<Symbol>| {
if item.is_some() {
handle_errors(diagnostic, meta.span, AttrError::MultipleItem(meta.name()));
}
};
- match &*tag.as_str() {
+ match &*meta.name.as_str() {
"rustc_deprecated" => {
if rustc_depr.is_some() {
span_err!(diagnostic, item_sp, E0540,
let mut depr: Option<Deprecation> = None;
'outer: for attr in attrs_iter {
- if attr.name() != "deprecated" {
+ if attr.path != "deprecated" {
continue
}
/// structure layout, and `packed` to remove padding.
pub fn find_repr_attrs(diagnostic: &Handler, attr: &Attribute) -> Vec<ReprAttr> {
let mut acc = Vec::new();
- match attr.value.node {
- ast::MetaItemKind::List(ref items) if attr.value.name == "repr" => {
+ if attr.path == "repr" {
+ if let Some(items) = attr.meta_item_list() {
mark_used(attr);
for item in items {
if !item.is_meta_item() {
}
}
}
- // Not a "repr" hint: ignore.
- _ => { }
}
acc
}
}
}
+impl MetaItem {
+ fn tokens(&self) -> TokenStream {
+ let ident = TokenTree::Token(self.span, Token::Ident(Ident::with_empty_ctxt(self.name)));
+ TokenStream::concat(vec![ident.into(), self.node.tokens(self.span)])
+ }
+
+ fn from_tokens<I>(tokens: &mut iter::Peekable<I>) -> Option<MetaItem>
+ where I: Iterator<Item = TokenTree>,
+ {
+ let (mut span, name) = match tokens.next() {
+ Some(TokenTree::Token(span, Token::Ident(ident))) => (span, ident.name),
+ _ => return None,
+ };
+ let node = match MetaItemKind::from_tokens(tokens) {
+ Some(node) => node,
+ _ => return None,
+ };
+ if let Some(last_span) = node.last_span() {
+ span.hi = last_span.hi;
+ }
+ Some(MetaItem { name: name, span: span, node: node })
+ }
+}
+
+impl MetaItemKind {
+ fn last_span(&self) -> Option<Span> {
+ match *self {
+ MetaItemKind::Word => None,
+ MetaItemKind::List(ref list) => list.last().map(NestedMetaItem::span),
+ MetaItemKind::NameValue(ref lit) => Some(lit.span),
+ }
+ }
+
+ pub fn tokens(&self, span: Span) -> TokenStream {
+ match *self {
+ MetaItemKind::Word => TokenStream::empty(),
+ MetaItemKind::NameValue(ref lit) => {
+ TokenStream::concat(vec![TokenTree::Token(span, Token::Eq).into(), lit.tokens()])
+ }
+ MetaItemKind::List(ref list) => {
+ let mut tokens = Vec::new();
+ for (i, item) in list.iter().enumerate() {
+ if i > 0 {
+ tokens.push(TokenTree::Token(span, Token::Comma).into());
+ }
+ tokens.push(item.node.tokens());
+ }
+ TokenTree::Delimited(span, Delimited {
+ delim: token::Paren,
+ tts: TokenStream::concat(tokens).into(),
+ }).into()
+ }
+ }
+ }
+
+ fn from_tokens<I>(tokens: &mut iter::Peekable<I>) -> Option<MetaItemKind>
+ where I: Iterator<Item = TokenTree>,
+ {
+ let delimited = match tokens.peek().cloned() {
+ Some(TokenTree::Token(_, token::Eq)) => {
+ tokens.next();
+ return if let Some(TokenTree::Token(span, token)) = tokens.next() {
+ LitKind::from_token(token)
+ .map(|lit| MetaItemKind::NameValue(Spanned { node: lit, span: span }))
+ } else {
+ None
+ };
+ }
+ Some(TokenTree::Delimited(_, ref delimited)) if delimited.delim == token::Paren => {
+ tokens.next();
+ delimited.stream()
+ }
+ _ => return Some(MetaItemKind::Word),
+ };
+
+ let mut tokens = delimited.into_trees().peekable();
+ let mut result = Vec::new();
+ while let Some(..) = tokens.peek() {
+ match NestedMetaItemKind::from_tokens(&mut tokens) {
+ Some(item) => result.push(Spanned { span: item.span(), node: item }),
+ None => return None,
+ }
+ match tokens.next() {
+ None | Some(TokenTree::Token(_, Token::Comma)) => {}
+ _ => return None,
+ }
+ }
+ Some(MetaItemKind::List(result))
+ }
+}
+
+impl NestedMetaItemKind {
+ fn span(&self) -> Span {
+ match *self {
+ NestedMetaItemKind::MetaItem(ref item) => item.span,
+ NestedMetaItemKind::Literal(ref lit) => lit.span,
+ }
+ }
+
+ fn tokens(&self) -> TokenStream {
+ match *self {
+ NestedMetaItemKind::MetaItem(ref item) => item.tokens(),
+ NestedMetaItemKind::Literal(ref lit) => lit.tokens(),
+ }
+ }
+
+ fn from_tokens<I>(tokens: &mut iter::Peekable<I>) -> Option<NestedMetaItemKind>
+ where I: Iterator<Item = TokenTree>,
+ {
+ if let Some(TokenTree::Token(span, token)) = tokens.peek().cloned() {
+ if let Some(node) = LitKind::from_token(token) {
+ tokens.next();
+ return Some(NestedMetaItemKind::Literal(Spanned { node: node, span: span }));
+ }
+ }
+
+ MetaItem::from_tokens(tokens).map(NestedMetaItemKind::MetaItem)
+ }
+}
+
+impl Lit {
+ fn tokens(&self) -> TokenStream {
+ TokenTree::Token(self.span, self.node.token()).into()
+ }
+}
+
+impl LitKind {
+ fn token(&self) -> Token {
+ use std::ascii;
+
+ match *self {
+ LitKind::Str(string, ast::StrStyle::Cooked) => {
+ let mut escaped = String::new();
+ for ch in string.as_str().chars() {
+ escaped.extend(ch.escape_unicode());
+ }
+ Token::Literal(token::Lit::Str_(Symbol::intern(&escaped)), None)
+ }
+ LitKind::Str(string, ast::StrStyle::Raw(n)) => {
+ Token::Literal(token::Lit::StrRaw(string, n), None)
+ }
+ LitKind::ByteStr(ref bytes) => {
+ let string = bytes.iter().cloned().flat_map(ascii::escape_default)
+ .map(Into::<char>::into).collect::<String>();
+ Token::Literal(token::Lit::ByteStr(Symbol::intern(&string)), None)
+ }
+ LitKind::Byte(byte) => {
+ let string: String = ascii::escape_default(byte).map(Into::<char>::into).collect();
+ Token::Literal(token::Lit::Byte(Symbol::intern(&string)), None)
+ }
+ LitKind::Char(ch) => {
+ let string: String = ch.escape_default().map(Into::<char>::into).collect();
+ Token::Literal(token::Lit::Char(Symbol::intern(&string)), None)
+ }
+ LitKind::Int(n, ty) => {
+ let suffix = match ty {
+ ast::LitIntType::Unsigned(ty) => Some(Symbol::intern(ty.ty_to_string())),
+ ast::LitIntType::Signed(ty) => Some(Symbol::intern(ty.ty_to_string())),
+ ast::LitIntType::Unsuffixed => None,
+ };
+ Token::Literal(token::Lit::Integer(Symbol::intern(&n.to_string())), suffix)
+ }
+ LitKind::Float(symbol, ty) => {
+ Token::Literal(token::Lit::Float(symbol), Some(Symbol::intern(ty.ty_to_string())))
+ }
+ LitKind::FloatUnsuffixed(symbol) => Token::Literal(token::Lit::Float(symbol), None),
+ LitKind::Bool(value) => Token::Ident(Ident::with_empty_ctxt(Symbol::intern(match value {
+ true => "true",
+ false => "false",
+ }))),
+ }
+ }
+
+ fn from_token(token: Token) -> Option<LitKind> {
+ match token {
+ Token::Ident(ident) if ident.name == "true" => Some(LitKind::Bool(true)),
+ Token::Ident(ident) if ident.name == "false" => Some(LitKind::Bool(false)),
+ Token::Literal(lit, suf) => {
+ let (suffix_illegal, result) = parse::lit_token(lit, suf, None);
+ if suffix_illegal && suf.is_some() {
+ return None;
+ }
+ result
+ }
+ _ => None,
+ }
+ }
+}
+
pub trait HasAttrs: Sized {
fn attrs(&self) -> &[ast::Attribute];
fn map_attrs<F: FnOnce(Vec<ast::Attribute>) -> Vec<ast::Attribute>>(self, f: F) -> Self;
self.process_cfg_attr(ast::Attribute {
id: attr::mk_attr_id(),
style: attr.style,
- value: mi.clone(),
+ path: ast::Path::from_ident(mi.span, ast::Ident::with_empty_ctxt(mi.name)),
+ tokens: mi.node.tokens(mi.span),
is_sugared_doc: false,
span: mi.span,
})
return false;
}
- let mis = match attr.value.node {
- ast::MetaItemKind::List(ref mis) if is_cfg(&attr) => mis,
+ let mis = attr.meta_item_list();
+ let mis = match mis {
+ Some(ref mis) if is_cfg(&attr) => mis,
_ => return true
};
pub fn collect_derives(cx: &mut ExtCtxt, attrs: &mut Vec<ast::Attribute>) -> Vec<(Symbol, Span)> {
let mut result = Vec::new();
attrs.retain(|attr| {
- if attr.name() != "derive" {
+ if attr.path != "derive" {
return true;
}
return false;
}
- let traits = attr.meta_item_list().unwrap_or(&[]).to_owned();
+ let traits = attr.meta_item_list().unwrap_or_else(Vec::new);
if traits.is_empty() {
cx.span_warn(attr.span, "empty trait list in `derive`");
return false;
self.collect_invocations(expansion, &[])
} else if let InvocationKind::Attr { attr: None, traits, item } = invoc.kind {
let item = item
- .map_attrs(|mut attrs| { attrs.retain(|a| a.name() != "derive"); attrs });
+ .map_attrs(|mut attrs| { attrs.retain(|a| a.path != "derive"); attrs });
let item_with_markers =
add_derived_markers(&mut self.cx, &traits, item.clone());
let derives = derives.entry(invoc.expansion_data.mark).or_insert_with(Vec::new);
};
attr::mark_used(&attr);
- let name = attr.name();
+ let name = attr.path.segments[0].identifier.name;
self.cx.bt_push(ExpnInfo {
call_site: attr.span,
callee: NameAndSpan {
match *ext {
MultiModifier(ref mac) => {
- let item = mac.expand(self.cx, attr.span, &attr.value, item);
+ let meta = panictry!(attr.parse_meta(&self.cx.parse_sess));
+ let item = mac.expand(self.cx, attr.span, &meta, item);
kind.expect_from_annotatables(item)
}
MultiDecorator(ref mac) => {
let mut items = Vec::new();
- mac.expand(self.cx, attr.span, &attr.value, &item,
- &mut |item| items.push(item));
+ let meta = panictry!(attr.parse_meta(&self.cx.parse_sess));
+ mac.expand(self.cx, attr.span, &meta, &item, &mut |item| items.push(item));
items.push(item);
kind.expect_from_annotatables(items)
}
SyntaxExtension::AttrProcMacro(ref mac) => {
- let attr_toks = stream_for_attr_args(&attr, &self.cx.parse_sess);
let item_toks = stream_for_item(&item, &self.cx.parse_sess);
let span = Span {
expn_id: self.cx.codemap().record_expansion(ExpnInfo {
call_site: attr.span,
callee: NameAndSpan {
- format: MacroAttribute(name),
+ format: MacroAttribute(Symbol::intern(&format!("{}", attr.path))),
span: None,
allow_internal_unstable: false,
},
..attr.span
};
- let tok_result = mac.expand(self.cx, attr.span, attr_toks, item_toks);
+ let tok_result = mac.expand(self.cx, attr.span, attr.tokens.clone(), item_toks);
self.parse_expansion(tok_result, kind, name, span)
}
SyntaxExtension::ProcMacroDerive(..) | SyntaxExtension::BuiltinDerive(..) => {
string_to_stream(text, parse_sess)
}
-fn stream_for_attr_args(attr: &ast::Attribute, parse_sess: &ParseSess) -> TokenStream {
- use ast::MetaItemKind::*;
- use print::pp::Breaks;
- use print::pprust::PrintState;
-
- let token_string = match attr.value.node {
- // For `#[foo]`, an empty token
- Word => return TokenStream::empty(),
- // For `#[foo(bar, baz)]`, returns `(bar, baz)`
- List(ref items) => pprust::to_string(|s| {
- s.popen()?;
- s.commasep(Breaks::Consistent,
- &items[..],
- |s, i| s.print_meta_list_item(&i))?;
- s.pclose()
- }),
- // For `#[foo = "bar"]`, returns `= "bar"`
- NameValue(ref lit) => pprust::to_string(|s| {
- s.word_space("=")?;
- s.print_literal(lit)
- }),
- };
-
- string_to_stream(token_string, parse_sess)
-}
-
fn string_to_stream(text: String, parse_sess: &ParseSess) -> TokenStream {
let filename = String::from("<macro expansion>");
filemap_to_stream(parse_sess, parse_sess.codemap().new_filemap(filename, None, text))
}
impl ToTokens for ast::Attribute {
- fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
+ fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree> {
let mut r = vec![];
// FIXME: The spans could be better
r.push(TokenTree::Token(self.span, token::Pound));
if self.style == ast::AttrStyle::Inner {
r.push(TokenTree::Token(self.span, token::Not));
}
+ let mut inner = Vec::new();
+ for (i, segment) in self.path.segments.iter().enumerate() {
+ if i > 0 {
+ inner.push(TokenTree::Token(self.span, token::Colon).into());
+ }
+ inner.push(TokenTree::Token(self.span, token::Ident(segment.identifier)).into());
+ }
+ inner.push(self.tokens.clone());
+
r.push(TokenTree::Delimited(self.span, tokenstream::Delimited {
- delim: token::Bracket,
- tts: self.value.to_tokens(cx).into_iter().collect::<TokenStream>().into(),
+ delim: token::Bracket, tts: TokenStream::concat(inner).into()
}));
r
}
impl<'a> Context<'a> {
fn check_attribute(&self, attr: &ast::Attribute, is_macro: bool) {
debug!("check_attribute(attr = {:?})", attr);
- let name = &*attr.name().as_str();
+ let name = unwrap_or!(attr.name(), return);
+
for &(n, ty, ref gateage) in BUILTIN_ATTRIBUTES {
- if n == name {
+ if name == n {
if let &Gated(_, ref name, ref desc, ref has_feature) = gateage {
gate_feature_fn!(self, has_feature, attr.span, name, desc);
}
- debug!("check_attribute: {:?} is builtin, {:?}, {:?}", name, ty, gateage);
+ debug!("check_attribute: {:?} is builtin, {:?}, {:?}", attr.path, ty, gateage);
return;
}
}
for &(ref n, ref ty) in self.plugin_attributes {
- if n == name {
+ if attr.path == &**n {
// Plugins can't gate attributes, so we don't check for it
// unlike the code above; we only use this loop to
// short-circuit to avoid the checks below
- debug!("check_attribute: {:?} is registered by a plugin, {:?}", name, ty);
+ debug!("check_attribute: {:?} is registered by a plugin, {:?}", attr.path, ty);
return;
}
}
- if name.starts_with("rustc_") {
+ if name.as_str().starts_with("rustc_") {
gate_feature!(self, rustc_attrs, attr.span,
"unless otherwise specified, attributes \
with the prefix `rustc_` \
are reserved for internal compiler diagnostics");
- } else if name.starts_with("derive_") {
+ } else if name.as_str().starts_with("derive_") {
gate_feature!(self, custom_derive, attr.span, EXPLAIN_DERIVE_UNDERSCORE);
- } else if attr::is_known(attr) {
- debug!("check_attribute: {:?} is known", name);
- } else {
+ } else if !attr::is_known(attr) {
// Only run the custom attribute lint during regular
// feature gate checking. Macro gating runs
// before the plugin attributes are registered
unknown to the compiler and \
may have meaning \
added to it in the future",
- name));
+ attr.path));
}
}
}
self.context.check_attribute(attr, false);
}
- if contains_novel_literal(&attr.value) {
+ let meta = panictry!(attr.parse_meta(&self.context.parse_sess));
+ if contains_novel_literal(&meta) {
gate_feature_post!(&self, attr_literals, attr.span,
"non-string literals in attributes, or string \
literals in top-level positions, are experimental");
`#[repr(simd)]` instead");
}
for attr in &i.attrs {
- if attr.name() == "repr" {
- for item in attr.meta_item_list().unwrap_or(&[]) {
+ if attr.path == "repr" {
+ for item in attr.meta_item_list().unwrap_or_else(Vec::new) {
if item.check_name("simd") {
gate_feature_post!(&self, repr_simd, i.span,
"SIMD types are experimental \
Some(Attribute {
id: attr.id,
style: attr.style,
- value: fld.fold_meta_item(attr.value),
+ path: fld.fold_path(attr.path),
+ tokens: fld.fold_tts(attr.tokens),
is_sugared_doc: attr.is_sugared_doc,
span: fld.new_span(attr.span),
})
token::NtExpr(expr) => token::NtExpr(fld.fold_expr(expr)),
token::NtTy(ty) => token::NtTy(fld.fold_ty(ty)),
token::NtIdent(id) => token::NtIdent(Spanned::<Ident>{node: fld.fold_ident(id.node), ..id}),
- token::NtMeta(meta_item) => token::NtMeta(fld.fold_meta_item(meta_item)),
+ token::NtMeta(meta) => token::NtMeta(fld.fold_meta_item(meta)),
token::NtPath(path) => token::NtPath(fld.fold_path(path)),
token::NtTT(tt) => token::NtTT(fld.fold_tt(tt)),
token::NtArm(arm) => token::NtArm(fld.fold_arm(arm)),
matches_codepattern,
"matches_codepattern",
pprust::to_string(|s| fake_print_crate(s, &folded_crate)),
- "#[a]mod zz{fn zz(zz:zz,zz:zz){zz!(zz,zz,zz);zz;zz}}".to_string());
+ "#[zz]mod zz{fn zz(zz:zz,zz:zz){zz!(zz,zz,zz);zz;zz}}".to_string());
}
// even inside macro defs....
})
}
+#[macro_export]
+macro_rules! unwrap_or {
+ ($opt:expr, $default:expr) => {
+ match $opt {
+ Some(x) => x,
+ None => $default,
+ }
+ }
+}
+
#[macro_use]
pub mod diagnostics {
#[macro_use]
Ok(ast::Attribute {
id: attr::mk_attr_id(),
style: style,
- value: value,
+ path: ast::Path::from_ident(value.span, ast::Ident::with_empty_ctxt(value.name)),
+ tokens: value.node.tokens(value.span),
is_sugared_doc: false,
span: span,
})
let lo = self.span.lo;
let ident = self.parse_ident()?;
- let node = if self.eat(&token::Eq) {
+ let node = self.parse_meta_item_kind()?;
+ let hi = self.prev_span.hi;
+ Ok(ast::MetaItem { name: ident.name, node: node, span: mk_sp(lo, hi) })
+ }
+
+ pub fn parse_meta_item_kind(&mut self) -> PResult<'a, ast::MetaItemKind> {
+ Ok(if self.eat(&token::Eq) {
ast::MetaItemKind::NameValue(self.parse_unsuffixed_lit()?)
} else if self.token == token::OpenDelim(token::Paren) {
ast::MetaItemKind::List(self.parse_meta_seq()?)
} else {
+ self.eat(&token::OpenDelim(token::Paren));
ast::MetaItemKind::Word
- };
- let hi = self.prev_span.hi;
- Ok(ast::MetaItem { name: ident.name, node: node, span: mk_sp(lo, hi) })
+ })
}
/// matches meta_item_inner : (meta_item | UNSUFFIXED_LIT) ;
s[1..].chars().all(|c| '0' <= c && c <= '9')
}
-fn filtered_float_lit(data: Symbol, suffix: Option<Symbol>, sd: &Handler, sp: Span)
- -> ast::LitKind {
+macro_rules! err {
+ ($opt_diag:expr, |$span:ident, $diag:ident| $($body:tt)*) => {
+ match $opt_diag {
+ Some(($span, $diag)) => { $($body)* }
+ None => return None,
+ }
+ }
+}
+
+pub fn lit_token(lit: token::Lit, suf: Option<Symbol>, diag: Option<(Span, &Handler)>)
+ -> (bool /* suffix illegal? */, Option<ast::LitKind>) {
+ use ast::LitKind;
+
+ match lit {
+ token::Byte(i) => (true, Some(LitKind::Byte(byte_lit(&i.as_str()).0))),
+ token::Char(i) => (true, Some(LitKind::Char(char_lit(&i.as_str()).0))),
+
+ // There are some valid suffixes for integer and float literals,
+ // so all the handling is done internally.
+ token::Integer(s) => (false, integer_lit(&s.as_str(), suf, diag)),
+ token::Float(s) => (false, float_lit(&s.as_str(), suf, diag)),
+
+ token::Str_(s) => {
+ let s = Symbol::intern(&str_lit(&s.as_str()));
+ (true, Some(LitKind::Str(s, ast::StrStyle::Cooked)))
+ }
+ token::StrRaw(s, n) => {
+ let s = Symbol::intern(&raw_str_lit(&s.as_str()));
+ (true, Some(LitKind::Str(s, ast::StrStyle::Raw(n))))
+ }
+ token::ByteStr(i) => {
+ (true, Some(LitKind::ByteStr(byte_str_lit(&i.as_str()))))
+ }
+ token::ByteStrRaw(i, _) => {
+ (true, Some(LitKind::ByteStr(Rc::new(i.to_string().into_bytes()))))
+ }
+ }
+}
+
+fn filtered_float_lit(data: Symbol, suffix: Option<Symbol>, diag: Option<(Span, &Handler)>)
+ -> Option<ast::LitKind> {
debug!("filtered_float_lit: {}, {:?}", data, suffix);
let suffix = match suffix {
Some(suffix) => suffix,
- None => return ast::LitKind::FloatUnsuffixed(data),
+ None => return Some(ast::LitKind::FloatUnsuffixed(data)),
};
- match &*suffix.as_str() {
+ Some(match &*suffix.as_str() {
"f32" => ast::LitKind::Float(data, ast::FloatTy::F32),
"f64" => ast::LitKind::Float(data, ast::FloatTy::F64),
suf => {
- if suf.len() >= 2 && looks_like_width_suffix(&['f'], suf) {
- // if it looks like a width, lets try to be helpful.
- sd.struct_span_err(sp, &format!("invalid width `{}` for float literal", &suf[1..]))
- .help("valid widths are 32 and 64")
- .emit();
- } else {
- sd.struct_span_err(sp, &format!("invalid suffix `{}` for float literal", suf))
- .help("valid suffixes are `f32` and `f64`")
- .emit();
- }
+ err!(diag, |span, diag| {
+ if suf.len() >= 2 && looks_like_width_suffix(&['f'], suf) {
+ // if it looks like a width, lets try to be helpful.
+ let msg = format!("invalid width `{}` for float literal", &suf[1..]);
+ diag.struct_span_err(span, &msg).help("valid widths are 32 and 64").emit()
+ } else {
+ let msg = format!("invalid suffix `{}` for float literal", suf);
+ diag.struct_span_err(span, &msg)
+ .help("valid suffixes are `f32` and `f64`")
+ .emit();
+ }
+ });
ast::LitKind::FloatUnsuffixed(data)
}
- }
+ })
}
-pub fn float_lit(s: &str, suffix: Option<Symbol>, sd: &Handler, sp: Span) -> ast::LitKind {
+pub fn float_lit(s: &str, suffix: Option<Symbol>, diag: Option<(Span, &Handler)>)
+ -> Option<ast::LitKind> {
debug!("float_lit: {:?}, {:?}", s, suffix);
// FIXME #2252: bounds checking float literals is deferred until trans
let s = s.chars().filter(|&c| c != '_').collect::<String>();
- filtered_float_lit(Symbol::intern(&s), suffix, sd, sp)
+ filtered_float_lit(Symbol::intern(&s), suffix, diag)
}
/// Parse a string representing a byte literal into its final form. Similar to `char_lit`
Rc::new(res)
}
-pub fn integer_lit(s: &str, suffix: Option<Symbol>, sd: &Handler, sp: Span) -> ast::LitKind {
+pub fn integer_lit(s: &str, suffix: Option<Symbol>, diag: Option<(Span, &Handler)>)
+ -> Option<ast::LitKind> {
// s can only be ascii, byte indexing is fine
let s2 = s.chars().filter(|&c| c != '_').collect::<String>();
// 1f64 and 2f32 etc. are valid float literals.
if let Some(suf) = suffix {
if looks_like_width_suffix(&['f'], &suf.as_str()) {
- match base {
- 16 => sd.span_err(sp, "hexadecimal float literal is not supported"),
- 8 => sd.span_err(sp, "octal float literal is not supported"),
- 2 => sd.span_err(sp, "binary float literal is not supported"),
- _ => ()
+ let err = match base {
+ 16 => Some("hexadecimal float literal is not supported"),
+ 8 => Some("octal float literal is not supported"),
+ 2 => Some("binary float literal is not supported"),
+ _ => None,
+ };
+ if let Some(err) = err {
+ err!(diag, |span, diag| diag.span_err(span, err));
}
- return filtered_float_lit(Symbol::intern(&s), Some(suf), sd, sp)
+ return filtered_float_lit(Symbol::intern(&s), Some(suf), diag)
}
}
}
if let Some(suf) = suffix {
- if suf.as_str().is_empty() { sd.span_bug(sp, "found empty literal suffix in Some")}
+ if suf.as_str().is_empty() {
+ err!(diag, |span, diag| diag.span_bug(span, "found empty literal suffix in Some"));
+ }
ty = match &*suf.as_str() {
"isize" => ast::LitIntType::Signed(ast::IntTy::Is),
"i8" => ast::LitIntType::Signed(ast::IntTy::I8),
suf => {
// i<digits> and u<digits> look like widths, so lets
// give an error message along those lines
- if looks_like_width_suffix(&['i', 'u'], suf) {
- sd.struct_span_err(sp, &format!("invalid width `{}` for integer literal",
- &suf[1..]))
- .help("valid widths are 8, 16, 32, 64 and 128")
- .emit();
- } else {
- sd.struct_span_err(sp, &format!("invalid suffix `{}` for numeric literal", suf))
- .help("the suffix must be one of the integral types \
- (`u32`, `isize`, etc)")
- .emit();
- }
+ err!(diag, |span, diag| {
+ if looks_like_width_suffix(&['i', 'u'], suf) {
+ let msg = format!("invalid width `{}` for integer literal", &suf[1..]);
+ diag.struct_span_err(span, &msg)
+ .help("valid widths are 8, 16, 32, 64 and 128")
+ .emit();
+ } else {
+ let msg = format!("invalid suffix `{}` for numeric literal", suf);
+ diag.struct_span_err(span, &msg)
+ .help("the suffix must be one of the integral types \
+ (`u32`, `isize`, etc)")
+ .emit();
+ }
+ });
ty
}
debug!("integer_lit: the type is {:?}, base {:?}, the new string is {:?}, the original \
string was {:?}, the original suffix was {:?}", ty, base, s, orig, suffix);
- match u128::from_str_radix(s, base) {
+ Some(match u128::from_str_radix(s, base) {
Ok(r) => ast::LitKind::Int(r, ty),
Err(_) => {
// small bases are lexed as if they were base 10, e.g, the string
s.chars().any(|c| c.to_digit(10).map_or(false, |d| d >= base));
if !already_errored {
- sd.span_err(sp, "int literal is too large");
+ err!(diag, |span, diag| diag.span_err(span, "int literal is too large"));
}
ast::LitKind::Int(0, ty)
}
- }
+ })
}
#[cfg(test)]
let source = "/// doc comment\r\n/// line 2\r\nfn foo() {}".to_string();
let item = parse_item_from_source_str(name.clone(), source, &sess)
.unwrap().unwrap();
- let docs = item.attrs.iter().filter(|a| a.name() == "doc")
+ let docs = item.attrs.iter().filter(|a| a.path == "doc")
.map(|a| a.value_str().unwrap().to_string()).collect::<Vec<_>>();
let b: &[_] = &["/// doc comment".to_string(), "/// line 2".to_string()];
assert_eq!(&docs[..], b);
use std::collections::HashSet;
use std::{cmp, mem, slice};
use std::path::{Path, PathBuf};
-use std::rc::Rc;
bitflags! {
flags Restrictions: u8 {
_ => { return self.unexpected_last(&self.token); }
},
token::Literal(lit, suf) => {
- let (suffix_illegal, out) = match lit {
- token::Byte(i) => (true, LitKind::Byte(parse::byte_lit(&i.as_str()).0)),
- token::Char(i) => (true, LitKind::Char(parse::char_lit(&i.as_str()).0)),
-
- // there are some valid suffixes for integer and
- // float literals, so all the handling is done
- // internally.
- token::Integer(s) => {
- let diag = &self.sess.span_diagnostic;
- (false, parse::integer_lit(&s.as_str(), suf, diag, self.span))
- }
- token::Float(s) => {
- let diag = &self.sess.span_diagnostic;
- (false, parse::float_lit(&s.as_str(), suf, diag, self.span))
- }
-
- token::Str_(s) => {
- let s = Symbol::intern(&parse::str_lit(&s.as_str()));
- (true, LitKind::Str(s, ast::StrStyle::Cooked))
- }
- token::StrRaw(s, n) => {
- let s = Symbol::intern(&parse::raw_str_lit(&s.as_str()));
- (true, LitKind::Str(s, ast::StrStyle::Raw(n)))
- }
- token::ByteStr(i) => {
- (true, LitKind::ByteStr(parse::byte_str_lit(&i.as_str())))
- }
- token::ByteStrRaw(i, _) => {
- (true, LitKind::ByteStr(Rc::new(i.to_string().into_bytes())))
- }
- };
+ let diag = Some((self.span, &self.sess.span_diagnostic));
+ let (suffix_illegal, result) = parse::lit_token(lit, suf, diag);
if suffix_illegal {
let sp = self.span;
self.expect_no_suffix(sp, &format!("{} literal", lit.short_name()), suf)
}
- out
+ result.unwrap()
}
_ => { return self.unexpected_last(&self.token); }
};
let attr = ast::Attribute {
id: attr::mk_attr_id(),
style: ast::AttrStyle::Outer,
- value: ast::MetaItem {
- name: Symbol::intern("warn_directory_ownership"),
- node: ast::MetaItemKind::Word,
- span: syntax_pos::DUMMY_SP,
- },
+ path: ast::Path::from_ident(syntax_pos::DUMMY_SP,
+ Ident::from_str("warn_directory_ownership")),
+ tokens: TokenStream::empty(),
is_sugared_doc: false,
span: syntax_pos::DUMMY_SP,
};
use ast::{self};
use ptr::P;
use symbol::keywords;
-use tokenstream;
+use tokenstream::TokenTree;
use std::fmt;
use std::rc::Rc;
/// Stuff inside brackets for attributes
NtMeta(ast::MetaItem),
NtPath(ast::Path),
- NtTT(tokenstream::TokenTree),
+ NtTT(TokenTree),
// These are not exposed to macros, but are used by quasiquote.
NtArm(ast::Arm),
NtImplItem(ast::ImplItem),
use std_inject;
use symbol::{Symbol, keywords};
use syntax_pos::DUMMY_SP;
-use tokenstream::{self, TokenTree};
+use tokenstream::{self, TokenStream, TokenTree};
use std::ascii;
use std::io::{self, Write, Read};
to_string(|s| s.print_tts(tts.iter().cloned().collect()))
}
+pub fn tokens_to_string(tokens: TokenStream) -> String {
+ to_string(|s| s.print_tts(tokens))
+}
+
pub fn stmt_to_string(stmt: &ast::Stmt) -> String {
to_string(|s| s.print_stmt(stmt))
}
ast::AttrStyle::Inner => word(self.writer(), "#![")?,
ast::AttrStyle::Outer => word(self.writer(), "#[")?,
}
- self.print_meta_item(&attr.meta())?;
+ if let Some(mi) = attr.meta() {
+ self.print_meta_item(&mi)?
+ } else {
+ for (i, segment) in attr.path.segments.iter().enumerate() {
+ if i > 0 {
+ word(self.writer(), "::")?
+ }
+ if segment.identifier.name != keywords::CrateRoot.name() &&
+ segment.identifier.name != "$crate" {
+ word(self.writer(), &segment.identifier.name.as_str())?;
+ }
+ }
+ space(self.writer())?;
+ self.print_tts(attr.tokens.clone())?;
+ }
word(self.writer(), "]")
}
}
self.end()
}
+ /// This doesn't deserve to be called "pretty" printing, but it should be
+ /// meaning-preserving. A quick hack that might help would be to look at the
+ /// spans embedded in the TTs to decide where to put spaces and newlines.
+ /// But it'd be better to parse these according to the grammar of the
+ /// appropriate macro, transcribe back into the grammar we just parsed from,
+ /// and then pretty-print the resulting AST nodes (so, e.g., we print
+ /// expression arguments as expressions). It can be done! I think.
+ fn print_tt(&mut self, tt: tokenstream::TokenTree) -> io::Result<()> {
+ match tt {
+ TokenTree::Token(_, ref tk) => {
+ word(self.writer(), &token_to_string(tk))?;
+ match *tk {
+ parse::token::DocComment(..) => {
+ hardbreak(self.writer())
+ }
+ _ => Ok(())
+ }
+ }
+ TokenTree::Delimited(_, ref delimed) => {
+ word(self.writer(), &token_to_string(&delimed.open_token()))?;
+ space(self.writer())?;
+ self.print_tts(delimed.stream())?;
+ space(self.writer())?;
+ word(self.writer(), &token_to_string(&delimed.close_token()))
+ },
+ }
+ }
+
+ fn print_tts(&mut self, tts: tokenstream::TokenStream) -> io::Result<()> {
+ self.ibox(0)?;
+ for (i, tt) in tts.into_trees().enumerate() {
+ if i != 0 {
+ space(self.writer())?;
+ }
+ self.print_tt(tt)?;
+ }
+ self.end()
+ }
+
fn space_if_not_bol(&mut self) -> io::Result<()> {
if !self.is_bol() { space(self.writer())?; }
Ok(())
}
}
- /// This doesn't deserve to be called "pretty" printing, but it should be
- /// meaning-preserving. A quick hack that might help would be to look at the
- /// spans embedded in the TTs to decide where to put spaces and newlines.
- /// But it'd be better to parse these according to the grammar of the
- /// appropriate macro, transcribe back into the grammar we just parsed from,
- /// and then pretty-print the resulting AST nodes (so, e.g., we print
- /// expression arguments as expressions). It can be done! I think.
- pub fn print_tt(&mut self, tt: tokenstream::TokenTree) -> io::Result<()> {
- match tt {
- TokenTree::Token(_, ref tk) => {
- word(&mut self.s, &token_to_string(tk))?;
- match *tk {
- parse::token::DocComment(..) => {
- hardbreak(&mut self.s)
- }
- _ => Ok(())
- }
- }
- TokenTree::Delimited(_, ref delimed) => {
- word(&mut self.s, &token_to_string(&delimed.open_token()))?;
- space(&mut self.s)?;
- self.print_tts(delimed.stream())?;
- space(&mut self.s)?;
- word(&mut self.s, &token_to_string(&delimed.close_token()))
- },
- }
- }
-
- pub fn print_tts(&mut self, tts: tokenstream::TokenStream) -> io::Result<()> {
- self.ibox(0)?;
- for (i, tt) in tts.into_trees().enumerate() {
- if i != 0 {
- space(&mut self.s)?;
- }
- self.print_tt(tt)?;
- }
- self.end()
- }
-
pub fn print_variant(&mut self, v: &ast::Variant) -> io::Result<()> {
self.head("")?;
let generics = ast::Generics::default();
use codemap::{self, ExpnInfo, NameAndSpan, MacroAttribute};
use parse::ParseSess;
use ptr::P;
+use tokenstream::TokenStream;
/// Craft a span that will be ignored by the stability lint's
/// call to codemap's is_internal check.
krate.module.items.insert(0, P(ast::Item {
attrs: vec![ast::Attribute {
style: ast::AttrStyle::Outer,
- value: ast::MetaItem {
- name: Symbol::intern("prelude_import"),
- node: ast::MetaItemKind::Word,
- span: span,
- },
+ path: ast::Path::from_ident(span, ast::Ident::from_str("prelude_import")),
+ tokens: TokenStream::empty(),
id: attr::mk_attr_id(),
is_sugared_doc: false,
span: span,
impl fmt::Display for TokenStream {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- f.write_str(&pprust::tts_to_string(&self.trees().collect::<Vec<_>>()))
+ f.write_str(&pprust::tokens_to_string(self.clone()))
}
}
impl<'a> Visitor<'a> for MarkAttrs<'a> {
fn visit_attribute(&mut self, attr: &Attribute) {
- if self.0.contains(&attr.name()) {
- mark_used(attr);
- mark_known(attr);
+ if let Some(name) = attr.name() {
+ if self.0.contains(&name) {
+ mark_used(attr);
+ mark_known(attr);
+ }
}
}
attrs.extend(item.attrs
.iter()
.filter(|a| {
- match &*a.name().as_str() {
+ a.name().is_some() && match &*a.name().unwrap().as_str() {
"allow" | "warn" | "deny" | "forbid" | "stable" | "unstable" => true,
_ => false,
}
fn visit_item(&mut self, item: &'a ast::Item) {
if let ast::ItemKind::MacroDef(..) = item.node {
if self.is_proc_macro_crate &&
- item.attrs.iter().any(|attr| attr.name() == "macro_export") {
+ item.attrs.iter().any(|attr| attr.path == "macro_export") {
let msg =
"cannot export macro_rules! macros from a `proc-macro` crate type currently";
self.handler.span_err(item.span, msg);
for attr in &item.attrs {
if is_proc_macro_attr(&attr) {
if let Some(prev_attr) = found_attr {
- let msg = if attr.name() == prev_attr.name() {
+ let msg = if attr.path == prev_attr.path {
format!("Only one `#[{}]` attribute is allowed on any given function",
- attr.name())
+ attr.path)
} else {
format!("`#[{}]` and `#[{}]` attributes cannot both be applied \
- to the same function", attr.name(), prev_attr.name())
+ to the same function", attr.path, prev_attr.path)
};
self.handler.struct_span_err(attr.span(), &msg)
if !is_fn {
let msg = format!("the `#[{}]` attribute may only be used on bare functions",
- attr.name());
+ attr.path);
self.handler.span_err(attr.span(), &msg);
return;
if !self.is_proc_macro_crate {
let msg = format!("the `#[{}]` attribute is only usable with crates of the \
- `proc-macro` crate type", attr.name());
+ `proc-macro` crate type", attr.path);
self.handler.span_err(attr.span(), &msg);
return;
projects / rust.git / commitdiff