use ast;
use ast::{AttrId, Attribute, Attribute_, MetaItem, MetaWord, MetaNameValue, MetaList};
-use ast::{Stmt, StmtDecl, StmtExpr, StmtMac, StmtSemi, DeclItem, DeclLocal};
+use ast::{Stmt, StmtKind, DeclKind};
use ast::{Expr, Item, Local, Decl};
use codemap::{Span, Spanned, spanned, dummy_spanned};
use codemap::BytePos;
use config::CfgDiag;
-use diagnostic::SpanHandler;
+use errors::Handler;
use feature_gate::{GatedCfg, GatedCfgAttr};
use parse::lexer::comments::{doc_comment_style, strip_doc_comment_decoration};
-use parse::token::{InternedString, intern_and_get_ident};
+use parse::token::InternedString;
use parse::token;
use ptr::P;
match self.node {
MetaNameValue(_, ref v) => {
match v.node {
- ast::LitStr(ref s, _) => Some((*s).clone()),
+ ast::LitKind::Str(ref s, _) => Some((*s).clone()),
_ => None,
}
},
pub fn mk_name_value_item_str(name: InternedString, value: InternedString)
-> P<MetaItem> {
- let value_lit = dummy_spanned(ast::LitStr(value, ast::CookedStr));
+ let value_lit = dummy_spanned(ast::LitKind::Str(value, ast::CookedStr));
mk_name_value_item(name, value_lit)
}
hi: BytePos)
-> Attribute {
let style = doc_comment_style(&text);
- let lit = spanned(lo, hi, ast::LitStr(text, ast::CookedStr));
+ let lit = spanned(lo, hi, ast::LitKind::Str(text, ast::CookedStr));
let attr = Attribute_ {
id: id,
style: style,
}
/// Find the value of #[export_name=*] attribute and check its validity.
-pub fn find_export_name_attr(diag: &SpanHandler, attrs: &[Attribute]) -> Option<InternedString> {
+pub fn find_export_name_attr(diag: &Handler, attrs: &[Attribute]) -> Option<InternedString> {
attrs.iter().fold(None, |ia,attr| {
if attr.check_name("export_name") {
if let s@Some(_) = attr.value_str() {
s
} else {
- diag.span_err(attr.span, "export_name attribute has invalid format");
- diag.handler.help("use #[export_name=\"*\"]");
+ diag.struct_span_err(attr.span,
+ "export_name attribute has invalid format")
+ .help("use #[export_name=\"*\"]")
+ .emit();
None
}
} else {
}
/// Determine what `#[inline]` attribute is present in `attrs`, if any.
-pub fn find_inline_attr(diagnostic: Option<&SpanHandler>, attrs: &[Attribute]) -> InlineAttr {
+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" => {
pub fn is_stable(&self) -> bool { if let Stable {..} = *self { true } else { false }}
}
-fn find_stability_generic<'a, I>(diagnostic: &SpanHandler,
+fn find_stability_generic<'a, I>(diagnostic: &Handler,
attrs_iter: I,
item_sp: Span)
-> Option<Stability>
stab
}
-fn find_deprecation_generic<'a, I>(diagnostic: &SpanHandler,
- attrs_iter: I,
- item_sp: Span)
- -> Option<Deprecation>
+fn find_deprecation_generic<'a, I>(diagnostic: &Handler,
+ attrs_iter: I,
+ item_sp: Span)
+ -> Option<Deprecation>
where I: Iterator<Item = &'a Attribute>
{
let mut depr: Option<Deprecation> = None;
}
/// Find the first stability attribute. `None` if none exists.
-pub fn find_stability(diagnostic: &SpanHandler, attrs: &[Attribute],
+pub fn find_stability(diagnostic: &Handler, attrs: &[Attribute],
item_sp: Span) -> Option<Stability> {
find_stability_generic(diagnostic, attrs.iter(), item_sp)
}
/// Find the deprecation attribute. `None` if none exists.
-pub fn find_deprecation(diagnostic: &SpanHandler, attrs: &[Attribute],
- item_sp: Span) -> Option<Deprecation> {
+pub fn find_deprecation(diagnostic: &Handler, attrs: &[Attribute],
+ item_sp: Span) -> Option<Deprecation> {
find_deprecation_generic(diagnostic, attrs.iter(), item_sp)
}
-pub fn require_unique_names(diagnostic: &SpanHandler, metas: &[P<MetaItem>]) {
+pub fn require_unique_names(diagnostic: &Handler, metas: &[P<MetaItem>]) {
let mut set = HashSet::new();
for meta in metas {
let name = meta.name();
/// `int_type_of_word`, below) to specify enum discriminant type; `C`, to use
/// the same discriminant size that the corresponding C enum would or C
/// structure layout, and `packed` to remove padding.
-pub fn find_repr_attrs(diagnostic: &SpanHandler, attr: &Attribute) -> Vec<ReprAttr> {
+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" => {
fn int_type_of_word(s: &str) -> Option<IntType> {
match s {
- "i8" => Some(SignedInt(ast::TyI8)),
- "u8" => Some(UnsignedInt(ast::TyU8)),
- "i16" => Some(SignedInt(ast::TyI16)),
- "u16" => Some(UnsignedInt(ast::TyU16)),
- "i32" => Some(SignedInt(ast::TyI32)),
- "u32" => Some(UnsignedInt(ast::TyU32)),
- "i64" => Some(SignedInt(ast::TyI64)),
- "u64" => Some(UnsignedInt(ast::TyU64)),
- "isize" => Some(SignedInt(ast::TyIs)),
- "usize" => Some(UnsignedInt(ast::TyUs)),
+ "i8" => Some(SignedInt(ast::IntTy::I8)),
+ "u8" => Some(UnsignedInt(ast::UintTy::U8)),
+ "i16" => Some(SignedInt(ast::IntTy::I16)),
+ "u16" => Some(UnsignedInt(ast::UintTy::U16)),
+ "i32" => Some(SignedInt(ast::IntTy::I32)),
+ "u32" => Some(UnsignedInt(ast::UintTy::U32)),
+ "i64" => Some(SignedInt(ast::IntTy::I64)),
+ "u64" => Some(UnsignedInt(ast::UintTy::U64)),
+ "isize" => Some(SignedInt(ast::IntTy::Is)),
+ "usize" => Some(UnsignedInt(ast::UintTy::Us)),
_ => None
}
}
}
fn is_ffi_safe(self) -> bool {
match self {
- SignedInt(ast::TyI8) | UnsignedInt(ast::TyU8) |
- SignedInt(ast::TyI16) | UnsignedInt(ast::TyU16) |
- SignedInt(ast::TyI32) | UnsignedInt(ast::TyU32) |
- SignedInt(ast::TyI64) | UnsignedInt(ast::TyU64) => true,
- SignedInt(ast::TyIs) | UnsignedInt(ast::TyUs) => false
+ SignedInt(ast::IntTy::I8) | UnsignedInt(ast::UintTy::U8) |
+ SignedInt(ast::IntTy::I16) | UnsignedInt(ast::UintTy::U16) |
+ SignedInt(ast::IntTy::I32) | UnsignedInt(ast::UintTy::U32) |
+ SignedInt(ast::IntTy::I64) | UnsignedInt(ast::UintTy::U64) => true,
+ SignedInt(ast::IntTy::Is) | UnsignedInt(ast::UintTy::Us) => false
}
}
}
Spanned {
span: span,
node: match node {
- DeclLocal(local) => DeclLocal(local.with_attrs(attrs)),
- DeclItem(item) => DeclItem(item.with_attrs(attrs)),
+ DeclKind::Local(local) => DeclKind::Local(local.with_attrs(attrs)),
+ DeclKind::Item(item) => DeclKind::Item(item.with_attrs(attrs)),
}
}
})
Spanned {
span: span,
node: match node {
- StmtDecl(decl, id) => StmtDecl(decl.with_attrs(attrs), id),
- StmtExpr(expr, id) => StmtExpr(expr.with_attrs(attrs), id),
- StmtSemi(expr, id) => StmtSemi(expr.with_attrs(attrs), id),
- StmtMac(mac, style, mut ats) => {
+ StmtKind::Decl(decl, id) => StmtKind::Decl(decl.with_attrs(attrs), id),
+ StmtKind::Expr(expr, id) => StmtKind::Expr(expr.with_attrs(attrs), id),
+ StmtKind::Semi(expr, id) => StmtKind::Semi(expr.with_attrs(attrs), id),
+ StmtKind::Mac(mac, style, mut ats) => {
ats.update(|a| a.append(attrs));
- StmtMac(mac, style, ats)
+ StmtKind::Mac(mac, style, ats)
}
},
}
projects / rust.git / blobdiff