// for the test suite (otherwise including libstd statically in all
// executables takes up quite a bit of space).
//
- // For targets like MUSL, however, there is no support for dynamic
- // libraries so we just go back to building a normal library. Note,
- // however, that if the library is built with `force_host` then it's
- // ok to be a dylib as the host should always support dylibs.
- if config.target.contains("musl") && !aux_props.force_host {
+ // For targets like MUSL or Emscripten, however, there is no support for
+ // dynamic libraries so we just go back to building a normal library. Note,
+ // however, that for MUSL if the library is built with `force_host` then
+ // it's ok to be a dylib as the host should always support dylibs.
+ if (config.target.contains("musl") && !aux_props.force_host) ||
+ config.target.contains("emscripten")
+ {
vec!("--crate-type=lib".to_owned())
} else {
vec!("--crate-type=dylib".to_owned())
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> fmt::Pointer for Arc<T> {
+impl<T: ?Sized> fmt::Pointer for Arc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Pointer::fmt(&*self._ptr, f)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> fmt::Pointer for Box<T> {
+impl<T: ?Sized> fmt::Pointer for Box<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
// It's not possible to extract the inner Uniq directly from the Box,
// instead we cast it to a *const which aliases the Unique
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> fmt::Pointer for Rc<T> {
+impl<T: ?Sized> fmt::Pointer for Rc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Pointer::fmt(&*self._ptr, f)
}
#[cfg(all(any(target_arch = "x86",
target_arch = "x86_64",
target_arch = "aarch64",
- target_arch = "powerpc64",
- target_arch = "powerpc64le")))]
+ target_arch = "powerpc64")))]
const MIN_ALIGN: usize = 16;
// MALLOCX_ALIGN(a) macro
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Pointer for *const T {
+impl<T: ?Sized> Pointer for *const T {
fn fmt(&self, f: &mut Formatter) -> Result {
let old_width = f.width;
let old_flags = f.flags;
}
f.flags |= 1 << (FlagV1::Alternate as u32);
- let ret = LowerHex::fmt(&(*self as usize), f);
+ let ret = LowerHex::fmt(&(*self as *const () as usize), f);
f.width = old_width;
f.flags = old_flags;
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Pointer for *mut T {
+impl<T: ?Sized> Pointer for *mut T {
fn fmt(&self, f: &mut Formatter) -> Result {
Pointer::fmt(&(*self as *const T), f)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> Pointer for &'a T {
+impl<'a, T: ?Sized> Pointer for &'a T {
fn fmt(&self, f: &mut Formatter) -> Result {
Pointer::fmt(&(*self as *const T), f)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> Pointer for &'a mut T {
+impl<'a, T: ?Sized> Pointer for &'a mut T {
fn fmt(&self, f: &mut Formatter) -> Result {
Pointer::fmt(&(&**self as *const T), f)
}
assert_eq!(format!("{: >3}", 'a'), " a");
}
+
+#[test]
+fn test_pointer_formats_data_pointer() {
+ let b: &[u8] = b"";
+ let s: &str = "";
+ assert_eq!(format!("{:p}", s), format!("{:p}", s.as_ptr()));
+ assert_eq!(format!("{:p}", b), format!("{:p}", b.as_ptr()));
+}
impl Target {
fn from_item(item: &ast::Item) -> Target {
match item.node {
- ast::ItemFn(..) => Target::Fn,
- ast::ItemStruct(..) => Target::Struct,
- ast::ItemEnum(..) => Target::Enum,
+ ast::ItemKind::Fn(..) => Target::Fn,
+ ast::ItemKind::Struct(..) => Target::Struct,
+ ast::ItemKind::Enum(..) => Target::Enum,
_ => Target::Other,
}
}
use middle::cstore::InlinedItem as II;
use middle::def_id::DefId;
-use syntax::abi;
+use syntax::abi::Abi;
use syntax::ast::{self, Name, NodeId, DUMMY_NODE_ID};
use syntax::codemap::{Span, Spanned};
use syntax::parse::token;
}
}
- pub fn get_foreign_abi(&self, id: NodeId) -> abi::Abi {
+ pub fn get_foreign_abi(&self, id: NodeId) -> Abi {
let parent = self.get_parent(id);
let abi = match self.find_entry(parent) {
Some(EntryItem(_, i)) => {
}
}
/// Wrong but OK, because the only inlined foreign items are intrinsics.
- Some(RootInlinedParent(_)) => Some(abi::RustIntrinsic),
+ Some(RootInlinedParent(_)) => Some(Abi::RustIntrinsic),
_ => None
};
match abi {
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),
});
}
fn const_val_to_expr(value: &ConstVal) -> P<hir::Expr> {
let node = match value {
- &ConstVal::Bool(b) => ast::LitBool(b),
+ &ConstVal::Bool(b) => ast::LitKind::Bool(b),
_ => unreachable!()
};
P(hir::Expr {
impl IntTy {
pub fn from(tcx: &ty::ctxt, t: ast::IntTy) -> IntTy {
- let t = if let ast::TyIs = t {
+ let t = if let ast::IntTy::Is = t {
tcx.sess.target.int_type
} else {
t
};
match t {
- ast::TyIs => unreachable!(),
- ast::TyI8 => IntTy::I8,
- ast::TyI16 => IntTy::I16,
- ast::TyI32 => IntTy::I32,
- ast::TyI64 => IntTy::I64,
+ ast::IntTy::Is => unreachable!(),
+ ast::IntTy::I8 => IntTy::I8,
+ ast::IntTy::I16 => IntTy::I16,
+ ast::IntTy::I32 => IntTy::I32,
+ ast::IntTy::I64 => IntTy::I64,
}
}
}
impl UintTy {
pub fn from(tcx: &ty::ctxt, t: ast::UintTy) -> UintTy {
- let t = if let ast::TyUs = t {
+ let t = if let ast::UintTy::Us = t {
tcx.sess.target.uint_type
} else {
t
};
match t {
- ast::TyUs => unreachable!(),
- ast::TyU8 => UintTy::U8,
- ast::TyU16 => UintTy::U16,
- ast::TyU32 => UintTy::U32,
- ast::TyU64 => UintTy::U64,
+ ast::UintTy::Us => unreachable!(),
+ ast::UintTy::U8 => UintTy::U8,
+ ast::UintTy::U16 => UintTy::U16,
+ ast::UintTy::U32 => UintTy::U32,
+ ast::UintTy::U64 => UintTy::U64,
}
}
}
// Issue #23890: If isize/usize, then dispatch to appropriate target representation type
match (&ty.sty, tcx.sess.target.int_type, tcx.sess.target.uint_type) {
- (&ty::TyInt(ast::TyIs), ast::TyI32, _) => return convert_val!(i32, Int, i64),
- (&ty::TyInt(ast::TyIs), ast::TyI64, _) => return convert_val!(i64, Int, i64),
- (&ty::TyInt(ast::TyIs), _, _) => panic!("unexpected target.int_type"),
+ (&ty::TyInt(ast::IntTy::Is), ast::IntTy::I32, _) => return convert_val!(i32, Int, i64),
+ (&ty::TyInt(ast::IntTy::Is), ast::IntTy::I64, _) => return convert_val!(i64, Int, i64),
+ (&ty::TyInt(ast::IntTy::Is), _, _) => panic!("unexpected target.int_type"),
- (&ty::TyUint(ast::TyUs), _, ast::TyU32) => return convert_val!(u32, Uint, u64),
- (&ty::TyUint(ast::TyUs), _, ast::TyU64) => return convert_val!(u64, Uint, u64),
- (&ty::TyUint(ast::TyUs), _, _) => panic!("unexpected target.uint_type"),
+ (&ty::TyUint(ast::UintTy::Us), _, ast::UintTy::U32) => return convert_val!(u32, Uint, u64),
+ (&ty::TyUint(ast::UintTy::Us), _, ast::UintTy::U64) => return convert_val!(u64, Uint, u64),
+ (&ty::TyUint(ast::UintTy::Us), _, _) => panic!("unexpected target.uint_type"),
_ => {}
}
match ty.sty {
- ty::TyInt(ast::TyIs) => unreachable!(),
- ty::TyUint(ast::TyUs) => unreachable!(),
+ ty::TyInt(ast::IntTy::Is) => unreachable!(),
+ ty::TyUint(ast::UintTy::Us) => unreachable!(),
- ty::TyInt(ast::TyI8) => convert_val!(i8, Int, i64),
- ty::TyInt(ast::TyI16) => convert_val!(i16, Int, i64),
- ty::TyInt(ast::TyI32) => convert_val!(i32, Int, i64),
- ty::TyInt(ast::TyI64) => convert_val!(i64, Int, i64),
+ ty::TyInt(ast::IntTy::I8) => convert_val!(i8, Int, i64),
+ ty::TyInt(ast::IntTy::I16) => convert_val!(i16, Int, i64),
+ ty::TyInt(ast::IntTy::I32) => convert_val!(i32, Int, i64),
+ ty::TyInt(ast::IntTy::I64) => convert_val!(i64, Int, i64),
- ty::TyUint(ast::TyU8) => convert_val!(u8, Uint, u64),
- ty::TyUint(ast::TyU16) => convert_val!(u16, Uint, u64),
- ty::TyUint(ast::TyU32) => convert_val!(u32, Uint, u64),
- ty::TyUint(ast::TyU64) => convert_val!(u64, Uint, u64),
+ ty::TyUint(ast::UintTy::U8) => convert_val!(u8, Uint, u64),
+ ty::TyUint(ast::UintTy::U16) => convert_val!(u16, Uint, u64),
+ ty::TyUint(ast::UintTy::U32) => convert_val!(u32, Uint, u64),
+ ty::TyUint(ast::UintTy::U64) => convert_val!(u64, Uint, u64),
- ty::TyFloat(ast::TyF32) => convert_val!(f32, Float, f64),
- ty::TyFloat(ast::TyF64) => convert_val!(f64, Float, f64),
+ ty::TyFloat(ast::FloatTy::F32) => convert_val!(f32, Float, f64),
+ ty::TyFloat(ast::FloatTy::F64) => convert_val!(f64, Float, f64),
_ => Err(ErrKind::CannotCast),
}
}
fn lit_to_const(sess: &Session, span: Span, lit: &ast::Lit, ty_hint: Option<Ty>) -> ConstVal {
match lit.node {
- ast::LitStr(ref s, _) => Str((*s).clone()),
- ast::LitByteStr(ref data) => {
+ ast::LitKind::Str(ref s, _) => Str((*s).clone()),
+ ast::LitKind::ByteStr(ref data) => {
ByteStr(data.clone())
}
- ast::LitByte(n) => Uint(n as u64),
- ast::LitChar(n) => Uint(n as u64),
- ast::LitInt(n, ast::SignedIntLit(_, ast::Plus)) => Int(n as i64),
- ast::LitInt(n, ast::UnsuffixedIntLit(ast::Plus)) => {
+ ast::LitKind::Byte(n) => Uint(n as u64),
+ ast::LitKind::Char(n) => Uint(n as u64),
+ ast::LitKind::Int(n, ast::LitIntType::Signed(_)) => Int(n as i64),
+ ast::LitKind::Int(n, ast::LitIntType::Unsuffixed) => {
match ty_hint.map(|ty| &ty.sty) {
Some(&ty::TyUint(_)) => Uint(n),
_ => Int(n as i64)
}
}
- ast::LitInt(n, ast::SignedIntLit(_, ast::Minus)) |
- ast::LitInt(n, ast::UnsuffixedIntLit(ast::Minus)) => Int(-(n as i64)),
- ast::LitInt(n, ast::UnsignedIntLit(_)) => Uint(n),
- ast::LitFloat(ref n, _) |
- ast::LitFloatUnsuffixed(ref n) => {
+ ast::LitKind::Int(n, ast::LitIntType::Unsigned(_)) => Uint(n),
+ ast::LitKind::Float(ref n, _) |
+ ast::LitKind::FloatUnsuffixed(ref n) => {
if let Ok(x) = n.parse::<f64>() {
Float(x)
} else {
sess.span_bug(span, "could not evaluate float literal (see issue #31407)");
}
}
- ast::LitBool(b) => Bool(b)
+ ast::LitKind::Bool(b) => Bool(b)
}
}
use std::fmt;
-use syntax::abi::RustIntrinsic;
+use syntax::abi::Abi::RustIntrinsic;
use syntax::ast;
use syntax::codemap::Span;
use rustc_front::intravisit::{self, Visitor, FnKind};
use util::nodemap::NodeSet;
use std::collections::HashSet;
-use syntax::abi;
+use syntax::abi::Abi;
use syntax::ast;
use syntax::attr;
use rustc_front::hir;
// participate in linkage after this product is produced)
if let ast_map::NodeItem(item) = *node {
if let hir::ItemFn(_, _, _, abi, _, _) = item.node {
- if abi != abi::Rust {
+ if abi != Abi::Rust {
self.reachable_symbols.insert(search_item);
}
}
use std::cell::RefCell;
use std::fmt;
use std::rc::Rc;
-use syntax::abi;
+use syntax::abi::Abi;
use rustc_front::hir;
use util::common::ErrorReported;
use util::nodemap::FnvHashMap;
// provide an impl, but only for suitable `fn` pointers
ty::TyBareFn(_, &ty::BareFnTy {
unsafety: hir::Unsafety::Normal,
- abi: abi::Rust,
+ abi: Abi::Rust,
sig: ty::Binder(ty::FnSig {
inputs: _,
output: ty::FnConverging(_),
let result = match ty.sty {
// usize and isize are ffi-unsafe
- ty::TyUint(ast::TyUs) | ty::TyInt(ast::TyIs) => {
+ ty::TyUint(ast::UintTy::Us) | ty::TyInt(ast::IntTy::Is) => {
TC::None
}
use std::cell::{Cell, RefCell, Ref};
use std::hash::{Hash, Hasher};
use std::rc::Rc;
-use syntax::abi;
+use syntax::abi::Abi;
use syntax::ast::{self, Name, NodeId};
use syntax::attr;
use syntax::parse::token::special_idents;
bool: mk(TyBool),
char: mk(TyChar),
err: mk(TyError),
- isize: mk(TyInt(ast::TyIs)),
- i8: mk(TyInt(ast::TyI8)),
- i16: mk(TyInt(ast::TyI16)),
- i32: mk(TyInt(ast::TyI32)),
- i64: mk(TyInt(ast::TyI64)),
- usize: mk(TyUint(ast::TyUs)),
- u8: mk(TyUint(ast::TyU8)),
- u16: mk(TyUint(ast::TyU16)),
- u32: mk(TyUint(ast::TyU32)),
- u64: mk(TyUint(ast::TyU64)),
- f32: mk(TyFloat(ast::TyF32)),
- f64: mk(TyFloat(ast::TyF64)),
+ isize: mk(TyInt(ast::IntTy::Is)),
+ i8: mk(TyInt(ast::IntTy::I8)),
+ i16: mk(TyInt(ast::IntTy::I16)),
+ i32: mk(TyInt(ast::IntTy::I32)),
+ i64: mk(TyInt(ast::IntTy::I64)),
+ usize: mk(TyUint(ast::UintTy::Us)),
+ u8: mk(TyUint(ast::UintTy::U8)),
+ u16: mk(TyUint(ast::UintTy::U16)),
+ u32: mk(TyUint(ast::UintTy::U32)),
+ u64: mk(TyUint(ast::UintTy::U64)),
+ f32: mk(TyFloat(ast::FloatTy::F32)),
+ f64: mk(TyFloat(ast::FloatTy::F64)),
}
}
}
pub fn mk_mach_int(&self, tm: ast::IntTy) -> Ty<'tcx> {
match tm {
- ast::TyIs => self.types.isize,
- ast::TyI8 => self.types.i8,
- ast::TyI16 => self.types.i16,
- ast::TyI32 => self.types.i32,
- ast::TyI64 => self.types.i64,
+ ast::IntTy::Is => self.types.isize,
+ ast::IntTy::I8 => self.types.i8,
+ ast::IntTy::I16 => self.types.i16,
+ ast::IntTy::I32 => self.types.i32,
+ ast::IntTy::I64 => self.types.i64,
}
}
pub fn mk_mach_uint(&self, tm: ast::UintTy) -> Ty<'tcx> {
match tm {
- ast::TyUs => self.types.usize,
- ast::TyU8 => self.types.u8,
- ast::TyU16 => self.types.u16,
- ast::TyU32 => self.types.u32,
- ast::TyU64 => self.types.u64,
+ ast::UintTy::Us => self.types.usize,
+ ast::UintTy::U8 => self.types.u8,
+ ast::UintTy::U16 => self.types.u16,
+ ast::UintTy::U32 => self.types.u32,
+ ast::UintTy::U64 => self.types.u64,
}
}
pub fn mk_mach_float(&self, tm: ast::FloatTy) -> Ty<'tcx> {
match tm {
- ast::TyF32 => self.types.f32,
- ast::TyF64 => self.types.f64,
+ ast::FloatTy::F32 => self.types.f32,
+ ast::FloatTy::F64 => self.types.f64,
}
}
let input_args = input_tys.iter().cloned().collect();
self.mk_fn(Some(def_id), self.mk_bare_fn(BareFnTy {
unsafety: hir::Unsafety::Normal,
- abi: abi::Rust,
+ abi: Abi::Rust,
sig: ty::Binder(ty::FnSig {
inputs: input_args,
output: ty::FnConverging(output),
} else {
let mutbl = a.mutbl;
let variance = match mutbl {
- ast::MutImmutable => ty::Covariant,
- ast::MutMutable => ty::Invariant,
+ ast::Mutability::MutImmutable => ty::Covariant,
+ ast::Mutability::MutMutable => ty::Invariant,
};
let ty = try!(relation.relate_with_variance(variance, &a.ty, &b.ty));
Ok(ty::TypeAndMut {ty: ty, mutbl: mutbl})
pub fn sequence_element_type(&self, cx: &ty::ctxt<'tcx>) -> Ty<'tcx> {
match self.sty {
TyArray(ty, _) | TySlice(ty) => ty,
- TyStr => cx.mk_mach_uint(ast::TyU8),
+ TyStr => cx.mk_mach_uint(ast::UintTy::U8),
_ => cx.sess.bug(&format!("sequence_element_type called on non-sequence value: {}",
self)),
}
pub fn is_uint(&self) -> bool {
match self.sty {
- TyInfer(IntVar(_)) | TyUint(ast::TyUs) => true,
+ TyInfer(IntVar(_)) | TyUint(ast::UintTy::Us) => true,
_ => false
}
}
pub fn is_machine(&self) -> bool {
match self.sty {
- TyInt(ast::TyIs) | TyUint(ast::TyUs) => false,
+ TyInt(ast::IntTy::Is) | TyUint(ast::UintTy::Us) => false,
TyInt(..) | TyUint(..) | TyFloat(..) => true,
_ => false
}
impl IntTypeExt for attr::IntType {
fn to_ty<'tcx>(&self, cx: &ty::ctxt<'tcx>) -> Ty<'tcx> {
match *self {
- SignedInt(ast::TyI8) => cx.types.i8,
- SignedInt(ast::TyI16) => cx.types.i16,
- SignedInt(ast::TyI32) => cx.types.i32,
- SignedInt(ast::TyI64) => cx.types.i64,
- SignedInt(ast::TyIs) => cx.types.isize,
- UnsignedInt(ast::TyU8) => cx.types.u8,
- UnsignedInt(ast::TyU16) => cx.types.u16,
- UnsignedInt(ast::TyU32) => cx.types.u32,
- UnsignedInt(ast::TyU64) => cx.types.u64,
- UnsignedInt(ast::TyUs) => cx.types.usize,
+ SignedInt(ast::IntTy::I8) => cx.types.i8,
+ SignedInt(ast::IntTy::I16) => cx.types.i16,
+ SignedInt(ast::IntTy::I32) => cx.types.i32,
+ SignedInt(ast::IntTy::I64) => cx.types.i64,
+ SignedInt(ast::IntTy::Is) => cx.types.isize,
+ UnsignedInt(ast::UintTy::U8) => cx.types.u8,
+ UnsignedInt(ast::UintTy::U16) => cx.types.u16,
+ UnsignedInt(ast::UintTy::U32) => cx.types.u32,
+ UnsignedInt(ast::UintTy::U64) => cx.types.u64,
+ UnsignedInt(ast::UintTy::Us) => cx.types.usize,
}
}
fn i64_to_disr(&self, val: i64) -> Option<Disr> {
match *self {
- SignedInt(ast::TyI8) => val.to_i8() .map(|v| v as Disr),
- SignedInt(ast::TyI16) => val.to_i16() .map(|v| v as Disr),
- SignedInt(ast::TyI32) => val.to_i32() .map(|v| v as Disr),
- SignedInt(ast::TyI64) => val.to_i64() .map(|v| v as Disr),
- UnsignedInt(ast::TyU8) => val.to_u8() .map(|v| v as Disr),
- UnsignedInt(ast::TyU16) => val.to_u16() .map(|v| v as Disr),
- UnsignedInt(ast::TyU32) => val.to_u32() .map(|v| v as Disr),
- UnsignedInt(ast::TyU64) => val.to_u64() .map(|v| v as Disr),
-
- UnsignedInt(ast::TyUs) |
- SignedInt(ast::TyIs) => unreachable!(),
+ SignedInt(ast::IntTy::I8) => val.to_i8() .map(|v| v as Disr),
+ SignedInt(ast::IntTy::I16) => val.to_i16() .map(|v| v as Disr),
+ SignedInt(ast::IntTy::I32) => val.to_i32() .map(|v| v as Disr),
+ SignedInt(ast::IntTy::I64) => val.to_i64() .map(|v| v as Disr),
+ UnsignedInt(ast::UintTy::U8) => val.to_u8() .map(|v| v as Disr),
+ UnsignedInt(ast::UintTy::U16) => val.to_u16() .map(|v| v as Disr),
+ UnsignedInt(ast::UintTy::U32) => val.to_u32() .map(|v| v as Disr),
+ UnsignedInt(ast::UintTy::U64) => val.to_u64() .map(|v| v as Disr),
+
+ UnsignedInt(ast::UintTy::Us) |
+ SignedInt(ast::IntTy::Is) => unreachable!(),
}
}
fn u64_to_disr(&self, val: u64) -> Option<Disr> {
match *self {
- SignedInt(ast::TyI8) => val.to_i8() .map(|v| v as Disr),
- SignedInt(ast::TyI16) => val.to_i16() .map(|v| v as Disr),
- SignedInt(ast::TyI32) => val.to_i32() .map(|v| v as Disr),
- SignedInt(ast::TyI64) => val.to_i64() .map(|v| v as Disr),
- UnsignedInt(ast::TyU8) => val.to_u8() .map(|v| v as Disr),
- UnsignedInt(ast::TyU16) => val.to_u16() .map(|v| v as Disr),
- UnsignedInt(ast::TyU32) => val.to_u32() .map(|v| v as Disr),
- UnsignedInt(ast::TyU64) => val.to_u64() .map(|v| v as Disr),
-
- UnsignedInt(ast::TyUs) |
- SignedInt(ast::TyIs) => unreachable!(),
+ SignedInt(ast::IntTy::I8) => val.to_i8() .map(|v| v as Disr),
+ SignedInt(ast::IntTy::I16) => val.to_i16() .map(|v| v as Disr),
+ SignedInt(ast::IntTy::I32) => val.to_i32() .map(|v| v as Disr),
+ SignedInt(ast::IntTy::I64) => val.to_i64() .map(|v| v as Disr),
+ UnsignedInt(ast::UintTy::U8) => val.to_u8() .map(|v| v as Disr),
+ UnsignedInt(ast::UintTy::U16) => val.to_u16() .map(|v| v as Disr),
+ UnsignedInt(ast::UintTy::U32) => val.to_u32() .map(|v| v as Disr),
+ UnsignedInt(ast::UintTy::U64) => val.to_u64() .map(|v| v as Disr),
+
+ UnsignedInt(ast::UintTy::Us) |
+ SignedInt(ast::IntTy::Is) => unreachable!(),
}
}
// SignedInt repr means we *want* to reinterpret the bits
// treating the highest bit of Disr as a sign-bit, so
// cast to i64 before range-checking.
- SignedInt(ast::TyI8) => add1!((val as i64).to_i8()),
- SignedInt(ast::TyI16) => add1!((val as i64).to_i16()),
- SignedInt(ast::TyI32) => add1!((val as i64).to_i32()),
- SignedInt(ast::TyI64) => add1!(Some(val as i64)),
-
- UnsignedInt(ast::TyU8) => add1!(val.to_u8()),
- UnsignedInt(ast::TyU16) => add1!(val.to_u16()),
- UnsignedInt(ast::TyU32) => add1!(val.to_u32()),
- UnsignedInt(ast::TyU64) => add1!(Some(val)),
-
- UnsignedInt(ast::TyUs) |
- SignedInt(ast::TyIs) => unreachable!(),
+ SignedInt(ast::IntTy::I8) => add1!((val as i64).to_i8()),
+ SignedInt(ast::IntTy::I16) => add1!((val as i64).to_i16()),
+ SignedInt(ast::IntTy::I32) => add1!((val as i64).to_i32()),
+ SignedInt(ast::IntTy::I64) => add1!(Some(val as i64)),
+
+ UnsignedInt(ast::UintTy::U8) => add1!(val.to_u8()),
+ UnsignedInt(ast::UintTy::U16) => add1!(val.to_u16()),
+ UnsignedInt(ast::UintTy::U32) => add1!(val.to_u32()),
+ UnsignedInt(ast::UintTy::U64) => add1!(Some(val)),
+
+ UnsignedInt(ast::UintTy::Us) |
+ SignedInt(ast::IntTy::Is) => unreachable!(),
}
}
// full range from `i64::MIN` through `u64::MAX`.
fn disr_string(&self, val: Disr) -> String {
match *self {
- SignedInt(ast::TyI8) => format!("{}", val as i8 ),
- SignedInt(ast::TyI16) => format!("{}", val as i16),
- SignedInt(ast::TyI32) => format!("{}", val as i32),
- SignedInt(ast::TyI64) => format!("{}", val as i64),
- UnsignedInt(ast::TyU8) => format!("{}", val as u8 ),
- UnsignedInt(ast::TyU16) => format!("{}", val as u16),
- UnsignedInt(ast::TyU32) => format!("{}", val as u32),
- UnsignedInt(ast::TyU64) => format!("{}", val as u64),
-
- UnsignedInt(ast::TyUs) |
- SignedInt(ast::TyIs) => unreachable!(),
+ SignedInt(ast::IntTy::I8) => format!("{}", val as i8 ),
+ SignedInt(ast::IntTy::I16) => format!("{}", val as i16),
+ SignedInt(ast::IntTy::I32) => format!("{}", val as i32),
+ SignedInt(ast::IntTy::I64) => format!("{}", val as i64),
+ UnsignedInt(ast::UintTy::U8) => format!("{}", val as u8 ),
+ UnsignedInt(ast::UintTy::U16) => format!("{}", val as u16),
+ UnsignedInt(ast::UintTy::U32) => format!("{}", val as u32),
+ UnsignedInt(ast::UintTy::U64) => format!("{}", val as u64),
+
+ UnsignedInt(ast::UintTy::Us) |
+ SignedInt(ast::IntTy::Is) => unreachable!(),
}
}
}
let val = val.unwrap_or(ty::INITIAL_DISCRIMINANT_VALUE);
match *self {
- SignedInt(ast::TyI8) => add1!(val as i8 ),
- SignedInt(ast::TyI16) => add1!(val as i16),
- SignedInt(ast::TyI32) => add1!(val as i32),
- SignedInt(ast::TyI64) => add1!(val as i64),
- UnsignedInt(ast::TyU8) => add1!(val as u8 ),
- UnsignedInt(ast::TyU16) => add1!(val as u16),
- UnsignedInt(ast::TyU32) => add1!(val as u32),
- UnsignedInt(ast::TyU64) => add1!(val as u64),
-
- UnsignedInt(ast::TyUs) |
- SignedInt(ast::TyIs) => unreachable!(),
+ SignedInt(ast::IntTy::I8) => add1!(val as i8 ),
+ SignedInt(ast::IntTy::I16) => add1!(val as i16),
+ SignedInt(ast::IntTy::I32) => add1!(val as i32),
+ SignedInt(ast::IntTy::I64) => add1!(val as i64),
+ UnsignedInt(ast::UintTy::U8) => add1!(val as u8 ),
+ UnsignedInt(ast::UintTy::U16) => add1!(val as u16),
+ UnsignedInt(ast::UintTy::U32) => add1!(val as u32),
+ UnsignedInt(ast::UintTy::U64) => add1!(val as u64),
+
+ UnsignedInt(ast::UintTy::Us) |
+ SignedInt(ast::IntTy::Is) => unreachable!(),
}
}
}
//
// NB. Historically `fn enum_variants` generate i64 here, while
// rustc_typeck::check would generate isize.
- _ => SignedInt(ast::TyIs),
+ _ => SignedInt(ast::IntTy::Is),
};
let repr_type_ty = repr_type.to_ty(self);
let repr_type = match repr_type {
- SignedInt(ast::TyIs) =>
+ SignedInt(ast::IntTy::Is) =>
SignedInt(self.sess.target.int_type),
- UnsignedInt(ast::TyUs) =>
+ UnsignedInt(ast::UintTy::Us) =>
UnsignedInt(self.sess.target.uint_type),
other => other
};
};
let (int_type, uint_type) = match &target.target_pointer_width[..] {
- "32" => (ast::TyI32, ast::TyU32),
- "64" => (ast::TyI64, ast::TyU64),
+ "32" => (ast::IntTy::I32, ast::UintTy::U32),
+ "64" => (ast::IntTy::I64, ast::UintTy::U64),
w => panic!(sp.fatal(&format!("target specification was invalid: \
unrecognized target-pointer-width {}", w))),
};
use middle::ty::{self, Ty, TypeFoldable};
use std::fmt;
-use syntax::{abi};
+use syntax::abi::Abi;
use syntax::parse::token;
use syntax::ast::CRATE_NODE_ID;
use rustc_front::hir;
try!(write!(f, "unsafe "));
}
- if bare_fn.abi != abi::Rust {
+ if bare_fn.abi != Abi::Rust {
try!(write!(f, "extern {} ", bare_fn.abi));
}
SawExprTup,
SawExprBinary(hir::BinOp_),
SawExprUnary(hir::UnOp),
- SawExprLit(ast::Lit_),
+ SawExprLit(ast::LitKind),
SawExprCast,
SawExprType,
SawExprIf,
use serialize::json::Json;
use std::default::Default;
use std::io::prelude::*;
-use syntax::abi;
+use syntax::abi::Abi;
mod android_base;
mod apple_base;
impl Target {
/// Given a function ABI, turn "System" into the correct ABI for this target.
- pub fn adjust_abi(&self, abi: abi::Abi) -> abi::Abi {
+ pub fn adjust_abi(&self, abi: Abi) -> Abi {
match abi {
- abi::System => {
+ Abi::System => {
if self.options.is_like_windows && self.arch == "x86" {
- abi::Stdcall
+ Abi::Stdcall
} else {
- abi::C
+ Abi::C
}
},
abi => abi
let mut saw_invalid_predicate = false;
for item in sopts.cfg.iter() {
match item.node {
- ast::MetaList(ref pred, _) => {
+ ast::MetaItemKind::List(ref pred, _) => {
saw_invalid_predicate = true;
emitter.emit(None,
&format!("invalid predicate in --cfg command line argument: `{}`",
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::LitStr(ref s, _) => s,
+ 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 rustc_resolve as resolve;
use rustc_metadata::cstore::CStore;
-use syntax::ast;
+use syntax::ast::{self, BlockCheckMode};
use syntax::codemap;
use syntax::fold::{self, Folder};
use syntax::print::{pp, pprust};
}
impl fold::Folder for ReplaceBodyWithLoop {
- fn fold_item_underscore(&mut self, i: ast::Item_) -> ast::Item_ {
+ fn fold_item_kind(&mut self, i: ast::ItemKind) -> ast::ItemKind {
match i {
- ast::ItemStatic(..) | ast::ItemConst(..) => {
+ ast::ItemKind::Static(..) | ast::ItemKind::Const(..) => {
self.within_static_or_const = true;
- let ret = fold::noop_fold_item_underscore(i, self);
+ let ret = fold::noop_fold_item_kind(i, self);
self.within_static_or_const = false;
return ret;
}
_ => {
- fold::noop_fold_item_underscore(i, self)
+ fold::noop_fold_item_kind(i, self)
}
}
}
fn fold_trait_item(&mut self, i: P<ast::TraitItem>) -> SmallVector<P<ast::TraitItem>> {
match i.node {
- ast::ConstTraitItem(..) => {
+ ast::TraitItemKind::Const(..) => {
self.within_static_or_const = true;
let ret = fold::noop_fold_trait_item(i, self);
self.within_static_or_const = false;
if !self.within_static_or_const {
- let empty_block = expr_to_block(ast::DefaultBlock, None);
+ let empty_block = expr_to_block(BlockCheckMode::Default, None);
let loop_expr = P(ast::Expr {
- node: ast::ExprLoop(empty_block, None),
+ node: ast::ExprKind::Loop(empty_block, None),
id: ast::DUMMY_NODE_ID,
span: codemap::DUMMY_SP,
attrs: None,
use rustc::front::map as hir_map;
use rustc::session::{self, config};
use std::rc::Rc;
-use syntax::{abi, ast};
+use syntax::ast;
+use syntax::abi::Abi;
use syntax::codemap::{MultiSpan, CodeMap, DUMMY_SP};
use syntax::errors;
use syntax::errors::emitter::Emitter;
self.infcx.tcx.mk_fn(None,
self.infcx.tcx.mk_bare_fn(ty::BareFnTy {
unsafety: hir::Unsafety::Normal,
- abi: abi::Rust,
+ abi: Abi::Rust,
sig: ty::Binder(ty::FnSig {
inputs: input_args,
output: ty::FnConverging(output_ty),
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),
}
ViewPathList(ref path, ref path_list_idents) => {
hir::ViewPathList(lower_path(lctx, path),
path_list_idents.iter()
- .map(|path_list_ident| {
- Spanned {
- node: match path_list_ident.node {
- PathListIdent { id, name, rename } =>
- hir::PathListIdent {
- id: id,
- name: name.name,
- rename: rename.map(|x| x.name),
- },
- PathListMod { id, rename } =>
- hir::PathListMod {
- id: id,
- rename: rename.map(|x| x.name),
- },
- },
- span: path_list_ident.span,
- }
- })
+ .map(lower_path_list_item)
.collect())
}
},
})
}
+fn lower_path_list_item(path_list_ident: &PathListItem) -> hir::PathListItem {
+ Spanned {
+ node: match path_list_ident.node {
+ PathListItemKind::Ident { id, name, rename } => hir::PathListIdent {
+ id: id,
+ name: name.name,
+ rename: rename.map(|x| x.name),
+ },
+ PathListItemKind::Mod { id, rename } => hir::PathListMod {
+ id: id,
+ rename: rename.map(|x| x.name),
+ },
+ },
+ span: path_list_ident.span,
+ }
+}
+
pub fn lower_arm(lctx: &LoweringContext, arm: &Arm) -> hir::Arm {
hir::Arm {
attrs: lower_attrs(lctx, &arm.attrs),
pub fn lower_decl(lctx: &LoweringContext, d: &Decl) -> P<hir::Decl> {
match d.node {
- DeclLocal(ref l) => P(Spanned {
+ DeclKind::Local(ref l) => P(Spanned {
node: hir::DeclLocal(lower_local(lctx, l)),
span: d.span,
}),
- DeclItem(ref it) => P(Spanned {
+ DeclKind::Item(ref it) => P(Spanned {
node: hir::DeclItem(lower_item_id(lctx, it)),
span: d.span,
}),
}
pub fn lower_ty(lctx: &LoweringContext, t: &Ty) -> P<hir::Ty> {
+ use syntax::ast::TyKind::*;
P(hir::Ty {
id: t.id,
node: match t.node {
- TyInfer => hir::TyInfer,
- TyVec(ref ty) => hir::TyVec(lower_ty(lctx, ty)),
- TyPtr(ref mt) => hir::TyPtr(lower_mt(lctx, mt)),
- TyRptr(ref region, ref mt) => {
+ Infer => hir::TyInfer,
+ Vec(ref ty) => hir::TyVec(lower_ty(lctx, ty)),
+ Ptr(ref mt) => hir::TyPtr(lower_mt(lctx, mt)),
+ Rptr(ref region, ref mt) => {
hir::TyRptr(lower_opt_lifetime(lctx, region), lower_mt(lctx, mt))
}
- TyBareFn(ref f) => {
+ BareFn(ref f) => {
hir::TyBareFn(P(hir::BareFnTy {
lifetimes: lower_lifetime_defs(lctx, &f.lifetimes),
unsafety: lower_unsafety(lctx, f.unsafety),
decl: lower_fn_decl(lctx, &f.decl),
}))
}
- TyTup(ref tys) => hir::TyTup(tys.iter().map(|ty| lower_ty(lctx, ty)).collect()),
- TyParen(ref ty) => {
+ Tup(ref tys) => hir::TyTup(tys.iter().map(|ty| lower_ty(lctx, ty)).collect()),
+ Paren(ref ty) => {
return lower_ty(lctx, ty);
}
- TyPath(ref qself, ref path) => {
+ Path(ref qself, ref path) => {
let qself = qself.as_ref().map(|&QSelf { ref ty, position }| {
hir::QSelf {
ty: lower_ty(lctx, ty),
});
hir::TyPath(qself, lower_path(lctx, path))
}
- TyObjectSum(ref ty, ref bounds) => {
+ ObjectSum(ref ty, ref bounds) => {
hir::TyObjectSum(lower_ty(lctx, ty), lower_bounds(lctx, bounds))
}
- TyFixedLengthVec(ref ty, ref e) => {
+ FixedLengthVec(ref ty, ref e) => {
hir::TyFixedLengthVec(lower_ty(lctx, ty), lower_expr(lctx, e))
}
- TyTypeof(ref expr) => {
+ Typeof(ref expr) => {
hir::TyTypeof(lower_expr(lctx, expr))
}
- TyPolyTraitRef(ref bounds) => {
+ PolyTraitRef(ref bounds) => {
hir::TyPolyTraitRef(bounds.iter().map(|b| lower_ty_param_bound(lctx, b)).collect())
}
- TyMac(_) => panic!("TyMac should have been expanded by now."),
+ Mac(_) => panic!("TyMac should have been expanded by now."),
},
span: t.span,
})
}
pub fn lower_explicit_self_underscore(lctx: &LoweringContext,
- es: &ExplicitSelf_)
+ es: &SelfKind)
-> hir::ExplicitSelf_ {
match *es {
- SelfStatic => hir::SelfStatic,
- SelfValue(v) => hir::SelfValue(v.name),
- SelfRegion(ref lifetime, m, ident) => {
+ SelfKind::Static => hir::SelfStatic,
+ SelfKind::Value(v) => hir::SelfValue(v.name),
+ SelfKind::Region(ref lifetime, m, ident) => {
hir::SelfRegion(lower_opt_lifetime(lctx, lifetime),
lower_mutability(lctx, m),
ident.name)
}
- SelfExplicit(ref typ, ident) => {
+ SelfKind::Explicit(ref typ, ident) => {
hir::SelfExplicit(lower_ty(lctx, typ), ident.name)
}
}
pub fn lower_mutability(_lctx: &LoweringContext, m: Mutability) -> hir::Mutability {
match m {
- MutMutable => hir::MutMutable,
- MutImmutable => hir::MutImmutable,
+ Mutability::Mutable => hir::MutMutable,
+ Mutability::Immutable => hir::MutImmutable,
}
}
P(hir::FnDecl {
inputs: decl.inputs.iter().map(|x| lower_arg(lctx, x)).collect(),
output: match decl.output {
- Return(ref ty) => hir::Return(lower_ty(lctx, ty)),
- DefaultReturn(span) => hir::DefaultReturn(span),
- NoReturn(span) => hir::NoReturn(span),
+ FunctionRetTy::Ty(ref ty) => hir::Return(lower_ty(lctx, ty)),
+ FunctionRetTy::Default(span) => hir::DefaultReturn(span),
+ FunctionRetTy::None(span) => hir::NoReturn(span),
},
variadic: decl.variadic,
})
})
}
-pub fn lower_item_underscore(lctx: &LoweringContext, i: &Item_) -> hir::Item_ {
+pub fn lower_item_kind(lctx: &LoweringContext, i: &ItemKind) -> hir::Item_ {
match *i {
- ItemExternCrate(string) => hir::ItemExternCrate(string),
- ItemUse(ref view_path) => {
+ ItemKind::ExternCrate(string) => hir::ItemExternCrate(string),
+ ItemKind::Use(ref view_path) => {
hir::ItemUse(lower_view_path(lctx, view_path))
}
- ItemStatic(ref t, m, ref e) => {
+ ItemKind::Static(ref t, m, ref e) => {
hir::ItemStatic(lower_ty(lctx, t),
lower_mutability(lctx, m),
lower_expr(lctx, e))
}
- ItemConst(ref t, ref e) => {
+ ItemKind::Const(ref t, ref e) => {
hir::ItemConst(lower_ty(lctx, t), lower_expr(lctx, e))
}
- ItemFn(ref decl, unsafety, constness, abi, ref generics, ref body) => {
+ ItemKind::Fn(ref decl, unsafety, constness, abi, ref generics, ref body) => {
hir::ItemFn(lower_fn_decl(lctx, decl),
lower_unsafety(lctx, unsafety),
lower_constness(lctx, constness),
lower_generics(lctx, generics),
lower_block(lctx, body))
}
- ItemMod(ref m) => hir::ItemMod(lower_mod(lctx, m)),
- ItemForeignMod(ref nm) => hir::ItemForeignMod(lower_foreign_mod(lctx, nm)),
- ItemTy(ref t, ref generics) => {
+ ItemKind::Mod(ref m) => hir::ItemMod(lower_mod(lctx, m)),
+ ItemKind::ForeignMod(ref nm) => hir::ItemForeignMod(lower_foreign_mod(lctx, nm)),
+ ItemKind::Ty(ref t, ref generics) => {
hir::ItemTy(lower_ty(lctx, t), lower_generics(lctx, generics))
}
- ItemEnum(ref enum_definition, ref generics) => {
+ ItemKind::Enum(ref enum_definition, ref generics) => {
hir::ItemEnum(hir::EnumDef {
variants: enum_definition.variants
.iter()
},
lower_generics(lctx, generics))
}
- ItemStruct(ref struct_def, ref generics) => {
+ ItemKind::Struct(ref struct_def, ref generics) => {
let struct_def = lower_variant_data(lctx, struct_def);
hir::ItemStruct(struct_def, lower_generics(lctx, generics))
}
- ItemDefaultImpl(unsafety, ref trait_ref) => {
+ ItemKind::DefaultImpl(unsafety, ref trait_ref) => {
hir::ItemDefaultImpl(lower_unsafety(lctx, unsafety),
lower_trait_ref(lctx, trait_ref))
}
- ItemImpl(unsafety, polarity, ref generics, ref ifce, ref ty, ref impl_items) => {
+ ItemKind::Impl(unsafety, polarity, ref generics, ref ifce, ref ty, ref impl_items) => {
let new_impl_items = impl_items.iter()
.map(|item| lower_impl_item(lctx, item))
.collect();
lower_ty(lctx, ty),
new_impl_items)
}
- ItemTrait(unsafety, ref generics, ref bounds, ref items) => {
+ ItemKind::Trait(unsafety, ref generics, ref bounds, ref items) => {
let bounds = lower_bounds(lctx, bounds);
let items = items.iter().map(|item| lower_trait_item(lctx, item)).collect();
hir::ItemTrait(lower_unsafety(lctx, unsafety),
bounds,
items)
}
- ItemMac(_) => panic!("Shouldn't still be around"),
+ ItemKind::Mac(_) => panic!("Shouldn't still be around"),
}
}
name: i.ident.name,
attrs: lower_attrs(lctx, &i.attrs),
node: match i.node {
- ConstTraitItem(ref ty, ref default) => {
+ TraitItemKind::Const(ref ty, ref default) => {
hir::ConstTraitItem(lower_ty(lctx, ty),
default.as_ref().map(|x| lower_expr(lctx, x)))
}
- MethodTraitItem(ref sig, ref body) => {
+ TraitItemKind::Method(ref sig, ref body) => {
hir::MethodTraitItem(lower_method_sig(lctx, sig),
body.as_ref().map(|x| lower_block(lctx, x)))
}
- TypeTraitItem(ref bounds, ref default) => {
+ TraitItemKind::Type(ref bounds, ref default) => {
hir::TypeTraitItem(lower_bounds(lctx, bounds),
default.as_ref().map(|x| lower_ty(lctx, x)))
}
}
pub fn lower_item(lctx: &LoweringContext, i: &Item) -> hir::Item {
- let node = lower_item_underscore(lctx, &i.node);
+ let node = lower_item_kind(lctx, &i.node);
hir::Item {
id: i.id,
name: i.ident.name,
attrs: lower_attrs(lctx, &i.attrs),
node: match i.node {
- ForeignItemFn(ref fdec, ref generics) => {
+ ForeignItemKind::Fn(ref fdec, ref generics) => {
hir::ForeignItemFn(lower_fn_decl(lctx, fdec), lower_generics(lctx, generics))
}
- ForeignItemStatic(ref t, m) => {
+ ForeignItemKind::Static(ref t, m) => {
hir::ForeignItemStatic(lower_ty(lctx, t), m)
}
},
pub fn lower_unop(_lctx: &LoweringContext, u: UnOp) -> hir::UnOp {
match u {
- UnDeref => hir::UnDeref,
- UnNot => hir::UnNot,
- UnNeg => hir::UnNeg,
+ UnOp::Deref => hir::UnDeref,
+ UnOp::Not => hir::UnNot,
+ UnOp::Neg => hir::UnNeg,
}
}
pub fn lower_binop(_lctx: &LoweringContext, b: BinOp) -> hir::BinOp {
Spanned {
node: match b.node {
- BiAdd => hir::BiAdd,
- BiSub => hir::BiSub,
- BiMul => hir::BiMul,
- BiDiv => hir::BiDiv,
- BiRem => hir::BiRem,
- BiAnd => hir::BiAnd,
- BiOr => hir::BiOr,
- BiBitXor => hir::BiBitXor,
- BiBitAnd => hir::BiBitAnd,
- BiBitOr => hir::BiBitOr,
- BiShl => hir::BiShl,
- BiShr => hir::BiShr,
- BiEq => hir::BiEq,
- BiLt => hir::BiLt,
- BiLe => hir::BiLe,
- BiNe => hir::BiNe,
- BiGe => hir::BiGe,
- BiGt => hir::BiGt,
+ BinOpKind::Add => hir::BiAdd,
+ BinOpKind::Sub => hir::BiSub,
+ BinOpKind::Mul => hir::BiMul,
+ BinOpKind::Div => hir::BiDiv,
+ BinOpKind::Rem => hir::BiRem,
+ BinOpKind::And => hir::BiAnd,
+ BinOpKind::Or => hir::BiOr,
+ BinOpKind::BitXor => hir::BiBitXor,
+ BinOpKind::BitAnd => hir::BiBitAnd,
+ BinOpKind::BitOr => hir::BiBitOr,
+ BinOpKind::Shl => hir::BiShl,
+ BinOpKind::Shr => hir::BiShr,
+ BinOpKind::Eq => hir::BiEq,
+ BinOpKind::Lt => hir::BiLt,
+ BinOpKind::Le => hir::BiLe,
+ BinOpKind::Ne => hir::BiNe,
+ BinOpKind::Ge => hir::BiGe,
+ BinOpKind::Gt => hir::BiGt,
},
span: b.span,
}
// }
//
// But for now there are type-inference issues doing that.
- ExprBox(ref e) => {
+ ExprKind::Box(ref e) => {
hir::ExprBox(lower_expr(lctx, e))
}
// Desugar ExprBox: `in (PLACE) EXPR`
- ExprInPlace(ref placer, ref value_expr) => {
+ ExprKind::InPlace(ref placer, ref value_expr) => {
// to:
//
// let p = PLACE;
});
}
- ExprVec(ref exprs) => {
+ ExprKind::Vec(ref exprs) => {
hir::ExprVec(exprs.iter().map(|x| lower_expr(lctx, x)).collect())
}
- ExprRepeat(ref expr, ref count) => {
+ ExprKind::Repeat(ref expr, ref count) => {
let expr = lower_expr(lctx, expr);
let count = lower_expr(lctx, count);
hir::ExprRepeat(expr, count)
}
- ExprTup(ref elts) => {
+ ExprKind::Tup(ref elts) => {
hir::ExprTup(elts.iter().map(|x| lower_expr(lctx, x)).collect())
}
- ExprCall(ref f, ref args) => {
+ ExprKind::Call(ref f, ref args) => {
let f = lower_expr(lctx, f);
hir::ExprCall(f, args.iter().map(|x| lower_expr(lctx, x)).collect())
}
- ExprMethodCall(i, ref tps, ref args) => {
+ ExprKind::MethodCall(i, ref tps, ref args) => {
let tps = tps.iter().map(|x| lower_ty(lctx, x)).collect();
let args = args.iter().map(|x| lower_expr(lctx, x)).collect();
hir::ExprMethodCall(respan(i.span, i.node.name), tps, args)
}
- ExprBinary(binop, ref lhs, ref rhs) => {
+ ExprKind::Binary(binop, ref lhs, ref rhs) => {
let binop = lower_binop(lctx, binop);
let lhs = lower_expr(lctx, lhs);
let rhs = lower_expr(lctx, rhs);
hir::ExprBinary(binop, lhs, rhs)
}
- ExprUnary(op, ref ohs) => {
+ ExprKind::Unary(op, ref ohs) => {
let op = lower_unop(lctx, op);
let ohs = lower_expr(lctx, ohs);
hir::ExprUnary(op, ohs)
}
- ExprLit(ref l) => hir::ExprLit(P((**l).clone())),
- ExprCast(ref expr, ref ty) => {
+ ExprKind::Lit(ref l) => hir::ExprLit(P((**l).clone())),
+ ExprKind::Cast(ref expr, ref ty) => {
let expr = lower_expr(lctx, expr);
hir::ExprCast(expr, lower_ty(lctx, ty))
}
- ExprType(ref expr, ref ty) => {
+ ExprKind::Type(ref expr, ref ty) => {
let expr = lower_expr(lctx, expr);
hir::ExprType(expr, lower_ty(lctx, ty))
}
- ExprAddrOf(m, ref ohs) => {
+ ExprKind::AddrOf(m, ref ohs) => {
let m = lower_mutability(lctx, m);
let ohs = lower_expr(lctx, ohs);
hir::ExprAddrOf(m, ohs)
}
// More complicated than you might expect because the else branch
// might be `if let`.
- ExprIf(ref cond, ref blk, ref else_opt) => {
+ ExprKind::If(ref cond, ref blk, ref else_opt) => {
let else_opt = else_opt.as_ref().map(|els| {
match els.node {
- ExprIfLet(..) => {
+ ExprKind::IfLet(..) => {
cache_ids(lctx, e.id, |lctx| {
// wrap the if-let expr in a block
let span = els.span;
hir::ExprIf(lower_expr(lctx, cond), lower_block(lctx, blk), else_opt)
}
- ExprWhile(ref cond, ref body, opt_ident) => {
+ ExprKind::While(ref cond, ref body, opt_ident) => {
hir::ExprWhile(lower_expr(lctx, cond), lower_block(lctx, body),
opt_ident.map(|ident| lower_ident(lctx, ident)))
}
- ExprLoop(ref body, opt_ident) => {
+ ExprKind::Loop(ref body, opt_ident) => {
hir::ExprLoop(lower_block(lctx, body),
opt_ident.map(|ident| lower_ident(lctx, ident)))
}
- ExprMatch(ref expr, ref arms) => {
+ ExprKind::Match(ref expr, ref arms) => {
hir::ExprMatch(lower_expr(lctx, expr),
arms.iter().map(|x| lower_arm(lctx, x)).collect(),
hir::MatchSource::Normal)
}
- ExprClosure(capture_clause, ref decl, ref body) => {
+ ExprKind::Closure(capture_clause, ref decl, ref body) => {
hir::ExprClosure(lower_capture_clause(lctx, capture_clause),
lower_fn_decl(lctx, decl),
lower_block(lctx, body))
}
- ExprBlock(ref blk) => hir::ExprBlock(lower_block(lctx, blk)),
- ExprAssign(ref el, ref er) => {
+ ExprKind::Block(ref blk) => hir::ExprBlock(lower_block(lctx, blk)),
+ ExprKind::Assign(ref el, ref er) => {
hir::ExprAssign(lower_expr(lctx, el), lower_expr(lctx, er))
}
- ExprAssignOp(op, ref el, ref er) => {
+ ExprKind::AssignOp(op, ref el, ref er) => {
hir::ExprAssignOp(lower_binop(lctx, op),
lower_expr(lctx, el),
lower_expr(lctx, er))
}
- ExprField(ref el, ident) => {
+ ExprKind::Field(ref el, ident) => {
hir::ExprField(lower_expr(lctx, el), respan(ident.span, ident.node.name))
}
- ExprTupField(ref el, ident) => {
+ ExprKind::TupField(ref el, ident) => {
hir::ExprTupField(lower_expr(lctx, el), ident)
}
- ExprIndex(ref el, ref er) => {
+ ExprKind::Index(ref el, ref er) => {
hir::ExprIndex(lower_expr(lctx, el), lower_expr(lctx, er))
}
- ExprRange(ref e1, ref e2) => {
+ ExprKind::Range(ref e1, ref e2) => {
hir::ExprRange(e1.as_ref().map(|x| lower_expr(lctx, x)),
e2.as_ref().map(|x| lower_expr(lctx, x)))
}
- ExprPath(ref qself, ref path) => {
+ ExprKind::Path(ref qself, ref path) => {
let hir_qself = qself.as_ref().map(|&QSelf { ref ty, position }| {
hir::QSelf {
ty: lower_ty(lctx, ty),
});
hir::ExprPath(hir_qself, lower_path_full(lctx, path, qself.is_none()))
}
- ExprBreak(opt_ident) => hir::ExprBreak(opt_ident.map(|sp_ident| {
+ ExprKind::Break(opt_ident) => hir::ExprBreak(opt_ident.map(|sp_ident| {
respan(sp_ident.span, lower_ident(lctx, sp_ident.node))
})),
- ExprAgain(opt_ident) => hir::ExprAgain(opt_ident.map(|sp_ident| {
+ ExprKind::Again(opt_ident) => hir::ExprAgain(opt_ident.map(|sp_ident| {
respan(sp_ident.span, lower_ident(lctx, sp_ident.node))
})),
- ExprRet(ref e) => hir::ExprRet(e.as_ref().map(|x| lower_expr(lctx, x))),
- ExprInlineAsm(InlineAsm {
+ ExprKind::Ret(ref e) => hir::ExprRet(e.as_ref().map(|x| lower_expr(lctx, x))),
+ ExprKind::InlineAsm(InlineAsm {
ref inputs,
ref outputs,
ref asm,
dialect: dialect,
expn_id: expn_id,
}),
- ExprStruct(ref path, ref fields, ref maybe_expr) => {
+ ExprKind::Struct(ref path, ref fields, ref maybe_expr) => {
hir::ExprStruct(lower_path(lctx, path),
fields.iter().map(|x| lower_field(lctx, x)).collect(),
maybe_expr.as_ref().map(|x| lower_expr(lctx, x)))
}
- ExprParen(ref ex) => {
+ ExprKind::Paren(ref ex) => {
// merge attributes into the inner expression.
return lower_expr(lctx, ex).map(|mut ex| {
ex.attrs.update(|attrs| {
// Desugar ExprIfLet
// From: `if let <pat> = <sub_expr> <body> [<else_opt>]`
- ExprIfLet(ref pat, ref sub_expr, ref body, ref else_opt) => {
+ ExprKind::IfLet(ref pat, ref sub_expr, ref body, ref else_opt) => {
// to:
//
// match <sub_expr> {
// Desugar ExprWhileLet
// From: `[opt_ident]: while let <pat> = <sub_expr> <body>`
- ExprWhileLet(ref pat, ref sub_expr, ref body, opt_ident) => {
+ ExprKind::WhileLet(ref pat, ref sub_expr, ref body, opt_ident) => {
// to:
//
// [opt_ident]: loop {
// Desugar ExprForLoop
// From: `[opt_ident]: for <pat> in <head> <body>`
- ExprForLoop(ref pat, ref head, ref body, opt_ident) => {
+ ExprKind::ForLoop(ref pat, ref head, ref body, opt_ident) => {
// to:
//
// {
});
}
- ExprMac(_) => panic!("Shouldn't exist here"),
+ ExprKind::Mac(_) => panic!("Shouldn't exist here"),
},
span: e.span,
attrs: e.attrs.clone(),
pub fn lower_stmt(lctx: &LoweringContext, s: &Stmt) -> hir::Stmt {
match s.node {
- StmtDecl(ref d, id) => {
+ StmtKind::Decl(ref d, id) => {
Spanned {
node: hir::StmtDecl(lower_decl(lctx, d), id),
span: s.span,
}
}
- StmtExpr(ref e, id) => {
+ StmtKind::Expr(ref e, id) => {
Spanned {
node: hir::StmtExpr(lower_expr(lctx, e), id),
span: s.span,
}
}
- StmtSemi(ref e, id) => {
+ StmtKind::Semi(ref e, id) => {
Spanned {
node: hir::StmtSemi(lower_expr(lctx, e), id),
span: s.span,
}
}
- StmtMac(..) => panic!("Shouldn't exist here"),
+ StmtKind::Mac(..) => panic!("Shouldn't exist here"),
}
}
-pub fn lower_capture_clause(_lctx: &LoweringContext, c: CaptureClause) -> hir::CaptureClause {
+pub fn lower_capture_clause(_lctx: &LoweringContext, c: CaptureBy) -> hir::CaptureClause {
match c {
- CaptureByValue => hir::CaptureByValue,
- CaptureByRef => hir::CaptureByRef,
+ CaptureBy::Value => hir::CaptureByValue,
+ CaptureBy::Ref => hir::CaptureByRef,
}
}
pub fn lower_visibility(_lctx: &LoweringContext, v: Visibility) -> hir::Visibility {
match v {
- Public => hir::Public,
- Inherited => hir::Inherited,
+ Visibility::Public => hir::Public,
+ Visibility::Inherited => hir::Inherited,
}
}
pub fn lower_block_check_mode(lctx: &LoweringContext, b: &BlockCheckMode) -> hir::BlockCheckMode {
match *b {
- DefaultBlock => hir::DefaultBlock,
- UnsafeBlock(u) => hir::UnsafeBlock(lower_unsafe_source(lctx, u)),
+ BlockCheckMode::Default => hir::DefaultBlock,
+ BlockCheckMode::Unsafe(u) => hir::UnsafeBlock(lower_unsafe_source(lctx, u)),
}
}
pub use self::AnnNode::*;
-use syntax::abi;
+use syntax::abi::Abi;
use syntax::ast;
use syntax::codemap::{self, CodeMap, BytePos, Spanned};
use syntax::errors;
try!(s.print_fn(decl,
unsafety,
constness,
- abi::Rust,
+ Abi::Rust,
Some(name),
generics,
opt_explicit_self,
try!(self.print_fn(decl,
hir::Unsafety::Normal,
hir::Constness::NotConst,
- abi::Rust,
+ Abi::Rust,
Some(item.name),
generics,
None,
if let Some(p) = *optional_path {
let val = p.as_str();
if val.contains("-") {
- try!(self.print_string(&val, ast::CookedStr));
+ try!(self.print_string(&val, ast::StrStyle::Cooked));
} else {
try!(self.print_name(p));
}
try!(self.commasep(Inconsistent, &a.outputs, |s, out| {
match out.constraint.slice_shift_char() {
Some(('=', operand)) if out.is_rw => {
- try!(s.print_string(&format!("+{}", operand), ast::CookedStr))
+ try!(s.print_string(&format!("+{}", operand), ast::StrStyle::Cooked))
}
- _ => try!(s.print_string(&out.constraint, ast::CookedStr)),
+ _ => try!(s.print_string(&out.constraint, ast::StrStyle::Cooked)),
}
try!(s.popen());
try!(s.print_expr(&*out.expr));
try!(self.word_space(":"));
try!(self.commasep(Inconsistent, &a.inputs, |s, &(ref co, ref o)| {
- try!(s.print_string(&co, ast::CookedStr));
+ try!(s.print_string(&co, ast::StrStyle::Cooked));
try!(s.popen());
try!(s.print_expr(&**o));
try!(s.pclose());
try!(self.word_space(":"));
try!(self.commasep(Inconsistent, &a.clobbers, |s, co| {
- try!(s.print_string(&co, ast::CookedStr));
+ try!(s.print_string(&co, ast::StrStyle::Cooked));
Ok(())
}));
try!(space(&mut self.s));
try!(self.word_space(":"));
try!(self.commasep(Inconsistent, &*options, |s, &co| {
- try!(s.print_string(co, ast::CookedStr));
+ try!(s.print_string(co, ast::StrStyle::Cooked));
Ok(())
}));
}
decl: &hir::FnDecl,
unsafety: hir::Unsafety,
constness: hir::Constness,
- abi: abi::Abi,
+ abi: Abi,
name: Option<ast::Name>,
generics: &hir::Generics,
opt_explicit_self: Option<&hir::ExplicitSelf_>,
}
pub fn print_ty_fn(&mut self,
- abi: abi::Abi,
+ abi: Abi,
unsafety: hir::Unsafety,
decl: &hir::FnDecl,
name: Option<ast::Name>,
}
pub fn print_opt_abi_and_extern_if_nondefault(&mut self,
- opt_abi: Option<abi::Abi>)
+ opt_abi: Option<Abi>)
-> io::Result<()> {
match opt_abi {
- Some(abi::Rust) => Ok(()),
+ Some(Abi::Rust) => Ok(()),
Some(abi) => {
try!(self.word_nbsp("extern"));
self.word_nbsp(&abi.to_string())
}
}
- pub fn print_extern_opt_abi(&mut self, opt_abi: Option<abi::Abi>) -> io::Result<()> {
+ pub fn print_extern_opt_abi(&mut self, opt_abi: Option<Abi>) -> io::Result<()> {
match opt_abi {
Some(abi) => {
try!(self.word_nbsp("extern"));
pub fn print_fn_header_info(&mut self,
unsafety: hir::Unsafety,
constness: hir::Constness,
- abi: abi::Abi,
+ abi: Abi,
vis: hir::Visibility)
-> io::Result<()> {
try!(word(&mut self.s, &visibility_qualified(vis, "")));
hir::Constness::Const => try!(self.word_nbsp("const")),
}
- if abi != abi::Rust {
+ if abi != Abi::Rust {
try!(self.word_nbsp("extern"));
try!(self.word_nbsp(&abi.to_string()));
}
fn check_expr(&mut self, cx: &LateContext, e: &hir::Expr) {
if let hir::ExprWhile(ref cond, _, _) = e.node {
if let hir::ExprLit(ref lit) = cond.node {
- if let ast::LitBool(true) = lit.node {
+ if let ast::LitKind::Bool(true) = lit.node {
cx.span_lint(WHILE_TRUE, e.span,
"denote infinite loops with loop { ... }");
}
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
}
});
impl LateLintPass for MutableTransmutes {
fn check_expr(&mut self, cx: &LateContext, expr: &hir::Expr) {
- use syntax::abi::RustIntrinsic;
+ use syntax::abi::Abi::RustIntrinsic;
let msg = "mutating transmuted &mut T from &T may cause undefined behavior,\
consider instead using an UnsafeCell";
use std::cmp;
use std::{i8, i16, i32, i64, u8, u16, u32, u64, f32, f64};
-use syntax::{abi, ast};
+use syntax::ast;
+use syntax::abi::Abi;
use syntax::attr::{self, AttrMetaMethods};
use syntax::codemap::{self, Span};
hir::ExprUnary(hir::UnNeg, ref expr) => {
if let hir::ExprLit(ref lit) = expr.node {
match lit.node {
- ast::LitInt(_, ast::UnsignedIntLit(_)) => {
+ ast::LitKind::Int(_, ast::LitIntType::Unsigned(_)) => {
forbid_unsigned_negation(cx, e.span);
},
- ast::LitInt(_, ast::UnsuffixedIntLit(_)) => {
+ ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
if let ty::TyUint(_) = cx.tcx.node_id_to_type(e.id).sty {
forbid_unsigned_negation(cx, e.span);
}
if let Some(bits) = opt_ty_bits {
let exceeding = if let hir::ExprLit(ref lit) = r.node {
- if let ast::LitInt(shift, _) = lit.node { shift >= bits }
+ if let ast::LitKind::Int(shift, _) = lit.node { shift >= bits }
else { false }
} else {
match eval_const_expr_partial(cx.tcx, &r, ExprTypeChecked, None) {
match cx.tcx.node_id_to_type(e.id).sty {
ty::TyInt(t) => {
match lit.node {
- ast::LitInt(v, ast::SignedIntLit(_, ast::Plus)) |
- ast::LitInt(v, ast::UnsuffixedIntLit(ast::Plus)) => {
- let int_type = if let ast::TyIs = t {
+ ast::LitKind::Int(v, ast::LitIntType::Signed(_)) |
+ ast::LitKind::Int(v, ast::LitIntType::Unsuffixed) => {
+ let int_type = if let ast::IntTy::Is = t {
cx.sess().target.int_type
} else {
t
};
},
ty::TyUint(t) => {
- let uint_type = if let ast::TyUs = t {
+ let uint_type = if let ast::UintTy::Us = t {
cx.sess().target.uint_type
} else {
t
};
let (min, max) = uint_ty_range(uint_type);
let lit_val: u64 = match lit.node {
- ast::LitByte(_v) => return, // _v is u8, within range by definition
- ast::LitInt(v, _) => v,
+ // _v is u8, within range by definition
+ ast::LitKind::Byte(_v) => return,
+ ast::LitKind::Int(v, _) => v,
_ => panic!()
};
if lit_val < min || lit_val > max {
ty::TyFloat(t) => {
let (min, max) = float_ty_range(t);
let lit_val: f64 = match lit.node {
- ast::LitFloat(ref v, _) |
- ast::LitFloatUnsuffixed(ref v) => {
+ ast::LitKind::Float(ref v, _) |
+ ast::LitKind::FloatUnsuffixed(ref v) => {
match v.parse() {
Ok(f) => f,
Err(_) => return
// warnings are consistent between 32- and 64-bit platforms
fn int_ty_range(int_ty: ast::IntTy) -> (i64, i64) {
match int_ty {
- ast::TyIs => (i64::MIN, i64::MAX),
- ast::TyI8 => (i8::MIN as i64, i8::MAX as i64),
- ast::TyI16 => (i16::MIN as i64, i16::MAX as i64),
- ast::TyI32 => (i32::MIN as i64, i32::MAX as i64),
- ast::TyI64 => (i64::MIN, i64::MAX)
+ ast::IntTy::Is => (i64::MIN, i64::MAX),
+ ast::IntTy::I8 => (i8::MIN as i64, i8::MAX as i64),
+ ast::IntTy::I16 => (i16::MIN as i64, i16::MAX as i64),
+ ast::IntTy::I32 => (i32::MIN as i64, i32::MAX as i64),
+ ast::IntTy::I64 => (i64::MIN, i64::MAX)
}
}
fn uint_ty_range(uint_ty: ast::UintTy) -> (u64, u64) {
match uint_ty {
- ast::TyUs => (u64::MIN, u64::MAX),
- ast::TyU8 => (u8::MIN as u64, u8::MAX as u64),
- ast::TyU16 => (u16::MIN as u64, u16::MAX as u64),
- ast::TyU32 => (u32::MIN as u64, u32::MAX as u64),
- ast::TyU64 => (u64::MIN, u64::MAX)
+ ast::UintTy::Us => (u64::MIN, u64::MAX),
+ ast::UintTy::U8 => (u8::MIN as u64, u8::MAX as u64),
+ ast::UintTy::U16 => (u16::MIN as u64, u16::MAX as u64),
+ ast::UintTy::U32 => (u32::MIN as u64, u32::MAX as u64),
+ ast::UintTy::U64 => (u64::MIN, u64::MAX)
}
}
fn float_ty_range(float_ty: ast::FloatTy) -> (f64, f64) {
match float_ty {
- ast::TyF32 => (f32::MIN as f64, f32::MAX as f64),
- ast::TyF64 => (f64::MIN, f64::MAX)
+ ast::FloatTy::F32 => (f32::MIN as f64, f32::MAX as f64),
+ ast::FloatTy::F64 => (f64::MIN, f64::MAX)
}
}
fn int_ty_bits(int_ty: ast::IntTy, target_int_ty: ast::IntTy) -> u64 {
match int_ty {
- ast::TyIs => int_ty_bits(target_int_ty, target_int_ty),
- ast::TyI8 => 8,
- ast::TyI16 => 16 as u64,
- ast::TyI32 => 32,
- ast::TyI64 => 64,
+ ast::IntTy::Is => int_ty_bits(target_int_ty, target_int_ty),
+ ast::IntTy::I8 => 8,
+ ast::IntTy::I16 => 16 as u64,
+ ast::IntTy::I32 => 32,
+ ast::IntTy::I64 => 64,
}
}
fn uint_ty_bits(uint_ty: ast::UintTy, target_uint_ty: ast::UintTy) -> u64 {
match uint_ty {
- ast::TyUs => uint_ty_bits(target_uint_ty, target_uint_ty),
- ast::TyU8 => 8,
- ast::TyU16 => 16,
- ast::TyU32 => 32,
- ast::TyU64 => 64,
+ ast::UintTy::Us => uint_ty_bits(target_uint_ty, target_uint_ty),
+ ast::UintTy::U8 => 8,
+ ast::UintTy::U16 => 16,
+ ast::UintTy::U32 => 32,
+ ast::UintTy::U64 => 64,
}
}
let (min, max) = int_ty_range(int_ty);
let lit_val: i64 = match lit.node {
hir::ExprLit(ref li) => match li.node {
- ast::LitInt(v, ast::SignedIntLit(_, ast::Plus)) |
- ast::LitInt(v, ast::UnsuffixedIntLit(ast::Plus)) => v as i64,
- ast::LitInt(v, ast::SignedIntLit(_, ast::Minus)) |
- ast::LitInt(v, ast::UnsuffixedIntLit(ast::Minus)) => -(v as i64),
+ ast::LitKind::Int(v, ast::LitIntType::Signed(_)) |
+ ast::LitKind::Int(v, ast::LitIntType::Unsuffixed) => v as i64,
_ => return true
},
_ => panic!()
let (min, max): (u64, u64) = uint_ty_range(uint_ty);
let lit_val: u64 = match lit.node {
hir::ExprLit(ref li) => match li.node {
- ast::LitInt(v, _) => v,
+ ast::LitKind::Int(v, _) => v,
_ => return true
},
_ => panic!()
ty::TyBareFn(None, bare_fn) => {
match bare_fn.abi {
- abi::Rust |
- abi::RustIntrinsic |
- abi::PlatformIntrinsic |
- abi::RustCall => {
+ Abi::Rust |
+ Abi::RustIntrinsic |
+ Abi::PlatformIntrinsic |
+ Abi::RustCall => {
return FfiUnsafe(
"found function pointer with Rust calling \
convention in foreign module; consider using an \
}
if let hir::ItemForeignMod(ref nmod) = it.node {
- if nmod.abi != abi::RustIntrinsic && nmod.abi != abi::PlatformIntrinsic {
+ if nmod.abi != Abi::RustIntrinsic && nmod.abi != Abi::PlatformIntrinsic {
for ni in &nmod.items {
match ni.node {
hir::ForeignItemFn(ref decl, _) => check_foreign_fn(cx, &**decl),
impl UnusedParens {
fn check_unused_parens_core(&self, cx: &EarlyContext, value: &ast::Expr, msg: &str,
struct_lit_needs_parens: bool) {
- if let ast::ExprParen(ref inner) = value.node {
+ if let ast::ExprKind::Paren(ref inner) = value.node {
let necessary = struct_lit_needs_parens && contains_exterior_struct_lit(&**inner);
if !necessary {
cx.span_lint(UNUSED_PARENS, value.span,
/// y: 1 }) == foo` does not.
fn contains_exterior_struct_lit(value: &ast::Expr) -> bool {
match value.node {
- ast::ExprStruct(..) => true,
+ ast::ExprKind::Struct(..) => true,
- ast::ExprAssign(ref lhs, ref rhs) |
- ast::ExprAssignOp(_, ref lhs, ref rhs) |
- ast::ExprBinary(_, ref lhs, ref rhs) => {
+ ast::ExprKind::Assign(ref lhs, ref rhs) |
+ ast::ExprKind::AssignOp(_, ref lhs, ref rhs) |
+ ast::ExprKind::Binary(_, ref lhs, ref rhs) => {
// X { y: 1 } + X { y: 2 }
contains_exterior_struct_lit(&**lhs) ||
contains_exterior_struct_lit(&**rhs)
}
- ast::ExprUnary(_, ref x) |
- ast::ExprCast(ref x, _) |
- ast::ExprType(ref x, _) |
- ast::ExprField(ref x, _) |
- ast::ExprTupField(ref x, _) |
- ast::ExprIndex(ref x, _) => {
+ ast::ExprKind::Unary(_, ref x) |
+ ast::ExprKind::Cast(ref x, _) |
+ ast::ExprKind::Type(ref x, _) |
+ ast::ExprKind::Field(ref x, _) |
+ ast::ExprKind::TupField(ref x, _) |
+ ast::ExprKind::Index(ref x, _) => {
// &X { y: 1 }, X { y: 1 }.y
contains_exterior_struct_lit(&**x)
}
- ast::ExprMethodCall(_, _, ref exprs) => {
+ ast::ExprKind::MethodCall(_, _, ref exprs) => {
// X { y: 1 }.bar(...)
contains_exterior_struct_lit(&*exprs[0])
}
impl EarlyLintPass for UnusedParens {
fn check_expr(&mut self, cx: &EarlyContext, e: &ast::Expr) {
+ use syntax::ast::ExprKind::*;
let (value, msg, struct_lit_needs_parens) = match e.node {
- ast::ExprIf(ref cond, _, _) => (cond, "`if` condition", true),
- ast::ExprWhile(ref cond, _, _) => (cond, "`while` condition", true),
- ast::ExprIfLet(_, ref cond, _, _) => (cond, "`if let` head expression", true),
- ast::ExprWhileLet(_, ref cond, _, _) => (cond, "`while let` head expression", true),
- ast::ExprForLoop(_, ref cond, _, _) => (cond, "`for` head expression", true),
- ast::ExprMatch(ref head, _) => (head, "`match` head expression", true),
- ast::ExprRet(Some(ref value)) => (value, "`return` value", false),
- ast::ExprAssign(_, ref value) => (value, "assigned value", false),
- ast::ExprAssignOp(_, _, ref value) => (value, "assigned value", false),
- ast::ExprInPlace(_, ref value) => (value, "emplacement value", false),
+ If(ref cond, _, _) => (cond, "`if` condition", true),
+ While(ref cond, _, _) => (cond, "`while` condition", true),
+ IfLet(_, ref cond, _, _) => (cond, "`if let` head expression", true),
+ WhileLet(_, ref cond, _, _) => (cond, "`while let` head expression", true),
+ ForLoop(_, ref cond, _, _) => (cond, "`for` head expression", true),
+ Match(ref head, _) => (head, "`match` head expression", true),
+ Ret(Some(ref value)) => (value, "`return` value", false),
+ Assign(_, ref value) => (value, "assigned value", false),
+ AssignOp(_, _, ref value) => (value, "assigned value", false),
+ InPlace(_, ref value) => (value, "emplacement value", false),
_ => return
};
self.check_unused_parens_core(cx, &**value, msg, struct_lit_needs_parens);
fn check_stmt(&mut self, cx: &EarlyContext, s: &ast::Stmt) {
let (value, msg) = match s.node {
- ast::StmtDecl(ref decl, _) => match decl.node {
- ast::DeclLocal(ref local) => match local.init {
+ ast::StmtKind::Decl(ref decl, _) => match decl.node {
+ ast::DeclKind::Local(ref local) => match local.init {
Some(ref value) => (value, "assigned value"),
None => return
},
use std::fs;
use syntax::ast;
-use syntax::abi;
+use syntax::abi::Abi;
use syntax::codemap::{self, Span, mk_sp, Pos};
use syntax::parse;
use syntax::attr;
fn extract_crate_info(&self, i: &ast::Item) -> Option<CrateInfo> {
match i.node {
- ast::ItemExternCrate(ref path_opt) => {
+ ast::ItemKind::ExternCrate(ref path_opt) => {
debug!("resolving extern crate stmt. ident: {} path_opt: {:?}",
i.ident, path_opt);
let name = match *path_opt {
}
fn process_foreign_mod(&mut self, i: &hir::Item, fm: &hir::ForeignMod) {
- if fm.abi == abi::Rust || fm.abi == abi::RustIntrinsic || fm.abi == abi::PlatformIntrinsic {
+ if fm.abi == Abi::Rust || fm.abi == Abi::RustIntrinsic || fm.abi == Abi::PlatformIntrinsic {
return;
}
use syntax::parse::token::{IdentInterner, special_idents};
use syntax::parse::token;
use syntax::ast;
-use syntax::abi;
+use syntax::abi::Abi;
use syntax::codemap::{self, Span, BytePos, NO_EXPANSION};
use syntax::print::pprust;
use syntax::ptr::P;
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| {
if let Fn = item_family(item_doc) {
let ty::TypeScheme { generics, ty } = get_type(cdata, id, tcx);
generics.types.is_empty() && match ty.sty {
- ty::TyBareFn(_, fn_ty) => fn_ty.abi != abi::Rust,
+ ty::TyBareFn(_, fn_ty) => fn_ty.abi != Abi::Rust,
_ => false,
}
} else {
use std::io::{Cursor, SeekFrom};
use std::rc::Rc;
use std::u32;
-use syntax::abi;
+use syntax::abi::Abi;
use syntax::ast::{self, NodeId, Name, CRATE_NODE_ID, CrateNum};
use syntax::codemap::BytePos;
use syntax::attr;
nitem: &hir::ForeignItem,
index: &mut CrateIndex<'tcx>,
path: PathElems,
- abi: abi::Abi) {
+ abi: Abi) {
let def_id = ecx.tcx.map.local_def_id(nitem.id);
index.record(def_id, rbml_w);
encode_family(rbml_w, FN_FAMILY);
encode_bounds_and_type_for_item(rbml_w, ecx, index, nitem.id);
encode_name(rbml_w, nitem.name);
- if abi == abi::RustIntrinsic || abi == abi::PlatformIntrinsic {
+ if abi == Abi::RustIntrinsic || abi == Abi::PlatformIntrinsic {
encode_inlined_item(ecx, rbml_w, InlinedItemRef::Foreign(nitem));
}
encode_attributes(rbml_w, &*nitem.attrs);
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::LitStr(ref value, _) => {
+ ast::LitKind::Str(ref value, _) => {
rbml_w.start_tag(tag_meta_item_name_value);
rbml_w.wr_tagged_str(tag_meta_item_name, name);
rbml_w.wr_tagged_str(tag_meta_item_value, 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 {
// crate root, because `$crate` won't work properly. Identify these by
// spans, because the crate map isn't set up yet.
for item in &krate.module.items {
- if let ast::ItemExternCrate(_) = item.node {
+ if let ast::ItemKind::ExternCrate(_) = item.node {
loader.span_whitelist.insert(item.span);
}
}
fn visit_item(&mut self, item: &ast::Item) {
// We're only interested in `extern crate`.
match item.node {
- ast::ItemExternCrate(_) => {}
+ ast::ItemKind::ExternCrate(_) => {}
_ => {
visit::walk_item(self, item);
return;
}
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);
ty::TyChar => { write!(w, "c"); }
ty::TyInt(t) => {
match t {
- ast::TyIs => write!(w, "is"),
- ast::TyI8 => write!(w, "MB"),
- ast::TyI16 => write!(w, "MW"),
- ast::TyI32 => write!(w, "ML"),
- ast::TyI64 => write!(w, "MD")
+ ast::IntTy::Is => write!(w, "is"),
+ ast::IntTy::I8 => write!(w, "MB"),
+ ast::IntTy::I16 => write!(w, "MW"),
+ ast::IntTy::I32 => write!(w, "ML"),
+ ast::IntTy::I64 => write!(w, "MD")
};
}
ty::TyUint(t) => {
match t {
- ast::TyUs => write!(w, "us"),
- ast::TyU8 => write!(w, "Mb"),
- ast::TyU16 => write!(w, "Mw"),
- ast::TyU32 => write!(w, "Ml"),
- ast::TyU64 => write!(w, "Md")
+ ast::UintTy::Us => write!(w, "us"),
+ ast::UintTy::U8 => write!(w, "Mb"),
+ ast::UintTy::U16 => write!(w, "Mw"),
+ ast::UintTy::U32 => write!(w, "Ml"),
+ ast::UintTy::U64 => write!(w, "Md")
};
}
ty::TyFloat(t) => {
match t {
- ast::TyF32 => write!(w, "Mf"),
- ast::TyF64 => write!(w, "MF"),
+ ast::FloatTy::F32 => write!(w, "Mf"),
+ ast::FloatTy::F64 => write!(w, "MF"),
};
}
ty::TyEnum(def, substs) => {
CheckConstFn{ sess: self.sess}.visit_block(block);
}
fn visit_expr(&mut self, e: &'v ast::Expr) {
- if let ast::ExprClosure(..) = e.node {
+ if let ast::ExprKind::Closure(..) = e.node {
CheckConstFn{ sess: self.sess}.visit_expr(e);
} else {
visit::walk_expr(self, e);
// Check all statements in the block
for stmt in &b.stmts {
let span = match stmt.node {
- ast::StmtDecl(ref decl, _) => {
+ ast::StmtKind::Decl(ref decl, _) => {
match decl.node {
- ast::DeclLocal(_) => decl.span,
+ ast::DeclKind::Local(_) => decl.span,
// Item statements are allowed
- ast::DeclItem(_) => continue,
+ ast::DeclKind::Item(_) => continue,
}
}
- ast::StmtExpr(ref expr, _) => expr.span,
- ast::StmtSemi(ref semi, _) => semi.span,
- ast::StmtMac(..) => unreachable!(),
+ ast::StmtKind::Expr(ref expr, _) => expr.span,
+ ast::StmtKind::Semi(ref semi, _) => semi.span,
+ ast::StmtKind::Mac(..) => unreachable!(),
};
span_err!(sess, span, E0016,
"blocks in {}s are limited to items and tail expressions", kind);
fn visit_item(&mut self, i: &'v ast::Item) {
visit::walk_item(self, i);
match i.node {
- ast::ItemConst(_, ref e) => {
+ ast::ItemKind::Const(_, ref e) => {
CheckBlock{ sess: self.sess, kind: "constant"}.visit_expr(e)
},
- ast::ItemStatic(_, _, ref e) => {
+ ast::ItemKind::Static(_, _, ref e) => {
CheckBlock{ sess: self.sess, kind: "static"}.visit_expr(e)
},
_ => {},
for arg in &fd.inputs {
match arg.pat.node {
ast::PatWild => {}
- ast::PatIdent(ast::BindingMode::ByValue(ast::MutImmutable), _, None) => {}
+ ast::PatIdent(ast::BindingMode::ByValue(ast::Mutability::Immutable), _, None) => {}
_ => {
span_err!(self.sess, arg.pat.span, E0022,
"arguments of constant functions can only \
impl<'a, 'v> Visitor<'v> for CheckNoAsm<'a> {
fn visit_expr(&mut self, e: &ast::Expr) {
match e.node {
- ast::ExprInlineAsm(_) => span_err!(self.sess, e.span, E0472,
- "asm! is unsupported on this target"),
+ ast::ExprKind::InlineAsm(_) => span_err!(self.sess, e.span, E0472,
+ "asm! is unsupported on this target"),
_ => {},
}
visit::walk_expr(self, e)
use DefModifiers;
use resolve_imports::ImportDirective;
use resolve_imports::ImportDirectiveSubclass::{self, SingleImport, GlobImport};
-use resolve_imports::ImportResolution;
use Module;
use Namespace::{self, TypeNS, ValueNS};
-use {NameBinding, DefOrModule};
+use {NameBinding, NameBindingKind};
use {names_to_string, module_to_string};
use ParentLink::{ModuleParentLink, BlockParentLink};
use Resolver;
impl<'a> ToNameBinding<'a> for (Def, Span, DefModifiers) {
fn to_name_binding(self) -> NameBinding<'a> {
- let def = DefOrModule::Def(self.0);
- NameBinding { modifiers: self.2, def_or_module: def, span: Some(self.1) }
+ let kind = NameBindingKind::Def(self.0);
+ NameBinding { modifiers: self.2, kind: kind, span: Some(self.1) }
}
}
fn try_define<T>(&self, parent: Module<'b>, name: Name, ns: Namespace, def: T)
where T: ToNameBinding<'b>
{
- parent.try_define_child(name, ns, def.to_name_binding());
+ let _ = parent.try_define_child(name, ns, self.new_name_binding(def.to_name_binding()));
}
/// Defines `name` in namespace `ns` of module `parent` to be `def` if it is not yet defined;
/// otherwise, reports an error.
fn define<T: ToNameBinding<'b>>(&self, parent: Module<'b>, name: Name, ns: Namespace, def: T) {
- let binding = def.to_name_binding();
- let old_binding = match parent.try_define_child(name, ns, binding.clone()) {
- Some(old_binding) => old_binding,
- None => return,
+ let binding = self.new_name_binding(def.to_name_binding());
+ let old_binding = match parent.try_define_child(name, ns, binding) {
+ Ok(()) => return,
+ Err(old_binding) => old_binding,
};
let span = binding.span.unwrap_or(DUMMY_SP);
debug!("(building import directive) building import directive: {}::{}",
names_to_string(&module_.imports.borrow().last().unwrap().module_path),
target);
-
- let mut import_resolutions = module_.import_resolutions.borrow_mut();
- for &ns in [TypeNS, ValueNS].iter() {
- let mut resolution = import_resolutions.entry((target, ns)).or_insert(
- ImportResolution::new(id, is_public)
- );
-
- resolution.outstanding_references += 1;
- // the source of this name is different now
- resolution.id = id;
- resolution.is_public = is_public;
- }
+ module_.increment_outstanding_references_for(target, ValueNS);
+ module_.increment_outstanding_references_for(target, TypeNS);
}
GlobImport => {
// Set the glob flag. This tells us that we don't know the
use rustc::middle::ty::{Freevar, FreevarMap, TraitMap, GlobMap};
use rustc::util::nodemap::{NodeMap, DefIdSet, FnvHashMap};
-use syntax::ast;
-use syntax::ast::{CRATE_NODE_ID, Name, NodeId, CrateNum, TyIs, TyI8, TyI16, TyI32, TyI64};
-use syntax::ast::{TyUs, TyU8, TyU16, TyU32, TyU64, TyF64, TyF32};
+use syntax::ast::{self, FloatTy};
+use syntax::ast::{CRATE_NODE_ID, Name, NodeId, CrateNum, IntTy, UintTy};
use syntax::attr::AttrMetaMethods;
use syntax::codemap::{self, Span, Pos};
use syntax::errors::DiagnosticBuilder;
use rustc_front::hir::{TyRptr, TyStr, TyUint, TyPath, TyPtr};
use rustc_front::util::walk_pat;
-use std::collections::{hash_map, HashMap, HashSet};
+use std::collections::{HashMap, HashSet};
use std::cell::{Cell, RefCell};
use std::fmt;
use std::mem::replace;
-use resolve_imports::{Target, ImportDirective, ImportResolution};
-use resolve_imports::Shadowable;
+use resolve_imports::{ImportDirective, NameResolution};
// NB: This module needs to be declared first so diagnostics are
// registered before they are used.
if let Some(sp) = resolver.ast_map.span_if_local(did) {
err.span_note(sp, "constant defined here");
}
- if let Some(directive) = resolver.current_module
- .import_resolutions
- .borrow()
- .get(&(name, ValueNS)) {
- let item = resolver.ast_map.expect_item(directive.id);
- err.span_note(item.span, "constant imported here");
+ if let Success(binding) = resolver.current_module.resolve_name(name, ValueNS, true) {
+ if binding.is_import() {
+ err.span_note(binding.span.unwrap(), "constant imported here");
+ }
}
err
}
}
}
-type ErrorMessage = Option<(Span, String)>;
+pub type ErrorMessage = Option<(Span, String)>;
#[derive(Clone, PartialEq, Eq)]
-enum ResolveResult<T> {
+pub enum ResolveResult<T> {
Failed(ErrorMessage), // Failed to resolve the name, optional helpful error message.
Indeterminate, // Couldn't determine due to unresolved globs.
Success(T), // Successfully resolved the import.
Success(t) => f(t),
}
}
+
+ fn success(self) -> Option<T> {
+ match self {
+ Success(t) => Some(t),
+ _ => None,
+ }
+ }
}
enum FallbackSuggestion {
is_public: bool,
is_extern_crate: bool,
- children: RefCell<HashMap<(Name, Namespace), NameBinding<'a>>>,
+ children: RefCell<HashMap<(Name, Namespace), NameResolution<'a>>>,
imports: RefCell<Vec<ImportDirective>>,
// The anonymous children of this node. Anonymous children are pseudo-
// entry block for `f`.
anonymous_children: RefCell<NodeMap<Module<'a>>>,
- // The status of resolving each import in this module.
- import_resolutions: RefCell<HashMap<(Name, Namespace), ImportResolution<'a>>>,
+ shadowed_traits: RefCell<Vec<&'a NameBinding<'a>>>,
// The number of unresolved globs that this module exports.
glob_count: Cell<usize>,
children: RefCell::new(HashMap::new()),
imports: RefCell::new(Vec::new()),
anonymous_children: RefCell::new(NodeMap()),
- import_resolutions: RefCell::new(HashMap::new()),
+ shadowed_traits: RefCell::new(Vec::new()),
glob_count: Cell::new(0),
pub_count: Cell::new(0),
pub_glob_count: Cell::new(0),
}
}
- fn get_child(&self, name: Name, ns: Namespace) -> Option<NameBinding<'a>> {
- self.children.borrow().get(&(name, ns)).cloned()
+ fn resolve_name(&self, name: Name, ns: Namespace, allow_private_imports: bool)
+ -> ResolveResult<&'a NameBinding<'a>> {
+ let glob_count =
+ if allow_private_imports { self.glob_count.get() } else { self.pub_glob_count.get() };
+
+ self.children.borrow().get(&(name, ns)).cloned().unwrap_or_default().result(glob_count)
+ .and_then(|binding| {
+ let allowed = allow_private_imports || !binding.is_import() || binding.is_public();
+ if allowed { Success(binding) } else { Failed(None) }
+ })
+ }
+
+ // Define the name or return the existing binding if there is a collision.
+ fn try_define_child(&self, name: Name, ns: Namespace, binding: &'a NameBinding<'a>)
+ -> Result<(), &'a NameBinding<'a>> {
+ let mut children = self.children.borrow_mut();
+ let resolution = children.entry((name, ns)).or_insert_with(Default::default);
+
+ // FIXME #31379: We can use methods from imported traits shadowed by non-import items
+ if let Some(old_binding) = resolution.binding {
+ if !old_binding.is_import() && binding.is_import() {
+ if let Some(Def::Trait(_)) = binding.def() {
+ self.shadowed_traits.borrow_mut().push(binding);
+ }
+ }
+ }
+
+ resolution.try_define(binding)
+ }
+
+ fn increment_outstanding_references_for(&self, name: Name, ns: Namespace) {
+ let mut children = self.children.borrow_mut();
+ children.entry((name, ns)).or_insert_with(Default::default).outstanding_references += 1;
}
- // If the name is not yet defined, define the name and return None.
- // Otherwise, return the existing definition.
- fn try_define_child(&self, name: Name, ns: Namespace, binding: NameBinding<'a>)
- -> Option<NameBinding<'a>> {
- match self.children.borrow_mut().entry((name, ns)) {
- hash_map::Entry::Vacant(entry) => { entry.insert(binding); None }
- hash_map::Entry::Occupied(entry) => { Some(entry.get().clone()) },
+ fn decrement_outstanding_references_for(&self, name: Name, ns: Namespace) {
+ match self.children.borrow_mut().get_mut(&(name, ns)).unwrap().outstanding_references {
+ 0 => panic!("No more outstanding references!"),
+ ref mut outstanding_references => { *outstanding_references -= 1; }
}
}
- fn for_each_local_child<F: FnMut(Name, Namespace, &NameBinding<'a>)>(&self, mut f: F) {
- for (&(name, ns), name_binding) in self.children.borrow().iter() {
- if !name_binding.is_extern_crate() {
+ fn for_each_child<F: FnMut(Name, Namespace, &'a NameBinding<'a>)>(&self, mut f: F) {
+ for (&(name, ns), name_resolution) in self.children.borrow().iter() {
+ name_resolution.binding.map(|binding| f(name, ns, binding));
+ }
+ }
+
+ fn for_each_local_child<F: FnMut(Name, Namespace, &'a NameBinding<'a>)>(&self, mut f: F) {
+ self.for_each_child(|name, ns, name_binding| {
+ if !name_binding.is_import() && !name_binding.is_extern_crate() {
f(name, ns, name_binding)
}
- }
+ })
}
fn def_id(&self) -> Option<DefId> {
// Variants are considered `PUBLIC`, but some of them live in private enums.
// We need to track them to prohibit reexports like `pub use PrivEnum::Variant`.
const PRIVATE_VARIANT = 1 << 2,
+ const PRELUDE = 1 << 3,
+ const GLOB_IMPORTED = 1 << 4,
}
}
// Records a possibly-private value, type, or module definition.
-#[derive(Clone, Debug)]
+#[derive(Debug)]
pub struct NameBinding<'a> {
- modifiers: DefModifiers, // see note in ImportResolution about how to use this
- def_or_module: DefOrModule<'a>,
+ modifiers: DefModifiers,
+ kind: NameBindingKind<'a>,
span: Option<Span>,
}
-#[derive(Clone, Debug)]
-enum DefOrModule<'a> {
+#[derive(Debug)]
+enum NameBindingKind<'a> {
Def(Def),
Module(Module<'a>),
+ Import {
+ binding: &'a NameBinding<'a>,
+ id: NodeId,
+ },
}
impl<'a> NameBinding<'a> {
DefModifiers::empty()
} | DefModifiers::IMPORTABLE;
- NameBinding { modifiers: modifiers, def_or_module: DefOrModule::Module(module), span: span }
+ NameBinding { modifiers: modifiers, kind: NameBindingKind::Module(module), span: span }
}
fn module(&self) -> Option<Module<'a>> {
- match self.def_or_module {
- DefOrModule::Module(ref module) => Some(module),
- DefOrModule::Def(_) => None,
+ match self.kind {
+ NameBindingKind::Module(module) => Some(module),
+ NameBindingKind::Def(_) => None,
+ NameBindingKind::Import { binding, .. } => binding.module(),
}
}
fn def(&self) -> Option<Def> {
- match self.def_or_module {
- DefOrModule::Def(def) => Some(def),
- DefOrModule::Module(ref module) => module.def,
+ match self.kind {
+ NameBindingKind::Def(def) => Some(def),
+ NameBindingKind::Module(module) => module.def,
+ NameBindingKind::Import { binding, .. } => binding.def(),
}
}
fn is_extern_crate(&self) -> bool {
self.module().map(|module| module.is_extern_crate).unwrap_or(false)
}
+
+ fn is_import(&self) -> bool {
+ match self.kind {
+ NameBindingKind::Import { .. } => true,
+ _ => false,
+ }
+ }
}
/// Interns the names of the primitive types.
table.intern("bool", TyBool);
table.intern("char", TyChar);
- table.intern("f32", TyFloat(TyF32));
- table.intern("f64", TyFloat(TyF64));
- table.intern("isize", TyInt(TyIs));
- table.intern("i8", TyInt(TyI8));
- table.intern("i16", TyInt(TyI16));
- table.intern("i32", TyInt(TyI32));
- table.intern("i64", TyInt(TyI64));
+ table.intern("f32", TyFloat(FloatTy::F32));
+ table.intern("f64", TyFloat(FloatTy::F64));
+ table.intern("isize", TyInt(IntTy::Is));
+ table.intern("i8", TyInt(IntTy::I8));
+ table.intern("i16", TyInt(IntTy::I16));
+ table.intern("i32", TyInt(IntTy::I32));
+ table.intern("i64", TyInt(IntTy::I64));
table.intern("str", TyStr);
- table.intern("usize", TyUint(TyUs));
- table.intern("u8", TyUint(TyU8));
- table.intern("u16", TyUint(TyU16));
- table.intern("u32", TyUint(TyU32));
- table.intern("u64", TyUint(TyU64));
+ table.intern("usize", TyUint(UintTy::Us));
+ table.intern("u8", TyUint(UintTy::U8));
+ table.intern("u16", TyUint(UintTy::U16));
+ table.intern("u32", TyUint(UintTy::U32));
+ table.intern("u64", TyUint(UintTy::U64));
table
}
pub struct ResolverArenas<'a> {
modules: arena::TypedArena<ModuleS<'a>>,
+ name_bindings: arena::TypedArena<NameBinding<'a>>,
}
#[derive(PartialEq)]
fn arenas() -> ResolverArenas<'a> {
ResolverArenas {
modules: arena::TypedArena::new(),
+ name_bindings: arena::TypedArena::new(),
}
}
self.arenas.modules.alloc(ModuleS::new(parent_link, def, external, is_public))
}
+ fn new_name_binding(&self, name_binding: NameBinding<'a>) -> &'a NameBinding<'a> {
+ self.arenas.name_bindings.alloc(name_binding)
+ }
+
fn new_extern_crate_module(&self, parent_link: ParentLink<'a>, def: Def) -> Module<'a> {
let mut module = ModuleS::new(parent_link, Some(def), false, true);
module.is_extern_crate = true;
}
#[inline]
- fn record_import_use(&mut self, name: Name, ns: Namespace, resolution: &ImportResolution<'a>) {
- let import_id = resolution.id;
- self.used_imports.insert((import_id, ns));
- match resolution.target.as_ref().and_then(|target| target.target_module.def_id()) {
- Some(DefId { krate, .. }) => { self.used_crates.insert(krate); }
- _ => {}
+ fn record_use(&mut self, name: Name, ns: Namespace, binding: &'a NameBinding<'a>) {
+ // track extern crates for unused_extern_crate lint
+ if let Some(DefId { krate, .. }) = binding.module().and_then(ModuleS::def_id) {
+ self.used_crates.insert(krate);
+ }
+
+ let import_id = match binding.kind {
+ NameBindingKind::Import { id, .. } => id,
+ _ => return,
};
+ self.used_imports.insert((import_id, ns));
+
if !self.make_glob_map {
return;
}
lp: LastPrivate)
-> ResolveResult<(Module<'a>, LastPrivate)> {
fn search_parent_externals<'a>(needle: Name, module: Module<'a>) -> Option<Module<'a>> {
- match module.get_child(needle, TypeNS) {
- Some(ref binding) if binding.is_extern_crate() => Some(module),
+ match module.resolve_name(needle, TypeNS, false) {
+ Success(binding) if binding.is_extern_crate() => Some(module),
_ => match module.parent_link {
ModuleParentLink(ref parent, _) => {
search_parent_externals(needle, parent)
name);
return Indeterminate;
}
- Success((target, used_proxy)) => {
+ Success(binding) => {
// Check to see whether there are type bindings, and, if
// so, whether there is a module within.
- if let Some(module_def) = target.binding.module() {
- // track extern crates for unused_extern_crate lint
- if let Some(did) = module_def.def_id() {
- self.used_crates.insert(did.krate);
- }
-
+ if let Some(module_def) = binding.module() {
search_module = module_def;
// Keep track of the closest private module used
// when resolving this import chain.
- if !used_proxy && !search_module.is_public {
+ if !binding.is_public() {
if let Some(did) = search_module.def_id() {
closest_private = LastMod(DependsOn(did));
}
debug!("(resolving module path for import) indeterminate; bailing");
return Indeterminate;
}
- Success((target, _)) => match target.binding.module() {
+ Success(binding) => match binding.module() {
Some(containing_module) => {
search_module = containing_module;
start_index = 1;
name: Name,
namespace: Namespace,
record_used: bool)
- -> ResolveResult<(Target<'a>, bool)> {
+ -> ResolveResult<&'a NameBinding<'a>> {
debug!("(resolving item in lexical scope) resolving `{}` in namespace {:?} in `{}`",
name,
namespace,
debug!("(resolving item in lexical scope) indeterminate higher scope; bailing");
return Indeterminate;
}
- Success((target, used_reexport)) => {
+ Success(binding) => {
// We found the module.
debug!("(resolving item in lexical scope) found name in module, done");
- return Success((target, used_reexport));
+ return Success(binding);
}
}
}
/// Attempts to resolve the supplied name in the given module for the
- /// given namespace. If successful, returns the target corresponding to
+ /// given namespace. If successful, returns the binding corresponding to
/// the name.
- ///
- /// The boolean returned on success is an indicator of whether this lookup
- /// passed through a public re-export proxy.
fn resolve_name_in_module(&mut self,
- module_: Module<'a>,
+ module: Module<'a>,
name: Name,
namespace: Namespace,
allow_private_imports: bool,
record_used: bool)
- -> ResolveResult<(Target<'a>, bool)> {
- debug!("(resolving name in module) resolving `{}` in `{}`",
- name,
- module_to_string(&*module_));
+ -> ResolveResult<&'a NameBinding<'a>> {
+ debug!("(resolving name in module) resolving `{}` in `{}`", name, module_to_string(module));
- // First, check the direct children of the module.
- build_reduced_graph::populate_module_if_necessary(self, module_);
-
- if let Some(binding) = module_.get_child(name, namespace) {
- debug!("(resolving name in module) found node as child");
- return Success((Target::new(module_, binding, Shadowable::Never), false));
- }
-
- // Check the list of resolved imports.
- match module_.import_resolutions.borrow().get(&(name, namespace)) {
- Some(import_resolution) if allow_private_imports || import_resolution.is_public => {
- if import_resolution.is_public && import_resolution.outstanding_references != 0 {
- debug!("(resolving name in module) import unresolved; bailing out");
- return Indeterminate;
- }
- if let Some(target) = import_resolution.target.clone() {
- debug!("(resolving name in module) resolved to import");
- if record_used {
- self.record_import_use(name, namespace, &import_resolution);
- }
- return Success((target, true));
- }
+ build_reduced_graph::populate_module_if_necessary(self, module);
+ module.resolve_name(name, namespace, allow_private_imports).and_then(|binding| {
+ if record_used {
+ self.record_use(name, namespace, binding);
}
- Some(..) | None => {} // Continue.
- }
-
- // We're out of luck.
- debug!("(resolving name in module) failed to resolve `{}`", name);
- return Failed(None);
+ Success(binding)
+ })
}
fn report_unresolved_imports(&mut self, module_: Module<'a>) {
Some(name) => {
build_reduced_graph::populate_module_if_necessary(self, &orig_module);
- match orig_module.get_child(name, TypeNS) {
- None => {
- debug!("!!! (with scope) didn't find `{}` in `{}`",
- name,
- module_to_string(&*orig_module));
- }
- Some(name_binding) => {
- match name_binding.module() {
- None => {
- debug!("!!! (with scope) didn't find module for `{}` in `{}`",
- name,
- module_to_string(&*orig_module));
- }
- Some(module_) => {
- self.current_module = module_;
- }
+ if let Success(name_binding) = orig_module.resolve_name(name, TypeNS, false) {
+ match name_binding.module() {
+ None => {
+ debug!("!!! (with scope) didn't find module for `{}` in `{}`",
+ name,
+ module_to_string(orig_module));
+ }
+ Some(module) => {
+ self.current_module = module;
}
}
}
-> BareIdentifierPatternResolution {
let module = self.current_module;
match self.resolve_item_in_lexical_scope(module, name, ValueNS, true) {
- Success((target, _)) => {
+ Success(binding) => {
debug!("(resolve bare identifier pattern) succeeded in finding {} at {:?}",
name,
- &target.binding);
- match target.binding.def() {
+ binding);
+ match binding.def() {
None => {
panic!("resolved name in the value namespace to a set of name bindings \
with no def?!");
let module = self.current_module;
let name = identifier.unhygienic_name;
match self.resolve_item_in_lexical_scope(module, name, namespace, record_used) {
- Success((target, _)) => target.binding.def().map(LocalDef::from_def),
+ Success(binding) => binding.def().map(LocalDef::from_def),
Failed(Some((span, msg))) => {
resolve_error(self, span, ResolutionError::FailedToResolve(&*msg));
None
let name = segments.last().unwrap().identifier.name;
let result = self.resolve_name_in_module(containing_module, name, namespace, false, true);
let def = match result {
- Success((Target { binding, .. }, _)) => {
+ Success(binding) => {
let (def, lp) = binding.def_and_lp();
(def, last_private.or(lp))
}
_ => return None,
};
- if let Some(DefId{krate: kid, ..}) = containing_module.def_id() {
- self.used_crates.insert(kid);
- }
return Some(def);
}
let name = segments.last().unwrap().identifier.name;
match self.resolve_name_in_module(containing_module, name, namespace, false, true) {
- Success((Target { binding, .. }, _)) => {
+ Success(binding) => {
let (def, lp) = binding.def_and_lp();
Some((def, last_private.or(lp)))
}
}
if let AnonymousModuleRibKind(module) = self.get_ribs(namespace)[i].kind {
- if let Success((target, _)) = self.resolve_name_in_module(module,
- ident.unhygienic_name,
- namespace,
- true,
- true) {
- if let Some(def) = target.binding.def() {
+ if let Success(binding) = self.resolve_name_in_module(module,
+ ident.unhygienic_name,
+ namespace,
+ true,
+ true) {
+ if let Some(def) = binding.def() {
return Some(LocalDef::from_def(def));
}
}
if name_path.len() == 1 {
match this.primitive_type_table.primitive_types.get(last_name) {
Some(_) => None,
- None => this.current_module.get_child(*last_name, TypeNS)
- .as_ref()
+ None => this.current_module.resolve_name(*last_name, TypeNS, true).success()
.and_then(NameBinding::module)
}
} else {
// Look for a method in the current self type's impl module.
if let Some(module) = get_module(self, path.span, &name_path) {
- if let Some(binding) = module.get_child(name, ValueNS) {
+ if let Success(binding) = module.resolve_name(name, ValueNS, true) {
if let Some(Def::Method(did)) = binding.def() {
if is_static_method(self, did) {
return StaticMethod(path_names_to_string(&path, 0));
// Look for trait children.
build_reduced_graph::populate_module_if_necessary(self, &search_module);
- for (&(_, ns), name_binding) in search_module.children.borrow().iter() {
- if ns != TypeNS { continue }
+ search_module.for_each_child(|_, ns, name_binding| {
+ if ns != TypeNS { return }
let trait_def_id = match name_binding.def() {
Some(Def::Trait(trait_def_id)) => trait_def_id,
- Some(..) | None => continue,
+ Some(..) | None => return,
};
if self.trait_item_map.contains_key(&(name, trait_def_id)) {
add_trait_info(&mut found_traits, trait_def_id, name);
+ let trait_name = self.get_trait_name(trait_def_id);
+ self.record_use(trait_name, TypeNS, name_binding);
}
- }
+ });
- // Look for imports.
- for (&(_, ns), import) in search_module.import_resolutions.borrow().iter() {
- if ns != TypeNS { continue }
- let target = match import.target {
- Some(ref target) => target,
- None => continue,
- };
- let did = match target.binding.def() {
- Some(Def::Trait(trait_def_id)) => trait_def_id,
- Some(..) | None => continue,
- };
+ // Look for shadowed traits.
+ for binding in search_module.shadowed_traits.borrow().iter() {
+ let did = binding.def().unwrap().def_id();
if self.trait_item_map.contains_key(&(name, did)) {
add_trait_info(&mut found_traits, did, name);
let trait_name = self.get_trait_name(did);
- self.record_import_use(trait_name, TypeNS, &import);
+ self.record_use(trait_name, TypeNS, binding);
}
}
use self::ImportDirectiveSubclass::*;
use DefModifiers;
-use DefOrModule;
use Module;
use Namespace::{self, TypeNS, ValueNS};
-use NameBinding;
+use {NameBinding, NameBindingKind};
use ResolveResult;
use ResolveResult::*;
use Resolver;
use rustc::lint;
use rustc::middle::def::*;
-use rustc::middle::def_id::DefId;
use rustc::middle::privacy::*;
use syntax::ast::{NodeId, Name};
shadowable: shadowable,
}
}
-}
-/// The item that an import resolves to.
-#[derive(Clone,Debug)]
-pub struct Target<'a> {
- pub target_module: Module<'a>,
- pub binding: NameBinding<'a>,
- pub shadowable: Shadowable,
-}
+ // Given the binding to which this directive resolves in a particular namespace,
+ // this returns the binding for the name this directive defines in that namespace.
+ fn import<'a>(&self, binding: &'a NameBinding<'a>) -> NameBinding<'a> {
+ let mut modifiers = match self.is_public {
+ true => DefModifiers::PUBLIC | DefModifiers::IMPORTABLE,
+ false => DefModifiers::empty(),
+ };
+ if let GlobImport = self.subclass {
+ modifiers = modifiers | DefModifiers::GLOB_IMPORTED;
+ }
+ if self.shadowable == Shadowable::Always {
+ modifiers = modifiers | DefModifiers::PRELUDE;
+ }
-impl<'a> Target<'a> {
- pub fn new(target_module: Module<'a>, binding: NameBinding<'a>, shadowable: Shadowable)
- -> Self {
- Target {
- target_module: target_module,
- binding: binding,
- shadowable: shadowable,
+ NameBinding {
+ kind: NameBindingKind::Import { binding: binding, id: self.id },
+ span: Some(self.span),
+ modifiers: modifiers,
}
}
}
-#[derive(Debug)]
-/// An ImportResolution records what we know about an imported name in a given namespace.
-/// More specifically, it records the number of unresolved `use` directives that import the name,
-/// the `use` directive importing the name in the namespace, and the `NameBinding` to which the
-/// name in the namespace resolves (if applicable).
-/// Different `use` directives may import the same name in different namespaces.
-pub struct ImportResolution<'a> {
- // When outstanding_references reaches zero, outside modules can count on the targets being
- // correct. Before then, all bets are off; future `use` directives could override the name.
- // Since shadowing is forbidden, the only way outstanding_references > 1 in a legal program
- // is if the name is imported by exactly two `use` directives, one of which resolves to a
- // value and the other of which resolves to a type.
+#[derive(Clone, Default)]
+/// Records information about the resolution of a name in a module.
+pub struct NameResolution<'a> {
+ /// The number of unresolved single imports that could define the name.
pub outstanding_references: usize,
-
- /// Whether this resolution came from a `use` or a `pub use`.
- pub is_public: bool,
-
- /// Resolution of the name in the namespace
- pub target: Option<Target<'a>>,
-
- /// The source node of the `use` directive
- pub id: NodeId,
+ /// The least shadowable known binding for this name, or None if there are no known bindings.
+ pub binding: Option<&'a NameBinding<'a>>,
}
-impl<'a> ImportResolution<'a> {
- pub fn new(id: NodeId, is_public: bool) -> Self {
- ImportResolution {
- outstanding_references: 0,
- id: id,
- target: None,
- is_public: is_public,
+impl<'a> NameResolution<'a> {
+ pub fn result(&self, outstanding_globs: usize) -> ResolveResult<&'a NameBinding<'a>> {
+ // If no unresolved imports (single or glob) can define the name, self.binding is final.
+ if self.outstanding_references == 0 && outstanding_globs == 0 {
+ return self.binding.map(Success).unwrap_or(Failed(None));
+ }
+
+ if let Some(binding) = self.binding {
+ // Single imports will never be shadowable by other single or glob imports.
+ if !binding.defined_with(DefModifiers::GLOB_IMPORTED) { return Success(binding); }
+ // Non-PRELUDE glob imports will never be shadowable by other glob imports.
+ if self.outstanding_references == 0 && !binding.defined_with(DefModifiers::PRELUDE) {
+ return Success(binding);
+ }
}
+
+ Indeterminate
}
- pub fn shadowable(&self) -> Shadowable {
- match self.target {
- Some(ref target) => target.shadowable,
- None => Shadowable::Always,
+ // Define the name or return the existing binding if there is a collision.
+ pub fn try_define(&mut self, binding: &'a NameBinding<'a>) -> Result<(), &'a NameBinding<'a>> {
+ let is_prelude = |binding: &NameBinding| binding.defined_with(DefModifiers::PRELUDE);
+ let old_binding = match self.binding {
+ Some(_) if is_prelude(binding) => return Ok(()),
+ Some(old_binding) if !is_prelude(old_binding) => old_binding,
+ _ => { self.binding = Some(binding); return Ok(()); }
+ };
+
+ // FIXME #31337: We currently allow items to shadow glob-imported re-exports.
+ if !old_binding.is_import() && binding.defined_with(DefModifiers::GLOB_IMPORTED) {
+ if let NameBindingKind::Import { binding, .. } = binding.kind {
+ if binding.is_import() { return Ok(()); }
+ }
}
+
+ Err(old_binding)
}
}
/// Resolves an `ImportResolvingError` into the correct enum discriminant
/// and passes that on to `resolve_error`.
- fn import_resolving_error(&self, e: ImportResolvingError) {
+ fn import_resolving_error(&self, e: ImportResolvingError<'b>) {
// If it's a single failed import then create a "fake" import
// resolution for it so that later resolve stages won't complain.
if let SingleImport(target, _) = e.import_directive.subclass {
- let mut import_resolutions = e.source_module.import_resolutions.borrow_mut();
-
- let resolution = import_resolutions.entry((target, ValueNS)).or_insert_with(|| {
- debug!("(resolving import error) adding import resolution for `{}`",
- target);
-
- ImportResolution::new(e.import_directive.id,
- e.import_directive.is_public)
+ let dummy_binding = self.resolver.new_name_binding(NameBinding {
+ modifiers: DefModifiers::PRELUDE,
+ kind: NameBindingKind::Def(Def::Err),
+ span: None,
});
- if resolution.target.is_none() {
- debug!("(resolving import error) adding fake target to import resolution of `{}`",
- target);
-
- let name_binding = NameBinding {
- modifiers: DefModifiers::IMPORTABLE,
- def_or_module: DefOrModule::Def(Def::Err),
- span: None,
- };
-
- // Create a fake target pointing to a fake name binding in our
- // own module
- let target = Target::new(e.source_module,
- name_binding,
- Shadowable::Always);
-
- resolution.target = Some(target);
- }
+ let _ = e.source_module.try_define_child(target, ValueNS, dummy_binding);
+ let _ = e.source_module.try_define_child(target, TypeNS, dummy_binding);
}
let path = import_path_to_string(&e.import_directive.module_path,
})
}
- /// Resolves the name in the namespace of the module because it is being imported by
- /// importing_module. Returns the module in which the name was defined (as opposed to imported),
- /// the name bindings defining the name, and whether or not the name was imported into `module`.
- fn resolve_name_in_module(&mut self,
- module: Module<'b>, // Module containing the name
- name: Name,
- ns: Namespace,
- importing_module: Module<'b>) // Module importing the name
- -> (ResolveResult<(Module<'b>, NameBinding<'b>)>, bool) {
- build_reduced_graph::populate_module_if_necessary(self.resolver, module);
- if let Some(name_binding) = module.get_child(name, ns) {
- if name_binding.is_extern_crate() {
- // track the extern crate as used.
- if let Some(DefId { krate, .. }) = name_binding.module().unwrap().def_id() {
- self.resolver.used_crates.insert(krate);
- }
- }
- return (Success((module, name_binding)), false)
- }
-
- // If there is an unresolved glob at this point in the containing module, bail out.
- // We don't know enough to be able to resolve the name.
- if module.pub_glob_count.get() > 0 {
- return (Indeterminate, false);
- }
-
- match module.import_resolutions.borrow().get(&(name, ns)) {
- // The containing module definitely doesn't have an exported import with the
- // name in question. We can therefore accurately report that names are unbound.
- None => (Failed(None), false),
-
- // The name is an import which has been fully resolved, so we just follow it.
- Some(resolution) if resolution.outstanding_references == 0 => {
- // Import resolutions must be declared with "pub" in order to be exported.
- if !resolution.is_public {
- return (Failed(None), false);
- }
-
- let target = resolution.target.clone();
- if let Some(Target { target_module, binding, shadowable: _ }) = target {
- self.resolver.record_import_use(name, ns, &resolution);
- (Success((target_module, binding)), true)
- } else {
- (Failed(None), false)
- }
- }
-
- // If module is the same module whose import we are resolving and
- // it has an unresolved import with the same name as `name`, then the user
- // is actually trying to import an item that is declared in the same scope
- //
- // e.g
- // use self::submodule;
- // pub mod submodule;
- //
- // In this case we continue as if we resolved the import and let
- // check_for_conflicts_between_imports_and_items handle the conflict
- Some(_) => match (importing_module.def_id(), module.def_id()) {
- (Some(id1), Some(id2)) if id1 == id2 => (Failed(None), false),
- _ => (Indeterminate, false)
- },
- }
- }
-
fn resolve_single_import(&mut self,
module_: Module<'b>,
target_module: Module<'b>,
}
};
+ // If this is a circular import, we temporarily count it as determined so that
+ // it fails (as opposed to being indeterminate) when nothing else can define it.
+ if target_module.def_id() == module_.def_id() && source == target {
+ module_.decrement_outstanding_references_for(target, ValueNS);
+ module_.decrement_outstanding_references_for(target, TypeNS);
+ }
+
// We need to resolve both namespaces for this to succeed.
- let (value_result, value_used_reexport) =
- self.resolve_name_in_module(target_module, source, ValueNS, module_);
- let (type_result, type_used_reexport) =
- self.resolve_name_in_module(target_module, source, TypeNS, module_);
+ let value_result =
+ self.resolver.resolve_name_in_module(target_module, source, ValueNS, false, true);
+ let type_result =
+ self.resolver.resolve_name_in_module(target_module, source, TypeNS, false, true);
+
+ if target_module.def_id() == module_.def_id() && source == target {
+ module_.increment_outstanding_references_for(target, ValueNS);
+ module_.increment_outstanding_references_for(target, TypeNS);
+ }
match (&value_result, &type_result) {
- (&Success((_, ref name_binding)), _) if !value_used_reexport &&
- directive.is_public &&
- !name_binding.is_public() => {
+ (&Success(name_binding), _) if !name_binding.is_import() &&
+ directive.is_public &&
+ !name_binding.is_public() => {
let msg = format!("`{}` is private, and cannot be reexported", source);
let note_msg = format!("Consider marking `{}` as `pub` in the imported module",
source);
.emit();
}
- (_, &Success((_, ref name_binding))) if !type_used_reexport &&
- directive.is_public => {
+ (_, &Success(name_binding)) if !name_binding.is_import() && directive.is_public => {
if !name_binding.is_public() {
let msg = format!("`{}` is private, and cannot be reexported", source);
let note_msg =
_ => {}
}
- let mut lev_suggestion = "".to_owned();
match (&value_result, &type_result) {
(&Indeterminate, _) | (_, &Indeterminate) => return Indeterminate,
(&Failed(_), &Failed(_)) => {
let children = target_module.children.borrow();
let names = children.keys().map(|&(ref name, _)| name);
- if let Some(name) = find_best_match_for_name(names, &source.as_str(), None) {
- lev_suggestion = format!(". Did you mean to use `{}`?", name);
- } else {
- let resolutions = target_module.import_resolutions.borrow();
- let names = resolutions.keys().map(|&(ref name, _)| name);
- if let Some(name) = find_best_match_for_name(names,
- &source.as_str(),
- None) {
- lev_suggestion =
- format!(". Did you mean to use the re-exported import `{}`?", name);
- }
- }
+ let lev_suggestion = match find_best_match_for_name(names, &source.as_str(), None) {
+ Some(name) => format!(". Did you mean to use `{}`?", name),
+ None => "".to_owned(),
+ };
+ let msg = format!("There is no `{}` in `{}`{}",
+ source,
+ module_to_string(target_module), lev_suggestion);
+ return Failed(Some((directive.span, msg)));
}
_ => (),
}
- let mut value_used_public = false;
- let mut type_used_public = false;
-
- // We've successfully resolved the import. Write the results in.
- let mut import_resolutions = module_.import_resolutions.borrow_mut();
-
- {
- let mut check_and_write_import = |namespace, result, used_public: &mut bool| {
- let result: &ResolveResult<(Module<'b>, NameBinding)> = result;
-
- let import_resolution = import_resolutions.get_mut(&(target, namespace)).unwrap();
- let namespace_name = match namespace {
- TypeNS => "type",
- ValueNS => "value",
- };
-
- match *result {
- Success((ref target_module, ref name_binding)) => {
- debug!("(resolving single import) found {:?} target: {:?}",
- namespace_name,
- name_binding.def());
- self.check_for_conflicting_import(&import_resolution,
- directive.span,
- target,
- namespace);
-
- self.check_that_import_is_importable(&name_binding,
- directive.span,
- target);
-
- import_resolution.target = Some(Target::new(target_module,
- name_binding.clone(),
- directive.shadowable));
- import_resolution.id = directive.id;
- import_resolution.is_public = directive.is_public;
-
- self.add_export(module_, target, &import_resolution);
- *used_public = name_binding.is_public();
- }
- Failed(_) => {
- // Continue.
- }
- Indeterminate => {
- panic!("{:?} result should be known at this point", namespace_name);
- }
+ for &(ns, result) in &[(ValueNS, &value_result), (TypeNS, &type_result)] {
+ if let Success(binding) = *result {
+ if !binding.defined_with(DefModifiers::IMPORTABLE) {
+ let msg = format!("`{}` is not directly importable", target);
+ span_err!(self.resolver.session, directive.span, E0253, "{}", &msg);
}
- self.check_for_conflicts_between_imports_and_items(module_,
- import_resolution,
- directive.span,
- (target, namespace));
- };
- check_and_write_import(ValueNS, &value_result, &mut value_used_public);
- check_and_write_import(TypeNS, &type_result, &mut type_used_public);
- }
-
- if let (&Failed(_), &Failed(_)) = (&value_result, &type_result) {
- let msg = format!("There is no `{}` in `{}`{}",
- source,
- module_to_string(target_module), lev_suggestion);
- return Failed(Some((directive.span, msg)));
+ self.define(module_, target, ns, directive.import(binding));
+ }
}
- let value_used_public = value_used_reexport || value_used_public;
- let type_used_public = type_used_reexport || type_used_public;
-
- let value_def_and_priv = {
- let import_resolution_value = import_resolutions.get_mut(&(target, ValueNS)).unwrap();
- assert!(import_resolution_value.outstanding_references >= 1);
- import_resolution_value.outstanding_references -= 1;
-
- // Record what this import resolves to for later uses in documentation,
- // this may resolve to either a value or a type, but for documentation
- // purposes it's good enough to just favor one over the other.
- import_resolution_value.target.as_ref().map(|target| {
- let def = target.binding.def().unwrap();
- let last_private = if value_used_public { lp } else { DependsOn(def.def_id()) };
- (def, last_private)
- })
- };
-
- let type_def_and_priv = {
- let import_resolution_type = import_resolutions.get_mut(&(target, TypeNS)).unwrap();
- assert!(import_resolution_type.outstanding_references >= 1);
- import_resolution_type.outstanding_references -= 1;
+ // Record what this import resolves to for later uses in documentation,
+ // this may resolve to either a value or a type, but for documentation
+ // purposes it's good enough to just favor one over the other.
+ module_.decrement_outstanding_references_for(target, ValueNS);
+ module_.decrement_outstanding_references_for(target, TypeNS);
- import_resolution_type.target.as_ref().map(|target| {
- let def = target.binding.def().unwrap();
- let last_private = if type_used_public { lp } else { DependsOn(def.def_id()) };
- (def, last_private)
- })
+ let def_and_priv = |binding: &NameBinding| {
+ let def = binding.def().unwrap();
+ let last_private = if binding.is_public() { lp } else { DependsOn(def.def_id()) };
+ (def, last_private)
};
+ let value_def_and_priv = value_result.success().map(&def_and_priv);
+ let type_def_and_priv = type_result.success().map(&def_and_priv);
let import_lp = LastImport {
value_priv: value_def_and_priv.map(|(_, p)| p),
type_used: Used,
};
- if let Some((def, _)) = value_def_and_priv {
- self.resolver.def_map.borrow_mut().insert(directive.id,
- PathResolution {
- base_def: def,
- last_private: import_lp,
- depth: 0,
- });
- }
- if let Some((def, _)) = type_def_and_priv {
- self.resolver.def_map.borrow_mut().insert(directive.id,
- PathResolution {
- base_def: def,
- last_private: import_lp,
- depth: 0,
- });
- }
+ let write_path_resolution = |(def, _)| {
+ let path_resolution =
+ PathResolution { base_def: def, last_private: import_lp, depth: 0 };
+ self.resolver.def_map.borrow_mut().insert(directive.id, path_resolution);
+ };
+ value_def_and_priv.map(&write_path_resolution);
+ type_def_and_priv.map(&write_path_resolution);
debug!("(resolving single import) successfully resolved import");
return Success(());
fn resolve_glob_import(&mut self,
module_: Module<'b>,
target_module: Module<'b>,
- import_directive: &ImportDirective,
+ directive: &ImportDirective,
lp: LastPrivate)
-> ResolveResult<()> {
- let id = import_directive.id;
- let is_public = import_directive.is_public;
-
- // This function works in a highly imperative manner; it eagerly adds
- // everything it can to the list of import resolutions of the module
- // node.
- debug!("(resolving glob import) resolving glob import {}", id);
-
- // We must bail out if the node has unresolved imports of any kind
- // (including globs).
- if (*target_module).pub_count.get() > 0 {
+ // We must bail out if the node has unresolved imports of any kind (including globs).
+ if target_module.pub_count.get() > 0 {
debug!("(resolving glob import) target module has unresolved pub imports; bailing out");
- return ResolveResult::Indeterminate;
- }
-
- // Add all resolved imports from the containing module.
- let import_resolutions = target_module.import_resolutions.borrow();
-
- if module_.import_resolutions.borrow_state() != ::std::cell::BorrowState::Unused {
- // In this case, target_module == module_
- // This means we are trying to glob import a module into itself,
- // and it is a no-go
- debug!("(resolving glob imports) target module is current module; giving up");
- return ResolveResult::Failed(Some((import_directive.span,
- "Cannot glob-import a module into itself.".into())));
+ return Indeterminate;
}
- for (&(name, ns), target_import_resolution) in import_resolutions.iter() {
- debug!("(resolving glob import) writing module resolution {} into `{}`",
- name,
- module_to_string(module_));
-
- // Here we merge two import resolutions.
- let mut import_resolutions = module_.import_resolutions.borrow_mut();
- let mut dest_import_resolution =
- import_resolutions.entry((name, ns))
- .or_insert_with(|| ImportResolution::new(id, is_public));
-
- match target_import_resolution.target {
- Some(ref target) if target_import_resolution.is_public => {
- self.check_for_conflicting_import(&dest_import_resolution,
- import_directive.span,
- name,
- ns);
- dest_import_resolution.id = id;
- dest_import_resolution.is_public = is_public;
- dest_import_resolution.target = Some(target.clone());
- self.add_export(module_, name, &dest_import_resolution);
- }
- _ => {}
- }
+ if module_.def_id() == target_module.def_id() {
+ // This means we are trying to glob import a module into itself, and it is a no-go
+ let msg = "Cannot glob-import a module into itself.".into();
+ return Failed(Some((directive.span, msg)));
}
// Add all children from the containing module.
build_reduced_graph::populate_module_if_necessary(self.resolver, target_module);
-
- target_module.for_each_local_child(|name, ns, name_binding| {
- self.merge_import_resolution(module_,
- target_module,
- import_directive,
- (name, ns),
- name_binding.clone());
+ target_module.for_each_child(|name, ns, binding| {
+ if !binding.defined_with(DefModifiers::IMPORTABLE | DefModifiers::PUBLIC) { return }
+ self.define(module_, name, ns, directive.import(binding));
+
+ if ns == TypeNS && directive.is_public &&
+ binding.defined_with(DefModifiers::PRIVATE_VARIANT) {
+ let msg = format!("variant `{}` is private, and cannot be reexported (error \
+ E0364), consider declaring its enum as `pub`", name);
+ self.resolver.session.add_lint(lint::builtin::PRIVATE_IN_PUBLIC,
+ directive.id,
+ directive.span,
+ msg);
+ }
});
// Record the destination of this import
if let Some(did) = target_module.def_id() {
- self.resolver.def_map.borrow_mut().insert(id,
+ self.resolver.def_map.borrow_mut().insert(directive.id,
PathResolution {
base_def: Def::Mod(did),
last_private: lp,
}
debug!("(resolving glob import) successfully resolved import");
- return ResolveResult::Success(());
- }
-
- fn merge_import_resolution(&mut self,
- module_: Module<'b>,
- containing_module: Module<'b>,
- import_directive: &ImportDirective,
- (name, ns): (Name, Namespace),
- name_binding: NameBinding<'b>) {
- let id = import_directive.id;
- let is_public = import_directive.is_public;
-
- let mut import_resolutions = module_.import_resolutions.borrow_mut();
- let dest_import_resolution = import_resolutions.entry((name, ns)).or_insert_with(|| {
- ImportResolution::new(id, is_public)
- });
-
- debug!("(resolving glob import) writing resolution `{}` in `{}` to `{}`",
- name,
- module_to_string(&*containing_module),
- module_to_string(module_));
-
- // Merge the child item into the import resolution.
- let modifier = DefModifiers::IMPORTABLE | DefModifiers::PUBLIC;
-
- if ns == TypeNS && is_public && name_binding.defined_with(DefModifiers::PRIVATE_VARIANT) {
- let msg = format!("variant `{}` is private, and cannot be reexported (error \
- E0364), consider declaring its enum as `pub`", name);
- self.resolver.session.add_lint(lint::builtin::PRIVATE_IN_PUBLIC,
- import_directive.id,
- import_directive.span,
- msg);
- }
-
- if name_binding.defined_with(modifier) {
- let namespace_name = match ns {
- TypeNS => "type",
- ValueNS => "value",
- };
- debug!("(resolving glob import) ... for {} target", namespace_name);
- if dest_import_resolution.shadowable() == Shadowable::Never {
- let msg = format!("a {} named `{}` has already been imported in this module",
- namespace_name,
- name);
- span_err!(self.resolver.session, import_directive.span, E0251, "{}", msg);
- } else {
- let target = Target::new(containing_module,
- name_binding.clone(),
- import_directive.shadowable);
- dest_import_resolution.target = Some(target);
- dest_import_resolution.id = id;
- dest_import_resolution.is_public = is_public;
- self.add_export(module_, name, &dest_import_resolution);
- }
- }
-
- self.check_for_conflicts_between_imports_and_items(module_,
- dest_import_resolution,
- import_directive.span,
- (name, ns));
- }
-
- fn add_export(&mut self, module: Module<'b>, name: Name, resolution: &ImportResolution<'b>) {
- if !resolution.is_public { return }
- let node_id = match module.def_id() {
- Some(def_id) => self.resolver.ast_map.as_local_node_id(def_id).unwrap(),
- None => return,
- };
- let export = match resolution.target.as_ref().unwrap().binding.def() {
- Some(def) => Export { name: name, def_id: def.def_id() },
- None => return,
- };
- self.resolver.export_map.entry(node_id).or_insert(Vec::new()).push(export);
+ return Success(());
}
- /// Checks that imported names and items don't have the same name.
- fn check_for_conflicting_import(&mut self,
- import_resolution: &ImportResolution,
- import_span: Span,
- name: Name,
- namespace: Namespace) {
- let target = &import_resolution.target;
- debug!("check_for_conflicting_import: {}; target exists: {}",
- name,
- target.is_some());
-
- match *target {
- Some(ref target) if target.shadowable != Shadowable::Always => {
- let ns_word = match namespace {
- TypeNS => {
- match target.binding.module() {
- Some(ref module) if module.is_normal() => "module",
- Some(ref module) if module.is_trait() => "trait",
- _ => "type",
- }
- }
- ValueNS => "value",
- };
- let use_id = import_resolution.id;
- let item = self.resolver.ast_map.expect_item(use_id);
- let mut err = struct_span_err!(self.resolver.session,
- import_span,
- E0252,
- "a {} named `{}` has already been imported \
- in this module",
- ns_word,
- name);
- span_note!(&mut err,
- item.span,
- "previous import of `{}` here",
- name);
- err.emit();
+ fn define(&mut self,
+ parent: Module<'b>,
+ name: Name,
+ ns: Namespace,
+ binding: NameBinding<'b>) {
+ let binding = self.resolver.new_name_binding(binding);
+ if let Err(old_binding) = parent.try_define_child(name, ns, binding) {
+ self.report_conflict(name, ns, binding, old_binding);
+ } else if binding.is_public() { // Add to the export map
+ if let (Some(parent_def_id), Some(def)) = (parent.def_id(), binding.def()) {
+ let parent_node_id = self.resolver.ast_map.as_local_node_id(parent_def_id).unwrap();
+ let export = Export { name: name, def_id: def.def_id() };
+ self.resolver.export_map.entry(parent_node_id).or_insert(Vec::new()).push(export);
}
- Some(_) | None => {}
}
}
- /// Checks that an import is actually importable
- fn check_that_import_is_importable(&mut self,
- name_binding: &NameBinding,
- import_span: Span,
- name: Name) {
- if !name_binding.defined_with(DefModifiers::IMPORTABLE) {
- let msg = format!("`{}` is not directly importable", name);
- span_err!(self.resolver.session, import_span, E0253, "{}", &msg[..]);
- }
- }
-
- /// Checks that imported names and items don't have the same name.
- fn check_for_conflicts_between_imports_and_items(&mut self,
- module: Module<'b>,
- import: &ImportResolution<'b>,
- import_span: Span,
- (name, ns): (Name, Namespace)) {
- // Check for item conflicts.
- let name_binding = match module.get_child(name, ns) {
- None => {
- // There can't be any conflicts.
- return;
- }
- Some(name_binding) => name_binding,
- };
-
- if ns == ValueNS {
- match import.target {
- Some(ref target) if target.shadowable != Shadowable::Always => {
- let mut err = struct_span_err!(self.resolver.session,
- import_span,
- E0255,
- "import `{}` conflicts with \
- value in this module",
- name);
- if let Some(span) = name_binding.span {
- err.span_note(span, "conflicting value here");
- }
- err.emit();
- }
- Some(_) | None => {}
- }
- } else {
- match import.target {
- Some(ref target) if target.shadowable != Shadowable::Always => {
- if name_binding.is_extern_crate() {
- let msg = format!("import `{0}` conflicts with imported crate \
- in this module (maybe you meant `use {0}::*`?)",
- name);
- span_err!(self.resolver.session, import_span, E0254, "{}", &msg[..]);
- return;
- }
-
- let (what, note) = match name_binding.module() {
- Some(ref module) if module.is_normal() =>
- ("existing submodule", "note conflicting module here"),
- Some(ref module) if module.is_trait() =>
- ("trait in this module", "note conflicting trait here"),
- _ => ("type in this module", "note conflicting type here"),
- };
- let mut err = struct_span_err!(self.resolver.session,
- import_span,
- E0256,
- "import `{}` conflicts with {}",
- name,
- what);
- if let Some(span) = name_binding.span {
- err.span_note(span, note);
- }
- err.emit();
- }
- Some(_) | None => {}
- }
+ fn report_conflict(&mut self,
+ name: Name,
+ ns: Namespace,
+ binding: &'b NameBinding<'b>,
+ old_binding: &'b NameBinding<'b>) {
+ if old_binding.is_extern_crate() {
+ let msg = format!("import `{0}` conflicts with imported crate \
+ in this module (maybe you meant `use {0}::*`?)",
+ name);
+ span_err!(self.resolver.session, binding.span.unwrap(), E0254, "{}", &msg);
+ } else if old_binding.is_import() {
+ let ns_word = match (ns, old_binding.module()) {
+ (ValueNS, _) => "value",
+ (TypeNS, Some(module)) if module.is_normal() => "module",
+ (TypeNS, Some(module)) if module.is_trait() => "trait",
+ (TypeNS, _) => "type",
+ };
+ let mut err = struct_span_err!(self.resolver.session,
+ binding.span.unwrap(),
+ E0252,
+ "a {} named `{}` has already been imported \
+ in this module",
+ ns_word,
+ name);
+ err.span_note(old_binding.span.unwrap(),
+ &format!("previous import of `{}` here", name));
+ err.emit();
+ } else if ns == ValueNS { // Check for item conflicts in the value namespace
+ let mut err = struct_span_err!(self.resolver.session,
+ binding.span.unwrap(),
+ E0255,
+ "import `{}` conflicts with value in this module",
+ name);
+ err.span_note(old_binding.span.unwrap(), "conflicting value here");
+ err.emit();
+ } else { // Check for item conflicts in the type namespace
+ let (what, note) = match old_binding.module() {
+ Some(ref module) if module.is_normal() =>
+ ("existing submodule", "note conflicting module here"),
+ Some(ref module) if module.is_trait() =>
+ ("trait in this module", "note conflicting trait here"),
+ _ => ("type in this module", "note conflicting type here"),
+ };
+ let mut err = struct_span_err!(self.resolver.session,
+ binding.span.unwrap(),
+ E0256,
+ "import `{}` conflicts with {}",
+ name,
+ what);
+ err.span_note(old_binding.span.unwrap(), note);
+ err.emit();
}
}
}
self.visit_ty(&arg.ty);
}
- if let ast::Return(ref ret_ty) = sig.decl.output {
+ if let ast::FunctionRetTy::Ty(ref ret_ty) = sig.decl.output {
self.visit_ty(ret_ty);
}
self.visit_ty(&arg.ty);
}
- if let ast::Return(ref ret_ty) = decl.output {
+ if let ast::FunctionRetTy::Ty(ref ret_ty) = decl.output {
self.visit_ty(&ret_ty);
}
self.visit_pat(&p);
for &(id, ref p, immut, _) in &collector.collected_paths {
- let value = if immut == ast::MutImmutable {
+ let value = if immut == ast::Mutability::Immutable {
value.to_string()
} else {
"<mutable>".to_string()
impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
fn visit_item(&mut self, item: &ast::Item) {
+ use syntax::ast::ItemKind::*;
self.process_macro_use(item.span, item.id);
match item.node {
- ast::ItemUse(ref use_item) => {
+ Use(ref use_item) => {
match use_item.node {
ast::ViewPathSimple(ident, ref path) => {
let sub_span = self.span.span_for_last_ident(path.span);
ast::ViewPathList(ref path, ref list) => {
for plid in list {
match plid.node {
- ast::PathListIdent { id, .. } => {
+ ast::PathListItemKind::Ident { id, .. } => {
match self.lookup_type_ref(id) {
Some(def_id) => match self.lookup_def_kind(id, plid.span) {
Some(kind) => {
None => (),
}
}
- ast::PathListMod { .. } => (),
+ ast::PathListItemKind::Mod { .. } => (),
}
}
}
}
}
- ast::ItemExternCrate(ref s) => {
+ ExternCrate(ref s) => {
let location = match *s {
Some(s) => s.to_string(),
None => item.ident.to_string(),
&location,
self.cur_scope);
}
- ast::ItemFn(ref decl, _, _, _, ref ty_params, ref body) =>
+ Fn(ref decl, _, _, _, ref ty_params, ref body) =>
self.process_fn(item, &**decl, ty_params, &**body),
- ast::ItemStatic(ref typ, _, ref expr) =>
+ Static(ref typ, _, ref expr) =>
self.process_static_or_const_item(item, typ, expr),
- ast::ItemConst(ref typ, ref expr) =>
+ Const(ref typ, ref expr) =>
self.process_static_or_const_item(item, &typ, &expr),
- ast::ItemStruct(ref def, ref ty_params) => self.process_struct(item, def, ty_params),
- ast::ItemEnum(ref def, ref ty_params) => self.process_enum(item, def, ty_params),
- ast::ItemImpl(_, _,
+ Struct(ref def, ref ty_params) => self.process_struct(item, def, ty_params),
+ Enum(ref def, ref ty_params) => self.process_enum(item, def, ty_params),
+ Impl(_, _,
ref ty_params,
ref trait_ref,
ref typ,
ref impl_items) => {
self.process_impl(item, ty_params, trait_ref, &typ, impl_items)
}
- ast::ItemTrait(_, ref generics, ref trait_refs, ref methods) =>
+ Trait(_, ref generics, ref trait_refs, ref methods) =>
self.process_trait(item, generics, trait_refs, methods),
- ast::ItemMod(ref m) => {
+ Mod(ref m) => {
self.process_mod(item);
self.nest(item.id, |v| visit::walk_mod(v, m));
}
- ast::ItemTy(ref ty, ref ty_params) => {
+ Ty(ref ty, ref ty_params) => {
let qualname = format!("::{}", self.tcx.map.path_to_string(item.id));
let value = ty_to_string(&**ty);
let sub_span = self.span.sub_span_after_keyword(item.span, keywords::Type);
self.visit_ty(&**ty);
self.process_generic_params(ty_params, item.span, &qualname, item.id);
}
- ast::ItemMac(_) => (),
+ Mac(_) => (),
_ => visit::walk_item(self, item),
}
}
fn visit_trait_item(&mut self, trait_item: &ast::TraitItem) {
self.process_macro_use(trait_item.span, trait_item.id);
match trait_item.node {
- ast::ConstTraitItem(ref ty, Some(ref expr)) => {
+ ast::TraitItemKind::Const(ref ty, Some(ref expr)) => {
self.process_const(trait_item.id,
trait_item.ident.name,
trait_item.span,
&*ty,
&*expr);
}
- ast::MethodTraitItem(ref sig, ref body) => {
+ ast::TraitItemKind::Method(ref sig, ref body) => {
self.process_method(sig,
body.as_ref().map(|x| &**x),
trait_item.id,
trait_item.ident.name,
trait_item.span);
}
- ast::ConstTraitItem(_, None) |
- ast::TypeTraitItem(..) => {}
+ ast::TraitItemKind::Const(_, None) |
+ ast::TraitItemKind::Type(..) => {}
}
}
fn visit_ty(&mut self, t: &ast::Ty) {
self.process_macro_use(t.span, t.id);
match t.node {
- ast::TyPath(_, ref path) => {
+ ast::TyKind::Path(_, ref path) => {
match self.lookup_type_ref(t.id) {
Some(id) => {
let sub_span = self.span.sub_span_for_type_name(t.span);
fn visit_expr(&mut self, ex: &ast::Expr) {
self.process_macro_use(ex.span, ex.id);
match ex.node {
- ast::ExprCall(ref _f, ref _args) => {
+ ast::ExprKind::Call(ref _f, ref _args) => {
// Don't need to do anything for function calls,
// because just walking the callee path does what we want.
visit::walk_expr(self, ex);
}
- ast::ExprPath(_, ref path) => {
+ ast::ExprKind::Path(_, ref path) => {
self.process_path(ex.id, path, None);
visit::walk_expr(self, ex);
}
- ast::ExprStruct(ref path, ref fields, ref base) => {
+ ast::ExprKind::Struct(ref path, ref fields, ref base) => {
let hir_expr = lower_expr(self.save_ctxt.lcx, ex);
let adt = self.tcx.expr_ty(&hir_expr).ty_adt_def().unwrap();
let def = self.tcx.resolve_expr(&hir_expr);
self.process_struct_lit(ex, path, fields, adt.variant_of_def(def), base)
}
- ast::ExprMethodCall(_, _, ref args) => self.process_method_call(ex, args),
- ast::ExprField(ref sub_ex, _) => {
+ ast::ExprKind::MethodCall(_, _, ref args) => self.process_method_call(ex, args),
+ ast::ExprKind::Field(ref sub_ex, _) => {
self.visit_expr(&sub_ex);
if let Some(field_data) = self.save_ctxt.get_expr_data(ex) {
field_data.scope);
}
}
- ast::ExprTupField(ref sub_ex, idx) => {
+ ast::ExprKind::TupField(ref sub_ex, idx) => {
self.visit_expr(&**sub_ex);
let hir_node = lower_expr(self.save_ctxt.lcx, sub_ex);
ty)),
}
}
- ast::ExprClosure(_, ref decl, ref body) => {
+ ast::ExprKind::Closure(_, ref decl, ref body) => {
let mut id = String::from("$");
id.push_str(&ex.id.to_string());
self.process_formals(&decl.inputs, &id);
self.visit_ty(&*arg.ty);
}
- if let ast::Return(ref ret_ty) = decl.output {
+ if let ast::FunctionRetTy::Ty(ref ret_ty) = decl.output {
self.visit_ty(&**ret_ty);
}
// walk the body
self.nest(ex.id, |v| v.visit_block(&**body));
}
- ast::ExprForLoop(ref pattern, ref subexpression, ref block, _) |
- ast::ExprWhileLet(ref pattern, ref subexpression, ref block, _) => {
+ ast::ExprKind::ForLoop(ref pattern, ref subexpression, ref block, _) |
+ ast::ExprKind::WhileLet(ref pattern, ref subexpression, ref block, _) => {
let value = self.span.snippet(mk_sp(ex.span.lo, subexpression.span.hi));
self.process_var_decl(pattern, value);
visit::walk_expr(self, subexpression);
visit::walk_block(self, block);
}
- ast::ExprIfLet(ref pattern, ref subexpression, ref block, ref opt_else) => {
+ ast::ExprKind::IfLet(ref pattern, ref subexpression, ref block, ref opt_else) => {
let value = self.span.snippet(mk_sp(ex.span.lo, subexpression.span.hi));
self.process_var_decl(pattern, value);
visit::walk_expr(self, subexpression);
let def = def_map.get(&id).unwrap().full_def();
match def {
Def::Local(_, id) => {
- let value = if immut == ast::MutImmutable {
+ let value = if immut == ast::Mutability::Immutable {
self.span.snippet(p.span).to_string()
} else {
"<mutable>".to_string()
pub fn get_item_data(&self, item: &ast::Item) -> Option<Data> {
match item.node {
- ast::ItemFn(..) => {
+ ast::ItemKind::Fn(..) => {
let name = self.tcx.map.path_to_string(item.id);
let qualname = format!("::{}", name);
let sub_span = self.span_utils.sub_span_after_keyword(item.span, keywords::Fn);
scope: self.enclosing_scope(item.id),
}))
}
- ast::ItemStatic(ref typ, mt, ref expr) => {
+ ast::ItemKind::Static(ref typ, mt, ref expr) => {
let qualname = format!("::{}", self.tcx.map.path_to_string(item.id));
// If the variable is immutable, save the initialising expression.
let (value, keyword) = match mt {
- ast::MutMutable => (String::from("<mutable>"), keywords::Mut),
- ast::MutImmutable => (self.span_utils.snippet(expr.span), keywords::Static),
+ ast::Mutability::Mutable => (String::from("<mutable>"), keywords::Mut),
+ ast::Mutability::Immutable => {
+ (self.span_utils.snippet(expr.span), keywords::Static)
+ },
};
let sub_span = self.span_utils.sub_span_after_keyword(item.span, keyword);
type_value: ty_to_string(&typ),
}))
}
- ast::ItemConst(ref typ, ref expr) => {
+ ast::ItemKind::Const(ref typ, ref expr) => {
let qualname = format!("::{}", self.tcx.map.path_to_string(item.id));
let sub_span = self.span_utils.sub_span_after_keyword(item.span, keywords::Const);
filter!(self.span_utils, sub_span, item.span, None);
type_value: ty_to_string(&typ),
}))
}
- ast::ItemMod(ref m) => {
+ ast::ItemKind::Mod(ref m) => {
let qualname = format!("::{}", self.tcx.map.path_to_string(item.id));
let cm = self.tcx.sess.codemap();
filename: filename,
}))
}
- ast::ItemEnum(..) => {
+ ast::ItemKind::Enum(..) => {
let enum_name = format!("::{}", self.tcx.map.path_to_string(item.id));
let val = self.span_utils.snippet(item.span);
let sub_span = self.span_utils.sub_span_after_keyword(item.span, keywords::Enum);
scope: self.enclosing_scope(item.id),
}))
}
- ast::ItemImpl(_, _, _, ref trait_ref, ref typ, _) => {
+ ast::ItemKind::Impl(_, _, _, ref trait_ref, ref typ, _) => {
let mut type_data = None;
let sub_span;
match typ.node {
// Common case impl for a struct or something basic.
- ast::TyPath(None, ref path) => {
+ ast::TyKind::Path(None, ref path) => {
sub_span = self.span_utils.sub_span_for_type_name(path.span);
filter!(self.span_utils, sub_span, path.span, None);
type_data = self.lookup_ref_id(typ.id).map(|id| {
return None;
}
match expr.node {
- ast::ExprField(ref sub_ex, ident) => {
+ ast::ExprKind::Field(ref sub_ex, ident) => {
let hir_node = lowering::lower_expr(self.lcx, sub_ex);
match self.tcx.expr_ty_adjusted(&hir_node).sty {
ty::TyStruct(def, _) => {
}
}
}
- ast::ExprStruct(ref path, _, _) => {
+ ast::ExprKind::Struct(ref path, _, _) => {
let hir_node = lowering::lower_expr(self.lcx, expr);
match self.tcx.expr_ty_adjusted(&hir_node).sty {
ty::TyStruct(def, _) => {
}
}
}
- ast::ExprMethodCall(..) => {
+ ast::ExprKind::MethodCall(..) => {
let method_call = ty::MethodCall::expr(expr.id);
let method_id = self.tcx.tables.borrow().method_map[&method_call].def_id;
let (def_id, decl_id) = match self.tcx.impl_or_trait_item(method_id).container() {
decl_id: decl_id,
}))
}
- ast::ExprPath(_, ref path) => {
+ ast::ExprKind::Path(_, ref path) => {
self.get_path_data(expr.id, path)
}
_ => {
match p.node {
ast::PatStruct(ref path, _, _) => {
self.collected_paths.push((p.id, path.clone(),
- ast::MutMutable, recorder::TypeRef));
+ ast::Mutability::Mutable, recorder::TypeRef));
}
ast::PatEnum(ref path, _) |
ast::PatQPath(_, ref path) => {
self.collected_paths.push((p.id, path.clone(),
- ast::MutMutable, recorder::VarRef));
+ ast::Mutability::Mutable, recorder::VarRef));
}
ast::PatIdent(bm, ref path1, _) => {
debug!("PathCollector, visit ident in pat {}: {:?} {:?}",
// Even if the ref is mut, you can't change the ref, only
// the data pointed at, so showing the initialising expression
// is still worthwhile.
- ast::BindingMode::ByRef(_) => ast::MutImmutable,
+ ast::BindingMode::ByRef(_) => ast::Mutability::Immutable,
ast::BindingMode::ByValue(mt) => mt,
};
// collect path for either visit_local or visit_arm
compare_str(cx, lhs_data, lhs_len, rhs_data, rhs_len, rhs_t, debug_loc)
}
ty::TyArray(ty, _) | ty::TySlice(ty) => match ty.sty {
- ty::TyUint(ast::TyU8) => {
+ ty::TyUint(ast::UintTy::U8) => {
// NOTE: cast &[u8] and &[u8; N] to &str and abuse the str_eq lang item,
// which calls memcmp().
let pat_len = val_ty(rhs).element_type().array_length();
let ity = if use_align {
// Use the overall alignment
match align {
- 1 => attr::UnsignedInt(ast::TyU8),
- 2 => attr::UnsignedInt(ast::TyU16),
- 4 => attr::UnsignedInt(ast::TyU32),
+ 1 => attr::UnsignedInt(ast::UintTy::U8),
+ 2 => attr::UnsignedInt(ast::UintTy::U16),
+ 4 => attr::UnsignedInt(ast::UintTy::U32),
8 if machine::llalign_of_min(cx, Type::i64(cx)) == 8 =>
- attr::UnsignedInt(ast::TyU64),
+ attr::UnsignedInt(ast::UintTy::U64),
_ => min_ity // use min_ity as a fallback
}
} else {
// Lists of sizes to try. u64 is always allowed as a fallback.
#[allow(non_upper_case_globals)]
const choose_shortest: &'static [IntType] = &[
- attr::UnsignedInt(ast::TyU8), attr::SignedInt(ast::TyI8),
- attr::UnsignedInt(ast::TyU16), attr::SignedInt(ast::TyI16),
- attr::UnsignedInt(ast::TyU32), attr::SignedInt(ast::TyI32)];
+ attr::UnsignedInt(ast::UintTy::U8), attr::SignedInt(ast::IntTy::I8),
+ attr::UnsignedInt(ast::UintTy::U16), attr::SignedInt(ast::IntTy::I16),
+ attr::UnsignedInt(ast::UintTy::U32), attr::SignedInt(ast::IntTy::I32)];
#[allow(non_upper_case_globals)]
const at_least_32: &'static [IntType] = &[
- attr::UnsignedInt(ast::TyU32), attr::SignedInt(ast::TyI32)];
+ attr::UnsignedInt(ast::UintTy::U32), attr::SignedInt(ast::IntTy::I32)];
let attempts;
match hint {
return ity;
}
}
- return attr::UnsignedInt(ast::TyU64);
+ return attr::UnsignedInt(ast::UintTy::U64);
}
pub fn ll_inttype(cx: &CrateContext, ity: IntType) -> Type {
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(
use middle::ty;
use middle::infer;
use session::config::NoDebugInfo;
-use syntax::abi;
+use syntax::abi::Abi;
pub use syntax::attr::InlineAttr;
use syntax::ast;
use rustc_front::hir;
let infcx = infer::normalizing_infer_ctxt(ccx.tcx(), &ccx.tcx().tables);
function_type = infcx.closure_type(closure_did, substs);
let self_type = base::self_type_for_closure(ccx, closure_did, fn_type);
- (&function_type.sig, abi::RustCall, Some(self_type))
+ (&function_type.sig, Abi::RustCall, Some(self_type))
}
_ => ccx.sess().bug("expected closure or function.")
};
// unpack the input ty's
let input_tys = match fn_type.sty {
ty::TyClosure(..) => {
- assert!(abi == abi::RustCall);
+ assert!(abi == Abi::RustCall);
match fn_sig.inputs[0].sty {
ty::TyTuple(ref inputs) => {
_ => ccx.sess().bug("expected tuple'd inputs")
}
},
- ty::TyBareFn(..) if abi == abi::RustCall => {
+ ty::TyBareFn(..) if abi == Abi::RustCall => {
let mut inputs = vec![fn_sig.inputs[0]];
match fn_sig.inputs[1].sty {
use std::collections::{HashMap, HashSet};
use std::str;
use std::{i8, i16, i32, i64};
-use syntax::abi::{Rust, RustCall, RustIntrinsic, PlatformIntrinsic, Abi};
+use syntax::abi::Abi;
use syntax::codemap::{Span, DUMMY_SP};
use syntax::parse::token::InternedString;
use syntax::attr::AttrMetaMethods;
ty::TyInt(t) => {
let llty = Type::int_from_ty(cx.ccx(), t);
let min = match t {
- ast::TyIs if llty == Type::i32(cx.ccx()) => i32::MIN as u64,
- ast::TyIs => i64::MIN as u64,
- ast::TyI8 => i8::MIN as u64,
- ast::TyI16 => i16::MIN as u64,
- ast::TyI32 => i32::MIN as u64,
- ast::TyI64 => i64::MIN as u64,
+ ast::IntTy::Is if llty == Type::i32(cx.ccx()) => i32::MIN as u64,
+ ast::IntTy::Is => i64::MIN as u64,
+ ast::IntTy::I8 => i8::MIN as u64,
+ ast::IntTy::I16 => i16::MIN as u64,
+ ast::IntTy::I32 => i32::MIN as u64,
+ ast::IntTy::I64 => i64::MIN as u64,
};
(llty, min)
}
match t.sty {
ty::TyBareFn(_, ref fn_ty) => {
match ccx.sess().target.target.adjust_abi(fn_ty.abi) {
- Rust | RustCall => {
+ Abi::Rust | Abi::RustCall => {
get_extern_rust_fn(ccx, t, &name[..], did)
}
- RustIntrinsic | PlatformIntrinsic => {
+ Abi::RustIntrinsic | Abi::PlatformIntrinsic => {
ccx.sess().bug("unexpected intrinsic in trans_external_path")
}
_ => {
bcx.fcx.ccx.tn().val_to_string(bcx.fcx.llfn));
let has_tupled_arg = match closure_env {
- closure::ClosureEnv::NotClosure => abi == RustCall,
+ closure::ClosureEnv::NotClosure => abi == Abi::RustCall,
_ => false,
};
for (ref ccx, is_origin) in ccx.maybe_iter(!from_external && trans_everywhere) {
let llfn = get_item_val(ccx, item.id);
let empty_substs = ccx.tcx().mk_substs(Substs::trans_empty());
- if abi != Rust {
+ if abi != Abi::Rust {
foreign::trans_rust_fn_with_foreign_abi(ccx,
&**decl,
&**body,
node_type: Ty<'tcx>)
-> ValueRef {
if let ty::TyBareFn(_, ref f) = node_type.sty {
- if f.abi != Rust && f.abi != RustCall {
+ if f.abi != Abi::Rust && f.abi != Abi::RustCall {
ccx.sess().span_bug(sp,
&format!("only the `{}` or `{}` calling conventions are valid \
for this function; `{}` was specified",
- Rust.name(),
- RustCall.name(),
+ Abi::Rust.name(),
+ Abi::RustCall.name(),
f.abi.name()));
}
} else {
hir::ItemFn(_, _, _, abi, _, _) => {
let sym = sym();
- let llfn = if abi == Rust {
+ let llfn = if abi == Abi::Rust {
register_fn(ccx, i.span, sym, i.id, ty)
} else {
foreign::register_rust_fn_with_foreign_abi(ccx, i.span, sym, i.id)
let sym = exported_name(ccx, id, mty, &attrs);
if let ty::TyBareFn(_, ref f) = mty.sty {
- let llfn = if f.abi == Rust || f.abi == RustCall {
+ let llfn = if f.abi == Abi::Rust || f.abi == Abi::RustCall {
register_fn(ccx, span, sym, id, mty)
} else {
foreign::register_rust_fn_with_foreign_abi(ccx, span, sym, id)
}
// The PowerPC64 big endian ABI doesn't return aggregates in registers
- if ccx.sess().target.target.arch == "powerpc64" {
+ if ccx.sess().target.target.target_endian == "big" {
return ArgType::indirect(ty, Some(Attribute::StructRet))
}
use middle::ty::MethodCall;
use rustc_front::hir;
-use syntax::abi as synabi;
+use syntax::abi::Abi;
use syntax::ast;
use syntax::errors;
use syntax::ptr::P;
}
}
Def::Fn(did) if match expr_ty.sty {
- ty::TyBareFn(_, ref f) => f.abi == synabi::RustIntrinsic ||
- f.abi == synabi::PlatformIntrinsic,
+ ty::TyBareFn(_, ref f) => f.abi == Abi::RustIntrinsic ||
+ f.abi == Abi::PlatformIntrinsic,
_ => false
} => {
let substs = common::node_id_substs(bcx.ccx(),
match bare_fn_ty.sty {
ty::TyBareFn(opt_def_id,
&ty::BareFnTy { unsafety: hir::Unsafety::Normal,
- abi: synabi::Rust,
+ abi: Abi::Rust,
ref sig }) => {
(opt_def_id, sig)
}
let tuple_fn_ty = tcx.mk_fn(opt_def_id,
tcx.mk_bare_fn(ty::BareFnTy {
unsafety: hir::Unsafety::Normal,
- abi: synabi::RustCall,
+ abi: Abi::RustCall,
sig: ty::Binder(ty::FnSig {
inputs: vec![bare_fn_ty_maybe_ref,
tuple_input_ty],
(d.llfn, Some(d.llself))
}
Intrinsic(node, substs) => {
- assert!(abi == synabi::RustIntrinsic || abi == synabi::PlatformIntrinsic);
+ assert!(abi == Abi::RustIntrinsic || abi == Abi::PlatformIntrinsic);
assert!(dest.is_some());
let call_info = match debug_loc {
// Intrinsics should not become actual functions.
// We trans them in place in `trans_intrinsic_call`
- assert!(abi != synabi::RustIntrinsic && abi != synabi::PlatformIntrinsic);
+ assert!(abi != Abi::RustIntrinsic && abi != Abi::PlatformIntrinsic);
- let is_rust_fn = abi == synabi::Rust || abi == synabi::RustCall;
+ let is_rust_fn = abi == Abi::Rust || abi == Abi::RustCall;
// Generate a location to store the result. If the user does
// not care about the result, just make a stack slot.
llargs: &mut Vec<ValueRef>,
arg_cleanup_scope: cleanup::ScopeId,
ignore_self: bool,
- abi: synabi::Abi)
+ abi: Abi)
-> Block<'blk, 'tcx> {
debug!("trans_args(abi={})", abi);
// to cast her view of the arguments to the caller's view.
match args {
ArgExprs(arg_exprs) => {
- if abi == synabi::RustCall {
+ if abi == Abi::RustCall {
// This is only used for direct calls to the `call`,
// `call_mut` or `call_once` functions.
return trans_args_under_call_abi(cx,
use middle::ty;
use session::config::FullDebugInfo;
-use syntax::abi::RustCall;
+use syntax::abi::Abi::RustCall;
use syntax::ast;
use syntax::attr::{ThinAttributes, ThinAttributesExt};
ty::TyBool => output.push_str("bool"),
ty::TyChar => output.push_str("char"),
ty::TyStr => output.push_str("str"),
- ty::TyInt(ast::TyIs) => output.push_str("isize"),
- ty::TyInt(ast::TyI8) => output.push_str("i8"),
- ty::TyInt(ast::TyI16) => output.push_str("i16"),
- ty::TyInt(ast::TyI32) => output.push_str("i32"),
- ty::TyInt(ast::TyI64) => output.push_str("i64"),
- ty::TyUint(ast::TyUs) => output.push_str("usize"),
- ty::TyUint(ast::TyU8) => output.push_str("u8"),
- ty::TyUint(ast::TyU16) => output.push_str("u16"),
- ty::TyUint(ast::TyU32) => output.push_str("u32"),
- ty::TyUint(ast::TyU64) => output.push_str("u64"),
- ty::TyFloat(ast::TyF32) => output.push_str("f32"),
- ty::TyFloat(ast::TyF64) => output.push_str("f64"),
+ ty::TyInt(ast::IntTy::Is) => output.push_str("isize"),
+ ty::TyInt(ast::IntTy::I8) => output.push_str("i8"),
+ ty::TyInt(ast::IntTy::I16) => output.push_str("i16"),
+ ty::TyInt(ast::IntTy::I32) => output.push_str("i32"),
+ ty::TyInt(ast::IntTy::I64) => output.push_str("i64"),
+ ty::TyUint(ast::UintTy::Us) => output.push_str("usize"),
+ ty::TyUint(ast::UintTy::U8) => output.push_str("u8"),
+ ty::TyUint(ast::UintTy::U16) => output.push_str("u16"),
+ ty::TyUint(ast::UintTy::U32) => output.push_str("u32"),
+ ty::TyUint(ast::UintTy::U64) => output.push_str("u64"),
+ ty::TyFloat(ast::FloatTy::F32) => output.push_str("f32"),
+ ty::TyFloat(ast::FloatTy::F64) => output.push_str("f64"),
ty::TyStruct(adt_def, substs) |
ty::TyEnum(adt_def, substs) => {
push_item_name(cx, adt_def.did, output);
output.push_str("unsafe ");
}
- if abi != ::syntax::abi::Rust {
+ if abi != ::syntax::abi::Abi::Rust {
output.push_str("extern \"");
output.push_str(abi.name());
output.push_str("\" ");
use std::ffi::{CStr, CString};
use std::borrow::Cow;
use libc::c_uint;
-use syntax::ast;
+use syntax::ast::{self, LitKind};
use syntax::attr;
use syntax::parse::token;
use syntax::ptr::P;
let _icx = push_ctxt("trans_lit");
debug!("const_lit: {:?}", lit);
match lit.node {
- ast::LitByte(b) => C_integral(Type::uint_from_ty(cx, ast::TyU8), b as u64, false),
- ast::LitChar(i) => C_integral(Type::char(cx), i as u64, false),
- ast::LitInt(i, ast::SignedIntLit(t, _)) => {
+ LitKind::Byte(b) => C_integral(Type::uint_from_ty(cx, ast::UintTy::U8), b as u64, false),
+ LitKind::Char(i) => C_integral(Type::char(cx), i as u64, false),
+ LitKind::Int(i, ast::LitIntType::Signed(t)) => {
C_integral(Type::int_from_ty(cx, t), i, true)
}
- ast::LitInt(u, ast::UnsignedIntLit(t)) => {
+ LitKind::Int(u, ast::LitIntType::Unsigned(t)) => {
C_integral(Type::uint_from_ty(cx, t), u, false)
}
- ast::LitInt(i, ast::UnsuffixedIntLit(_)) => {
+ LitKind::Int(i, ast::LitIntType::Unsuffixed) => {
let lit_int_ty = cx.tcx().node_id_to_type(e.id);
match lit_int_ty.sty {
ty::TyInt(t) => {
lit_int_ty))
}
}
- ast::LitFloat(ref fs, t) => {
+ LitKind::Float(ref fs, t) => {
C_floating(&fs, Type::float_from_ty(cx, t))
}
- ast::LitFloatUnsuffixed(ref fs) => {
+ LitKind::FloatUnsuffixed(ref fs) => {
let lit_float_ty = cx.tcx().node_id_to_type(e.id);
match lit_float_ty.sty {
ty::TyFloat(t) => {
}
}
}
- ast::LitBool(b) => C_bool(cx, b),
- ast::LitStr(ref s, _) => C_str_slice(cx, (*s).clone()),
- ast::LitByteStr(ref data) => {
+ LitKind::Bool(b) => C_bool(cx, b),
+ LitKind::Str(ref s, _) => C_str_slice(cx, (*s).clone()),
+ LitKind::ByteStr(ref data) => {
addr_of(cx, C_bytes(cx, &data[..]), 1, "byte_str")
}
}
use std::rc::Rc;
use syntax::codemap::{Span, Pos};
-use syntax::{abi, ast, codemap};
+use syntax::{ast, codemap};
+use syntax::abi::Abi;
use syntax::attr::IntType;
use syntax::parse::token::{self, special_idents};
ty::FnDiverging => diverging_type_metadata(cx)
});
- let inputs = &if abi == abi::RustCall {
+ let inputs = &if abi == Abi::RustCall {
type_of::untuple_arguments(cx, &sig.inputs)
} else {
sig.inputs
output.push_str("unsafe ");
}
- if abi != ::syntax::abi::Rust {
+ if abi != ::syntax::abi::Abi::Rust {
output.push_str("extern \"");
output.push_str(abi.name());
output.push_str("\" ");
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
}
})
use llvm::{self, ValueRef};
use middle::ty;
use middle::infer;
-use syntax::abi;
+use syntax::abi::Abi;
use trans::attributes;
use trans::base;
use trans::context::CrateContext;
let llenvironment_type = type_of::type_of_explicit_arg(ccx, self_type);
debug!("declare_rust_fn function_type={:?} self_type={:?}",
function_type, self_type);
- (&function_type.sig, abi::RustCall, Some(llenvironment_type))
+ (&function_type.sig, Abi::RustCall, Some(llenvironment_type))
}
_ => ccx.sess().bug("expected closure or fn")
};
}
hir::ExprLit(ref lit) => {
match lit.node {
- ast::LitStr(ref s, _) => {
+ ast::LitKind::Str(ref s, _) => {
tvec::trans_lit_str(bcx, expr, (*s).clone(), dest)
}
_ => {
use middle::ty::{TyInt, TyUint};
let new_sty = match ty.sty {
- TyInt(TyIs) => match &tcx.sess.target.target.target_pointer_width[..] {
- "32" => TyInt(TyI32),
- "64" => TyInt(TyI64),
+ TyInt(Is) => match &tcx.sess.target.target.target_pointer_width[..] {
+ "32" => TyInt(I32),
+ "64" => TyInt(I64),
_ => panic!("unsupported target word size")
},
- TyUint(TyUs) => match &tcx.sess.target.target.target_pointer_width[..] {
- "32" => TyUint(TyU32),
- "64" => TyUint(TyU64),
+ TyUint(Us) => match &tcx.sess.target.target.target_pointer_width[..] {
+ "32" => TyUint(U32),
+ "64" => TyUint(U64),
_ => panic!("unsupported target word size")
},
ref t @ TyUint(_) | ref t @ TyInt(_) => t.clone(),
match *self {
OverflowOpViaIntrinsic::Add => match new_sty {
- TyInt(TyI8) => "llvm.sadd.with.overflow.i8",
- TyInt(TyI16) => "llvm.sadd.with.overflow.i16",
- TyInt(TyI32) => "llvm.sadd.with.overflow.i32",
- TyInt(TyI64) => "llvm.sadd.with.overflow.i64",
+ TyInt(I8) => "llvm.sadd.with.overflow.i8",
+ TyInt(I16) => "llvm.sadd.with.overflow.i16",
+ TyInt(I32) => "llvm.sadd.with.overflow.i32",
+ TyInt(I64) => "llvm.sadd.with.overflow.i64",
- TyUint(TyU8) => "llvm.uadd.with.overflow.i8",
- TyUint(TyU16) => "llvm.uadd.with.overflow.i16",
- TyUint(TyU32) => "llvm.uadd.with.overflow.i32",
- TyUint(TyU64) => "llvm.uadd.with.overflow.i64",
+ TyUint(U8) => "llvm.uadd.with.overflow.i8",
+ TyUint(U16) => "llvm.uadd.with.overflow.i16",
+ TyUint(U32) => "llvm.uadd.with.overflow.i32",
+ TyUint(U64) => "llvm.uadd.with.overflow.i64",
_ => unreachable!(),
},
OverflowOpViaIntrinsic::Sub => match new_sty {
- TyInt(TyI8) => "llvm.ssub.with.overflow.i8",
- TyInt(TyI16) => "llvm.ssub.with.overflow.i16",
- TyInt(TyI32) => "llvm.ssub.with.overflow.i32",
- TyInt(TyI64) => "llvm.ssub.with.overflow.i64",
+ TyInt(I8) => "llvm.ssub.with.overflow.i8",
+ TyInt(I16) => "llvm.ssub.with.overflow.i16",
+ TyInt(I32) => "llvm.ssub.with.overflow.i32",
+ TyInt(I64) => "llvm.ssub.with.overflow.i64",
- TyUint(TyU8) => "llvm.usub.with.overflow.i8",
- TyUint(TyU16) => "llvm.usub.with.overflow.i16",
- TyUint(TyU32) => "llvm.usub.with.overflow.i32",
- TyUint(TyU64) => "llvm.usub.with.overflow.i64",
+ TyUint(U8) => "llvm.usub.with.overflow.i8",
+ TyUint(U16) => "llvm.usub.with.overflow.i16",
+ TyUint(U32) => "llvm.usub.with.overflow.i32",
+ TyUint(U64) => "llvm.usub.with.overflow.i64",
_ => unreachable!(),
},
OverflowOpViaIntrinsic::Mul => match new_sty {
- TyInt(TyI8) => "llvm.smul.with.overflow.i8",
- TyInt(TyI16) => "llvm.smul.with.overflow.i16",
- TyInt(TyI32) => "llvm.smul.with.overflow.i32",
- TyInt(TyI64) => "llvm.smul.with.overflow.i64",
-
- TyUint(TyU8) => "llvm.umul.with.overflow.i8",
- TyUint(TyU16) => "llvm.umul.with.overflow.i16",
- TyUint(TyU32) => "llvm.umul.with.overflow.i32",
- TyUint(TyU64) => "llvm.umul.with.overflow.i64",
+ TyInt(I8) => "llvm.smul.with.overflow.i8",
+ TyInt(I16) => "llvm.smul.with.overflow.i16",
+ TyInt(I32) => "llvm.smul.with.overflow.i32",
+ TyInt(I64) => "llvm.smul.with.overflow.i64",
+
+ TyUint(U8) => "llvm.umul.with.overflow.i8",
+ TyUint(U16) => "llvm.umul.with.overflow.i16",
+ TyUint(U32) => "llvm.umul.with.overflow.i32",
+ TyUint(U64) => "llvm.umul.with.overflow.i64",
_ => unreachable!(),
},
use std::cmp;
use std::iter::once;
use libc::c_uint;
-use syntax::abi::{Cdecl, Aapcs, C, Win64, Abi};
-use syntax::abi::{PlatformIntrinsic, RustIntrinsic, Rust, RustCall, Stdcall};
-use syntax::abi::{Fastcall, Vectorcall, System};
+use syntax::abi::Abi;
use syntax::attr;
use syntax::codemap::Span;
use syntax::parse::token::{InternedString, special_idents};
pub fn llvm_calling_convention(ccx: &CrateContext,
abi: Abi) -> CallConv {
+ use syntax::abi::Abi::*;
match ccx.sess().target.target.adjust_abi(abi) {
RustIntrinsic => {
// Intrinsics are emitted at the call site
if let hir::ForeignItemFn(ref decl, _) = foreign_item.node {
match foreign_mod.abi {
- Rust | RustIntrinsic | PlatformIntrinsic => {}
+ Abi::Rust | Abi::RustIntrinsic | Abi::PlatformIntrinsic => {}
abi => {
let ty = ccx.tcx().node_id_to_type(foreign_item.id);
match ty.sty {
// normal Rust function. This will be the type of the wrappee fn.
match t.sty {
ty::TyBareFn(_, ref f) => {
- assert!(f.abi != Rust && f.abi != RustIntrinsic && f.abi != PlatformIntrinsic);
+ assert!(f.abi != Abi::Rust);
+ assert!(f.abi != Abi::RustIntrinsic);
+ assert!(f.abi != Abi::PlatformIntrinsic);
}
_ => {
ccx.sess().bug(&format!("build_rust_fn: extern fn {} has ty {:?}, \
use middle::subst::Substs;
use rustc::dep_graph::DepNode;
use rustc_front::hir;
-use syntax::abi::{self, RustIntrinsic};
+use syntax::abi::Abi;
use syntax::ast;
use syntax::ptr::P;
use syntax::parse::token;
&mut llargs,
cleanup::CustomScope(cleanup_scope),
false,
- RustIntrinsic);
+ Abi::RustIntrinsic);
fcx.scopes.borrow_mut().last_mut().unwrap().drop_non_lifetime_clean();
let i8p = tcx.mk_mut_ptr(tcx.types.i8);
let fn_ty = tcx.mk_bare_fn(ty::BareFnTy {
unsafety: hir::Unsafety::Unsafe,
- abi: abi::Rust,
+ abi: Abi::Rust,
sig: ty::Binder(ty::FnSig {
inputs: vec![i8p],
output: ty::FnOutput::FnConverging(tcx.mk_nil()),
let output = ty::FnOutput::FnConverging(tcx.types.i32);
let try_fn_ty = tcx.mk_bare_fn(ty::BareFnTy {
unsafety: hir::Unsafety::Unsafe,
- abi: abi::Rust,
+ abi: Abi::Rust,
sig: ty::Binder(ty::FnSig {
inputs: vec![fn_ty, i8p, i8p],
output: output,
// just do the same.
let filter_fn_ty = tcx.mk_bare_fn(ty::BareFnTy {
unsafety: hir::Unsafety::Unsafe,
- abi: abi::Rust,
+ abi: Abi::Rust,
sig: ty::Binder(ty::FnSig {
inputs: vec![],
output: output,
// those along.
let filter_fn_ty = tcx.mk_bare_fn(ty::BareFnTy {
unsafety: hir::Unsafety::Unsafe,
- abi: abi::Rust,
+ abi: Abi::Rust,
sig: ty::Binder(ty::FnSig {
inputs: vec![i8p, i8p],
output: output,
use rustc::middle::ty::{TyInt, TyUint};
match *sty {
TyInt(t) => Some((match t {
- ast::TyIs => {
+ ast::IntTy::Is => {
match &ccx.tcx().sess.target.target.target_pointer_width[..] {
"32" => 32,
"64" => 64,
tws => panic!("Unsupported target word size for isize: {}", tws),
}
},
- ast::TyI8 => 8,
- ast::TyI16 => 16,
- ast::TyI32 => 32,
- ast::TyI64 => 64,
+ ast::IntTy::I8 => 8,
+ ast::IntTy::I16 => 16,
+ ast::IntTy::I32 => 32,
+ ast::IntTy::I64 => 64,
}, true)),
TyUint(t) => Some((match t {
- ast::TyUs => {
+ ast::UintTy::Us => {
match &ccx.tcx().sess.target.target.target_pointer_width[..] {
"32" => 32,
"64" => 64,
tws => panic!("Unsupported target word size for usize: {}", tws),
}
},
- ast::TyU8 => 8,
- ast::TyU16 => 16,
- ast::TyU32 => 32,
- ast::TyU64 => 64,
+ ast::UintTy::U8 => 8,
+ ast::UintTy::U16 => 16,
+ ast::UintTy::U32 => 32,
+ ast::UintTy::U64 => 64,
}, false)),
_ => None,
}
fn opaque_method_ty<'tcx>(tcx: &ty::ctxt<'tcx>, method_ty: &ty::BareFnTy<'tcx>)
-> &'tcx ty::BareFnTy<'tcx> {
let mut inputs = method_ty.sig.0.inputs.clone();
- inputs[0] = tcx.mk_mut_ptr(tcx.mk_mach_int(ast::TyI8));
+ inputs[0] = tcx.mk_mut_ptr(tcx.mk_mach_int(ast::IntTy::I8));
tcx.mk_bare_fn(ty::BareFnTy {
unsafety: method_ty.unsafety,
use rustc_front::hir;
-use syntax::abi;
+use syntax::abi::Abi;
use syntax::ast;
use syntax::attr;
use syntax::errors;
if let hir_map::NodeForeignItem(_) = map_node {
let abi = ccx.tcx().map.get_foreign_abi(fn_node_id);
- if abi != abi::RustIntrinsic && abi != abi::PlatformIntrinsic {
+ if abi != Abi::RustIntrinsic && abi != Abi::PlatformIntrinsic {
// Foreign externs don't have to be monomorphized.
return (get_item_val(ccx, fn_node_id), mono_ty, true);
}
// This shouldn't need to option dance.
let mut hash_id = Some(hash_id);
- let mut mk_lldecl = |abi: abi::Abi| {
- let lldecl = if abi != abi::Rust {
+ let mut mk_lldecl = |abi: Abi| {
+ let lldecl = if abi != Abi::Rust {
foreign::decl_rust_fn_with_foreign_abi(ccx, mono_ty, &s)
} else {
// FIXME(nagisa): perhaps needs a more fine grained selection? See
let d = mk_lldecl(abi);
let needs_body = setup_lldecl(d, &i.attrs);
if needs_body {
- if abi != abi::Rust {
+ if abi != Abi::Rust {
foreign::trans_rust_fn_with_foreign_abi(
ccx, &**decl, &**body, &[], d, psubsts, fn_node_id,
Some(&hash[..]));
hir_map::NodeVariant(v) => {
let variant = inlined_variant_def(ccx, fn_node_id);
assert_eq!(v.node.name, variant.name);
- let d = mk_lldecl(abi::Rust);
+ let d = mk_lldecl(Abi::Rust);
attributes::inline(d, attributes::InlineAttr::Hint);
trans_enum_variant(ccx, fn_node_id, Disr::from(variant.disr_val), psubsts, d);
d
hir_map::NodeImplItem(impl_item) => {
match impl_item.node {
hir::ImplItemKind::Method(ref sig, ref body) => {
- let d = mk_lldecl(abi::Rust);
+ let d = mk_lldecl(Abi::Rust);
let needs_body = setup_lldecl(d, &impl_item.attrs);
if needs_body {
trans_fn(ccx,
hir_map::NodeTraitItem(trait_item) => {
match trait_item.node {
hir::MethodTraitItem(ref sig, Some(ref body)) => {
- let d = mk_lldecl(abi::Rust);
+ let d = mk_lldecl(Abi::Rust);
let needs_body = setup_lldecl(d, &trait_item.attrs);
if needs_body {
trans_fn(ccx,
}
}
hir_map::NodeStructCtor(struct_def) => {
- let d = mk_lldecl(abi::Rust);
+ let d = mk_lldecl(Abi::Rust);
attributes::inline(d, attributes::InlineAttr::Hint);
if struct_def.is_struct() {
panic!("ast-mapped struct didn't have a ctor id")
// Handle the "..." case (returns a slice since strings are always unsized):
if let hir::ExprLit(ref lit) = content_expr.node {
- if let ast::LitStr(ref s, _) = lit.node {
+ if let ast::LitKind::Str(ref s, _) = lit.node {
let scratch = rvalue_scratch_datum(bcx, vec_ty, "");
bcx = trans_lit_str(bcx,
content_expr,
match content_expr.node {
hir::ExprLit(ref lit) => {
match lit.node {
- ast::LitStr(ref s, _) => {
+ ast::LitKind::Str(ref s, _) => {
match dest {
Ignore => return bcx,
SaveIn(lldest) => {
match content_expr.node {
hir::ExprLit(ref lit) => {
match lit.node {
- ast::LitStr(ref s, _) => s.len(),
+ ast::LitKind::Str(ref s, _) => s.len(),
_ => {
bcx.tcx().sess.span_bug(content_expr.span,
"unexpected evec content")
pub fn int_from_ty(ccx: &CrateContext, t: ast::IntTy) -> Type {
match t {
- ast::TyIs => ccx.int_type(),
- ast::TyI8 => Type::i8(ccx),
- ast::TyI16 => Type::i16(ccx),
- ast::TyI32 => Type::i32(ccx),
- ast::TyI64 => Type::i64(ccx)
+ ast::IntTy::Is => ccx.int_type(),
+ ast::IntTy::I8 => Type::i8(ccx),
+ ast::IntTy::I16 => Type::i16(ccx),
+ ast::IntTy::I32 => Type::i32(ccx),
+ ast::IntTy::I64 => Type::i64(ccx)
}
}
pub fn uint_from_ty(ccx: &CrateContext, t: ast::UintTy) -> Type {
match t {
- ast::TyUs => ccx.int_type(),
- ast::TyU8 => Type::i8(ccx),
- ast::TyU16 => Type::i16(ccx),
- ast::TyU32 => Type::i32(ccx),
- ast::TyU64 => Type::i64(ccx)
+ ast::UintTy::Us => ccx.int_type(),
+ ast::UintTy::U8 => Type::i8(ccx),
+ ast::UintTy::U16 => Type::i16(ccx),
+ ast::UintTy::U32 => Type::i32(ccx),
+ ast::UintTy::U64 => Type::i64(ccx)
}
}
pub fn float_from_ty(ccx: &CrateContext, t: ast::FloatTy) -> Type {
match t {
- ast::TyF32 => Type::f32(ccx),
- ast::TyF64 => Type::f64(ccx),
+ ast::FloatTy::F32 => Type::f32(ccx),
+ ast::FloatTy::F64 => Type::f64(ccx),
}
}
use trans::type_::Type;
-use syntax::abi;
+use syntax::abi::Abi;
use syntax::ast;
// LLVM doesn't like objects that are too big. Issue #17913
pub fn type_of_rust_fn<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
llenvironment_type: Option<Type>,
sig: &ty::FnSig<'tcx>,
- abi: abi::Abi)
+ abi: Abi)
-> Type
{
debug!("type_of_rust_fn(sig={:?},abi={:?})",
// First, munge the inputs, if this has the `rust-call` ABI.
let inputs_temp;
- let inputs = if abi == abi::RustCall {
+ let inputs = if abi == Abi::RustCall {
inputs_temp = untuple_arguments(cx, &sig.inputs);
&inputs_temp
} else {
ty::TyBareFn(_, ref f) => {
// FIXME(#19925) once fn item types are
// zero-sized, we'll need to do something here
- if f.abi == abi::Rust || f.abi == abi::RustCall {
+ if f.abi == Abi::Rust || f.abi == Abi::RustCall {
let sig = cx.tcx().erase_late_bound_regions(&f.sig);
let sig = infer::normalize_associated_type(cx.tcx(), &sig);
type_of_rust_fn(cx, None, &sig, f.abi)
let unsized_part = cx.tcx().struct_tail(ty);
let info_ty = match unsized_part.sty {
ty::TyStr | ty::TyArray(..) | ty::TySlice(_) => {
- Type::uint_from_ty(cx, ast::TyUs)
+ Type::uint_from_ty(cx, ast::UintTy::Us)
}
ty::TyTrait(_) => Type::vtable_ptr(cx),
_ => panic!("Unexpected type returned from \
// They can denote both statically and dynamically sized byte arrays
let mut pat_ty = expr_ty;
if let hir::ExprLit(ref lt) = lt.node {
- if let ast::LitByteStr(_) = lt.node {
+ if let ast::LitKind::ByteStr(_) = lt.node {
let expected_ty = structurally_resolved_type(fcx, pat.span, expected);
if let ty::TyRef(_, mt) = expected_ty.sty {
if let ty::TySlice(_) = mt.ty.sty {
(_, Int(Bool)) => Err(CastError::CastToBool),
// * -> Char
- (Int(U(ast::TyU8)), Int(Char)) => Ok(CastKind::U8CharCast), // u8-char-cast
+ (Int(U(ast::UintTy::U8)), Int(Char)) => Ok(CastKind::U8CharCast), // u8-char-cast
(_, Int(Char)) => Err(CastError::CastToChar),
// prim -> float,ptr
use middle::subst;
use middle::ty::{self, ToPolyTraitRef, Ty};
use std::cmp;
-use syntax::abi;
+use syntax::abi::Abi;
use rustc_front::hir;
pub fn check_expr_closure<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
let mut fn_ty = astconv::ty_of_closure(fcx,
hir::Unsafety::Normal,
decl,
- abi::RustCall,
+ Abi::RustCall,
expected_sig);
// Create type variables (for now) to represent the transformed
use {CrateCtxt, require_same_types};
use std::collections::{HashMap};
-use syntax::abi;
+use syntax::abi::Abi;
use syntax::ast;
use syntax::attr::AttrMetaMethods;
use syntax::codemap::Span;
fn equate_intrinsic_type<'a, 'tcx>(tcx: &ty::ctxt<'tcx>, it: &hir::ForeignItem,
n_tps: usize,
- abi: abi::Abi,
+ abi: Abi,
inputs: Vec<ty::Ty<'tcx>>,
output: ty::FnOutput<'tcx>) {
let fty = tcx.mk_fn(None, tcx.mk_bare_fn(ty::BareFnTy {
let mut_u8 = tcx.mk_mut_ptr(tcx.types.u8);
let fn_ty = ty::BareFnTy {
unsafety: hir::Unsafety::Normal,
- abi: abi::Rust,
+ abi: Abi::Rust,
sig: ty::Binder(FnSig {
inputs: vec![mut_u8],
output: ty::FnOutput::FnConverging(tcx.mk_nil()),
tcx,
it,
n_tps,
- abi::RustIntrinsic,
+ Abi::RustIntrinsic,
inputs,
output
)
tcx,
it,
n_tps,
- abi::PlatformIntrinsic,
+ Abi::PlatformIntrinsic,
inputs,
ty::FnConverging(output)
)
},
// (The width we pass to LLVM doesn't concern the type checker.)
Integer(signed, bits, _llvm_width) => match (signed, bits, &t.sty) {
- (true, 8, &ty::TyInt(ast::IntTy::TyI8)) |
- (false, 8, &ty::TyUint(ast::UintTy::TyU8)) |
- (true, 16, &ty::TyInt(ast::IntTy::TyI16)) |
- (false, 16, &ty::TyUint(ast::UintTy::TyU16)) |
- (true, 32, &ty::TyInt(ast::IntTy::TyI32)) |
- (false, 32, &ty::TyUint(ast::UintTy::TyU32)) |
- (true, 64, &ty::TyInt(ast::IntTy::TyI64)) |
- (false, 64, &ty::TyUint(ast::UintTy::TyU64)) => {},
+ (true, 8, &ty::TyInt(ast::IntTy::I8)) |
+ (false, 8, &ty::TyUint(ast::UintTy::U8)) |
+ (true, 16, &ty::TyInt(ast::IntTy::I16)) |
+ (false, 16, &ty::TyUint(ast::UintTy::U16)) |
+ (true, 32, &ty::TyInt(ast::IntTy::I32)) |
+ (false, 32, &ty::TyUint(ast::UintTy::U32)) |
+ (true, 64, &ty::TyInt(ast::IntTy::I64)) |
+ (false, 64, &ty::TyUint(ast::UintTy::U64)) => {},
_ => simple_error(&format!("`{}`", t),
&format!("`{}{n}`",
if signed {"i"} else {"u"},
n = bits)),
},
Float(bits) => match (bits, &t.sty) {
- (32, &ty::TyFloat(ast::FloatTy::TyF32)) |
- (64, &ty::TyFloat(ast::FloatTy::TyF64)) => {},
+ (32, &ty::TyFloat(ast::FloatTy::F32)) |
+ (64, &ty::TyFloat(ast::FloatTy::F64)) => {},
_ => simple_error(&format!("`{}`", t),
&format!("`f{n}`", n = bits)),
},
let lang_def_id = self.tcx().lang_items.mut_ptr_impl();
self.assemble_inherent_impl_for_primitive(lang_def_id);
}
- ty::TyInt(ast::TyI8) => {
+ ty::TyInt(ast::IntTy::I8) => {
let lang_def_id = self.tcx().lang_items.i8_impl();
self.assemble_inherent_impl_for_primitive(lang_def_id);
}
- ty::TyInt(ast::TyI16) => {
+ ty::TyInt(ast::IntTy::I16) => {
let lang_def_id = self.tcx().lang_items.i16_impl();
self.assemble_inherent_impl_for_primitive(lang_def_id);
}
- ty::TyInt(ast::TyI32) => {
+ ty::TyInt(ast::IntTy::I32) => {
let lang_def_id = self.tcx().lang_items.i32_impl();
self.assemble_inherent_impl_for_primitive(lang_def_id);
}
- ty::TyInt(ast::TyI64) => {
+ ty::TyInt(ast::IntTy::I64) => {
let lang_def_id = self.tcx().lang_items.i64_impl();
self.assemble_inherent_impl_for_primitive(lang_def_id);
}
- ty::TyInt(ast::TyIs) => {
+ ty::TyInt(ast::IntTy::Is) => {
let lang_def_id = self.tcx().lang_items.isize_impl();
self.assemble_inherent_impl_for_primitive(lang_def_id);
}
- ty::TyUint(ast::TyU8) => {
+ ty::TyUint(ast::UintTy::U8) => {
let lang_def_id = self.tcx().lang_items.u8_impl();
self.assemble_inherent_impl_for_primitive(lang_def_id);
}
- ty::TyUint(ast::TyU16) => {
+ ty::TyUint(ast::UintTy::U16) => {
let lang_def_id = self.tcx().lang_items.u16_impl();
self.assemble_inherent_impl_for_primitive(lang_def_id);
}
- ty::TyUint(ast::TyU32) => {
+ ty::TyUint(ast::UintTy::U32) => {
let lang_def_id = self.tcx().lang_items.u32_impl();
self.assemble_inherent_impl_for_primitive(lang_def_id);
}
- ty::TyUint(ast::TyU64) => {
+ ty::TyUint(ast::UintTy::U64) => {
let lang_def_id = self.tcx().lang_items.u64_impl();
self.assemble_inherent_impl_for_primitive(lang_def_id);
}
- ty::TyUint(ast::TyUs) => {
+ ty::TyUint(ast::UintTy::Us) => {
let lang_def_id = self.tcx().lang_items.usize_impl();
self.assemble_inherent_impl_for_primitive(lang_def_id);
}
- ty::TyFloat(ast::TyF32) => {
+ ty::TyFloat(ast::FloatTy::F32) => {
let lang_def_id = self.tcx().lang_items.f32_impl();
self.assemble_inherent_impl_for_primitive(lang_def_id);
}
- ty::TyFloat(ast::TyF64) => {
+ ty::TyFloat(ast::FloatTy::F64) => {
let lang_def_id = self.tcx().lang_items.f64_impl();
self.assemble_inherent_impl_for_primitive(lang_def_id);
}
use std::cell::{Cell, Ref, RefCell};
use std::collections::{HashSet};
use std::mem::replace;
-use syntax::abi;
+use syntax::abi::Abi;
use syntax::ast;
use syntax::attr;
use syntax::attr::AttrMetaMethods;
check_bounds_are_used(ccx, &generics.ty_params, pty_ty);
}
hir::ItemForeignMod(ref m) => {
- if m.abi == abi::RustIntrinsic {
+ if m.abi == Abi::RustIntrinsic {
for item in &m.items {
intrinsic::check_intrinsic_type(ccx, item);
}
- } else if m.abi == abi::PlatformIntrinsic {
+ } else if m.abi == Abi::PlatformIntrinsic {
for item in &m.items {
intrinsic::check_platform_intrinsic_type(ccx, item);
}
// First, try built-in indexing.
match (adjusted_ty.builtin_index(), &index_ty.sty) {
- (Some(ty), &ty::TyUint(ast::TyUs)) | (Some(ty), &ty::TyInfer(ty::IntVar(_))) => {
+ (Some(ty), &ty::TyUint(ast::UintTy::Us)) | (Some(ty), &ty::TyInfer(ty::IntVar(_))) => {
debug!("try_index_step: success, using built-in indexing");
// If we had `[T; N]`, we should've caught it before unsizing to `[T]`.
assert!(!unsize);
let arg_ty = structurally_resolved_type(fcx, arg.span,
fcx.expr_ty(&**arg));
match arg_ty.sty {
- ty::TyFloat(ast::TyF32) => {
+ ty::TyFloat(ast::FloatTy::F32) => {
fcx.type_error_message(arg.span,
|t| {
format!("can't pass an {} to variadic \
function, cast to c_double", t)
}, arg_ty, None);
}
- ty::TyInt(ast::TyI8) | ty::TyInt(ast::TyI16) | ty::TyBool => {
+ ty::TyInt(ast::IntTy::I8) | ty::TyInt(ast::IntTy::I16) | ty::TyBool => {
fcx.type_error_message(arg.span, |t| {
format!("can't pass {} to variadic \
function, cast to c_int",
t)
}, arg_ty, None);
}
- ty::TyUint(ast::TyU8) | ty::TyUint(ast::TyU16) => {
+ ty::TyUint(ast::UintTy::U8) | ty::TyUint(ast::UintTy::U16) => {
fcx.type_error_message(arg.span, |t| {
format!("can't pass {} to variadic \
function, cast to c_uint",
let tcx = fcx.ccx.tcx;
match lit.node {
- ast::LitStr(..) => tcx.mk_static_str(),
- ast::LitByteStr(ref v) => {
+ ast::LitKind::Str(..) => tcx.mk_static_str(),
+ ast::LitKind::ByteStr(ref v) => {
tcx.mk_imm_ref(tcx.mk_region(ty::ReStatic),
tcx.mk_array(tcx.types.u8, v.len()))
}
- ast::LitByte(_) => tcx.types.u8,
- ast::LitChar(_) => tcx.types.char,
- ast::LitInt(_, ast::SignedIntLit(t, _)) => tcx.mk_mach_int(t),
- ast::LitInt(_, ast::UnsignedIntLit(t)) => tcx.mk_mach_uint(t),
- ast::LitInt(_, ast::UnsuffixedIntLit(_)) => {
+ ast::LitKind::Byte(_) => tcx.types.u8,
+ ast::LitKind::Char(_) => tcx.types.char,
+ ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => tcx.mk_mach_int(t),
+ ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => tcx.mk_mach_uint(t),
+ ast::LitKind::Int(_, ast::LitIntType::Unsuffixed) => {
let opt_ty = expected.to_option(fcx).and_then(|ty| {
match ty.sty {
ty::TyInt(_) | ty::TyUint(_) => Some(ty),
opt_ty.unwrap_or_else(
|| tcx.mk_int_var(fcx.infcx().next_int_var_id()))
}
- ast::LitFloat(_, t) => tcx.mk_mach_float(t),
- ast::LitFloatUnsuffixed(_) => {
+ ast::LitKind::Float(_, t) => tcx.mk_mach_float(t),
+ ast::LitKind::FloatUnsuffixed(_) => {
let opt_ty = expected.to_option(fcx).and_then(|ty| {
match ty.sty {
ty::TyFloat(_) => Some(ty),
opt_ty.unwrap_or_else(
|| tcx.mk_float_var(fcx.infcx().next_float_var_id()))
}
- ast::LitBool(_) => tcx.types.bool
+ ast::LitKind::Bool(_) => tcx.types.bool
}
}
disr: ty::Disr) -> bool {
fn uint_in_range(ccx: &CrateCtxt, ty: ast::UintTy, disr: ty::Disr) -> bool {
match ty {
- ast::TyU8 => disr as u8 as Disr == disr,
- ast::TyU16 => disr as u16 as Disr == disr,
- ast::TyU32 => disr as u32 as Disr == disr,
- ast::TyU64 => disr as u64 as Disr == disr,
- ast::TyUs => uint_in_range(ccx, ccx.tcx.sess.target.uint_type, disr)
+ ast::UintTy::U8 => disr as u8 as Disr == disr,
+ ast::UintTy::U16 => disr as u16 as Disr == disr,
+ ast::UintTy::U32 => disr as u32 as Disr == disr,
+ ast::UintTy::U64 => disr as u64 as Disr == disr,
+ ast::UintTy::Us => uint_in_range(ccx, ccx.tcx.sess.target.uint_type, disr)
}
}
fn int_in_range(ccx: &CrateCtxt, ty: ast::IntTy, disr: ty::Disr) -> bool {
match ty {
- ast::TyI8 => disr as i8 as Disr == disr,
- ast::TyI16 => disr as i16 as Disr == disr,
- ast::TyI32 => disr as i32 as Disr == disr,
- ast::TyI64 => disr as i64 as Disr == disr,
- ast::TyIs => int_in_range(ccx, ccx.tcx.sess.target.int_type, disr)
+ ast::IntTy::I8 => disr as i8 as Disr == disr,
+ ast::IntTy::I16 => disr as i16 as Disr == disr,
+ ast::IntTy::I32 => disr as i32 as Disr == disr,
+ ast::IntTy::I64 => disr as i64 as Disr == disr,
+ ast::IntTy::Is => int_in_range(ccx, ccx.tcx.sess.target.int_type, disr)
}
}
match ty {
"*mut T",
item.span);
}
- ty::TyInt(ast::TyI8) => {
+ ty::TyInt(ast::IntTy::I8) => {
self.check_primitive_impl(def_id,
self.tcx.lang_items.i8_impl(),
"i8",
"i8",
item.span);
}
- ty::TyInt(ast::TyI16) => {
+ ty::TyInt(ast::IntTy::I16) => {
self.check_primitive_impl(def_id,
self.tcx.lang_items.i16_impl(),
"i16",
"i16",
item.span);
}
- ty::TyInt(ast::TyI32) => {
+ ty::TyInt(ast::IntTy::I32) => {
self.check_primitive_impl(def_id,
self.tcx.lang_items.i32_impl(),
"i32",
"i32",
item.span);
}
- ty::TyInt(ast::TyI64) => {
+ ty::TyInt(ast::IntTy::I64) => {
self.check_primitive_impl(def_id,
self.tcx.lang_items.i64_impl(),
"i64",
"i64",
item.span);
}
- ty::TyInt(ast::TyIs) => {
+ ty::TyInt(ast::IntTy::Is) => {
self.check_primitive_impl(def_id,
self.tcx.lang_items.isize_impl(),
"isize",
"isize",
item.span);
}
- ty::TyUint(ast::TyU8) => {
+ ty::TyUint(ast::UintTy::U8) => {
self.check_primitive_impl(def_id,
self.tcx.lang_items.u8_impl(),
"u8",
"u8",
item.span);
}
- ty::TyUint(ast::TyU16) => {
+ ty::TyUint(ast::UintTy::U16) => {
self.check_primitive_impl(def_id,
self.tcx.lang_items.u16_impl(),
"u16",
"u16",
item.span);
}
- ty::TyUint(ast::TyU32) => {
+ ty::TyUint(ast::UintTy::U32) => {
self.check_primitive_impl(def_id,
self.tcx.lang_items.u32_impl(),
"u32",
"u32",
item.span);
}
- ty::TyUint(ast::TyU64) => {
+ ty::TyUint(ast::UintTy::U64) => {
self.check_primitive_impl(def_id,
self.tcx.lang_items.u64_impl(),
"u64",
"u64",
item.span);
}
- ty::TyUint(ast::TyUs) => {
+ ty::TyUint(ast::UintTy::Us) => {
self.check_primitive_impl(def_id,
self.tcx.lang_items.usize_impl(),
"usize",
"usize",
item.span);
}
- ty::TyFloat(ast::TyF32) => {
+ ty::TyFloat(ast::FloatTy::F32) => {
self.check_primitive_impl(def_id,
self.tcx.lang_items.f32_impl(),
"f32",
"f32",
item.span);
}
- ty::TyFloat(ast::TyF64) => {
+ ty::TyFloat(ast::FloatTy::F64) => {
self.check_primitive_impl(def_id,
self.tcx.lang_items.f64_impl(),
"f64",
use rustc_front::hir;
use syntax::codemap::Span;
-use syntax::{ast, abi};
+use syntax::ast;
+use syntax::abi::Abi;
use std::cell::RefCell;
fn require_c_abi_if_variadic(tcx: &ty::ctxt,
decl: &hir::FnDecl,
- abi: abi::Abi,
+ abi: Abi,
span: Span) {
- if decl.variadic && abi != abi::C {
+ if decl.variadic && abi != Abi::C {
span_err!(tcx.sess, span, E0045,
"variadic function must have C calling convention");
}
let main_def_id = tcx.map.local_def_id(main_id);
let se_ty = tcx.mk_fn(Some(main_def_id), tcx.mk_bare_fn(ty::BareFnTy {
unsafety: hir::Unsafety::Normal,
- abi: abi::Rust,
+ abi: Abi::Rust,
sig: ty::Binder(ty::FnSig {
inputs: Vec::new(),
output: ty::FnConverging(tcx.mk_nil()),
let se_ty = tcx.mk_fn(Some(ccx.tcx.map.local_def_id(start_id)),
tcx.mk_bare_fn(ty::BareFnTy {
unsafety: hir::Unsafety::Normal,
- abi: abi::Rust,
+ abi: Abi::Rust,
sig: ty::Binder(ty::FnSig {
inputs: vec!(
tcx.types.isize,
pub use self::FunctionRetTy::*;
use syntax;
-use syntax::abi;
+use syntax::abi::Abi;
use syntax::ast;
use syntax::attr;
use syntax::attr::{AttributeMethods, AttrMetaMethods};
_ => String::new(),
}
}
+
+ pub fn stable_since(&self) -> Option<&str> {
+ if let Some(ref s) = self.stability {
+ return Some(&s.since[..]);
+ }
+
+ None
+ }
}
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
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))
}
}
pub unsafety: hir::Unsafety,
pub constness: hir::Constness,
pub decl: FnDecl,
- pub abi: abi::Abi
+ pub abi: Abi,
}
impl Clean<Method> for hir::MethodSig {
pub decl: FnDecl,
pub generics: Generics,
pub self_: SelfTy,
- pub abi: abi::Abi
+ pub abi: Abi,
}
impl Clean<TyMethod> for hir::MethodSig {
pub generics: Generics,
pub unsafety: hir::Unsafety,
pub constness: hir::Constness,
- pub abi: abi::Abi,
+ pub abi: Abi,
}
impl Clean<Item> for doctree::Function {
match self.sty {
ty::TyBool => Primitive(Bool),
ty::TyChar => Primitive(Char),
- ty::TyInt(ast::TyIs) => Primitive(Isize),
- ty::TyInt(ast::TyI8) => Primitive(I8),
- ty::TyInt(ast::TyI16) => Primitive(I16),
- ty::TyInt(ast::TyI32) => Primitive(I32),
- ty::TyInt(ast::TyI64) => Primitive(I64),
- ty::TyUint(ast::TyUs) => Primitive(Usize),
- ty::TyUint(ast::TyU8) => Primitive(U8),
- ty::TyUint(ast::TyU16) => Primitive(U16),
- ty::TyUint(ast::TyU32) => Primitive(U32),
- ty::TyUint(ast::TyU64) => Primitive(U64),
- ty::TyFloat(ast::TyF32) => Primitive(F32),
- ty::TyFloat(ast::TyF64) => Primitive(F64),
+ ty::TyInt(ast::IntTy::Is) => Primitive(Isize),
+ ty::TyInt(ast::IntTy::I8) => Primitive(I8),
+ ty::TyInt(ast::IntTy::I16) => Primitive(I16),
+ ty::TyInt(ast::IntTy::I32) => Primitive(I32),
+ ty::TyInt(ast::IntTy::I64) => Primitive(I64),
+ ty::TyUint(ast::UintTy::Us) => Primitive(Usize),
+ ty::TyUint(ast::UintTy::U8) => Primitive(U8),
+ ty::TyUint(ast::UintTy::U16) => Primitive(U16),
+ ty::TyUint(ast::UintTy::U32) => Primitive(U32),
+ ty::TyUint(ast::UintTy::U64) => Primitive(U64),
+ ty::TyFloat(ast::FloatTy::F32) => Primitive(F32),
+ ty::TyFloat(ast::FloatTy::F64) => Primitive(F64),
ty::TyStr => Primitive(Str),
ty::TyBox(t) => {
let box_did = cx.tcx_opt().and_then(|tcx| {
decl: decl.clean(cx),
generics: generics.clean(cx),
unsafety: hir::Unsafety::Unsafe,
- abi: abi::Rust,
+ abi: Abi::Rust,
constness: hir::Constness::NotConst,
})
}
fn lit_to_string(lit: &ast::Lit) -> String {
match lit.node {
- ast::LitStr(ref st, _) => st.to_string(),
- ast::LitByteStr(ref data) => format!("{:?}", data),
- ast::LitByte(b) => {
+ ast::LitKind::Str(ref st, _) => st.to_string(),
+ ast::LitKind::ByteStr(ref data) => format!("{:?}", data),
+ ast::LitKind::Byte(b) => {
let mut res = String::from("b'");
for c in (b as char).escape_default() {
res.push(c);
res.push('\'');
res
},
- ast::LitChar(c) => format!("'{}'", c),
- ast::LitInt(i, _t) => i.to_string(),
- ast::LitFloat(ref f, _t) => f.to_string(),
- ast::LitFloatUnsuffixed(ref f) => f.to_string(),
- ast::LitBool(b) => b.to_string(),
+ ast::LitKind::Char(c) => format!("'{}'", c),
+ ast::LitKind::Int(i, _t) => i.to_string(),
+ ast::LitKind::Float(ref f, _t) => f.to_string(),
+ ast::LitKind::FloatUnsuffixed(ref f) => f.to_string(),
+ ast::LitKind::Bool(b) => b.to_string(),
}
}
hir::TyStr => return Primitive(Str),
hir::TyBool => return Primitive(Bool),
hir::TyChar => return Primitive(Char),
- hir::TyInt(ast::TyIs) => return Primitive(Isize),
- hir::TyInt(ast::TyI8) => return Primitive(I8),
- hir::TyInt(ast::TyI16) => return Primitive(I16),
- hir::TyInt(ast::TyI32) => return Primitive(I32),
- hir::TyInt(ast::TyI64) => return Primitive(I64),
- hir::TyUint(ast::TyUs) => return Primitive(Usize),
- hir::TyUint(ast::TyU8) => return Primitive(U8),
- hir::TyUint(ast::TyU16) => return Primitive(U16),
- hir::TyUint(ast::TyU32) => return Primitive(U32),
- hir::TyUint(ast::TyU64) => return Primitive(U64),
- hir::TyFloat(ast::TyF32) => return Primitive(F32),
- hir::TyFloat(ast::TyF64) => return Primitive(F64),
+ hir::TyInt(ast::IntTy::Is) => return Primitive(Isize),
+ hir::TyInt(ast::IntTy::I8) => return Primitive(I8),
+ hir::TyInt(ast::IntTy::I16) => return Primitive(I16),
+ hir::TyInt(ast::IntTy::I32) => return Primitive(I32),
+ hir::TyInt(ast::IntTy::I64) => return Primitive(I64),
+ hir::TyUint(ast::UintTy::Us) => return Primitive(Usize),
+ hir::TyUint(ast::UintTy::U8) => return Primitive(U8),
+ hir::TyUint(ast::UintTy::U16) => return Primitive(U16),
+ hir::TyUint(ast::UintTy::U32) => return Primitive(U32),
+ hir::TyUint(ast::UintTy::U64) => return Primitive(U64),
+ hir::TyFloat(ast::FloatTy::F32) => return Primitive(F32),
+ hir::TyFloat(ast::FloatTy::F64) => return Primitive(F64),
},
Def::SelfTy(..) if path.segments.len() == 1 => {
return Generic(special_idents::type_self.name.to_string());
let arenas = ty::CtxtArenas::new();
let hir_map = driver::make_map(&sess, &mut hir_forest);
- abort_on_err(driver::phase_3_run_analysis_passes(&sess,
+ let krate_and_analysis = abort_on_err(driver::phase_3_run_analysis_passes(&sess,
&cstore,
hir_map,
&arenas,
&name,
resolve::MakeGlobMap::No,
- |tcx, _, analysis, _| {
+ |tcx, _, analysis, result| {
+ // Return if the driver hit an err (in `result`)
+ if let Err(_) = result {
+ return None
+ }
+
let _ignore = tcx.dep_graph.in_ignore();
let ty::CrateAnalysis { access_levels, .. } = analysis;
let external_paths = ctxt.external_paths.borrow_mut().take();
*analysis.external_paths.borrow_mut() = external_paths;
+
let map = ctxt.external_typarams.borrow_mut().take();
*analysis.external_typarams.borrow_mut() = map;
+
let map = ctxt.inlined.borrow_mut().take();
*analysis.inlined.borrow_mut() = map;
+
analysis.deref_trait_did = ctxt.deref_trait_did.get();
- (krate, analysis)
- }), &sess)
+
+ Some((krate, analysis))
+ }), &sess);
+
+ krate_and_analysis.unwrap()
}
generics = f.generics,
where_clause = WhereClause(&f.generics),
decl = f.decl));
+ try!(render_stability_since_raw(w, it.stable_since(), None));
document(w, cx, it)
}
// Trait documentation
try!(document(w, cx, it));
- fn trait_item(w: &mut fmt::Formatter, cx: &Context, m: &clean::Item)
+ fn trait_item(w: &mut fmt::Formatter, cx: &Context, m: &clean::Item, t: &clean::Item)
-> fmt::Result {
let name = m.name.as_ref().unwrap();
let id = derive_id(format!("{}.{}", shortty(m), name));
id = id,
stab = m.stability_class()));
try!(render_assoc_item(w, m, AssocItemLink::Anchor));
- try!(write!(w, "</code></h3>"));
+ try!(write!(w, "</code>"));
+ try!(render_stability_since(w, m, t));
+ try!(write!(w, "</h3>"));
try!(document(w, cx, m));
Ok(())
}
<div class='methods'>
"));
for t in &types {
- try!(trait_item(w, cx, *t));
+ try!(trait_item(w, cx, *t, it));
}
try!(write!(w, "</div>"));
}
<div class='methods'>
"));
for t in &consts {
- try!(trait_item(w, cx, *t));
+ try!(trait_item(w, cx, *t, it));
}
try!(write!(w, "</div>"));
}
<div class='methods'>
"));
for m in &required {
- try!(trait_item(w, cx, *m));
+ try!(trait_item(w, cx, *m, it));
}
try!(write!(w, "</div>"));
}
<div class='methods'>
"));
for m in &provided {
- try!(trait_item(w, cx, *m));
+ try!(trait_item(w, cx, *m, it));
}
try!(write!(w, "</div>"));
}
// If there are methods directly on this trait object, render them here.
- try!(render_assoc_items(w, cx, it.def_id, AssocItemRender::All));
+ try!(render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All));
let cache = cache();
try!(write!(w, "
Ok(())
}
+fn render_stability_since_raw<'a>(w: &mut fmt::Formatter,
+ ver: Option<&'a str>,
+ containing_ver: Option<&'a str>) -> fmt::Result {
+ if containing_ver != ver {
+ match ver {
+ Some(v) =>
+ if v.len() > 0 {
+ try!(write!(w, "<span class=\"since\">{}</span>",
+ v))
+ },
+ None => {}
+ }
+ }
+
+ Ok(())
+}
+
+fn render_stability_since(w: &mut fmt::Formatter,
+ item: &clean::Item,
+ containing_item: &clean::Item) -> fmt::Result {
+ render_stability_since_raw(w, item.stable_since(), containing_item.stable_since())
+}
+
fn render_assoc_item(w: &mut fmt::Formatter, meth: &clean::Item,
link: AssocItemLink) -> fmt::Result {
fn method(w: &mut fmt::Formatter,
"",
true));
try!(write!(w, "</pre>"));
+ try!(render_stability_since_raw(w, it.stable_since(), None));
try!(document(w, cx, it));
let mut fields = s.fields.iter().filter(|f| {
try!(write!(w, "</table>"));
}
}
- render_assoc_items(w, cx, it.def_id, AssocItemRender::All)
+ render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
}
fn item_enum(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
try!(write!(w, "}}"));
}
try!(write!(w, "</pre>"));
+ try!(render_stability_since_raw(w, it.stable_since(), None));
try!(document(w, cx, it));
if !e.variants.is_empty() {
- try!(write!(w, "<h2 class='variants'>Variants</h2>\n<table>"));
+ try!(write!(w, "<h2 class='variants'>Variants</h2>\n<table class='variants_table'>"));
for variant in &e.variants {
try!(write!(w, "<tr><td id='variant.{name}'><code>{name}</code></td><td>",
name = variant.name.as_ref().unwrap()));
}
_ => ()
}
+ try!(write!(w, "</td><td>"));
+ try!(render_stability_since(w, variant, it));
try!(write!(w, "</td></tr>"));
}
try!(write!(w, "</table>"));
}
- try!(render_assoc_items(w, cx, it.def_id, AssocItemRender::All));
+ try!(render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All));
Ok(())
}
fn render_assoc_items(w: &mut fmt::Formatter,
cx: &Context,
+ containing_item: &clean::Item,
it: DefId,
what: AssocItemRender) -> fmt::Result {
let c = cache();
}
};
for i in &non_trait {
- try!(render_impl(w, cx, i, AssocItemLink::Anchor, render_header));
+ try!(render_impl(w, cx, i, AssocItemLink::Anchor, render_header,
+ containing_item.stable_since()));
}
}
if let AssocItemRender::DerefFor { .. } = what {
}
});
if let Some(impl_) = deref_impl {
- try!(render_deref_methods(w, cx, impl_));
+ try!(render_deref_methods(w, cx, impl_, containing_item));
}
try!(write!(w, "<h2 id='implementations'>Trait \
Implementations</h2>"));
});
for i in &manual {
let did = i.trait_did().unwrap();
- try!(render_impl(w, cx, i, AssocItemLink::GotoSource(did), true));
+ try!(render_impl(w, cx, i, AssocItemLink::GotoSource(did), true,
+ containing_item.stable_since()));
}
if !derived.is_empty() {
try!(write!(w, "<h3 id='derived_implementations'>\
</h3>"));
for i in &derived {
let did = i.trait_did().unwrap();
- try!(render_impl(w, cx, i, AssocItemLink::GotoSource(did), true));
+ try!(render_impl(w, cx, i, AssocItemLink::GotoSource(did), true,
+ containing_item.stable_since()));
}
}
}
Ok(())
}
-fn render_deref_methods(w: &mut fmt::Formatter, cx: &Context, impl_: &Impl) -> fmt::Result {
+fn render_deref_methods(w: &mut fmt::Formatter, cx: &Context, impl_: &Impl,
+ container_item: &clean::Item) -> fmt::Result {
let deref_type = impl_.impl_.trait_.as_ref().unwrap();
let target = impl_.impl_.items.iter().filter_map(|item| {
match item.inner {
}).next().expect("Expected associated type binding");
let what = AssocItemRender::DerefFor { trait_: deref_type, type_: target };
match *target {
- clean::ResolvedPath { did, .. } => render_assoc_items(w, cx, did, what),
+ clean::ResolvedPath { did, .. } => render_assoc_items(w, cx, container_item, did, what),
_ => {
if let Some(prim) = target.primitive_type() {
if let Some(c) = cache().primitive_locations.get(&prim) {
let did = DefId { krate: *c, index: prim.to_def_index() };
- try!(render_assoc_items(w, cx, did, what));
+ try!(render_assoc_items(w, cx, container_item, did, what));
}
}
Ok(())
// otherwise. If render_header is false, we will avoid rendering static
// methods, since they are not accessible for the type implementing `Deref`
fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLink,
- render_header: bool) -> fmt::Result {
+ render_header: bool, outer_version: Option<&str>) -> fmt::Result {
if render_header {
- try!(write!(w, "<h3 class='impl'><code>{}</code></h3>", i.impl_));
+ try!(write!(w, "<h3 class='impl'><code>{}</code>", i.impl_));
+ let since = i.stability.as_ref().map(|s| &s.since[..]);
+ try!(render_stability_since_raw(w, since, outer_version));
+ try!(write!(w, "</h3>"));
if let Some(ref dox) = i.dox {
try!(write!(w, "<div class='docblock'>{}</div>", Markdown(dox)));
}
}
fn doctraititem(w: &mut fmt::Formatter, cx: &Context, item: &clean::Item,
- link: AssocItemLink, render_static: bool) -> fmt::Result {
+ link: AssocItemLink, render_static: bool,
+ outer_version: Option<&str>) -> fmt::Result {
let name = item.name.as_ref().unwrap();
match item.inner {
clean::MethodItem(..) | clean::TyMethodItem(..) => {
// Only render when the method is not static or we allow static methods
if !is_static_method(item) || render_static {
let id = derive_id(format!("method.{}", name));
- try!(write!(w, "<h4 id='{}' class='{}'><code>", id, shortty(item)));
- try!(render_assoc_item(w, item, link));
+ try!(write!(w, "<h4 id='{}' class='{}'>", id, shortty(item)));
+ try!(render_stability_since_raw(w, item.stable_since(), outer_version));
+ try!(write!(w, "<code>"));
+ try!(render_assoc_item(w, item, link));
try!(write!(w, "</code></h4>\n"));
}
}
try!(write!(w, "<div class='impl-items'>"));
for trait_item in &i.impl_.items {
- try!(doctraititem(w, cx, trait_item, link, render_header));
+ try!(doctraititem(w, cx, trait_item, link, render_header, outer_version));
}
fn render_default_items(w: &mut fmt::Formatter,
did: DefId,
t: &clean::Trait,
i: &clean::Impl,
- render_static: bool) -> fmt::Result {
+ render_static: bool,
+ outer_version: Option<&str>) -> fmt::Result {
for trait_item in &t.items {
let n = trait_item.name.clone();
match i.items.iter().find(|m| { m.name == n }) {
None => {}
}
- try!(doctraititem(w, cx, trait_item, AssocItemLink::GotoSource(did), render_static));
+ try!(doctraititem(w, cx, trait_item, AssocItemLink::GotoSource(did), render_static,
+ outer_version));
}
Ok(())
}
// for them work.
if let Some(clean::ResolvedPath { did, .. }) = i.impl_.trait_ {
if let Some(t) = cache().traits.get(&did) {
- try!(render_default_items(w, cx, did, t, &i.impl_, render_header));
+ try!(render_default_items(w, cx, did, t, &i.impl_, render_header, outer_version));
}
}
try!(w.write_str(&highlight::highlight(&t.source,
Some("macro"),
None)));
+ try!(render_stability_since_raw(w, it.stable_since(), None));
document(w, cx, it)
}
it: &clean::Item,
_p: &clean::PrimitiveType) -> fmt::Result {
try!(document(w, cx, it));
- render_assoc_items(w, cx, it.def_id, AssocItemRender::All)
+ render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
}
fn get_basic_keywords() -> &'static str {
opacity: 0.65;
}
+span.since {
+ float: right;
+ font-weight: normal;
+ font-size: initial;
+ color: grey;
+}
+
+.variants_table {
+ width: 100%;
+}
+
+.variants_table tbody tr td:first-child {
+ width: 1%; /* make the variant name as small as possible */
+}
+
td.summary-column {
width: 100%;
}
HashMap::with_capacity_and_hasher(capacity, hash_state)
}
+ /// Returns a reference to the map's hasher.
+ #[unstable(feature = "hashmap_public_hasher", reason = "don't want to make insta-stable",
+ issue = "31262")]
+ pub fn hasher(&self) -> &S {
+ &self.hash_builder
+ }
+
/// Returns the number of elements the map can hold without reallocating.
///
/// This number is a lower bound; the `HashMap<K, V>` might be able to hold
}
}
+ /// Returns a reference to the set's hasher.
+ #[unstable(feature = "hashmap_public_hasher", reason = "don't want to make insta-stable",
+ issue = "31262")]
+ pub fn hasher(&self) -> &S {
+ self.map.hasher()
+ }
+
/// Deprecated, renamed to `with_hasher`
#[inline]
#[unstable(feature = "hashmap_hasher", reason = "hasher stuff is unclear",
}
}
+ /// Change the IP address associated with this socket address.
+ #[unstable(feature = "sockaddr_setters", reason = "recent addition", issue = "31572")]
+ pub fn set_ip(&mut self, new_ip: IpAddr) {
+ // `match (*self, new_ip)` would have us mutate a copy of self only to throw it away.
+ match (self, new_ip) {
+ (&mut SocketAddr::V4(ref mut a), IpAddr::V4(new_ip)) => a.set_ip(new_ip),
+ (&mut SocketAddr::V6(ref mut a), IpAddr::V6(new_ip)) => a.set_ip(new_ip),
+ (self_, new_ip) => *self_ = Self::new(new_ip, self_.port()),
+ }
+ }
+
/// Returns the port number associated with this socket address.
#[stable(feature = "rust1", since = "1.0.0")]
pub fn port(&self) -> u16 {
SocketAddr::V6(ref a) => a.port(),
}
}
+
+ /// Change the port number associated with this socket address.
+ #[unstable(feature = "sockaddr_setters", reason = "recent addition", issue = "31572")]
+ pub fn set_port(&mut self, new_port: u16) {
+ match *self {
+ SocketAddr::V4(ref mut a) => a.set_port(new_port),
+ SocketAddr::V6(ref mut a) => a.set_port(new_port),
+ }
+ }
}
impl SocketAddrV4 {
}
}
+ /// Change the IP address associated with this socket address.
+ #[unstable(feature = "sockaddr_setters", reason = "recent addition", issue = "31572")]
+ pub fn set_ip(&mut self, new_ip: Ipv4Addr) { self.inner.sin_addr = *new_ip.as_inner() }
+
/// Returns the port number associated with this socket address.
#[stable(feature = "rust1", since = "1.0.0")]
pub fn port(&self) -> u16 { ntoh(self.inner.sin_port) }
+
+ /// Change the port number associated with this socket address.
+ #[unstable(feature = "sockaddr_setters", reason = "recent addition", issue = "31572")]
+ pub fn set_port(&mut self, new_port: u16) { self.inner.sin_port = hton(new_port) }
}
impl SocketAddrV6 {
}
}
+ /// Change the IP address associated with this socket address.
+ #[unstable(feature = "sockaddr_setters", reason = "recent addition", issue = "31572")]
+ pub fn set_ip(&mut self, new_ip: Ipv6Addr) { self.inner.sin6_addr = *new_ip.as_inner() }
+
/// Returns the port number associated with this socket address.
#[stable(feature = "rust1", since = "1.0.0")]
pub fn port(&self) -> u16 { ntoh(self.inner.sin6_port) }
+ /// Change the port number associated with this socket address.
+ #[unstable(feature = "sockaddr_setters", reason = "recent addition", issue = "31572")]
+ pub fn set_port(&mut self, new_port: u16) { self.inner.sin6_port = hton(new_port) }
+
/// Returns the flow information associated with this address,
/// corresponding to the `sin6_flowinfo` field in C.
#[stable(feature = "rust1", since = "1.0.0")]
pub fn flowinfo(&self) -> u32 { ntoh(self.inner.sin6_flowinfo) }
+ /// Change the flow information associated with this socket address.
+ #[unstable(feature = "sockaddr_setters", reason = "recent addition", issue = "31572")]
+ pub fn set_flowinfo(&mut self, new_flowinfo: u32) {
+ self.inner.sin6_flowinfo = hton(new_flowinfo)
+ }
+
/// Returns the scope ID associated with this address,
/// corresponding to the `sin6_scope_id` field in C.
#[stable(feature = "rust1", since = "1.0.0")]
pub fn scope_id(&self) -> u32 { ntoh(self.inner.sin6_scope_id) }
+
+ /// Change the scope ID associated with this socket address.
+ #[unstable(feature = "sockaddr_setters", reason = "recent addition", issue = "31572")]
+ pub fn set_scope_id(&mut self, new_scope_id: u32) {
+ self.inner.sin6_scope_id = hton(new_scope_id)
+ }
}
impl FromInner<c::sockaddr_in> for SocketAddrV4 {
fn resolve_socket_addr(s: &str, p: u16) -> io::Result<vec::IntoIter<SocketAddr>> {
let ips = try!(lookup_host(s));
let v: Vec<_> = try!(ips.map(|a| {
- a.map(|a| {
- match a {
- SocketAddr::V4(ref a) => {
- SocketAddr::V4(SocketAddrV4::new(*a.ip(), p))
- }
- SocketAddr::V6(ref a) => {
- SocketAddr::V6(SocketAddrV6::new(*a.ip(), p, a.flowinfo(),
- a.scope_id()))
- }
- }
+ a.map(|mut a| {
+ a.set_port(p);
+ a
})
}).collect());
Ok(v.into_iter())
fn to_socket_addr_str_bad() {
assert!(tsa("1200::AB00:1234::2552:7777:1313:34300").is_err());
}
+
+ #[test]
+ fn set_ip() {
+ fn ip4(low: u8) -> Ipv4Addr { Ipv4Addr::new(77, 88, 21, low) }
+ fn ip6(low: u16) -> Ipv6Addr { Ipv6Addr::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, low) }
+
+ let mut v4 = SocketAddrV4::new(ip4(11), 80);
+ assert_eq!(v4.ip(), &ip4(11));
+ v4.set_ip(ip4(12));
+ assert_eq!(v4.ip(), &ip4(12));
+
+ let mut addr = SocketAddr::V4(v4);
+ assert_eq!(addr.ip(), IpAddr::V4(ip4(12)));
+ addr.set_ip(IpAddr::V4(ip4(13)));
+ assert_eq!(addr.ip(), IpAddr::V4(ip4(13)));
+ addr.set_ip(IpAddr::V6(ip6(14)));
+ assert_eq!(addr.ip(), IpAddr::V6(ip6(14)));
+
+ let mut v6 = SocketAddrV6::new(ip6(1), 80, 0, 0);
+ assert_eq!(v6.ip(), &ip6(1));
+ v6.set_ip(ip6(2));
+ assert_eq!(v6.ip(), &ip6(2));
+
+ let mut addr = SocketAddr::V6(v6);
+ assert_eq!(addr.ip(), IpAddr::V6(ip6(2)));
+ addr.set_ip(IpAddr::V6(ip6(3)));
+ assert_eq!(addr.ip(), IpAddr::V6(ip6(3)));
+ addr.set_ip(IpAddr::V4(ip4(4)));
+ assert_eq!(addr.ip(), IpAddr::V4(ip4(4)));
+ }
+
+ #[test]
+ fn set_port() {
+ let mut v4 = SocketAddrV4::new(Ipv4Addr::new(77, 88, 21, 11), 80);
+ assert_eq!(v4.port(), 80);
+ v4.set_port(443);
+ assert_eq!(v4.port(), 443);
+
+ let mut addr = SocketAddr::V4(v4);
+ assert_eq!(addr.port(), 443);
+ addr.set_port(8080);
+ assert_eq!(addr.port(), 8080);
+
+ let mut v6 = SocketAddrV6::new(Ipv6Addr::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), 80, 0, 0);
+ assert_eq!(v6.port(), 80);
+ v6.set_port(443);
+ assert_eq!(v6.port(), 443);
+
+ let mut addr = SocketAddr::V6(v6);
+ assert_eq!(addr.port(), 443);
+ addr.set_port(8080);
+ assert_eq!(addr.port(), 8080);
+ }
+
+ #[test]
+ fn set_flowinfo() {
+ let mut v6 = SocketAddrV6::new(Ipv6Addr::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), 80, 10, 0);
+ assert_eq!(v6.flowinfo(), 10);
+ v6.set_flowinfo(20);
+ assert_eq!(v6.flowinfo(), 20);
+ }
+
+ #[test]
+ fn set_scope_id() {
+ let mut v6 = SocketAddrV6::new(Ipv6Addr::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), 80, 0, 10);
+ assert_eq!(v6.scope_id(), 10);
+ v6.set_scope_id(20);
+ assert_eq!(v6.scope_id(), 20);
+ }
}
//! Working with processes.
#![stable(feature = "process", since = "1.0.0")]
-#![allow(non_upper_case_globals)]
use prelude::v1::*;
use io::prelude::*;
use ffi::OsStr;
use fmt;
-use io::{self, Error, ErrorKind};
-use path;
+use io;
+use path::Path;
use str;
-use sys::pipe::{self, AnonPipe};
+use sys::pipe::AnonPipe;
use sys::process as imp;
use sys_common::{AsInner, AsInnerMut, FromInner, IntoInner};
use thread::{self, JoinHandle};
pub struct Child {
handle: imp::Process,
- /// None until wait() or wait_with_output() is called.
- status: Option<imp::ExitStatus>,
-
/// The handle for writing to the child's stdin, if it has been captured
#[stable(feature = "process", since = "1.0.0")]
pub stdin: Option<ChildStdin>,
fn as_inner(&self) -> &imp::Process { &self.handle }
}
+impl FromInner<(imp::Process, imp::StdioPipes)> for Child {
+ fn from_inner((handle, io): (imp::Process, imp::StdioPipes)) -> Child {
+ Child {
+ handle: handle,
+ stdin: io.stdin.map(ChildStdin::from_inner),
+ stdout: io.stdout.map(ChildStdout::from_inner),
+ stderr: io.stderr.map(ChildStderr::from_inner),
+ }
+ }
+}
+
impl IntoInner<imp::Process> for Child {
fn into_inner(self) -> imp::Process { self.handle }
}
fn into_inner(self) -> AnonPipe { self.inner }
}
+impl FromInner<AnonPipe> for ChildStdin {
+ fn from_inner(pipe: AnonPipe) -> ChildStdin {
+ ChildStdin { inner: pipe }
+ }
+}
+
/// A handle to a child process's stdout
#[stable(feature = "process", since = "1.0.0")]
pub struct ChildStdout {
fn into_inner(self) -> AnonPipe { self.inner }
}
+impl FromInner<AnonPipe> for ChildStdout {
+ fn from_inner(pipe: AnonPipe) -> ChildStdout {
+ ChildStdout { inner: pipe }
+ }
+}
+
/// A handle to a child process's stderr
#[stable(feature = "process", since = "1.0.0")]
pub struct ChildStderr {
fn into_inner(self) -> AnonPipe { self.inner }
}
+impl FromInner<AnonPipe> for ChildStderr {
+ fn from_inner(pipe: AnonPipe) -> ChildStderr {
+ ChildStderr { inner: pipe }
+ }
+}
+
/// The `Command` type acts as a process builder, providing fine-grained control
/// over how a new process should be spawned. A default configuration can be
/// generated using `Command::new(program)`, where `program` gives a path to the
#[stable(feature = "process", since = "1.0.0")]
pub struct Command {
inner: imp::Command,
-
- // Details explained in the builder methods
- stdin: Option<Stdio>,
- stdout: Option<Stdio>,
- stderr: Option<Stdio>,
}
impl Command {
/// otherwise configure the process.
#[stable(feature = "process", since = "1.0.0")]
pub fn new<S: AsRef<OsStr>>(program: S) -> Command {
- Command {
- inner: imp::Command::new(program.as_ref()),
- stdin: None,
- stdout: None,
- stderr: None,
- }
+ Command { inner: imp::Command::new(program.as_ref()) }
}
/// Add an argument to pass to the program.
/// Add multiple arguments to pass to the program.
#[stable(feature = "process", since = "1.0.0")]
pub fn args<S: AsRef<OsStr>>(&mut self, args: &[S]) -> &mut Command {
- self.inner.args(args.iter().map(AsRef::as_ref));
+ for arg in args {
+ self.arg(arg.as_ref());
+ }
self
}
/// Sets the working directory for the child process.
#[stable(feature = "process", since = "1.0.0")]
- pub fn current_dir<P: AsRef<path::Path>>(&mut self, dir: P) -> &mut Command {
+ pub fn current_dir<P: AsRef<Path>>(&mut self, dir: P) -> &mut Command {
self.inner.cwd(dir.as_ref().as_ref());
self
}
/// Configuration for the child process's stdin handle (file descriptor 0).
#[stable(feature = "process", since = "1.0.0")]
pub fn stdin(&mut self, cfg: Stdio) -> &mut Command {
- self.stdin = Some(cfg);
+ self.inner.stdin(cfg.0);
self
}
/// Configuration for the child process's stdout handle (file descriptor 1).
#[stable(feature = "process", since = "1.0.0")]
pub fn stdout(&mut self, cfg: Stdio) -> &mut Command {
- self.stdout = Some(cfg);
+ self.inner.stdout(cfg.0);
self
}
/// Configuration for the child process's stderr handle (file descriptor 2).
#[stable(feature = "process", since = "1.0.0")]
pub fn stderr(&mut self, cfg: Stdio) -> &mut Command {
- self.stderr = Some(cfg);
+ self.inner.stderr(cfg.0);
self
}
- fn spawn_inner(&self, default_io: StdioImp) -> io::Result<Child> {
- let default_io = Stdio(default_io);
-
- // See comment on `setup_io` for what `_drop_later` is.
- let (their_stdin, our_stdin, _drop_later) = try!(
- setup_io(self.stdin.as_ref().unwrap_or(&default_io), true)
- );
- let (their_stdout, our_stdout, _drop_later) = try!(
- setup_io(self.stdout.as_ref().unwrap_or(&default_io), false)
- );
- let (their_stderr, our_stderr, _drop_later) = try!(
- setup_io(self.stderr.as_ref().unwrap_or(&default_io), false)
- );
-
- match imp::Process::spawn(&self.inner, their_stdin, their_stdout,
- their_stderr) {
- Err(e) => Err(e),
- Ok(handle) => Ok(Child {
- handle: handle,
- status: None,
- stdin: our_stdin.map(|fd| ChildStdin { inner: fd }),
- stdout: our_stdout.map(|fd| ChildStdout { inner: fd }),
- stderr: our_stderr.map(|fd| ChildStderr { inner: fd }),
- })
- }
- }
-
/// Executes the command as a child process, returning a handle to it.
///
/// By default, stdin, stdout and stderr are inherited from the parent.
#[stable(feature = "process", since = "1.0.0")]
pub fn spawn(&mut self) -> io::Result<Child> {
- self.spawn_inner(StdioImp::Inherit)
+ self.inner.spawn(imp::Stdio::Inherit).map(Child::from_inner)
}
/// Executes the command as a child process, waiting for it to finish and
/// ```
#[stable(feature = "process", since = "1.0.0")]
pub fn output(&mut self) -> io::Result<Output> {
- self.spawn_inner(StdioImp::MakePipe).and_then(|p| p.wait_with_output())
+ self.inner.spawn(imp::Stdio::MakePipe).map(Child::from_inner)
+ .and_then(|p| p.wait_with_output())
}
/// Executes a command as a child process, waiting for it to finish and
fn as_inner_mut(&mut self) -> &mut imp::Command { &mut self.inner }
}
-// Takes a `Stdio` configuration (this module) and whether the to-be-owned
-// handle will be readable.
-//
-// Returns a triple of (stdio to spawn with, stdio to store, stdio to drop). The
-// stdio to spawn with is passed down to the `sys` module and indicates how the
-// stdio stream should be set up. The "stdio to store" is an object which
-// should be returned in the `Child` that makes its way out. The "stdio to drop"
-// represents the raw value of "stdio to spawn with", but is the owned variant
-// for it. This needs to be dropped after the child spawns
-fn setup_io(io: &Stdio, readable: bool)
- -> io::Result<(imp::Stdio, Option<AnonPipe>, Option<AnonPipe>)>
-{
- Ok(match io.0 {
- StdioImp::MakePipe => {
- let (reader, writer) = try!(pipe::anon_pipe());
- if readable {
- (imp::Stdio::Raw(reader.raw()), Some(writer), Some(reader))
- } else {
- (imp::Stdio::Raw(writer.raw()), Some(reader), Some(writer))
- }
- }
- StdioImp::Raw(ref owned) => (imp::Stdio::Raw(owned.raw()), None, None),
- StdioImp::Inherit => (imp::Stdio::Inherit, None, None),
- StdioImp::None => (imp::Stdio::None, None, None),
- })
-}
-
/// The output of a finished process.
#[derive(PartialEq, Eq, Clone)]
#[stable(feature = "process", since = "1.0.0")]
/// Describes what to do with a standard I/O stream for a child process.
#[stable(feature = "process", since = "1.0.0")]
-pub struct Stdio(StdioImp);
-
-// The internal enum for stdio setup; see below for descriptions.
-enum StdioImp {
- MakePipe,
- Raw(imp::RawStdio),
- Inherit,
- None,
-}
+pub struct Stdio(imp::Stdio);
impl Stdio {
/// A new pipe should be arranged to connect the parent and child processes.
#[stable(feature = "process", since = "1.0.0")]
- pub fn piped() -> Stdio { Stdio(StdioImp::MakePipe) }
+ pub fn piped() -> Stdio { Stdio(imp::Stdio::MakePipe) }
/// The child inherits from the corresponding parent descriptor.
#[stable(feature = "process", since = "1.0.0")]
- pub fn inherit() -> Stdio { Stdio(StdioImp::Inherit) }
+ pub fn inherit() -> Stdio { Stdio(imp::Stdio::Inherit) }
/// This stream will be ignored. This is the equivalent of attaching the
/// stream to `/dev/null`
#[stable(feature = "process", since = "1.0.0")]
- pub fn null() -> Stdio { Stdio(StdioImp::None) }
+ pub fn null() -> Stdio { Stdio(imp::Stdio::Null) }
}
-impl FromInner<imp::RawStdio> for Stdio {
- fn from_inner(inner: imp::RawStdio) -> Stdio {
- Stdio(StdioImp::Raw(inner))
+impl FromInner<imp::Stdio> for Stdio {
+ fn from_inner(inner: imp::Stdio) -> Stdio {
+ Stdio(inner)
}
}
/// SIGKILL on unix platforms.
#[stable(feature = "process", since = "1.0.0")]
pub fn kill(&mut self) -> io::Result<()> {
- #[cfg(unix)] fn collect_status(p: &mut Child) {
- // On Linux (and possibly other unices), a process that has exited will
- // continue to accept signals because it is "defunct". The delivery of
- // signals will only fail once the child has been reaped. For this
- // reason, if the process hasn't exited yet, then we attempt to collect
- // their status with WNOHANG.
- if p.status.is_none() {
- match p.handle.try_wait() {
- Some(status) => { p.status = Some(status); }
- None => {}
- }
- }
- }
- #[cfg(windows)] fn collect_status(_p: &mut Child) {}
-
- collect_status(self);
-
- // if the process has finished, and therefore had waitpid called,
- // and we kill it, then on unix we might ending up killing a
- // newer process that happens to have the same (re-used) id
- if self.status.is_some() {
- return Err(Error::new(
- ErrorKind::InvalidInput,
- "invalid argument: can't kill an exited process",
- ))
- }
-
- unsafe { self.handle.kill() }
+ self.handle.kill()
}
/// Returns the OS-assigned process identifier associated with this child.
#[stable(feature = "process", since = "1.0.0")]
pub fn wait(&mut self) -> io::Result<ExitStatus> {
drop(self.stdin.take());
- match self.status {
- Some(code) => Ok(ExitStatus(code)),
- None => {
- let status = try!(self.handle.wait());
- self.status = Some(status);
- Ok(ExitStatus(status))
- }
- }
+ self.handle.wait().map(ExitStatus)
}
/// Simultaneously waits for the child to exit and collect all remaining
#![stable(feature = "rust1", since = "1.0.0")]
-use os::unix::raw::{uid_t, gid_t};
+use prelude::v1::*;
+
+use io;
use os::unix::io::{FromRawFd, RawFd, AsRawFd, IntoRawFd};
+use os::unix::raw::{uid_t, gid_t};
use process;
use sys;
use sys_common::{AsInnerMut, AsInner, FromInner, IntoInner};
#[unstable(feature = "process_session_leader", reason = "recently added",
issue = "27811")]
fn session_leader(&mut self, on: bool) -> &mut process::Command;
+
+ /// Schedules a closure to be run just before the `exec` function is
+ /// invoked.
+ ///
+ /// The closure is allowed to return an I/O error whose OS error code will
+ /// be communicated back to the parent and returned as an error from when
+ /// the spawn was requested.
+ ///
+ /// Multiple closures can be registered and they will be called in order of
+ /// their registration. If a closure returns `Err` then no further closures
+ /// will be called and the spawn operation will immediately return with a
+ /// failure.
+ ///
+ /// # Notes
+ ///
+ /// This closure will be run in the context of the child process after a
+ /// `fork`. This primarily means that any modificatons made to memory on
+ /// behalf of this closure will **not** be visible to the parent process.
+ /// This is often a very constrained environment where normal operations
+ /// like `malloc` or acquiring a mutex are not guaranteed to work (due to
+ /// other threads perhaps still running when the `fork` was run).
+ ///
+ /// When this closure is run, aspects such as the stdio file descriptors and
+ /// working directory have successfully been changed, so output to these
+ /// locations may not appear where intended.
+ #[unstable(feature = "process_exec", issue = "31398")]
+ fn before_exec<F>(&mut self, f: F) -> &mut process::Command
+ where F: FnMut() -> io::Result<()> + Send + Sync + 'static;
+
+ /// Performs all the required setup by this `Command`, followed by calling
+ /// the `execvp` syscall.
+ ///
+ /// On success this function will not return, and otherwise it will return
+ /// an error indicating why the exec (or another part of the setup of the
+ /// `Command`) failed.
+ ///
+ /// This function, unlike `spawn`, will **not** `fork` the process to create
+ /// a new child. Like spawn, however, the default behavior for the stdio
+ /// descriptors will be to inherited from the current process.
+ ///
+ /// # Notes
+ ///
+ /// The process may be in a "broken state" if this function returns in
+ /// error. For example the working directory, environment variables, signal
+ /// handling settings, various user/group information, or aspects of stdio
+ /// file descriptors may have changed. If a "transactional spawn" is
+ /// required to gracefully handle errors it is recommended to use the
+ /// cross-platform `spawn` instead.
+ #[unstable(feature = "process_exec", issue = "31398")]
+ fn exec(&mut self) -> io::Error;
}
#[stable(feature = "rust1", since = "1.0.0")]
self.as_inner_mut().session_leader(on);
self
}
+
+ fn before_exec<F>(&mut self, f: F) -> &mut process::Command
+ where F: FnMut() -> io::Result<()> + Send + Sync + 'static
+ {
+ self.as_inner_mut().before_exec(Box::new(f));
+ self
+ }
+
+ fn exec(&mut self) -> io::Error {
+ self.as_inner_mut().exec(sys::process::Stdio::Inherit)
+ }
}
/// Unix-specific extensions to `std::process::ExitStatus`
#[stable(feature = "process_extensions", since = "1.2.0")]
impl FromRawFd for process::Stdio {
unsafe fn from_raw_fd(fd: RawFd) -> process::Stdio {
- process::Stdio::from_inner(sys::fd::FileDesc::new(fd))
+ let fd = sys::fd::FileDesc::new(fd);
+ let io = sys::process::Stdio::Fd(fd);
+ process::Stdio::from_inner(io)
}
}
Ok(ret as usize)
}
- #[cfg(not(any(target_env = "newlib", target_os = "solaris")))]
+ #[cfg(not(any(target_env = "newlib", target_os = "solaris", target_os = "emscripten")))]
pub fn set_cloexec(&self) {
unsafe {
let ret = libc::ioctl(self.fd, libc::FIOCLEX);
debug_assert_eq!(ret, 0);
}
}
- #[cfg(any(target_env = "newlib", target_os = "solaris"))]
+ #[cfg(any(target_env = "newlib", target_os = "solaris", target_os = "emscripten"))]
pub fn set_cloexec(&self) {
unsafe {
let previous = libc::fcntl(self.fd, libc::F_GETFD);
self.0.write(buf)
}
- pub fn raw(&self) -> libc::c_int { self.0.raw() }
pub fn fd(&self) -> &FileDesc { &self.0 }
pub fn into_fd(self) -> FileDesc { self.0 }
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![allow(non_snake_case)]
-
use prelude::v1::*;
use os::unix::prelude::*;
-use collections::HashMap;
+use collections::hash_map::{HashMap, Entry};
use env;
use ffi::{OsString, OsStr, CString, CStr};
use fmt;
use io::{self, Error, ErrorKind};
-use libc::{self, pid_t, c_void, c_int, gid_t, uid_t};
+use libc::{self, pid_t, c_int, gid_t, uid_t, c_char};
+use mem;
use ptr;
use sys::fd::FileDesc;
use sys::fs::{File, OpenOptions};
-use sys::pipe::AnonPipe;
+use sys::pipe::{self, AnonPipe};
use sys::{self, cvt, cvt_r};
////////////////////////////////////////////////////////////////////////////////
// Command
////////////////////////////////////////////////////////////////////////////////
-#[derive(Clone)]
pub struct Command {
+ // Currently we try hard to ensure that the call to `.exec()` doesn't
+ // actually allocate any memory. While many platforms try to ensure that
+ // memory allocation works after a fork in a multithreaded process, it's
+ // been observed to be buggy and somewhat unreliable, so we do our best to
+ // just not do it at all!
+ //
+ // Along those lines, the `argv` and `envp` raw pointers here are exactly
+ // what's gonna get passed to `execvp`. The `argv` array starts with the
+ // `program` and ends with a NULL, and the `envp` pointer, if present, is
+ // also null-terminated.
+ //
+ // Right now we don't support removing arguments, so there's no much fancy
+ // support there, but we support adding and removing environment variables,
+ // so a side table is used to track where in the `envp` array each key is
+ // located. Whenever we add a key we update it in place if it's already
+ // present, and whenever we remove a key we update the locations of all
+ // other keys.
program: CString,
args: Vec<CString>,
- env: Option<HashMap<OsString, OsString>>, // Guaranteed to have no NULs.
+ env: Option<HashMap<OsString, (usize, CString)>>,
+ argv: Vec<*const c_char>,
+ envp: Option<Vec<*const c_char>>,
+
cwd: Option<CString>,
uid: Option<uid_t>,
gid: Option<gid_t>,
session_leader: bool,
saw_nul: bool,
+ closures: Vec<Box<FnMut() -> io::Result<()> + Send + Sync>>,
+ stdin: Option<Stdio>,
+ stdout: Option<Stdio>,
+ stderr: Option<Stdio>,
+}
+
+// passed back to std::process with the pipes connected to the child, if any
+// were requested
+pub struct StdioPipes {
+ pub stdin: Option<AnonPipe>,
+ pub stdout: Option<AnonPipe>,
+ pub stderr: Option<AnonPipe>,
+}
+
+// passed to do_exec() with configuration of what the child stdio should look
+// like
+struct ChildPipes {
+ stdin: ChildStdio,
+ stdout: ChildStdio,
+ stderr: ChildStdio,
+}
+
+enum ChildStdio {
+ Inherit,
+ Explicit(c_int),
+ Owned(FileDesc),
+}
+
+pub enum Stdio {
+ Inherit,
+ Null,
+ MakePipe,
+ Fd(FileDesc),
}
impl Command {
pub fn new(program: &OsStr) -> Command {
let mut saw_nul = false;
+ let program = os2c(program, &mut saw_nul);
Command {
- program: os2c(program, &mut saw_nul),
+ argv: vec![program.as_ptr(), 0 as *const _],
+ program: program,
args: Vec::new(),
env: None,
+ envp: None,
cwd: None,
uid: None,
gid: None,
session_leader: false,
saw_nul: saw_nul,
+ closures: Vec::new(),
+ stdin: None,
+ stdout: None,
+ stderr: None,
}
}
pub fn arg(&mut self, arg: &OsStr) {
- self.args.push(os2c(arg, &mut self.saw_nul));
- }
- pub fn args<'a, I: Iterator<Item = &'a OsStr>>(&mut self, args: I) {
- let mut saw_nul = self.saw_nul;
- self.args.extend(args.map(|arg| os2c(arg, &mut saw_nul)));
- self.saw_nul = saw_nul;
+ // Overwrite the trailing NULL pointer in `argv` and then add a new null
+ // pointer.
+ let arg = os2c(arg, &mut self.saw_nul);
+ self.argv[self.args.len() + 1] = arg.as_ptr();
+ self.argv.push(0 as *const _);
+
+ // Also make sure we keep track of the owned value to schedule a
+ // destructor for this memory.
+ self.args.push(arg);
}
- fn init_env_map(&mut self) {
+
+ fn init_env_map(&mut self) -> (&mut HashMap<OsString, (usize, CString)>,
+ &mut Vec<*const c_char>) {
if self.env.is_none() {
- // Will not add NULs to env: preexisting environment will not contain any.
- self.env = Some(env::vars_os().collect());
+ let mut map = HashMap::new();
+ let mut envp = Vec::new();
+ for (k, v) in env::vars_os() {
+ let s = pair_to_key(&k, &v, &mut self.saw_nul);
+ envp.push(s.as_ptr());
+ map.insert(k, (envp.len() - 1, s));
+ }
+ envp.push(0 as *const _);
+ self.env = Some(map);
+ self.envp = Some(envp);
}
+ (self.env.as_mut().unwrap(), self.envp.as_mut().unwrap())
}
- pub fn env(&mut self, key: &OsStr, val: &OsStr) {
- let k = OsString::from_vec(os2c(key, &mut self.saw_nul).into_bytes());
- let v = OsString::from_vec(os2c(val, &mut self.saw_nul).into_bytes());
- // Will not add NULs to env: return without inserting if any were seen.
- if self.saw_nul {
- return;
+ pub fn env(&mut self, key: &OsStr, val: &OsStr) {
+ let new_key = pair_to_key(key, val, &mut self.saw_nul);
+ let (map, envp) = self.init_env_map();
+
+ // If `key` is already present then we we just update `envp` in place
+ // (and store the owned value), but if it's not there we override the
+ // trailing NULL pointer, add a new NULL pointer, and store where we
+ // were located.
+ match map.entry(key.to_owned()) {
+ Entry::Occupied(mut e) => {
+ let (i, ref mut s) = *e.get_mut();
+ envp[i] = new_key.as_ptr();
+ *s = new_key;
+ }
+ Entry::Vacant(e) => {
+ let len = envp.len();
+ envp[len - 1] = new_key.as_ptr();
+ envp.push(0 as *const _);
+ e.insert((len - 1, new_key));
+ }
}
-
- self.init_env_map();
- self.env.as_mut()
- .unwrap()
- .insert(k, v);
}
+
pub fn env_remove(&mut self, key: &OsStr) {
- self.init_env_map();
- self.env.as_mut().unwrap().remove(key);
+ let (map, envp) = self.init_env_map();
+
+ // If we actually ended up removing a key, then we need to update the
+ // position of all keys that come after us in `envp` because they're all
+ // one element sooner now.
+ if let Some((i, _)) = map.remove(key) {
+ envp.remove(i);
+
+ for (_, &mut (ref mut j, _)) in map.iter_mut() {
+ if *j >= i {
+ *j -= 1;
+ }
+ }
+ }
}
+
pub fn env_clear(&mut self) {
- self.env = Some(HashMap::new())
+ self.env = Some(HashMap::new());
+ self.envp = Some(vec![0 as *const _]);
}
+
pub fn cwd(&mut self, dir: &OsStr) {
self.cwd = Some(os2c(dir, &mut self.saw_nul));
}
pub fn session_leader(&mut self, session_leader: bool) {
self.session_leader = session_leader;
}
-}
-
-fn os2c(s: &OsStr, saw_nul: &mut bool) -> CString {
- CString::new(s.as_bytes()).unwrap_or_else(|_e| {
- *saw_nul = true;
- CString::new("<string-with-nul>").unwrap()
- })
-}
-impl fmt::Debug for Command {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- try!(write!(f, "{:?}", self.program));
- for arg in &self.args {
- try!(write!(f, " {:?}", arg));
- }
- Ok(())
+ pub fn before_exec(&mut self,
+ f: Box<FnMut() -> io::Result<()> + Send + Sync>) {
+ self.closures.push(f);
}
-}
-////////////////////////////////////////////////////////////////////////////////
-// Processes
-////////////////////////////////////////////////////////////////////////////////
-
-/// Unix exit statuses
-#[derive(PartialEq, Eq, Clone, Copy, Debug)]
-pub struct ExitStatus(c_int);
-
-#[cfg(any(target_os = "linux", target_os = "android",
- target_os = "nacl", target_os = "solaris",
- target_os = "emscripten"))]
-mod status_imp {
- pub fn WIFEXITED(status: i32) -> bool { (status & 0xff) == 0 }
- pub fn WEXITSTATUS(status: i32) -> i32 { (status >> 8) & 0xff }
- pub fn WTERMSIG(status: i32) -> i32 { status & 0x7f }
-}
-
-#[cfg(any(target_os = "macos",
- target_os = "ios",
- target_os = "freebsd",
- target_os = "dragonfly",
- target_os = "bitrig",
- target_os = "netbsd",
- target_os = "openbsd"))]
-mod status_imp {
- pub fn WIFEXITED(status: i32) -> bool { (status & 0x7f) == 0 }
- pub fn WEXITSTATUS(status: i32) -> i32 { status >> 8 }
- pub fn WTERMSIG(status: i32) -> i32 { status & 0o177 }
-}
-
-impl ExitStatus {
- fn exited(&self) -> bool {
- status_imp::WIFEXITED(self.0)
+ pub fn stdin(&mut self, stdin: Stdio) {
+ self.stdin = Some(stdin);
}
-
- pub fn success(&self) -> bool {
- self.code() == Some(0)
+ pub fn stdout(&mut self, stdout: Stdio) {
+ self.stdout = Some(stdout);
}
-
- pub fn code(&self) -> Option<i32> {
- if self.exited() {
- Some(status_imp::WEXITSTATUS(self.0))
- } else {
- None
- }
- }
-
- pub fn signal(&self) -> Option<i32> {
- if !self.exited() {
- Some(status_imp::WTERMSIG(self.0))
- } else {
- None
- }
- }
-}
-
-impl fmt::Display for ExitStatus {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- if let Some(code) = self.code() {
- write!(f, "exit code: {}", code)
- } else {
- let signal = self.signal().unwrap();
- write!(f, "signal: {}", signal)
- }
+ pub fn stderr(&mut self, stderr: Stdio) {
+ self.stderr = Some(stderr);
}
-}
-/// The unique id of the process (this should never be negative).
-pub struct Process {
- pid: pid_t
-}
+ pub fn spawn(&mut self, default: Stdio)
+ -> io::Result<(Process, StdioPipes)> {
+ const CLOEXEC_MSG_FOOTER: &'static [u8] = b"NOEX";
-pub enum Stdio {
- Inherit,
- None,
- Raw(c_int),
-}
-
-pub type RawStdio = FileDesc;
-
-const CLOEXEC_MSG_FOOTER: &'static [u8] = b"NOEX";
-
-impl Process {
- pub unsafe fn kill(&self) -> io::Result<()> {
- try!(cvt(libc::kill(self.pid, libc::SIGKILL)));
- Ok(())
- }
-
- pub fn spawn(cfg: &Command,
- in_fd: Stdio,
- out_fd: Stdio,
- err_fd: Stdio) -> io::Result<Process> {
- if cfg.saw_nul {
- return Err(io::Error::new(ErrorKind::InvalidInput, "nul byte found in provided data"));
+ if self.saw_nul {
+ return Err(io::Error::new(ErrorKind::InvalidInput,
+ "nul byte found in provided data"));
}
- let dirp = cfg.cwd.as_ref().map(|c| c.as_ptr()).unwrap_or(ptr::null());
-
- let (envp, _a, _b) = make_envp(cfg.env.as_ref());
- let (argv, _a) = make_argv(&cfg.program, &cfg.args);
+ let (ours, theirs) = try!(self.setup_io(default));
let (input, output) = try!(sys::pipe::anon_pipe());
let pid = unsafe {
- match libc::fork() {
+ match try!(cvt(libc::fork())) {
0 => {
drop(input);
- Process::child_after_fork(cfg, output, argv, envp, dirp,
- in_fd, out_fd, err_fd)
+ let err = self.do_exec(theirs);
+ let errno = err.raw_os_error().unwrap_or(libc::EINVAL) as u32;
+ let bytes = [
+ (errno >> 24) as u8,
+ (errno >> 16) as u8,
+ (errno >> 8) as u8,
+ (errno >> 0) as u8,
+ CLOEXEC_MSG_FOOTER[0], CLOEXEC_MSG_FOOTER[1],
+ CLOEXEC_MSG_FOOTER[2], CLOEXEC_MSG_FOOTER[3]
+ ];
+ // pipe I/O up to PIPE_BUF bytes should be atomic, and then
+ // we want to be sure we *don't* run at_exit destructors as
+ // we're being torn down regardless
+ assert!(output.write(&bytes).is_ok());
+ libc::_exit(1)
}
- n if n < 0 => return Err(Error::last_os_error()),
n => n,
}
};
- let p = Process{ pid: pid };
+ let mut p = Process { pid: pid, status: None };
drop(output);
let mut bytes = [0; 8];
// loop to handle EINTR
loop {
match input.read(&mut bytes) {
- Ok(0) => return Ok(p),
+ Ok(0) => return Ok((p, ours)),
Ok(8) => {
assert!(combine(CLOEXEC_MSG_FOOTER) == combine(&bytes[4.. 8]),
"Validation on the CLOEXEC pipe failed: {:?}", bytes);
}
}
+ pub fn exec(&mut self, default: Stdio) -> io::Error {
+ if self.saw_nul {
+ return io::Error::new(ErrorKind::InvalidInput,
+ "nul byte found in provided data")
+ }
+
+ match self.setup_io(default) {
+ Ok((_, theirs)) => unsafe { self.do_exec(theirs) },
+ Err(e) => e,
+ }
+ }
+
// And at this point we've reached a special time in the life of the
// child. The child must now be considered hamstrung and unable to
// do anything other than syscalls really. Consider the following
// allocation). Instead we just close it manually. This will never
// have the drop glue anyway because this code never returns (the
// child will either exec() or invoke libc::exit)
- unsafe fn child_after_fork(cfg: &Command,
- mut output: AnonPipe,
- argv: *const *const libc::c_char,
- envp: *const libc::c_void,
- dirp: *const libc::c_char,
- in_fd: Stdio,
- out_fd: Stdio,
- err_fd: Stdio) -> ! {
- fn fail(output: &mut AnonPipe) -> ! {
- let errno = sys::os::errno() as u32;
- let bytes = [
- (errno >> 24) as u8,
- (errno >> 16) as u8,
- (errno >> 8) as u8,
- (errno >> 0) as u8,
- CLOEXEC_MSG_FOOTER[0], CLOEXEC_MSG_FOOTER[1],
- CLOEXEC_MSG_FOOTER[2], CLOEXEC_MSG_FOOTER[3]
- ];
- // pipe I/O up to PIPE_BUF bytes should be atomic, and then we want
- // to be sure we *don't* run at_exit destructors as we're being torn
- // down regardless
- assert!(output.write(&bytes).is_ok());
- unsafe { libc::_exit(1) }
+ unsafe fn do_exec(&mut self, stdio: ChildPipes) -> io::Error {
+ macro_rules! try {
+ ($e:expr) => (match $e {
+ Ok(e) => e,
+ Err(e) => return e,
+ })
}
- // Make sure that the source descriptors are not an stdio descriptor,
- // otherwise the order which we set the child's descriptors may blow
- // away a descriptor which we are hoping to save. For example,
- // suppose we want the child's stderr to be the parent's stdout, and
- // the child's stdout to be the parent's stderr. No matter which we
- // dup first, the second will get overwritten prematurely.
- let maybe_migrate = |src: Stdio, output: &mut AnonPipe| {
- match src {
- Stdio::Raw(fd @ libc::STDIN_FILENO) |
- Stdio::Raw(fd @ libc::STDOUT_FILENO) |
- Stdio::Raw(fd @ libc::STDERR_FILENO) => {
- let fd = match cvt_r(|| libc::dup(fd)) {
- Ok(fd) => fd,
- Err(_) => fail(output),
- };
- let fd = FileDesc::new(fd);
- fd.set_cloexec();
- Stdio::Raw(fd.into_raw())
- },
-
- s @ Stdio::None |
- s @ Stdio::Inherit |
- s @ Stdio::Raw(_) => s,
- }
- };
-
- let setup = |src: Stdio, dst: c_int| {
- match src {
- Stdio::Inherit => true,
- Stdio::Raw(fd) => cvt_r(|| libc::dup2(fd, dst)).is_ok(),
-
- // If a stdio file descriptor is set to be ignored, we open up
- // /dev/null into that file descriptor. Otherwise, the first
- // file descriptor opened up in the child would be numbered as
- // one of the stdio file descriptors, which is likely to wreak
- // havoc.
- Stdio::None => {
- let mut opts = OpenOptions::new();
- opts.read(dst == libc::STDIN_FILENO);
- opts.write(dst != libc::STDIN_FILENO);
- let devnull = CStr::from_ptr(b"/dev/null\0".as_ptr()
- as *const _);
- if let Ok(f) = File::open_c(devnull, &opts) {
- cvt_r(|| libc::dup2(f.fd().raw(), dst)).is_ok()
- } else {
- false
- }
- }
- }
- };
-
- // Make sure we migrate all source descriptors before
- // we start overwriting them
- let in_fd = maybe_migrate(in_fd, &mut output);
- let out_fd = maybe_migrate(out_fd, &mut output);
- let err_fd = maybe_migrate(err_fd, &mut output);
-
- if !setup(in_fd, libc::STDIN_FILENO) { fail(&mut output) }
- if !setup(out_fd, libc::STDOUT_FILENO) { fail(&mut output) }
- if !setup(err_fd, libc::STDERR_FILENO) { fail(&mut output) }
+ if let Some(fd) = stdio.stdin.fd() {
+ try!(cvt_r(|| libc::dup2(fd, libc::STDIN_FILENO)));
+ }
+ if let Some(fd) = stdio.stdout.fd() {
+ try!(cvt_r(|| libc::dup2(fd, libc::STDOUT_FILENO)));
+ }
+ if let Some(fd) = stdio.stderr.fd() {
+ try!(cvt_r(|| libc::dup2(fd, libc::STDERR_FILENO)));
+ }
- if let Some(u) = cfg.gid {
- if libc::setgid(u as libc::gid_t) != 0 {
- fail(&mut output);
- }
+ if let Some(u) = self.gid {
+ try!(cvt(libc::setgid(u as gid_t)));
}
- if let Some(u) = cfg.uid {
+ if let Some(u) = self.uid {
// When dropping privileges from root, the `setgroups` call
// will remove any extraneous groups. If we don't call this,
// then even though our uid has dropped, we may still have
// privilege dropping function.
let _ = libc::setgroups(0, ptr::null());
- if libc::setuid(u as libc::uid_t) != 0 {
- fail(&mut output);
- }
+ try!(cvt(libc::setuid(u as uid_t)));
}
- if cfg.session_leader {
+ if self.session_leader {
// Don't check the error of setsid because it fails if we're the
// process leader already. We just forked so it shouldn't return
// error, but ignore it anyway.
let _ = libc::setsid();
}
- if !dirp.is_null() && libc::chdir(dirp) == -1 {
- fail(&mut output);
+ if let Some(ref cwd) = self.cwd {
+ try!(cvt(libc::chdir(cwd.as_ptr())));
}
- if !envp.is_null() {
- *sys::os::environ() = envp as *const _;
+ if let Some(ref envp) = self.envp {
+ *sys::os::environ() = envp.as_ptr();
}
- #[cfg(not(target_os = "nacl"))]
- unsafe fn reset_signal_handling(output: &mut AnonPipe) {
- use mem;
+ // NaCl has no signal support.
+ if cfg!(not(target_os = "nacl")) {
// Reset signal handling so the child process starts in a
// standardized state. libstd ignores SIGPIPE, and signal-handling
// libraries often set a mask. Child processes inherit ignored
// need to clean things up now to avoid confusing the program
// we're about to run.
let mut set: libc::sigset_t = mem::uninitialized();
- if libc::sigemptyset(&mut set) != 0 ||
- libc::pthread_sigmask(libc::SIG_SETMASK, &set, ptr::null_mut()) != 0 ||
- libc::signal(
- libc::SIGPIPE, mem::transmute(libc::SIG_DFL)
- ) == mem::transmute(libc::SIG_ERR)
- {
- fail(output);
+ try!(cvt(libc::sigemptyset(&mut set)));
+ try!(cvt(libc::pthread_sigmask(libc::SIG_SETMASK, &set,
+ ptr::null_mut())));
+ let ret = libc::signal(libc::SIGPIPE, libc::SIG_DFL);
+ if ret == libc::SIG_ERR {
+ return io::Error::last_os_error()
}
}
- #[cfg(target_os = "nacl")]
- unsafe fn reset_signal_handling(_output: &mut AnonPipe) {
- // NaCl has no signal support.
+
+ for callback in self.closures.iter_mut() {
+ try!(callback());
}
- reset_signal_handling(&mut output);
- let _ = libc::execvp(*argv, argv);
- fail(&mut output)
+ libc::execvp(self.argv[0], self.argv.as_ptr());
+ io::Error::last_os_error()
}
- pub fn id(&self) -> u32 {
- self.pid as u32
+
+ fn setup_io(&self, default: Stdio) -> io::Result<(StdioPipes, ChildPipes)> {
+ let stdin = self.stdin.as_ref().unwrap_or(&default);
+ let stdout = self.stdout.as_ref().unwrap_or(&default);
+ let stderr = self.stderr.as_ref().unwrap_or(&default);
+ let (their_stdin, our_stdin) = try!(stdin.to_child_stdio(true));
+ let (their_stdout, our_stdout) = try!(stdout.to_child_stdio(false));
+ let (their_stderr, our_stderr) = try!(stderr.to_child_stdio(false));
+ let ours = StdioPipes {
+ stdin: our_stdin,
+ stdout: our_stdout,
+ stderr: our_stderr,
+ };
+ let theirs = ChildPipes {
+ stdin: their_stdin,
+ stdout: their_stdout,
+ stderr: their_stderr,
+ };
+ Ok((ours, theirs))
}
+}
- pub fn wait(&self) -> io::Result<ExitStatus> {
- let mut status = 0 as c_int;
- try!(cvt_r(|| unsafe { libc::waitpid(self.pid, &mut status, 0) }));
- Ok(ExitStatus(status))
+fn os2c(s: &OsStr, saw_nul: &mut bool) -> CString {
+ CString::new(s.as_bytes()).unwrap_or_else(|_e| {
+ *saw_nul = true;
+ CString::new("<string-with-nul>").unwrap()
+ })
+}
+
+impl Stdio {
+ fn to_child_stdio(&self, readable: bool)
+ -> io::Result<(ChildStdio, Option<AnonPipe>)> {
+ match *self {
+ Stdio::Inherit => Ok((ChildStdio::Inherit, None)),
+
+ // Make sure that the source descriptors are not an stdio
+ // descriptor, otherwise the order which we set the child's
+ // descriptors may blow away a descriptor which we are hoping to
+ // save. For example, suppose we want the child's stderr to be the
+ // parent's stdout, and the child's stdout to be the parent's
+ // stderr. No matter which we dup first, the second will get
+ // overwritten prematurely.
+ Stdio::Fd(ref fd) => {
+ if fd.raw() >= 0 && fd.raw() <= libc::STDERR_FILENO {
+ Ok((ChildStdio::Owned(try!(fd.duplicate())), None))
+ } else {
+ Ok((ChildStdio::Explicit(fd.raw()), None))
+ }
+ }
+
+ Stdio::MakePipe => {
+ let (reader, writer) = try!(pipe::anon_pipe());
+ let (ours, theirs) = if readable {
+ (writer, reader)
+ } else {
+ (reader, writer)
+ };
+ Ok((ChildStdio::Owned(theirs.into_fd()), Some(ours)))
+ }
+
+ Stdio::Null => {
+ let mut opts = OpenOptions::new();
+ opts.read(readable);
+ opts.write(!readable);
+ let path = unsafe {
+ CStr::from_ptr("/dev/null\0".as_ptr() as *const _)
+ };
+ let fd = try!(File::open_c(&path, &opts));
+ Ok((ChildStdio::Owned(fd.into_fd()), None))
+ }
+ }
}
+}
- pub fn try_wait(&self) -> Option<ExitStatus> {
- let mut status = 0 as c_int;
- match cvt_r(|| unsafe {
- libc::waitpid(self.pid, &mut status, libc::WNOHANG)
- }) {
- Ok(0) => None,
- Ok(n) if n == self.pid => Some(ExitStatus(status)),
- Ok(n) => panic!("unknown pid: {}", n),
- Err(e) => panic!("unknown waitpid error: {}", e),
+impl ChildStdio {
+ fn fd(&self) -> Option<c_int> {
+ match *self {
+ ChildStdio::Inherit => None,
+ ChildStdio::Explicit(fd) => Some(fd),
+ ChildStdio::Owned(ref fd) => Some(fd.raw()),
}
}
}
-fn make_argv(prog: &CString, args: &[CString])
- -> (*const *const libc::c_char, Vec<*const libc::c_char>)
-{
- let mut ptrs: Vec<*const libc::c_char> = Vec::with_capacity(args.len()+1);
+fn pair_to_key(key: &OsStr, value: &OsStr, saw_nul: &mut bool) -> CString {
+ let (key, value) = (key.as_bytes(), value.as_bytes());
+ let mut v = Vec::with_capacity(key.len() + value.len() + 1);
+ v.extend(key);
+ v.push(b'=');
+ v.extend(value);
+ CString::new(v).unwrap_or_else(|_e| {
+ *saw_nul = true;
+ CString::new("foo=bar").unwrap()
+ })
+}
- // Convert the CStrings into an array of pointers. Also return the
- // vector that owns the raw pointers, to ensure they live long
- // enough.
- ptrs.push(prog.as_ptr());
- ptrs.extend(args.iter().map(|tmp| tmp.as_ptr()));
+impl fmt::Debug for Command {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ try!(write!(f, "{:?}", self.program));
+ for arg in &self.args {
+ try!(write!(f, " {:?}", arg));
+ }
+ Ok(())
+ }
+}
- // Add a terminating null pointer (required by libc).
- ptrs.push(ptr::null());
+////////////////////////////////////////////////////////////////////////////////
+// Processes
+////////////////////////////////////////////////////////////////////////////////
+
+/// Unix exit statuses
+#[derive(PartialEq, Eq, Clone, Copy, Debug)]
+pub struct ExitStatus(c_int);
- (ptrs.as_ptr(), ptrs)
+impl ExitStatus {
+ fn exited(&self) -> bool {
+ unsafe { libc::WIFEXITED(self.0) }
+ }
+
+ pub fn success(&self) -> bool {
+ self.code() == Some(0)
+ }
+
+ pub fn code(&self) -> Option<i32> {
+ if self.exited() {
+ Some(unsafe { libc::WEXITSTATUS(self.0) })
+ } else {
+ None
+ }
+ }
+
+ pub fn signal(&self) -> Option<i32> {
+ if !self.exited() {
+ Some(unsafe { libc::WTERMSIG(self.0) })
+ } else {
+ None
+ }
+ }
}
-fn make_envp(env: Option<&HashMap<OsString, OsString>>)
- -> (*const c_void, Vec<Vec<u8>>, Vec<*const libc::c_char>)
-{
- // On posixy systems we can pass a char** for envp, which is a
- // null-terminated array of "k=v\0" strings. As with make_argv, we
- // return two vectors that own the data to ensure that they live
- // long enough.
- if let Some(env) = env {
- let mut tmps = Vec::with_capacity(env.len());
-
- for pair in env {
- let mut kv = Vec::new();
- kv.extend_from_slice(pair.0.as_bytes());
- kv.push('=' as u8);
- kv.extend_from_slice(pair.1.as_bytes());
- kv.push(0); // terminating null
- tmps.push(kv);
+impl fmt::Display for ExitStatus {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ if let Some(code) = self.code() {
+ write!(f, "exit code: {}", code)
+ } else {
+ let signal = self.signal().unwrap();
+ write!(f, "signal: {}", signal)
}
+ }
+}
- let mut ptrs: Vec<*const libc::c_char> =
- tmps.iter()
- .map(|tmp| tmp.as_ptr() as *const libc::c_char)
- .collect();
- ptrs.push(ptr::null());
+/// The unique id of the process (this should never be negative).
+pub struct Process {
+ pid: pid_t,
+ status: Option<ExitStatus>,
+}
- (ptrs.as_ptr() as *const _, tmps, ptrs)
- } else {
- (ptr::null(), Vec::new(), Vec::new())
+impl Process {
+ pub fn id(&self) -> u32 {
+ self.pid as u32
+ }
+
+ pub fn kill(&mut self) -> io::Result<()> {
+ // If we've already waited on this process then the pid can be recycled
+ // and used for another process, and we probably shouldn't be killing
+ // random processes, so just return an error.
+ if self.status.is_some() {
+ Err(Error::new(ErrorKind::InvalidInput,
+ "invalid argument: can't kill an exited process"))
+ } else {
+ cvt(unsafe { libc::kill(self.pid, libc::SIGKILL) }).map(|_| ())
+ }
+ }
+
+ pub fn wait(&mut self) -> io::Result<ExitStatus> {
+ if let Some(status) = self.status {
+ return Ok(status)
+ }
+ let mut status = 0 as c_int;
+ try!(cvt_r(|| unsafe { libc::waitpid(self.pid, &mut status, 0) }));
+ self.status = Some(ExitStatus(status));
+ Ok(ExitStatus(status))
}
}
use mem;
use ptr;
use libc;
- use sys::{self, cvt};
+ use sys::cvt;
macro_rules! t {
($e:expr) => {
fn test_process_mask() {
unsafe {
// Test to make sure that a signal mask does not get inherited.
- let cmd = Command::new(OsStr::new("cat"));
- let (stdin_read, stdin_write) = t!(sys::pipe::anon_pipe());
- let (stdout_read, stdout_write) = t!(sys::pipe::anon_pipe());
+ let mut cmd = Command::new(OsStr::new("cat"));
let mut set: libc::sigset_t = mem::uninitialized();
let mut old_set: libc::sigset_t = mem::uninitialized();
t!(cvt(sigaddset(&mut set, libc::SIGINT)));
t!(cvt(libc::pthread_sigmask(libc::SIG_SETMASK, &set, &mut old_set)));
- let cat = t!(Process::spawn(&cmd, Stdio::Raw(stdin_read.raw()),
- Stdio::Raw(stdout_write.raw()),
- Stdio::None));
- drop(stdin_read);
- drop(stdout_write);
+ cmd.stdin(Stdio::MakePipe);
+ cmd.stdout(Stdio::MakePipe);
+
+ let (mut cat, mut pipes) = t!(cmd.spawn(Stdio::Null));
+ let stdin_write = pipes.stdin.take().unwrap();
+ let stdout_read = pipes.stdout.take().unwrap();
t!(cvt(libc::pthread_sigmask(libc::SIG_SETMASK, &old_set,
ptr::null_mut())));
impl FromRawHandle for process::Stdio {
unsafe fn from_raw_handle(handle: RawHandle) -> process::Stdio {
let handle = sys::handle::Handle::new(handle as *mut _);
- process::Stdio::from_inner(handle)
+ let io = sys::process::Stdio::Handle(handle);
+ process::Stdio::from_inner(io)
}
}
pub fn handle(&self) -> &Handle { &self.inner }
pub fn into_handle(self) -> Handle { self.inner }
- pub fn raw(&self) -> c::HANDLE { self.inner.raw() }
-
pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
self.inner.read(buf)
}
use ptr;
use sync::StaticMutex;
use sys::c;
-
use sys::fs::{OpenOptions, File};
-use sys::handle::{Handle, RawHandle};
+use sys::handle::Handle;
+use sys::pipe::{self, AnonPipe};
use sys::stdio;
use sys::{self, cvt};
use sys_common::{AsInner, FromInner};
}
}
-#[derive(Clone)]
pub struct Command {
program: OsString,
args: Vec<OsString>,
env: Option<HashMap<OsString, OsString>>,
cwd: Option<OsString>,
detach: bool, // not currently exposed in std::process
+ stdin: Option<Stdio>,
+ stdout: Option<Stdio>,
+ stderr: Option<Stdio>,
+}
+
+pub enum Stdio {
+ Inherit,
+ Null,
+ MakePipe,
+ Handle(Handle),
+}
+
+pub struct StdioPipes {
+ pub stdin: Option<AnonPipe>,
+ pub stdout: Option<AnonPipe>,
+ pub stderr: Option<AnonPipe>,
}
impl Command {
env: None,
cwd: None,
detach: false,
+ stdin: None,
+ stdout: None,
+ stderr: None,
}
}
pub fn arg(&mut self, arg: &OsStr) {
self.args.push(arg.to_os_string())
}
- pub fn args<'a, I: Iterator<Item = &'a OsStr>>(&mut self, args: I) {
- self.args.extend(args.map(OsStr::to_os_string))
- }
fn init_env_map(&mut self){
if self.env.is_none() {
self.env = Some(env::vars_os().map(|(key, val)| {
pub fn cwd(&mut self, dir: &OsStr) {
self.cwd = Some(dir.to_os_string())
}
-}
-
-impl fmt::Debug for Command {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- try!(write!(f, "{:?}", self.program));
- for arg in &self.args {
- try!(write!(f, " {:?}", arg));
- }
- Ok(())
+ pub fn stdin(&mut self, stdin: Stdio) {
+ self.stdin = Some(stdin);
+ }
+ pub fn stdout(&mut self, stdout: Stdio) {
+ self.stdout = Some(stdout);
+ }
+ pub fn stderr(&mut self, stderr: Stdio) {
+ self.stderr = Some(stderr);
}
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Processes
-////////////////////////////////////////////////////////////////////////////////
-
-/// A value representing a child process.
-///
-/// The lifetime of this value is linked to the lifetime of the actual
-/// process - the Process destructor calls self.finish() which waits
-/// for the process to terminate.
-pub struct Process {
- handle: Handle,
-}
-
-pub enum Stdio {
- Inherit,
- None,
- Raw(c::HANDLE),
-}
-
-pub type RawStdio = Handle;
-impl Process {
- pub fn spawn(cfg: &Command,
- in_handle: Stdio,
- out_handle: Stdio,
- err_handle: Stdio) -> io::Result<Process>
- {
+ pub fn spawn(&mut self, default: Stdio)
+ -> io::Result<(Process, StdioPipes)> {
// To have the spawning semantics of unix/windows stay the same, we need
// to read the *child's* PATH if one is provided. See #15149 for more
// details.
- let program = cfg.env.as_ref().and_then(|env| {
+ let program = self.env.as_ref().and_then(|env| {
for (key, v) in env {
if OsStr::new("PATH") != &**key { continue }
// Split the value and test each path to see if the
// program exists.
for path in split_paths(&v) {
- let path = path.join(cfg.program.to_str().unwrap())
+ let path = path.join(self.program.to_str().unwrap())
.with_extension(env::consts::EXE_EXTENSION);
if fs::metadata(&path).is_ok() {
return Some(path.into_os_string())
si.cb = mem::size_of::<c::STARTUPINFO>() as c::DWORD;
si.dwFlags = c::STARTF_USESTDHANDLES;
- let stdin = try!(in_handle.to_handle(c::STD_INPUT_HANDLE));
- let stdout = try!(out_handle.to_handle(c::STD_OUTPUT_HANDLE));
- let stderr = try!(err_handle.to_handle(c::STD_ERROR_HANDLE));
-
- si.hStdInput = stdin.raw();
- si.hStdOutput = stdout.raw();
- si.hStdError = stderr.raw();
-
- let program = program.as_ref().unwrap_or(&cfg.program);
- let mut cmd_str = try!(make_command_line(program, &cfg.args));
+ let program = program.as_ref().unwrap_or(&self.program);
+ let mut cmd_str = try!(make_command_line(program, &self.args));
cmd_str.push(0); // add null terminator
// stolen from the libuv code.
let mut flags = c::CREATE_UNICODE_ENVIRONMENT;
- if cfg.detach {
+ if self.detach {
flags |= c::DETACHED_PROCESS | c::CREATE_NEW_PROCESS_GROUP;
}
- let (envp, _data) = try!(make_envp(cfg.env.as_ref()));
- let (dirp, _data) = try!(make_dirp(cfg.cwd.as_ref()));
+ let (envp, _data) = try!(make_envp(self.env.as_ref()));
+ let (dirp, _data) = try!(make_dirp(self.cwd.as_ref()));
let mut pi = zeroed_process_information();
- try!(unsafe {
- // `CreateProcess` is racy!
- // http://support.microsoft.com/kb/315939
- static CREATE_PROCESS_LOCK: StaticMutex = StaticMutex::new();
- let _lock = CREATE_PROCESS_LOCK.lock();
+ // Prepare all stdio handles to be inherited by the child. This
+ // currently involves duplicating any existing ones with the ability to
+ // be inherited by child processes. Note, however, that once an
+ // inheritable handle is created, *any* spawned child will inherit that
+ // handle. We only want our own child to inherit this handle, so we wrap
+ // the remaining portion of this spawn in a mutex.
+ //
+ // For more information, msdn also has an article about this race:
+ // http://support.microsoft.com/kb/315939
+ static CREATE_PROCESS_LOCK: StaticMutex = StaticMutex::new();
+ let _lock = CREATE_PROCESS_LOCK.lock();
+
+ let mut pipes = StdioPipes {
+ stdin: None,
+ stdout: None,
+ stderr: None,
+ };
+ let stdin = self.stdin.as_ref().unwrap_or(&default);
+ let stdout = self.stdout.as_ref().unwrap_or(&default);
+ let stderr = self.stderr.as_ref().unwrap_or(&default);
+ let stdin = try!(stdin.to_handle(c::STD_INPUT_HANDLE, &mut pipes.stdin));
+ let stdout = try!(stdout.to_handle(c::STD_OUTPUT_HANDLE,
+ &mut pipes.stdout));
+ let stderr = try!(stderr.to_handle(c::STD_ERROR_HANDLE,
+ &mut pipes.stderr));
+ si.hStdInput = stdin.raw();
+ si.hStdOutput = stdout.raw();
+ si.hStdError = stderr.raw();
+
+ try!(unsafe {
cvt(c::CreateProcessW(ptr::null(),
cmd_str.as_mut_ptr(),
ptr::null_mut(),
// around to be able to close it later.
drop(Handle::new(pi.hThread));
- Ok(Process { handle: Handle::new(pi.hProcess) })
+ Ok((Process { handle: Handle::new(pi.hProcess) }, pipes))
+ }
+
+}
+
+impl fmt::Debug for Command {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ try!(write!(f, "{:?}", self.program));
+ for arg in &self.args {
+ try!(write!(f, " {:?}", arg));
+ }
+ Ok(())
+ }
+}
+
+impl Stdio {
+ fn to_handle(&self, stdio_id: c::DWORD, pipe: &mut Option<AnonPipe>)
+ -> io::Result<Handle> {
+ match *self {
+ // If no stdio handle is available, then inherit means that it
+ // should still be unavailable so propagate the
+ // INVALID_HANDLE_VALUE.
+ Stdio::Inherit => {
+ match stdio::get(stdio_id) {
+ Ok(io) => io.handle().duplicate(0, true,
+ c::DUPLICATE_SAME_ACCESS),
+ Err(..) => Ok(Handle::new(c::INVALID_HANDLE_VALUE)),
+ }
+ }
+
+ Stdio::MakePipe => {
+ let (reader, writer) = try!(pipe::anon_pipe());
+ let (ours, theirs) = if stdio_id == c::STD_INPUT_HANDLE {
+ (writer, reader)
+ } else {
+ (reader, writer)
+ };
+ *pipe = Some(ours);
+ try!(cvt(unsafe {
+ c::SetHandleInformation(theirs.handle().raw(),
+ c::HANDLE_FLAG_INHERIT,
+ c::HANDLE_FLAG_INHERIT)
+ }));
+ Ok(theirs.into_handle())
+ }
+
+ Stdio::Handle(ref handle) => {
+ handle.duplicate(0, true, c::DUPLICATE_SAME_ACCESS)
+ }
+
+ // Open up a reference to NUL with appropriate read/write
+ // permissions as well as the ability to be inherited to child
+ // processes (as this is about to be inherited).
+ Stdio::Null => {
+ let size = mem::size_of::<c::SECURITY_ATTRIBUTES>();
+ let mut sa = c::SECURITY_ATTRIBUTES {
+ nLength: size as c::DWORD,
+ lpSecurityDescriptor: ptr::null_mut(),
+ bInheritHandle: 1,
+ };
+ let mut opts = OpenOptions::new();
+ opts.read(stdio_id == c::STD_INPUT_HANDLE);
+ opts.write(stdio_id != c::STD_INPUT_HANDLE);
+ opts.security_attributes(&mut sa);
+ File::open(Path::new("NUL"), &opts).map(|file| {
+ file.into_handle()
+ })
+ }
+ }
}
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Processes
+////////////////////////////////////////////////////////////////////////////////
+
+/// A value representing a child process.
+///
+/// The lifetime of this value is linked to the lifetime of the actual
+/// process - the Process destructor calls self.finish() which waits
+/// for the process to terminate.
+pub struct Process {
+ handle: Handle,
+}
- pub unsafe fn kill(&self) -> io::Result<()> {
- try!(cvt(c::TerminateProcess(self.handle.raw(), 1)));
+impl Process {
+ pub fn kill(&mut self) -> io::Result<()> {
+ try!(cvt(unsafe {
+ c::TerminateProcess(self.handle.raw(), 1)
+ }));
Ok(())
}
}
}
- pub fn wait(&self) -> io::Result<ExitStatus> {
+ pub fn wait(&mut self) -> io::Result<ExitStatus> {
unsafe {
let res = c::WaitForSingleObject(self.handle.raw(), c::INFINITE);
if res != c::WAIT_OBJECT_0 {
}
}
-impl Stdio {
- fn to_handle(&self, stdio_id: c::DWORD) -> io::Result<Handle> {
- match *self {
- // If no stdio handle is available, then inherit means that it
- // should still be unavailable so propagate the
- // INVALID_HANDLE_VALUE.
- Stdio::Inherit => {
- match stdio::get(stdio_id) {
- Ok(io) => io.handle().duplicate(0, true,
- c::DUPLICATE_SAME_ACCESS),
- Err(..) => Ok(Handle::new(c::INVALID_HANDLE_VALUE)),
- }
- }
- Stdio::Raw(handle) => {
- RawHandle::new(handle).duplicate(0, true, c::DUPLICATE_SAME_ACCESS)
- }
-
- // Similarly to unix, we don't actually leave holes for the
- // stdio file descriptors, but rather open up /dev/null
- // equivalents. These equivalents are drawn from libuv's
- // windows process spawning.
- Stdio::None => {
- let size = mem::size_of::<c::SECURITY_ATTRIBUTES>();
- let mut sa = c::SECURITY_ATTRIBUTES {
- nLength: size as c::DWORD,
- lpSecurityDescriptor: ptr::null_mut(),
- bInheritHandle: 1,
- };
- let mut opts = OpenOptions::new();
- opts.read(stdio_id == c::STD_INPUT_HANDLE);
- opts.write(stdio_id != c::STD_INPUT_HANDLE);
- opts.security_attributes(&mut sa);
- File::open(Path::new("NUL"), &opts).map(|file| {
- file.into_handle()
- })
- }
- }
- }
-}
-
#[cfg(test)]
mod tests {
use prelude::v1::*;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub use self::Os::*;
-pub use self::Abi::*;
-pub use self::Architecture::*;
-pub use self::AbiArchitecture::*;
-
use std::fmt;
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[allow(non_camel_case_types)]
pub enum Os {
- OsWindows,
- OsMacos,
- OsLinux,
- OsAndroid,
- OsFreebsd,
- OsiOS,
- OsDragonfly,
- OsBitrig,
- OsNetbsd,
- OsOpenbsd,
- OsNaCl,
- OsSolaris,
+ Windows,
+ Macos,
+ Linux,
+ Android,
+ Freebsd,
+ iOS,
+ Dragonfly,
+ Bitrig,
+ Netbsd,
+ Openbsd,
+ NaCl,
+ Solaris,
}
#[derive(PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Clone, Copy, Debug)]
#[derive(Copy, Clone)]
pub enum AbiArchitecture {
/// Not a real ABI (e.g., intrinsic)
- RustArch,
+ Rust,
/// An ABI that specifies cross-platform defaults (e.g., "C")
- AllArch,
+ All,
/// Multiple architectures (bitset)
Archs(u32)
}
#[allow(non_upper_case_globals)]
const AbiDatas: &'static [AbiData] = &[
// Platform-specific ABIs
- AbiData {abi: Cdecl, name: "cdecl" },
- AbiData {abi: Stdcall, name: "stdcall" },
- AbiData {abi: Fastcall, name: "fastcall" },
- AbiData {abi: Vectorcall, name: "vectorcall"},
- AbiData {abi: Aapcs, name: "aapcs" },
- AbiData {abi: Win64, name: "win64" },
+ AbiData {abi: Abi::Cdecl, name: "cdecl" },
+ AbiData {abi: Abi::Stdcall, name: "stdcall" },
+ AbiData {abi: Abi::Fastcall, name: "fastcall" },
+ AbiData {abi: Abi::Vectorcall, name: "vectorcall"},
+ AbiData {abi: Abi::Aapcs, name: "aapcs" },
+ AbiData {abi: Abi::Win64, name: "win64" },
// Cross-platform ABIs
//
// NB: Do not adjust this ordering without
// adjusting the indices below.
- AbiData {abi: Rust, name: "Rust" },
- AbiData {abi: C, name: "C" },
- AbiData {abi: System, name: "system" },
- AbiData {abi: RustIntrinsic, name: "rust-intrinsic" },
- AbiData {abi: RustCall, name: "rust-call" },
- AbiData {abi: PlatformIntrinsic, name: "platform-intrinsic" }
+ AbiData {abi: Abi::Rust, name: "Rust" },
+ AbiData {abi: Abi::C, name: "C" },
+ AbiData {abi: Abi::System, name: "system" },
+ AbiData {abi: Abi::RustIntrinsic, name: "rust-intrinsic" },
+ AbiData {abi: Abi::RustCall, name: "rust-call" },
+ AbiData {abi: Abi::PlatformIntrinsic, name: "platform-intrinsic" }
];
/// Returns the ABI with the given name (if any).
impl fmt::Display for Os {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
- OsLinux => "linux".fmt(f),
- OsWindows => "windows".fmt(f),
- OsMacos => "macos".fmt(f),
- OsiOS => "ios".fmt(f),
- OsAndroid => "android".fmt(f),
- OsFreebsd => "freebsd".fmt(f),
- OsDragonfly => "dragonfly".fmt(f),
- OsBitrig => "bitrig".fmt(f),
- OsNetbsd => "netbsd".fmt(f),
- OsOpenbsd => "openbsd".fmt(f),
- OsNaCl => "nacl".fmt(f),
- OsSolaris => "solaris".fmt(f),
+ Os::Linux => "linux".fmt(f),
+ Os::Windows => "windows".fmt(f),
+ Os::Macos => "macos".fmt(f),
+ Os::iOS => "ios".fmt(f),
+ Os::Android => "android".fmt(f),
+ Os::Freebsd => "freebsd".fmt(f),
+ Os::Dragonfly => "dragonfly".fmt(f),
+ Os::Bitrig => "bitrig".fmt(f),
+ Os::Netbsd => "netbsd".fmt(f),
+ Os::Openbsd => "openbsd".fmt(f),
+ Os::NaCl => "nacl".fmt(f),
+ Os::Solaris => "solaris".fmt(f),
}
}
}
// The Rust abstract syntax tree.
-pub use self::BinOp_::*;
-pub use self::BlockCheckMode::*;
-pub use self::CaptureClause::*;
-pub use self::Decl_::*;
-pub use self::ExplicitSelf_::*;
-pub use self::Expr_::*;
-pub use self::FloatTy::*;
-pub use self::FunctionRetTy::*;
-pub use self::ForeignItem_::*;
-pub use self::IntTy::*;
-pub use self::Item_::*;
-pub use self::KleeneOp::*;
-pub use self::Lit_::*;
-pub use self::LitIntType::*;
-pub use self::MacStmtStyle::*;
-pub use self::MetaItem_::*;
-pub use self::Mutability::*;
pub use self::Pat_::*;
-pub use self::PathListItem_::*;
-pub use self::PrimTy::*;
-pub use self::Sign::*;
-pub use self::Stmt_::*;
-pub use self::StrStyle::*;
pub use self::StructFieldKind::*;
-pub use self::TraitItem_::*;
-pub use self::Ty_::*;
pub use self::TyParamBound::*;
-pub use self::UintTy::*;
-pub use self::UnOp::*;
pub use self::UnsafeSource::*;
pub use self::ViewPath_::*;
-pub use self::Visibility::*;
pub use self::PathParameters::*;
use attr::ThinAttributes;
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))
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
pub enum Mutability {
- MutMutable,
- MutImmutable,
+ Mutable,
+ Immutable,
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
-pub enum BinOp_ {
+pub enum BinOpKind {
/// The `+` operator (addition)
- BiAdd,
+ Add,
/// The `-` operator (subtraction)
- BiSub,
+ Sub,
/// The `*` operator (multiplication)
- BiMul,
+ Mul,
/// The `/` operator (division)
- BiDiv,
+ Div,
/// The `%` operator (modulus)
- BiRem,
+ Rem,
/// The `&&` operator (logical and)
- BiAnd,
+ And,
/// The `||` operator (logical or)
- BiOr,
+ Or,
/// The `^` operator (bitwise xor)
- BiBitXor,
+ BitXor,
/// The `&` operator (bitwise and)
- BiBitAnd,
+ BitAnd,
/// The `|` operator (bitwise or)
- BiBitOr,
+ BitOr,
/// The `<<` operator (shift left)
- BiShl,
+ Shl,
/// The `>>` operator (shift right)
- BiShr,
+ Shr,
/// The `==` operator (equality)
- BiEq,
+ Eq,
/// The `<` operator (less than)
- BiLt,
+ Lt,
/// The `<=` operator (less than or equal to)
- BiLe,
+ Le,
/// The `!=` operator (not equal to)
- BiNe,
+ Ne,
/// The `>=` operator (greater than or equal to)
- BiGe,
+ Ge,
/// The `>` operator (greater than)
- BiGt,
+ Gt,
}
-impl BinOp_ {
+impl BinOpKind {
pub fn to_string(&self) -> &'static str {
+ use self::BinOpKind::*;
match *self {
- BiAdd => "+",
- BiSub => "-",
- BiMul => "*",
- BiDiv => "/",
- BiRem => "%",
- BiAnd => "&&",
- BiOr => "||",
- BiBitXor => "^",
- BiBitAnd => "&",
- BiBitOr => "|",
- BiShl => "<<",
- BiShr => ">>",
- BiEq => "==",
- BiLt => "<",
- BiLe => "<=",
- BiNe => "!=",
- BiGe => ">=",
- BiGt => ">"
+ Add => "+",
+ Sub => "-",
+ Mul => "*",
+ Div => "/",
+ Rem => "%",
+ And => "&&",
+ Or => "||",
+ BitXor => "^",
+ BitAnd => "&",
+ BitOr => "|",
+ Shl => "<<",
+ Shr => ">>",
+ Eq => "==",
+ Lt => "<",
+ Le => "<=",
+ Ne => "!=",
+ Ge => ">=",
+ Gt => ">",
}
}
pub fn lazy(&self) -> bool {
match *self {
- BiAnd | BiOr => true,
+ BinOpKind::And | BinOpKind::Or => true,
_ => false
}
}
pub fn is_shift(&self) -> bool {
match *self {
- BiShl | BiShr => true,
+ BinOpKind::Shl | BinOpKind::Shr => true,
_ => false
}
}
pub fn is_comparison(&self) -> bool {
+ use self::BinOpKind::*;
match *self {
- BiEq | BiLt | BiLe | BiNe | BiGt | BiGe =>
+ Eq | Lt | Le | Ne | Gt | Ge =>
true,
- BiAnd | BiOr | BiAdd | BiSub | BiMul | BiDiv | BiRem |
- BiBitXor | BiBitAnd | BiBitOr | BiShl | BiShr =>
+ And | Or | Add | Sub | Mul | Div | Rem |
+ BitXor | BitAnd | BitOr | Shl | Shr =>
false,
}
}
/// Returns `true` if the binary operator takes its arguments by value
pub fn is_by_value(&self) -> bool {
- !BinOp_::is_comparison(self)
+ !self.is_comparison()
}
}
-pub type BinOp = Spanned<BinOp_>;
+pub type BinOp = Spanned<BinOpKind>;
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
pub enum UnOp {
/// The `*` operator for dereferencing
- UnDeref,
+ Deref,
/// The `!` operator for logical inversion
- UnNot,
+ Not,
/// The `-` operator for negation
- UnNeg
+ Neg,
}
impl UnOp {
/// Returns `true` if the unary operator takes its argument by value
pub fn is_by_value(u: UnOp) -> bool {
match u {
- UnNeg | UnNot => true,
+ UnOp::Neg | UnOp::Not => true,
_ => false,
}
}
pub fn to_string(op: UnOp) -> &'static str {
match op {
- UnDeref => "*",
- UnNot => "!",
- UnNeg => "-",
+ UnOp::Deref => "*",
+ UnOp::Not => "!",
+ UnOp::Neg => "-",
}
}
}
/// A statement
-pub type Stmt = Spanned<Stmt_>;
+pub type Stmt = Spanned<StmtKind>;
impl fmt::Debug for Stmt {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash)]
-pub enum Stmt_ {
+pub enum StmtKind {
/// Could be an item or a local (let) binding:
- StmtDecl(P<Decl>, NodeId),
+ Decl(P<Decl>, NodeId),
/// Expr without trailing semi-colon (must have unit type):
- StmtExpr(P<Expr>, NodeId),
+ Expr(P<Expr>, NodeId),
/// Expr with trailing semi-colon (may have any type):
- StmtSemi(P<Expr>, NodeId),
+ Semi(P<Expr>, NodeId),
- StmtMac(P<Mac>, MacStmtStyle, ThinAttributes),
+ Mac(P<Mac>, MacStmtStyle, ThinAttributes),
}
-impl Stmt_ {
+impl StmtKind {
pub fn id(&self) -> Option<NodeId> {
match *self {
- StmtDecl(_, id) => Some(id),
- StmtExpr(_, id) => Some(id),
- StmtSemi(_, id) => Some(id),
- StmtMac(..) => None,
+ StmtKind::Decl(_, id) => Some(id),
+ StmtKind::Expr(_, id) => Some(id),
+ StmtKind::Semi(_, id) => Some(id),
+ StmtKind::Mac(..) => None,
}
}
pub fn attrs(&self) -> &[Attribute] {
match *self {
- StmtDecl(ref d, _) => d.attrs(),
- StmtExpr(ref e, _) |
- StmtSemi(ref e, _) => e.attrs(),
- StmtMac(_, _, Some(ref b)) => b,
- StmtMac(_, _, None) => &[],
+ StmtKind::Decl(ref d, _) => d.attrs(),
+ StmtKind::Expr(ref e, _) |
+ StmtKind::Semi(ref e, _) => e.attrs(),
+ StmtKind::Mac(_, _, Some(ref b)) => b,
+ StmtKind::Mac(_, _, None) => &[],
}
}
}
pub enum MacStmtStyle {
/// The macro statement had a trailing semicolon, e.g. `foo! { ... };`
/// `foo!(...);`, `foo![...];`
- MacStmtWithSemicolon,
+ Semicolon,
/// The macro statement had braces; e.g. foo! { ... }
- MacStmtWithBraces,
+ Braces,
/// The macro statement had parentheses or brackets and no semicolon; e.g.
/// `foo!(...)`. All of these will end up being converted into macro
/// expressions.
- MacStmtWithoutBraces,
+ NoBraces,
}
// FIXME (pending discussion of #1697, #2178...): local should really be
}
}
-pub type Decl = Spanned<Decl_>;
+pub type Decl = Spanned<DeclKind>;
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub enum Decl_ {
+pub enum DeclKind {
/// A local (let) binding:
- DeclLocal(P<Local>),
+ Local(P<Local>),
/// An item binding:
- DeclItem(P<Item>),
+ Item(P<Item>),
}
impl Decl {
pub fn attrs(&self) -> &[Attribute] {
match self.node {
- DeclLocal(ref l) => l.attrs(),
- DeclItem(ref i) => i.attrs(),
+ DeclKind::Local(ref l) => l.attrs(),
+ DeclKind::Item(ref i) => i.attrs(),
}
}
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
pub enum BlockCheckMode {
- DefaultBlock,
- UnsafeBlock(UnsafeSource),
+ Default,
+ Unsafe(UnsafeSource),
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash,)]
pub struct Expr {
pub id: NodeId,
- pub node: Expr_,
+ pub node: ExprKind,
pub span: Span,
pub attrs: ThinAttributes
}
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub enum Expr_ {
+pub enum ExprKind {
/// A `box x` expression.
- ExprBox(P<Expr>),
+ Box(P<Expr>),
/// First expr is the place; second expr is the value.
- ExprInPlace(P<Expr>, P<Expr>),
+ InPlace(P<Expr>, P<Expr>),
/// An array (`[a, b, c, d]`)
+ Vec(Vec<P<Expr>>),
/// A function call
///
/// The first field resolves to the function itself,
/// and the second field is the list of arguments
-
ExprCall(P<Expr>, Vec<P<Expr>>),
+ Call(P<Expr>, Vec<P<Expr>>),
/// A method call (`x.foo::<Bar, Baz>(a, b, c, d)`)
///
/// The `SpannedIdent` is the identifier for the method name.
/// and the remaining elements are the rest of the arguments.
///
/// Thus, `x.foo::<Bar, Baz>(a, b, c, d)` is represented as
- /// `ExprMethodCall(foo, [Bar, Baz], [x, a, b, c, d])`.
-
ExprMethodCall(SpannedIdent, Vec<P<Ty>>, Vec<P<Expr>>),
+ /// `ExprKind::MethodCall(foo, [Bar, Baz], [x, a, b, c, d])`.
+ MethodCall(SpannedIdent, Vec<P<Ty>>, Vec<P<Expr>>),
/// A tuple (`(a, b, c ,d)`)
+ Tup(Vec<P<Expr>>),
/// A binary operation (For example: `a + b`, `a * b`)
- ExprBinary(BinOp, P<Expr>, P<Expr>),
+ Binary(BinOp, P<Expr>, P<Expr>),
/// A unary operation (For example: `!x`, `*x`)
- ExprUnary(UnOp, P<Expr>),
+ Unary(UnOp, P<Expr>),
/// A literal (For example: `1u8`, `"foo"`)
- ExprLit(P<Lit>),
+ Lit(P<Lit>),
/// A cast (`foo as f64`)
- ExprCast(P<Expr>, P<Ty>),
- ExprType(P<Expr>, P<Ty>),
+ Cast(P<Expr>, P<Ty>),
+ Type(P<Expr>, P<Ty>),
/// An `if` block, with an optional else block
///
/// `if expr { block } else { expr }`
-
ExprIf(P<Expr>, P<Block>, Option<P<Expr>>),
+ If(P<Expr>, P<Block>, Option<P<Expr>>),
/// An `if let` expression with an optional else block
///
/// `if let pat = expr { block } else { expr }`
///
/// This is desugared to a `match` expression.
-
ExprIfLet(P<Pat>, P<Expr>, P<Block>, Option<P<Expr>>),
+ IfLet(P<Pat>, P<Expr>, P<Block>, Option<P<Expr>>),
/// A while loop, with an optional label
///
/// `'label: while expr { block }`
- ExprWhile(P<Expr>, P<Block>, Option<Ident>),
+ While(P<Expr>, P<Block>, Option<Ident>),
/// A while-let loop, with an optional label
///
/// `'label: while let pat = expr { block }`
///
/// This is desugared to a combination of `loop` and `match` expressions.
-
ExprWhileLet(P<Pat>, P<Expr>, P<Block>, Option<Ident>),
+ WhileLet(P<Pat>, P<Expr>, P<Block>, Option<Ident>),
/// A for loop, with an optional label
///
/// `'label: for pat in expr { block }`
///
/// This is desugared to a combination of `loop` and `match` expressions.
-
ExprForLoop(P<Pat>, P<Expr>, P<Block>, Option<Ident>),
+ ForLoop(P<Pat>, P<Expr>, P<Block>, Option<Ident>),
/// Conditionless loop (can be exited with break, continue, or return)
///
/// `'label: loop { block }`
- ExprLoop(P<Block>, Option<Ident>),
+ Loop(P<Block>, Option<Ident>),
/// A `match` block.
-
ExprMatch(P<Expr>, Vec<Arm>),
+ Match(P<Expr>, Vec<Arm>),
/// A closure (for example, `move |a, b, c| {a + b + c}`)
- ExprClosure(CaptureClause, P<FnDecl>, P<Block>),
+ Closure(CaptureBy, P<FnDecl>, P<Block>),
/// A block (`{ ... }`)
- ExprBlock(P<Block>),
+ Block(P<Block>),
/// An assignment (`a = foo()`)
- ExprAssign(P<Expr>, P<Expr>),
+ Assign(P<Expr>, P<Expr>),
/// An assignment with an operator
///
/// For example, `a += 1`.
- ExprAssignOp(BinOp, P<Expr>, P<Expr>),
+ AssignOp(BinOp, P<Expr>, P<Expr>),
/// Access of a named struct field (`obj.foo`)
- ExprField(P<Expr>, SpannedIdent),
+ Field(P<Expr>, SpannedIdent),
/// Access of an unnamed field of a struct or tuple-struct
///
/// For example, `foo.0`.
- ExprTupField(P<Expr>, Spanned<usize>),
+ TupField(P<Expr>, Spanned<usize>),
/// An indexing operation (`foo[2]`)
- ExprIndex(P<Expr>, P<Expr>),
+ Index(P<Expr>, P<Expr>),
/// A range (`1..2`, `1..`, or `..2`)
-
ExprRange(Option<P<Expr>>, Option<P<Expr>>),
+ Range(Option<P<Expr>>, Option<P<Expr>>),
/// Variable reference, possibly containing `::` and/or type
/// parameters, e.g. foo::bar::<baz>.
///
/// Optionally "qualified",
/// e.g. `<Vec<T> as SomeTrait>::SomeType`.
- ExprPath(Option<QSelf>, Path),
+ Path(Option<QSelf>, Path),
/// A referencing operation (`&a` or `&mut a`)
- ExprAddrOf(Mutability, P<Expr>),
+ AddrOf(Mutability, P<Expr>),
/// A `break`, with an optional label to break
- ExprBreak(Option<SpannedIdent>),
+ Break(Option<SpannedIdent>),
/// A `continue`, with an optional label
- ExprAgain(Option<SpannedIdent>),
+ Again(Option<SpannedIdent>),
/// A `return`, with an optional value to be returned
-
ExprRet(Option<P<Expr>>),
+ Ret(Option<P<Expr>>),
/// Output of the `asm!()` macro
- ExprInlineAsm(InlineAsm),
+ InlineAsm(InlineAsm),
/// A macro invocation; pre-expansion
- ExprMac(Mac),
+ Mac(Mac),
/// A struct literal expression.
///
/// For example, `Foo {x: 1, y: 2}`, or
/// `Foo {x: 1, .. base}`, where `base` is the `Option<Expr>`.
-
ExprStruct(Path, Vec<Field>, Option<P<Expr>>),
+ Struct(Path, Vec<Field>, Option<P<Expr>>),
/// An array literal constructed from one repeated element.
///
/// For example, `[1u8; 5]`. The first expression is the element
/// to be repeated; the second is the number of times to repeat it.
- ExprRepeat(P<Expr>, P<Expr>),
+ Repeat(P<Expr>, P<Expr>),
/// No-op: used solely so we can pretty-print faithfully
- ExprParen(P<Expr>)
+ Paren(P<Expr>),
}
/// The explicit Self type in a "qualified path". The actual
pub position: usize
}
+/// A capture clause
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
-pub enum CaptureClause {
- CaptureByValue,
- CaptureByRef,
+pub enum CaptureBy {
+ Value,
+ Ref,
}
/// A delimited sequence of token trees
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
pub enum StrStyle {
/// A regular string, like `"foo"`
- CookedStr,
+ Cooked,
/// A raw string, like `r##"foo"##`
///
/// The uint is the number of `#` symbols used
- RawStr(usize)
+ Raw(usize)
}
/// A literal
-pub type Lit = Spanned<Lit_>;
-
-#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
-pub enum Sign {
- Minus,
- Plus
-}
-
-impl Sign {
- pub fn new<T: IntSign>(n: T) -> Sign {
- n.sign()
- }
-}
-
-pub trait IntSign {
- fn sign(&self) -> Sign;
-}
-macro_rules! doit {
- ($($t:ident)*) => ($(impl IntSign for $t {
- #[allow(unused_comparisons)]
- fn sign(&self) -> Sign {
- if *self < 0 {Minus} else {Plus}
- }
- })*)
-}
-doit! { i8 i16 i32 i64 isize u8 u16 u32 u64 usize }
+pub type Lit = Spanned<LitKind>;
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
pub enum LitIntType {
- SignedIntLit(IntTy, Sign),
- UnsignedIntLit(UintTy),
- UnsuffixedIntLit(Sign)
+ Signed(IntTy),
+ Unsigned(UintTy),
+ Unsuffixed,
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub enum Lit_ {
+pub enum LitKind {
/// A string literal (`"foo"`)
- LitStr(InternedString, StrStyle),
+ Str(InternedString, StrStyle),
/// A byte string (`b"foo"`)
- LitByteStr(Rc<Vec<u8>>),
+ ByteStr(Rc<Vec<u8>>),
/// A byte char (`b'f'`)
- LitByte(u8),
+ Byte(u8),
/// A character literal (`'a'`)
- LitChar(char),
+ Char(char),
/// An integer literal (`1u8`)
- LitInt(u64, LitIntType),
+ Int(u64, LitIntType),
/// A float literal (`1f64` or `1E10f64`)
- LitFloat(InternedString, FloatTy),
+ Float(InternedString, FloatTy),
/// A float literal without a suffix (`1.0 or 1.0E10`)
- LitFloatUnsuffixed(InternedString),
+ FloatUnsuffixed(InternedString),
/// A boolean literal
- LitBool(bool),
+ Bool(bool),
}
-impl Lit_ {
+impl LitKind {
/// Returns true if this literal is a string and false otherwise.
pub fn is_str(&self) -> bool {
match *self {
- LitStr(..) => true,
+ LitKind::Str(..) => true,
_ => false,
}
}
pub id: NodeId,
pub ident: Ident,
pub attrs: Vec<Attribute>,
- pub node: TraitItem_,
+ pub node: TraitItemKind,
pub span: Span,
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub enum TraitItem_ {
- Const
TraitItem(P<Ty>, Option<P<Expr>>),
- Method
TraitItem(MethodSig, Option<P<Block>>),
- Type
TraitItem(TyParamBounds, Option<P<Ty>>),
+pub enum TraitItemKind {
+ Const(P<Ty>, Option<P<Expr>>),
+ Method(MethodSig, Option<P<Block>>),
+ Type(TyParamBounds, Option<P<Ty>>),
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)]
pub enum IntTy {
- TyIs,
- TyI8,
- TyI16,
- TyI32,
- TyI64,
+ Is,
+ I8,
+ I16,
+ I32,
+ I64,
}
impl fmt::Debug for IntTy {
impl IntTy {
pub fn ty_to_string(&self) -> &'static str {
match *self {
- TyIs => "isize",
- TyI8 => "i8",
- TyI16 => "i16",
- TyI32 => "i32",
- TyI64 => "i64"
+ IntTy::Is => "isize",
+ IntTy::I8 => "i8",
+ IntTy::I16 => "i16",
+ IntTy::I32 => "i32",
+ IntTy::I64 => "i64"
}
}
pub fn ty_max(&self) -> u64 {
match *self {
- TyI8 => 0x80,
- TyI16 => 0x8000,
- TyIs | TyI32 => 0x80000000, // actually ni about TyIs
- TyI64 => 0x8000000000000000
+ IntTy::I8 => 0x80,
+ IntTy::I16 => 0x8000,
+ IntTy::Is | IntTy::I32 => 0x80000000, // FIXME: actually ni about Is
+ IntTy::I64 => 0x8000000000000000
}
}
pub fn bit_width(&self) -> Option<usize> {
Some(match *self {
- TyIs => return None,
- TyI8 => 8,
- TyI16 => 16,
- TyI32 => 32,
- TyI64 => 64,
+ IntTy::Is => return None,
+ IntTy::I8 => 8,
+ IntTy::I16 => 16,
+ IntTy::I32 => 32,
+ IntTy::I64 => 64,
})
}
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)]
pub enum UintTy {
- TyUs,
- TyU8,
- TyU16,
- TyU32,
- TyU64,
+ Us,
+ U8,
+ U16,
+ U32,
+ U64,
}
impl UintTy {
pub fn ty_to_string(&self) -> &'static str {
match *self {
- TyUs => "usize",
- TyU8 => "u8",
- TyU16 => "u16",
- TyU32 => "u32",
- TyU64 => "u64"
+ UintTy::Us => "usize",
+ UintTy::U8 => "u8",
+ UintTy::U16 => "u16",
+ UintTy::U32 => "u32",
+ UintTy::U64 => "u64"
}
}
pub fn ty_max(&self) -> u64 {
match *self {
- TyU8 => 0xff,
- TyU16 => 0xffff,
- TyUs | TyU32 => 0xffffffff, // actually ni about TyUs
- TyU64 => 0xffffffffffffffff
+ UintTy::U8 => 0xff,
+ UintTy::U16 => 0xffff,
+ UintTy::Us | UintTy::U32 => 0xffffffff, // FIXME: actually ni about Us
+ UintTy::U64 => 0xffffffffffffffff
}
}
pub fn bit_width(&self) -> Option<usize> {
Some(match *self {
- TyUs => return None,
- TyU8 => 8,
- TyU16 => 16,
- TyU32 => 32,
- TyU64 => 64,
+ UintTy::Us => return None,
+ UintTy::U8 => 8,
+ UintTy::U16 => 16,
+ UintTy::U32 => 32,
+ UintTy::U64 => 64,
})
}
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)]
pub enum FloatTy {
- TyF32,
- TyF64,
+ F32,
+ F64,
}
impl fmt::Debug for FloatTy {
impl FloatTy {
pub fn ty_to_string(&self) -> &'static str {
match *self {
- TyF32 => "f32",
- TyF64 => "f64",
+ FloatTy::F32 => "f32",
+ FloatTy::F64 => "f64",
}
}
pub fn bit_width(&self) -> usize {
match *self {
- TyF32 => 32,
- TyF64 => 64,
+ FloatTy::F32 => 32,
+ FloatTy::F64 => 64,
}
}
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash)]
pub struct Ty {
pub id: NodeId,
- pub node: Ty_,
+ pub node: TyKind,
pub span: Span,
}
}
}
-/// Not represented directly in the AST, referred to by name through a ty_path.
-#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
-pub enum PrimTy {
- TyInt(IntTy),
- TyUint(UintTy),
- TyFloat(FloatTy),
- TyStr,
- TyBool,
- TyChar
-}
-
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct BareFnTy {
pub unsafety: Unsafety,
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
/// The different kinds of types recognized by the compiler
-pub enum Ty_ {
- TyVec(P<Ty>),
+pub enum TyKind {
+ Vec(P<Ty>),
/// A fixed length array (`[T; n]`)
- TyFixedLengthVec(P<Ty>, P<Expr>),
+ FixedLengthVec(P<Ty>, P<Expr>),
/// A raw pointer (`*const T` or `*mut T`)
- TyPtr(MutTy),
+ Ptr(MutTy),
/// A reference (`&'a T` or `&'a mut T`)
- TyRptr(Option<Lifetime>, MutTy),
+ Rptr(Option<Lifetime>, MutTy),
/// A bare function (e.g. `fn(usize) -> bool`)
- TyBareFn(P<BareFnTy>),
+ BareFn(P<BareFnTy>),
/// A tuple (`(A, B, C, D,...)`)
+ Tup(Vec<P<Ty>> ),
/// A path (`module::module::...::Type`), optionally
/// "qualified", e.g. `<Vec<T> as SomeTrait>::SomeType`.
///
/// Type parameters are stored in the Path itself
- TyPath(Option<QSelf>, Path),
+ Path(Option<QSelf>, Path),
/// Something like `A+B`. Note that `B` must always be a path.
- TyObjectSum(P<Ty>, TyParamBounds),
+ ObjectSum(P<Ty>, TyParamBounds),
/// A type like `for<'a> Foo<&'a Bar>`
- TyPolyTraitRef(TyParamBounds),
+ PolyTraitRef(TyParamBounds),
/// No-op; kept solely so that we can pretty-print faithfully
- TyParen(P<Ty>),
+ Paren(P<Ty>),
/// Unused for now
- TyTypeof(P<Expr>),
- /// TyInfer means the type should be inferred instead of it having been
+ Typeof(P<Expr>),
+ /// TyKind::Infer means the type should be inferred instead of it having been
/// specified. This can appear anywhere in a type.
- TyInfer,
+ Infer,
// A macro in the type position.
- TyMac(Mac)
+ Mac(Mac),
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
// HACK(eddyb) fake type for the self argument.
ty: P(Ty {
id: DUMMY_NODE_ID,
- node: TyInfer,
+ node: TyKind::Infer,
span: DUMMY_SP,
}),
pat: P(Pat {
pub enum FunctionRetTy {
/// Functions with return type `!`that always
/// raise an error or exit (i.e. never return to the caller)
- NoReturn(Span),
+ None(Span),
/// Return type is not specified.
///
/// Functions default to `()` and
/// closures default to inference. Span points to where return
/// type would be inserted.
- DefaultReturn(Span),
+ Default(Span),
/// Everything else
- Return(P<Ty>),
+ Ty(P<Ty>),
}
impl FunctionRetTy {
pub fn span(&self) -> Span {
match *self {
- NoReturn(span) => span,
- DefaultReturn(span) => span,
- Return(ref ty) => ty.span
+ FunctionRetTy::None(span) => span,
+ FunctionRetTy::Default(span) => span,
+ FunctionRetTy::Ty(ref ty) => ty.span,
}
}
}
/// Represents the kind of 'self' associated with a method
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub enum ExplicitSelf_ {
+pub enum SelfKind {
/// No self
- SelfStatic,
+ Static,
/// `self`
- SelfValue(Ident),
+ Value(Ident),
/// `&'lt self`, `&'lt mut self`
- SelfRegion(Option<Lifetime>, Mutability, Ident),
+ Region(Option<Lifetime>, Mutability, Ident),
/// `self: TYPE`
- SelfExplicit(P<Ty>, Ident),
+ Explicit(P<Ty>, Ident),
}
-pub type ExplicitSelf = Spanned<ExplicitSelf_>;
+pub type ExplicitSelf = Spanned<SelfKind>;
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct Mod {
pub type Variant = Spanned<Variant_>;
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
-pub enum PathListItem_ {
- PathListIdent {
+pub enum PathListItemKind {
+ Ident {
name: Ident,
/// renamed in list, eg `use foo::{bar as baz};`
rename: Option<Ident>,
id: NodeId
},
- PathListMod {
+ Mod {
/// renamed in list, eg `use foo::{self as baz};`
rename: Option<Ident>,
id: NodeId
}
}
-impl PathListItem_ {
+impl PathListItemKind {
pub fn id(&self) -> NodeId {
match *self {
- PathListIdent { id, .. } | PathListMod { id, .. } => id
+ PathListItemKind::Ident { id, .. } | PathListItemKind::Mod { id, .. } => id
}
}
pub fn name(&self) -> Option<Ident> {
match *self {
- PathListIdent { name, .. } => Some(name),
- PathListMod { .. } => None,
+ PathListItemKind::Ident { name, .. } => Some(name),
+ PathListItemKind::Mod { .. } => None,
}
}
pub fn rename(&self) -> Option<Ident> {
match *self {
- PathListIdent { rename, .. } | PathListMod { rename, .. } => rename
+ PathListItemKind::Ident { rename, .. } | PathListItemKind::Mod { rename, .. } => rename
}
}
}
-pub type PathListItem = Spanned<PathListItem_>;
+pub type PathListItem = Spanned<PathListItemKind>;
pub type ViewPath = Spanned<ViewPath_>;
///
/// resolve maps each TraitRef's ref_id to its defining trait; that's all
/// that the ref_id is for. The impl_id maps to the "self type" of this impl.
-/// If this impl is an ItemImpl, the impl_id is redundant (it could be the
+/// If this impl is an ItemKind::Impl, the impl_id is redundant (it could be the
/// same as the impl's node id).
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct TraitRef {
impl Visibility {
pub fn inherit_from(&self, parent_visibility: Visibility) -> Visibility {
match *self {
- Inherited => parent_visibility,
- Public => *self
+ Visibility::Inherited => parent_visibility,
+ Visibility::Public => *self
}
}
}
pub ident: Ident,
pub attrs: Vec<Attribute>,
pub id: NodeId,
- pub node: Item_,
+ pub node: ItemKind,
pub vis: Visibility,
pub span: Span,
}
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub enum Item_ {
+pub enum ItemKind {
/// An`extern crate` item, with optional original crate name,
///
/// e.g. `extern crate foo` or `extern crate foo_bar as foo`
- ItemExternCrate(Option<Name>),
+ ExternCrate(Option<Name>),
/// A `use` or `pub use` item
- ItemUse(P<ViewPath>),
+ Use(P<ViewPath>),
/// A `static` item
- ItemStatic(P<Ty>, Mutability, P<Expr>),
+ Static(P<Ty>, Mutability, P<Expr>),
/// A `const` item
- ItemConst(P<Ty>, P<Expr>),
+ Const(P<Ty>, P<Expr>),
/// A function declaration
- ItemFn(P<FnDecl>, Unsafety, Constness, Abi, Generics, P<Block>),
+ Fn(P<FnDecl>, Unsafety, Constness, Abi, Generics, P<Block>),
/// A module
- ItemMod(Mod),
+ Mod(Mod),
/// An external module
- ItemForeignMod(ForeignMod),
+ ForeignMod(ForeignMod),
/// A type alias, e.g. `type Foo = Bar<u8>`
- ItemTy(P<Ty>, Generics),
+ Ty(P<Ty>, Generics),
/// An enum definition, e.g. `enum Foo<A, B> {C<A>, D<B>}`
- ItemEnum(EnumDef, Generics),
+ Enum(EnumDef, Generics),
/// A struct definition, e.g. `struct Foo<A> {x: A}`
- ItemStruct(VariantData, Generics),
+ Struct(VariantData, Generics),
/// Represents a Trait Declaration
- ItemTrait(Unsafety,
+ Trait(Unsafety,
Generics,
TyParamBounds,
Vec<P<TraitItem>>),
// Default trait implementations
///
// `impl Trait for .. {}`
- ItemDefaultImpl(Unsafety, TraitRef),
+ DefaultImpl(Unsafety, TraitRef),
/// An implementation, eg `impl<A> Trait for Foo { .. }`
- ItemImpl(Unsafety,
+ Impl(Unsafety,
ImplPolarity,
Generics,
Option<TraitRef>, // (optional) trait this impl implements
P<Ty>, // self
Vec<P<ImplItem>>),
/// A macro invocation (which includes macro definition)
- ItemMac(Mac),
+ Mac(Mac),
}
-impl Item_ {
+impl ItemKind {
pub fn descriptive_variant(&self) -> &str {
match *self {
- ItemExternCrate(..) => "extern crate",
- ItemUse(..) => "use",
- ItemStatic(..) => "static item",
- ItemConst(..) => "constant item",
- ItemFn(..) => "function",
- ItemMod(..) => "module",
- ItemForeignMod(..) => "foreign module",
- ItemTy(..) => "type alias",
- ItemEnum(..) => "enum",
- ItemStruct(..) => "struct",
- ItemTrait(..) => "trait",
- ItemMac(..) |
- ItemImpl(..) |
- ItemDefaultImpl(..) => "item"
+ ItemKind::ExternCrate(..) => "extern crate",
+ ItemKind::Use(..) => "use",
+ ItemKind::Static(..) => "static item",
+ ItemKind::Const(..) => "constant item",
+ ItemKind::Fn(..) => "function",
+ ItemKind::Mod(..) => "module",
+ ItemKind::ForeignMod(..) => "foreign module",
+ ItemKind::Ty(..) => "type alias",
+ ItemKind::Enum(..) => "enum",
+ ItemKind::Struct(..) => "struct",
+ ItemKind::Trait(..) => "trait",
+ ItemKind::Mac(..) |
+ ItemKind::Impl(..) |
+ ItemKind::DefaultImpl(..) => "item"
}
}
}
pub struct ForeignItem {
pub ident: Ident,
pub attrs: Vec<Attribute>,
- pub node: ForeignItem_,
+ pub node: ForeignItemKind,
pub id: NodeId,
pub span: Span,
pub vis: Visibility,
/// An item within an `extern` block
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub enum ForeignItem_ {
+pub enum ForeignItemKind {
/// A foreign function
- ForeignItemFn(P<FnDecl>, Generics),
+ Fn(P<FnDecl>, Generics),
/// A foreign static item (`static ext: u8`), with optional mutability
/// (the boolean is true when mutable)
- ForeignItemStatic(P<Ty>, bool),
+ Static(P<Ty>, bool),
}
-impl ForeignItem_ {
+impl ForeignItemKind {
pub fn descriptive_variant(&self) -> &str {
match *self {
- ForeignItemFn(..) => "foreign function",
- ForeignItemStatic(..) => "foreign static item"
+ ForeignItemKind::Fn(..) => "foreign function",
+ ForeignItemKind::Static(..) => "foreign static item"
}
}
}
}
pub fn is_path(e: P<Expr>) -> bool {
- match e.node { ExprPath(..) => true, _ => false }
+ match e.node { ExprKind::Path(..) => true, _ => false }
}
}
pub fn ident_to_pat(id: NodeId, s: Span, i: Ident) -> P<Pat> {
+ let spanned = codemap::Spanned{ span: s, node: i };
P(Pat {
id: id,
- node: PatIdent(BindingMode::ByValue(MutImmutable), codemap::Spanned{span:s, node:i}, None),
+ node: PatIdent(BindingMode::ByValue(Mutability::Immutable), spanned, None),
span: s
})
}
self.operation.visit_id(item.id);
match item.node {
- ItemUse(ref view_path) => {
+ ItemKind::Use(ref view_path) => {
match view_path.node {
ViewPathSimple(_, _) |
ViewPathGlob(_) => {}
pub use self::IntType::*;
use ast;
-use ast::{AttrId, Attribute, Attribute_, MetaItem, MetaWord, MetaNameValue, MetaList};
-use ast::{Stmt, StmtDecl, StmtExpr, StmtMac, StmtSemi, DeclItem, DeclLocal};
+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};
use codemap::BytePos;
/// `#[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::LitStr(ref s, _) => Some((*s).clone()),
+ 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_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::StrStyle::Cooked));
mk_name_value_item(name, value_lit)
}
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) }
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::StrStyle::Cooked));
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),
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)
}
},
}
fn fold_foreign_mod(&mut self, foreign_mod: ast::ForeignMod) -> ast::ForeignMod {
fold_foreign_mod(self, foreign_mod)
}
- fn fold_item_underscore(&mut self, item: ast::Item_) -> ast::Item_ {
- fold_item_underscore(self, item)
+ fn fold_item_kind(&mut self, item: ast::ItemKind) -> ast::ItemKind {
+ fold_item_kind(self, item)
}
fn fold_expr(&mut self, expr: P<ast::Expr>) -> P<ast::Expr> {
// If an expr is valid to cfg away it will have been removed by the
}
}
-fn fold_item_underscore<F>(cx: &mut Context<F>, item: ast::Item_) -> ast::Item_ where
+fn fold_item_kind<F>(cx: &mut Context<F>, item: ast::ItemKind) -> ast::ItemKind where
F: FnMut(&[ast::Attribute]) -> bool
{
let item = match item {
- ast::ItemImpl(u, o, a, b, c, impl_items) => {
+ ast::ItemKind::Impl(u, o, a, b, c, impl_items) => {
let impl_items = impl_items.into_iter()
.filter(|ii| (cx.in_cfg)(&ii.attrs))
.collect();
- ast::ItemImpl(u, o, a, b, c, impl_items)
+ ast::ItemKind::Impl(u, o, a, b, c, impl_items)
}
- ast::ItemTrait(u, a, b, methods) => {
+ ast::ItemKind::Trait(u, a, b, methods) => {
let methods = methods.into_iter()
.filter(|ti| (cx.in_cfg)(&ti.attrs))
.collect();
- ast::ItemTrait(u, a, b, methods)
+ ast::ItemKind::Trait(u, a, b, methods)
}
- ast::ItemStruct(def, generics) => {
- ast::ItemStruct(fold_struct(cx, def), generics)
+ ast::ItemKind::Struct(def, generics) => {
+ ast::ItemKind::Struct(fold_struct(cx, def), generics)
}
- ast::ItemEnum(def, generics) => {
+ ast::ItemKind::Enum(def, generics) => {
let variants = def.variants.into_iter().filter_map(|v| {
if !(cx.in_cfg)(&v.node.attrs) {
None
}))
}
});
- ast::ItemEnum(ast::EnumDef {
+ ast::ItemKind::Enum(ast::EnumDef {
variants: variants.collect(),
}, generics)
}
item => item,
};
- fold::noop_fold_item_underscore(item, cx)
+ fold::noop_fold_item_kind(item, cx)
}
fn fold_struct<F>(cx: &mut Context<F>, vdata: ast::VariantData) -> ast::VariantData where
fold::noop_fold_expr(ast::Expr {
id: id,
node: match node {
- ast::ExprMatch(m, arms) => {
- ast::ExprMatch(m, arms.into_iter()
+ ast::ExprKind::Match(m, arms) => {
+ ast::ExprKind::Match(m, arms.into_iter()
.filter(|a| (cx.in_cfg)(&a.attrs))
.collect())
}
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
};
let stmt_attrs = s.node.attrs();
if stmt_attrs.len() > 0 {
// attributes on items are fine
- if let ast::StmtDecl(ref decl, _) = s.node {
- if let ast::DeclItem(_) = decl.node {
+ if let ast::StmtKind::Decl(ref decl, _) = s.node {
+ if let ast::DeclKind::Item(_) = decl.node {
visit::walk_stmt(self, s);
return;
}
span,
ecx.ty_ident(span, ecx.ident_of("str")),
Some(static_),
- ast::MutImmutable,
+ ast::Mutability::Immutable,
);
let ty = ecx.ty(
span,
- ast::TyFixedLengthVec(
+ ast::TyKind::FixedLengthVec(
ecx.ty(
span,
- ast::TyTup(vec![ty_str.clone(), ty_str])
+ ast::TyKind::Tup(vec![ty_str.clone(), ty_str])
),
ecx.expr_usize(span, count),
),
ident: name.clone(),
attrs: Vec::new(),
id: ast::DUMMY_NODE_ID,
- node: ast::ItemConst(
+ node: ast::ItemKind::Const(
ty,
expr,
),
- vis: ast::Public,
+ vis: ast::Visibility::Public,
span: span,
})
]))
// except according to those terms.
use attr;
-use ast::{Item, ItemFn};
+use ast::{Item, ItemKind};
pub enum EntryPointType {
None,
// them in sync.
pub fn entry_point_type(item: &Item, depth: usize) -> EntryPointType {
match item.node {
- ItemFn(..) => {
+ ItemKind::Fn(..) => {
if attr::contains_name(&item.attrs, "start") {
EntryPointType::Start
} else if attr::contains_name(&item.attrs, "main") {
}
}
-// A more flexible ItemModifier (ItemModifier should go away, eventually, FIXME).
+// A more flexible ItemKind::Modifier (ItemKind::Modifier should go away, eventually, FIXME).
// meta_item is the annotation, item is the item being modified, parent_item
// is the impl or trait item is declared in if item is part of such a thing.
// FIXME Decorators should follow the same pattern too.
($me:expr) => {
$me.make_expr().map(|e| {
SmallVector::one(P(codemap::respan(
- e.span, ast::StmtExpr(e, ast::DUMMY_NODE_ID))))
+ e.span, ast::StmtKind::Expr(e, ast::DUMMY_NODE_ID))))
})
}
}
return Some(p);
}
if let Some(e) = self.expr {
- if let ast::ExprLit(_) = e.node {
+ if let ast::ExprKind::Lit(_) = e.node {
return Some(P(ast::Pat {
id: ast::DUMMY_NODE_ID,
span: e.span,
pub fn raw_expr(sp: Span) -> P<ast::Expr> {
P(ast::Expr {
id: ast::DUMMY_NODE_ID,
- node: ast::ExprLit(P(codemap::respan(sp, ast::LitBool(false)))),
+ node: ast::ExprKind::Lit(P(codemap::respan(sp, ast::LitKind::Bool(false)))),
span: sp,
attrs: None,
})
pub fn raw_ty(sp: Span) -> P<ast::Ty> {
P(ast::Ty {
id: ast::DUMMY_NODE_ID,
- node: ast::TyInfer,
+ node: ast::TyKind::Infer,
span: sp
})
}
fn make_stmts(self: Box<DummyResult>) -> Option<SmallVector<P<ast::Stmt>>> {
Some(SmallVector::one(P(
codemap::respan(self.span,
- ast::StmtExpr(DummyResult::raw_expr(self.span),
- ast::DUMMY_NODE_ID)))))
+ ast::StmtKind::Expr(DummyResult::raw_expr(self.span),
+ ast::DUMMY_NODE_ID)))))
}
}
// we want to be able to handle e.g. concat("foo", "bar")
let expr = cx.expander().fold_expr(expr);
match expr.node {
- ast::ExprLit(ref l) => match l.node {
- ast::LitStr(ref s, style) => return Some(((*s).clone(), style)),
+ ast::ExprKind::Lit(ref l) => match l.node {
+ ast::LitKind::Str(ref s, style) => return Some(((*s).clone(), style)),
_ => cx.span_err(l.span, err_msg)
},
_ => cx.span_err(expr.span, err_msg)
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use abi;
-use ast::{Ident, Generics, Expr};
-use ast;
+use abi::Abi;
+use ast::{self, Ident, Generics, Expr, BlockCheckMode, UnOp};
use attr;
use codemap::{Span, respan, Spanned, DUMMY_SP, Pos};
use ext::base::ExtCtxt;
// types
fn ty_mt(&self, ty: P<ast::Ty>, mutbl: ast::Mutability) -> ast::MutTy;
- fn ty(&self, span: Span, ty: ast::Ty
_) -> P<ast::Ty>;
+ fn ty(&self, span: Span, ty: ast::Ty
Kind) -> P<ast::Ty>;
fn ty_path(&self, ast::Path) -> P<ast::Ty>;
fn ty_sum(&self, ast::Path, ast::TyParamBounds) -> P<ast::Ty>;
fn ty_ident(&self, span: Span, idents: ast::Ident) -> P<ast::Ty>;
expr: Option<P<ast::Expr>>) -> P<ast::Block>;
// expressions
- fn expr(&self, span: Span, node: ast::Expr
_) -> P<ast::Expr>;
+ fn expr(&self, span: Span, node: ast::Expr
Kind) -> P<ast::Expr>;
fn expr_path(&self, path: ast::Path) -> P<ast::Expr>;
fn expr_qpath(&self, span: Span, qself: ast::QSelf, path: ast::Path) -> P<ast::Expr>;
fn expr_ident(&self, span: Span, id: ast::Ident) -> P<ast::Expr>;
fn expr_self(&self, span: Span) -> P<ast::Expr>;
- fn expr_binary(&self, sp: Span, op: ast::BinOp_,
+ fn expr_binary(&self, sp: Span, op: ast::BinOpKind,
lhs: P<ast::Expr>, rhs: P<ast::Expr>) -> P<ast::Expr>;
fn expr_deref(&self, sp: Span, e: P<ast::Expr>) -> P<ast::Expr>;
fn expr_unary(&self, sp: Span, op: ast::UnOp, e: P<ast::Expr>) -> P<ast::Expr>;
fn expr_struct_ident(&self, span: Span, id: ast::Ident,
fields: Vec<ast::Field>) -> P<ast::Expr>;
- fn expr_lit(&self, sp: Span, lit: ast::Lit
_) -> P<ast::Expr>;
+ fn expr_lit(&self, sp: Span, lit: ast::Lit
Kind) -> P<ast::Expr>;
fn expr_usize(&self, span: Span, i: usize) -> P<ast::Expr>;
fn expr_isize(&self, sp: Span, i: isize) -> P<ast::Expr>;
// items
fn item(&self, span: Span,
- name: Ident, attrs: Vec<ast::Attribute> , node: ast::Item
_) -> P<ast::Item>;
+ name: Ident, attrs: Vec<ast::Attribute> , node: ast::Item
Kind) -> P<ast::Item>;
fn arg(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> ast::Arg;
// FIXME unused self
fn meta_name_value(&self,
sp: Span,
name: InternedString,
- value: ast::Lit_)
+ value: ast::LitKind)
-> P<ast::MetaItem>;
fn item_use(&self, sp: Span,
}
}
- fn ty(&self, span: Span, ty: ast::Ty
_) -> P<ast::Ty> {
+ fn ty(&self, span: Span, ty: ast::Ty
Kind) -> P<ast::Ty> {
P(ast::Ty {
id: ast::DUMMY_NODE_ID,
span: span,
}
fn ty_path(&self, path: ast::Path) -> P<ast::Ty> {
- self.ty(path.span, ast::TyPath(None, path))
+ self.ty(path.span, ast::TyKind::Path(None, path))
}
fn ty_sum(&self, path: ast::Path, bounds: ast::TyParamBounds) -> P<ast::Ty> {
self.ty(path.span,
- ast::TyObjectSum(self.ty_path(path),
+ ast::TyKind::ObjectSum(self.ty_path(path),
bounds))
}
mutbl: ast::Mutability)
-> P<ast::Ty> {
self.ty(span,
- ast::TyRptr(lifetime, self.ty_mt(ty, mutbl)))
+ ast::TyKind::Rptr(lifetime, self.ty_mt(ty, mutbl)))
}
fn ty_ptr(&self,
mutbl: ast::Mutability)
-> P<ast::Ty> {
self.ty(span,
- ast::TyPtr(self.ty_mt(ty, mutbl)))
+ ast::TyKind::Ptr(self.ty_mt(ty, mutbl)))
}
fn ty_option(&self, ty: P<ast::Ty>) -> P<ast::Ty> {
}
fn ty_infer(&self, span: Span) -> P<ast::Ty> {
- self.ty(span, ast::TyInfer)
+ self.ty(span, ast::TyKind::Infer)
}
fn typaram(&self,
}
fn stmt_expr(&self, expr: P<ast::Expr>) -> P<ast::Stmt> {
- P(respan(expr.span, ast::StmtSemi(expr, ast::DUMMY_NODE_ID)))
+ P(respan(expr.span, ast::StmtKind::Semi(expr, ast::DUMMY_NODE_ID)))
}
fn stmt_let(&self, sp: Span, mutbl: bool, ident: ast::Ident,
ex: P<ast::Expr>) -> P<ast::Stmt> {
let pat = if mutbl {
- self.pat_ident_binding_mode(sp, ident, ast::BindingMode::ByValue(ast::MutMutable))
+ let binding_mode = ast::BindingMode::ByValue(ast::Mutability::Mutable);
+ self.pat_ident_binding_mode(sp, ident, binding_mode)
} else {
self.pat_ident(sp, ident)
};
span: sp,
attrs: None,
});
- let decl = respan(sp, ast::DeclLocal(local));
- P(respan(sp, ast::StmtDecl(P(decl), ast::DUMMY_NODE_ID)))
+ let decl = respan(sp, ast::DeclKind::Local(local));
+ P(respan(sp, ast::StmtKind::Decl(P(decl), ast::DUMMY_NODE_ID)))
}
fn stmt_let_typed(&self,
ex: P<ast::Expr>)
-> P<ast::Stmt> {
let pat = if mutbl {
- self.pat_ident_binding_mode(sp, ident, ast::BindingMode::ByValue(ast::MutMutable))
+ let binding_mode = ast::BindingMode::ByValue(ast::Mutability::Mutable);
+ self.pat_ident_binding_mode(sp, ident, binding_mode)
} else {
self.pat_ident(sp, ident)
};
span: sp,
attrs: None,
});
- let decl = respan(sp, ast::DeclLocal(local));
- P(respan(sp, ast::StmtDecl(P(decl), ast::DUMMY_NODE_ID)))
+ let decl = respan(sp, ast::DeclKind::Local(local));
+ P(respan(sp, ast::StmtKind::Decl(P(decl), ast::DUMMY_NODE_ID)))
}
fn block(&self, span: Span, stmts: Vec<P<ast::Stmt>>,
}
fn stmt_item(&self, sp: Span, item: P<ast::Item>) -> P<ast::Stmt> {
- let decl = respan(sp, ast::DeclItem(item));
- P(respan(sp, ast::StmtDecl(P(decl), ast::DUMMY_NODE_ID)))
+ let decl = respan(sp, ast::DeclKind::Item(item));
+ P(respan(sp, ast::StmtKind::Decl(P(decl), ast::DUMMY_NODE_ID)))
}
fn block_expr(&self, expr: P<ast::Expr>) -> P<ast::Block> {
stmts: stmts,
expr: expr,
id: ast::DUMMY_NODE_ID,
- rules: ast::DefaultBlock,
+ rules: BlockCheckMode::Default,
span: span,
})
}
- fn expr(&self, span: Span, node: ast::Expr
_) -> P<ast::Expr> {
+ fn expr(&self, span: Span, node: ast::Expr
Kind) -> P<ast::Expr> {
P(ast::Expr {
id: ast::DUMMY_NODE_ID,
node: node,
}
fn expr_path(&self, path: ast::Path) -> P<ast::Expr> {
- self.expr(path.span, ast::ExprPath(None, path))
+ self.expr(path.span, ast::ExprKind::Path(None, path))
}
/// Constructs a QPath expression.
fn expr_qpath(&self, span: Span, qself: ast::QSelf, path: ast::Path) -> P<ast::Expr> {
- self.expr(span, ast::ExprPath(Some(qself), path))
+ self.expr(span, ast::ExprKind::Path(Some(qself), path))
}
fn expr_ident(&self, span: Span, id: ast::Ident) -> P<ast::Expr> {
self.expr_ident(span, special_idents::self_)
}
- fn expr_binary(&self, sp: Span, op: ast::BinOp_,
+ fn expr_binary(&self, sp: Span, op: ast::BinOpKind,
lhs: P<ast::Expr>, rhs: P<ast::Expr>) -> P<ast::Expr> {
- self.expr(sp, ast::ExprBinary(Spanned { node: op, span: sp }, lhs, rhs))
+ self.expr(sp, ast::ExprKind::Binary(Spanned { node: op, span: sp }, lhs, rhs))
}
fn expr_deref(&self, sp: Span, e: P<ast::Expr>) -> P<ast::Expr> {
- self.expr_unary(sp, ast::UnDeref, e)
+ self.expr_unary(sp, UnOp::Deref, e)
}
fn expr_unary(&self, sp: Span, op: ast::UnOp, e: P<ast::Expr>) -> P<ast::Expr> {
- self.expr(sp, ast::ExprUnary(op, e))
+ self.expr(sp, ast::ExprKind::Unary(op, e))
}
fn expr_field_access(&self, sp: Span, expr: P<ast::Expr>, ident: ast::Ident) -> P<ast::Expr> {
};
let id = Spanned { node: ident, span: field_span };
- self.expr(sp, ast::ExprField(expr, id))
+ self.expr(sp, ast::ExprKind::Field(expr, id))
}
fn expr_tup_field_access(&self, sp: Span, expr: P<ast::Expr>, idx: usize) -> P<ast::Expr> {
let field_span = Span {
};
let id = Spanned { node: idx, span: field_span };
- self.expr(sp, ast::ExprTupField(expr, id))
+ self.expr(sp, ast::ExprKind::TupField(expr, id))
}
fn expr_addr_of(&self, sp: Span, e: P<ast::Expr>) -> P<ast::Expr> {
- self.expr(sp, ast::ExprAddrOf(ast::MutImmutable, e))
+ self.expr(sp, ast::ExprKind::AddrOf(ast::Mutability::Immutable, e))
}
fn expr_mut_addr_of(&self, sp: Span, e: P<ast::Expr>) -> P<ast::Expr> {
- self.expr(sp, ast::ExprAddrOf(ast::MutMutable, e))
+ self.expr(sp, ast::ExprKind::AddrOf(ast::Mutability::Mutable, e))
}
fn expr_call(&self, span: Span, expr: P<ast::Expr>, args: Vec<P<ast::Expr>>) -> P<ast::Expr> {
- self.expr(span, ast::ExprCall(expr, args))
+ self.expr(span, ast::ExprKind::Call(expr, args))
}
fn expr_call_ident(&self, span: Span, id: ast::Ident,
args: Vec<P<ast::Expr>>) -> P<ast::Expr> {
- self.expr(span, ast::ExprCall(self.expr_ident(span, id), args))
+ self.expr(span, ast::ExprKind::Call(self.expr_ident(span, id), args))
}
fn expr_call_global(&self, sp: Span, fn_path: Vec<ast::Ident> ,
args: Vec<P<ast::Expr>> ) -> P<ast::Expr> {
mut args: Vec<P<ast::Expr>> ) -> P<ast::Expr> {
let id = Spanned { node: ident, span: span };
args.insert(0, expr);
- self.expr(span, ast::ExprMethodCall(id, Vec::new(), args))
+ self.expr(span, ast::ExprKind::MethodCall(id, Vec::new(), args))
}
fn expr_block(&self, b: P<ast::Block>) -> P<ast::Expr> {
- self.expr(b.span, ast::ExprBlock(b))
+ self.expr(b.span, ast::ExprKind::Block(b))
}
fn field_imm(&self, span: Span, name: Ident, e: P<ast::Expr>) -> ast::Field {
ast::Field { ident: respan(span, name), expr: e, span: span }
}
fn expr_struct(&self, span: Span, path: ast::Path, fields: Vec<ast::Field>) -> P<ast::Expr> {
- self.expr(span, ast::ExprStruct(path, fields, None))
+ self.expr(span, ast::ExprKind::Struct(path, fields, None))
}
fn expr_struct_ident(&self, span: Span,
id: ast::Ident, fields: Vec<ast::Field>) -> P<ast::Expr> {
self.expr_struct(span, self.path_ident(span, id), fields)
}
- fn expr_lit(&self, sp: Span, lit: ast::Lit
_) -> P<ast::Expr> {
- self.expr(sp, ast::ExprLit(P(respan(sp, lit))))
+ fn expr_lit(&self, sp: Span, lit: ast::Lit
Kind) -> P<ast::Expr> {
+ self.expr(sp, ast::ExprKind::Lit(P(respan(sp, lit))))
}
fn expr_usize(&self, span: Span, i: usize) -> P<ast::Expr> {
- self.expr_lit(span, ast::LitInt(i as u64, ast::UnsignedIntLit(ast::TyUs)))
+ self.expr_lit(span, ast::LitKind::Int(i as u64, ast::LitIntType::Unsigned(ast::UintTy::Us)))
}
fn expr_isize(&self, sp: Span, i: isize) -> P<ast::Expr> {
- self.expr_lit(sp, ast::LitInt(i as u64, ast::SignedIntLit(ast::TyIs,
- ast::Sign::new(i))))
+ if i < 0 {
+ let i = (-i) as u64;
+ let lit_ty = ast::LitIntType::Signed(ast::IntTy::Is);
+ let lit = self.expr_lit(sp, ast::LitKind::Int(i, lit_ty));
+ self.expr_unary(sp, ast::UnOp::Neg, lit)
+ } else {
+ self.expr_lit(sp, ast::LitKind::Int(i as u64, ast::LitIntType::Signed(ast::IntTy::Is)))
+ }
}
fn expr_u32(&self, sp: Span, u: u32) -> P<ast::Expr> {
- self.expr_lit(sp, ast::LitInt(u as u64, ast::UnsignedIntLit(ast::TyU32)))
+ self.expr_lit(sp, ast::LitKind::Int(u as u64, ast::LitIntType::Unsigned(ast::UintTy::U32)))
}
fn expr_u8(&self, sp: Span, u: u8) -> P<ast::Expr> {
- self.expr_lit(sp, ast::LitInt(u as u64, ast::UnsignedIntLit(ast::TyU8)))
+ self.expr_lit(sp, ast::LitKind::Int(u as u64, ast::LitIntType::Unsigned(ast::UintTy::U8)))
}
fn expr_bool(&self, sp: Span, value: bool) -> P<ast::Expr> {
- self.expr_lit(sp, ast::LitBool(value))
+ self.expr_lit(sp, ast::LitKind::Bool(value))
}
fn expr_vec(&self, sp: Span, exprs: Vec<P<ast::Expr>>) -> P<ast::Expr> {
- self.expr(sp, ast::ExprVec(exprs))
+ self.expr(sp, ast::ExprKind::Vec(exprs))
}
fn expr_vec_ng(&self, sp: Span) -> P<ast::Expr> {
self.expr_call_global(sp, self.std_path(&["vec", "Vec", "new"]),
self.expr_addr_of(sp, self.expr_vec(sp, exprs))
}
fn expr_str(&self, sp: Span, s: InternedString) -> P<ast::Expr> {
- self.expr_lit(sp, ast::LitStr(s, ast::CookedStr))
+ self.expr_lit(sp, ast::LitKind::Str(s, ast::StrStyle::Cooked))
}
fn expr_cast(&self, sp: Span, expr: P<ast::Expr>, ty: P<ast::Ty>) -> P<ast::Expr> {
- self.expr(sp, ast::ExprCast(expr, ty))
+ self.expr(sp, ast::ExprKind::Cast(expr, ty))
}
fn expr_break(&self, sp: Span) -> P<ast::Expr> {
- self.expr(sp, ast::ExprBreak(None))
+ self.expr(sp, ast::ExprKind::Break(None))
}
fn expr_tuple(&self, sp: Span, exprs: Vec<P<ast::Expr>>) -> P<ast::Expr> {
- self.expr(sp, ast::ExprTup(exprs))
+ self.expr(sp, ast::ExprKind::Tup(exprs))
}
fn expr_fail(&self, span: Span, msg: InternedString) -> P<ast::Expr> {
let err_inner_expr = self.expr_call(sp, self.expr_path(err_path),
vec!(binding_expr.clone()));
// return Err(__try_var)
- let err_expr = self.expr(sp, ast::ExprRet(Some(err_inner_expr)));
+ let err_expr = self.expr(sp, ast::ExprKind::Ret(Some(err_inner_expr)));
// Ok(__try_var) => __try_var
let ok_arm = self.arm(sp, vec!(ok_pat), binding_expr);
self.pat(span, ast::PatLit(expr))
}
fn pat_ident(&self, span: Span, ident: ast::Ident) -> P<ast::Pat> {
- self.pat_ident_binding_mode(span, ident, ast::BindingMode::ByValue(ast::MutImmutable))
+ let binding_mode = ast::BindingMode::ByValue(ast::Mutability::Immutable);
+ self.pat_ident_binding_mode(span, ident, binding_mode)
}
fn pat_ident_binding_mode(&self,
}
fn expr_match(&self, span: Span, arg: P<ast::Expr>, arms: Vec<ast::Arm>) -> P<Expr> {
- self.expr(span, ast::ExprMatch(arg, arms))
+ self.expr(span, ast::ExprKind::Match(arg, arms))
}
fn expr_if(&self, span: Span, cond: P<ast::Expr>,
then: P<ast::Expr>, els: Option<P<ast::Expr>>) -> P<ast::Expr> {
let els = els.map(|x| self.expr_block(self.block_expr(x)));
- self.expr(span, ast::ExprIf(cond, self.block_expr(then), els))
+ self.expr(span, ast::ExprKind::If(cond, self.block_expr(then), els))
}
fn expr_loop(&self, span: Span, block: P<ast::Block>) -> P<ast::Expr> {
- self.expr(span, ast::ExprLoop(block, None))
+ self.expr(span, ast::ExprKind::Loop(block, None))
}
fn lambda_fn_decl(&self, span: Span,
fn_decl: P<ast::FnDecl>, blk: P<ast::Block>) -> P<ast::Expr> {
- self.expr(span, ast::ExprClosure(ast::CaptureByRef, fn_decl, blk))
+ self.expr(span, ast::ExprKind::Closure(ast::CaptureBy::Ref, fn_decl, blk))
}
fn lambda(&self, span: Span, ids: Vec<ast::Ident>, blk: P<ast::Block>) -> P<ast::Expr> {
let fn_decl = self.fn_decl(
ids.iter().map(|id| self.arg(span, *id, self.ty_infer(span))).collect(),
self.ty_infer(span));
- self.expr(span, ast::ExprClosure(ast::CaptureByRef, fn_decl, blk))
+ self.expr(span, ast::ExprKind::Closure(ast::CaptureBy::Ref, fn_decl, blk))
}
fn lambda0(&self, span: Span, blk: P<ast::Block>) -> P<ast::Expr> {
self.lambda(span, Vec::new(), blk)
fn fn_decl(&self, inputs: Vec<ast::Arg>, output: P<ast::Ty>) -> P<ast::FnDecl> {
P(ast::FnDecl {
inputs: inputs,
- output: ast::Return(output),
+ output: ast::FunctionRetTy::Ty(output),
variadic: false
})
}
fn item(&self, span: Span, name: Ident,
- attrs: Vec<ast::Attribute>, node: ast::Item
_) -> P<ast::Item> {
+ attrs: Vec<ast::Attribute>, node: ast::Item
Kind) -> P<ast::Item> {
// FIXME: Would be nice if our generated code didn't violate
// Rust coding conventions
P(ast::Item {
attrs: attrs,
id: ast::DUMMY_NODE_ID,
node: node,
- vis: ast::Inherited,
+ vis: ast::Visibility::Inherited,
span: span
})
}
self.item(span,
name,
Vec::new(),
- ast::ItemFn(self.fn_decl(inputs, output),
+ ast::ItemKind::Fn(self.fn_decl(inputs, output),
ast::Unsafety::Normal,
ast::Constness::NotConst,
- abi::Rust,
+ Abi::Rust,
generics,
body))
}
let fields: Vec<_> = tys.into_iter().map(|ty| {
Spanned { span: ty.span, node: ast::StructField_ {
ty: ty,
- kind: ast::UnnamedField(ast::Inherited),
+ kind: ast::UnnamedField(ast::Visibility::Inherited),
attrs: Vec::new(),
id: ast::DUMMY_NODE_ID,
}}
fn item_enum_poly(&self, span: Span, name: Ident,
enum_definition: ast::EnumDef,
generics: Generics) -> P<ast::Item> {
- self.item(span, name, Vec::new(), ast::ItemEnum(enum_definition, generics))
+ self.item(span, name, Vec::new(), ast::ItemKind::Enum(enum_definition, generics))
}
fn item_enum(&self, span: Span, name: Ident,
fn item_struct_poly(&self, span: Span, name: Ident,
struct_def: ast::VariantData, generics: Generics) -> P<ast::Item> {
- self.item(span, name, Vec::new(), ast::ItemStruct(struct_def, generics))
+ self.item(span, name, Vec::new(), ast::ItemKind::Struct(struct_def, generics))
}
fn item_mod(&self, span: Span, inner_span: Span, name: Ident,
span,
name,
attrs,
- ast::ItemMod(ast::Mod {
+ ast::ItemKind::Mod(ast::Mod {
inner: inner_span,
items: items,
})
mutbl: ast::Mutability,
expr: P<ast::Expr>)
-> P<ast::Item> {
- self.item(span, name, Vec::new(), ast::ItemStatic(ty, mutbl, expr))
+ self.item(span, name, Vec::new(), ast::ItemKind::Static(ty, mutbl, expr))
}
fn item_const(&self,
ty: P<ast::Ty>,
expr: P<ast::Expr>)
-> P<ast::Item> {
- self.item(span, name, Vec::new(), ast::ItemConst(ty, expr))
+ self.item(span, name, Vec::new(), ast::ItemKind::Const(ty, expr))
}
fn item_ty_poly(&self, span: Span, name: Ident, ty: P<ast::Ty>,
generics: Generics) -> P<ast::Item> {
- self.item(span, name, Vec::new(), ast::ItemTy(ty, generics))
+ self.item(span, name, Vec::new(), ast::ItemKind::Ty(ty, generics))
}
fn item_ty(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> P<ast::Item> {
}
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::Lit_)
+ 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,
id: ast::DUMMY_NODE_ID,
ident: special_idents::invalid,
attrs: vec![],
- node: ast::ItemUse(vp),
+ node: ast::ItemKind::Use(vp),
vis: vis,
span: sp
})
fn item_use_list(&self, sp: Span, vis: ast::Visibility,
path: Vec<ast::Ident>, imports: &[ast::Ident]) -> P<ast::Item> {
let imports = imports.iter().map(|id| {
- respan(sp, ast::PathListIdent { name: *id, rename: None, id: ast::DUMMY_NODE_ID })
+ let item = ast::PathListItemKind::Ident {
+ name: *id,
+ rename: None,
+ id: ast::DUMMY_NODE_ID,
+ };
+ respan(sp, item)
}).collect();
self.item_use(sp, vis,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use ast::{Block, Crate, DeclLocal, PatMac};
+use ast::{Block, Crate, DeclKind, PatMac};
use ast::{Local, Ident, Mac_, Name};
-use ast::{ItemMac, MacStmtWithSemicolon, Mrk, Stmt, StmtDecl, StmtMac};
-use ast::{StmtExpr, StmtSemi};
+use ast::{MacStmtStyle, Mrk, Stmt, StmtKind, ItemKind};
use ast::TokenTree;
use ast;
use ext::mtwt;
// expr_mac should really be expr_ext or something; it's the
// entry-point for all syntax extensions.
- ast::ExprMac(mac) => {
+ ast::ExprKind::Mac(mac) => {
// Assert that we drop any macro attributes on the floor here
drop(attrs);
})
}
- ast::ExprInPlace(placer, value_expr) => {
+ ast::ExprKind::InPlace(placer, value_expr) => {
// Ensure feature-gate is enabled
feature_gate::check_for_placement_in(
fld.cx.ecfg.features,
let placer = fld.fold_expr(placer);
let value_expr = fld.fold_expr(value_expr);
- fld.cx.expr(span, ast::ExprInPlace(placer, value_expr))
+ fld.cx.expr(span, ast::ExprKind::InPlace(placer, value_expr))
.with_attrs(fold_thin_attrs(attrs, fld))
}
- ast::ExprWhile(cond, body, opt_ident) => {
+ ast::ExprKind::While(cond, body, opt_ident) => {
let cond = fld.fold_expr(cond);
let (body, opt_ident) = expand_loop_block(body, opt_ident, fld);
- fld.cx.expr(span, ast::ExprWhile(cond, body, opt_ident))
+ fld.cx.expr(span, ast::ExprKind::While(cond, body, opt_ident))
.with_attrs(fold_thin_attrs(attrs, fld))
}
- ast::ExprWhileLet(pat, expr, body, opt_ident) => {
+ ast::ExprKind::WhileLet(pat, expr, body, opt_ident) => {
let pat = fld.fold_pat(pat);
let expr = fld.fold_expr(expr);
});
assert!(rewritten_pats.len() == 1);
- fld.cx.expr(span, ast::ExprWhileLet(rewritten_pats.remove(0), expr, body, opt_ident))
- .with_attrs(fold_thin_attrs(attrs, fld))
+ let wl = ast::ExprKind::WhileLet(rewritten_pats.remove(0), expr, body, opt_ident);
+ fld.cx.expr(span, wl).with_attrs(fold_thin_attrs(attrs, fld))
}
- ast::ExprLoop(loop_block, opt_ident) => {
+ ast::ExprKind::Loop(loop_block, opt_ident) => {
let (loop_block, opt_ident) = expand_loop_block(loop_block, opt_ident, fld);
- fld.cx.expr(span, ast::ExprLoop(loop_block, opt_ident))
+ fld.cx.expr(span, ast::ExprKind::Loop(loop_block, opt_ident))
.with_attrs(fold_thin_attrs(attrs, fld))
}
- ast::ExprForLoop(pat, head, body, opt_ident) => {
+ ast::ExprKind::ForLoop(pat, head, body, opt_ident) => {
let pat = fld.fold_pat(pat);
// Hygienic renaming of the for loop body (for loop binds its pattern).
assert!(rewritten_pats.len() == 1);
let head = fld.fold_expr(head);
- fld.cx.expr(span, ast::ExprForLoop(rewritten_pats.remove(0), head, body, opt_ident))
- .with_attrs(fold_thin_attrs(attrs, fld))
+ let fl = ast::ExprKind::ForLoop(rewritten_pats.remove(0), head, body, opt_ident);
+ fld.cx.expr(span, fl).with_attrs(fold_thin_attrs(attrs, fld))
}
- ast::ExprIfLet(pat, sub_expr, body, else_opt) => {
+ ast::ExprKind::IfLet(pat, sub_expr, body, else_opt) => {
let pat = fld.fold_pat(pat);
// Hygienic renaming of the body.
let else_opt = else_opt.map(|else_opt| fld.fold_expr(else_opt));
let sub_expr = fld.fold_expr(sub_expr);
- fld.cx.expr(span, ast::ExprIfLet(rewritten_pats.remove(0), sub_expr, body, else_opt))
- .with_attrs(fold_thin_attrs(attrs, fld))
+ let il = ast::ExprKind::IfLet(rewritten_pats.remove(0), sub_expr, body, else_opt);
+ fld.cx.expr(span, il).with_attrs(fold_thin_attrs(attrs, fld))
}
- ast::ExprClosure(capture_clause, fn_decl, block) => {
+ ast::ExprKind::Closure(capture_clause, fn_decl, block) => {
let (rewritten_fn_decl, rewritten_block)
= expand_and_rename_fn_decl_and_block(fn_decl, block, fld);
- let new_node = ast::ExprClosure(capture_clause,
+ let new_node = ast::ExprKind::Closure(capture_clause,
rewritten_fn_decl,
rewritten_block);
P(ast::Expr{id:id, node: new_node, span: fld.new_span(span),
.into_iter().map(|i| i.expect_item()).collect()
}
-/// Expand item_underscore
-fn expand_item_underscore(item: ast::Item_, fld: &mut MacroExpander) -> ast::Item_ {
+/// Expand item_kind
+fn expand_item_kind(item: ast::ItemKind, fld: &mut MacroExpander) -> ast::ItemKind {
match item {
- ast::ItemFn(decl, unsafety, constness, abi, generics, body) => {
+ ast::ItemKind::Fn(decl, unsafety, constness, abi, generics, body) => {
let (rewritten_fn_decl, rewritten_body)
= expand_and_rename_fn_decl_and_block(decl, body, fld);
let expanded_generics = fold::noop_fold_generics(generics,fld);
- ast::ItemFn(rewritten_fn_decl, unsafety, constness, abi,
+ ast::ItemKind::Fn(rewritten_fn_decl, unsafety, constness, abi,
expanded_generics, rewritten_body)
}
- _ => noop_fold_item_underscore(item, fld)
+ _ => noop_fold_item_kind(item, fld)
}
}
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;
pub fn expand_item_mac(it: P<ast::Item>,
fld: &mut MacroExpander) -> SmallVector<P<ast::Item>> {
let (extname, path_span, tts, span, attrs, ident) = it.and_then(|it| match it.node {
- ItemMac(codemap::Spanned { node: Mac_ { path, tts, .. }, .. }) =>
+ ItemKind::Mac(codemap::Spanned { node: Mac_ { path, tts, .. }, .. }) =>
(path.segments[0].identifier.name, path.span, tts, it.span, it.attrs, it.ident),
_ => fld.cx.span_bug(it.span, "invalid item macro invocation")
});
fn expand_stmt(stmt: P<Stmt>, fld: &mut MacroExpander) -> SmallVector<P<Stmt>> {
let stmt = stmt.and_then(|stmt| stmt);
let (mac, style, attrs) = match stmt.node {
- StmtMac(mac, style, attrs) => (mac, style, attrs),
+ StmtKind::Mac(mac, style, attrs) => (mac, style, attrs),
_ => return expand_non_macro_stmt(stmt, fld)
};
// If this is a macro invocation with a semicolon, then apply that
// semicolon to the final statement produced by expansion.
- if style == MacStmtWithSemicolon {
+ if style == MacStmtStyle::Semicolon {
if let Some(stmt) = fully_expanded.pop() {
let new_stmt = stmt.map(|Spanned {node, span}| {
Spanned {
node: match node {
- StmtExpr(e, stmt_id) => StmtSemi(e, stmt_id),
+ StmtKind::Expr(e, stmt_id) => StmtKind::Semi(e, stmt_id),
_ => node /* might already have a semi */
},
span: span
-> SmallVector<P<Stmt>> {
// is it a let?
match node {
- StmtDecl(decl, node_id) => decl.and_then(|Spanned {node: decl, span}| match decl {
- DeclLocal(local) => {
+ StmtKind::Decl(decl, node_id) => decl.and_then(|Spanned {node: decl, span}| match decl {
+ DeclKind::Local(local) => {
// take it apart:
let rewritten_local = local.map(|Local {id, pat, ty, init, span, attrs}| {
- // expand the ty since TyFixedLengthVec contains an Expr
+ // expand the ty since TyKind::FixedLengthVec contains an Expr
// and thus may have a macro use
let expanded_ty = ty.map(|t| fld.fold_ty(t));
// expand the pat (it might contain macro uses):
}
});
SmallVector::one(P(Spanned {
- node: StmtDecl(P(Spanned {
- node: DeclLocal(rewritten_local),
+ node: StmtKind::Decl(P(Spanned {
+ node: DeclKind::Local(rewritten_local),
span: span
}),
node_id),
}
_ => {
noop_fold_stmt(Spanned {
- node: StmtDecl(P(Spanned {
+ node: StmtKind::Decl(P(Spanned {
node: decl,
span: span
}),
let mut new_items: SmallVector<Annotatable> = match a {
Annotatable::Item(it) => match it.node {
- ast::ItemMac(..) => {
+ ast::ItemKind::Mac(..) => {
expand_item_mac(it, fld).into_iter().map(|i| Annotatable::Item(i)).collect()
}
- ast::ItemMod(_) | ast::ItemForeignMod(_) => {
+ ast::ItemKind::Mod(_) | ast::ItemKind::ForeignMod(_) => {
let valid_ident =
it.ident.name != parse::token::special_idents::invalid.name;
},
Annotatable::TraitItem(it) => match it.node {
- ast::MethodTraitItem(_, Some(_)) => SmallVector::one(it.map(|ti| ast::TraitItem {
+ ast::TraitItemKind::Method(_, Some(_)) => SmallVector::one(it.map(|ti| ast::TraitItem {
id: ti.id,
ident: ti.ident,
attrs: ti.attrs,
node: match ti.node {
- ast::MethodTraitItem(sig, Some(body)) => {
+ ast::TraitItemKind::Method(sig, Some(body)) => {
let (sig, body) = expand_and_rename_method(sig, body, fld);
- ast::MethodTraitItem(sig, Some(body))
+ ast::TraitItemKind::Method(sig, Some(body))
}
_ => unreachable!()
},
}
}
- // Expansion may have added new ItemModifiers.
+ // Expansion may have added new ItemKind::Modifiers.
expand_item_multi_modifier(it, fld)
}
pub fn expand_type(t: P<ast::Ty>, fld: &mut MacroExpander) -> P<ast::Ty> {
let t = match t.node.clone() {
- ast::Ty_::TyMac(mac) => {
+ ast::TyKind::Mac(mac) => {
if fld.cx.ecfg.features.unwrap().type_macros {
let expanded_ty = match expand_mac_invoc(mac, t.span,
|r| r.make_ty(),
expand_item(item, self)
}
- fn fold_item_underscore(&mut self, item: ast::Item_) -> ast::Item_ {
- expand_item_underscore(item, self)
+ fn fold_item_kind(&mut self, item: ast::ItemKind) -> ast::ItemKind {
+ expand_item_kind(item, self)
}
fn fold_stmt(&mut self, stmt: P<ast::Stmt>) -> SmallVector<P<ast::Stmt>> {
impl<'v> Visitor<'v> for PathExprFinderContext {
fn visit_expr(&mut self, expr: &ast::Expr) {
- if let ast::ExprPath(None, ref p) = expr.node {
+ if let ast::ExprKind::Path(None, ref p) = expr.node {
self.path_accumulator.push(p.clone());
}
visit::walk_expr(self, expr);
0)
}
- // closure arg hygiene (ExprClosure)
+ // closure arg hygiene (ExprKind::Closure)
// expands to fn f(){(|x_1 : i32| {(x_2 + x_1)})(3);}
#[test]
fn closure_arg_hygiene(){
impl ToTokens for str {
fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
- let lit = ast::LitStr(
- token::intern_and_get_ident(self), ast::CookedStr);
+ let lit = ast::LitKind::Str(
+ token::intern_and_get_ident(self), ast::StrStyle::Cooked);
dummy_spanned(lit).to_tokens(cx)
}
}
// FIXME: This is wrong
P(ast::Expr {
id: ast::DUMMY_NODE_ID,
- node: ast::ExprLit(P(self.clone())),
+ node: ast::ExprKind::Lit(P(self.clone())),
span: DUMMY_SP,
attrs: None,
}).to_tokens(cx)
impl ToTokens for bool {
fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
- dummy_spanned(ast::LitBool(*self)).to_tokens(cx)
+ dummy_spanned(ast::LitKind::Bool(*self)).to_tokens(cx)
}
}
impl ToTokens for char {
fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
- dummy_spanned(ast::LitChar(*self)).to_tokens(cx)
+ dummy_spanned(ast::LitKind::Char(*self)).to_tokens(cx)
}
}
(signed, $t:ty, $tag:expr) => (
impl ToTokens for $t {
fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
- let lit = ast::LitInt(*self as u64, ast::SignedIntLit($tag,
- ast::Sign::new(*self)));
- dummy_spanned(lit).to_tokens(cx)
+ let val = if *self < 0 {
+ -self
+ } else {
+ *self
+ };
+ let lit = ast::LitKind::Int(val as u64, ast::LitIntType::Signed($tag));
+ let lit = P(ast::Expr {
+ id: ast::DUMMY_NODE_ID,
+ node: ast::ExprKind::Lit(P(dummy_spanned(lit))),
+ span: DUMMY_SP,
+ attrs: None,
+ });
+ if *self >= 0 {
+ return lit.to_tokens(cx);
+ }
+ P(ast::Expr {
+ id: ast::DUMMY_NODE_ID,
+ node: ast::ExprKind::Unary(ast::UnOp::Neg, lit),
+ span: DUMMY_SP,
+ attrs: None,
+ }).to_tokens(cx)
}
}
);
(unsigned, $t:ty, $tag:expr) => (
impl ToTokens for $t {
fn to_tokens(&self, cx: &ExtCtxt) -> Vec<TokenTree> {
- let lit = ast::LitInt(*self as u64, ast::UnsignedIntLit($tag));
+ let lit = ast::LitKind::Int(*self as u64, ast::LitIntType::Unsigned($tag));
dummy_spanned(lit).to_tokens(cx)
}
}
);
}
- impl_to_tokens_int! { signed, isize, ast::TyIs }
- impl_to_tokens_int! { signed, i8, ast::TyI8 }
- impl_to_tokens_int! { signed, i16, ast::TyI16 }
- impl_to_tokens_int! { signed, i32, ast::TyI32 }
- impl_to_tokens_int! { signed, i64, ast::TyI64 }
+ impl_to_tokens_int! { signed, isize, ast::IntTy::Is }
+ impl_to_tokens_int! { signed, i8, ast::IntTy::I8 }
+ impl_to_tokens_int! { signed, i16, ast::IntTy::I16 }
+ impl_to_tokens_int! { signed, i32, ast::IntTy::I32 }
+ impl_to_tokens_int! { signed, i64, ast::IntTy::I64 }
- impl_to_tokens_int! { unsigned, usize, ast::TyUs }
- impl_to_tokens_int! { unsigned, u8, ast::TyU8 }
- impl_to_tokens_int! { unsigned, u16, ast::TyU16 }
- impl_to_tokens_int! { unsigned, u32, ast::TyU32 }
- impl_to_tokens_int! { unsigned, u64, ast::TyU64 }
+ impl_to_tokens_int! { unsigned, usize, ast::UintTy::Us }
+ impl_to_tokens_int! { unsigned, u8, ast::UintTy::U8 }
+ impl_to_tokens_int! { unsigned, u16, ast::UintTy::U16 }
+ impl_to_tokens_int! { unsigned, u32, ast::UintTy::U32 }
+ impl_to_tokens_int! { unsigned, u64, ast::UintTy::U64 }
pub trait ExtParseUtils {
fn parse_item(&self, s: String) -> P<ast::Item>;
cx.expr_path(cx.path_global(sp, idents))
}
-fn mk_ast_path(cx: &ExtCtxt, sp: Span, name: &str) -> P<ast::Expr> {
- let idents = vec!(id_ext("syntax"), id_ext("ast"), id_ext(name));
- cx.expr_path(cx.path_global(sp, idents))
-}
-
fn mk_token_path(cx: &ExtCtxt, sp: Span, name: &str) -> P<ast::Expr> {
let idents = vec!(id_ext("syntax"), id_ext("parse"), id_ext("token"), id_ext(name));
cx.expr_path(cx.path_global(sp, idents))
None => cx.expr_none(sp),
};
let e_op = match seq.op {
- ast::ZeroOrMore => mk_ast_path(cx, sp, "ZeroOrMore"),
- ast::OneOrMore => mk_ast_path(cx, sp, "OneOrMore"),
+ ast::KleeneOp::ZeroOrMore => "ZeroOrMore",
+ ast::KleeneOp::OneOrMore => "OneOrMore",
};
+ let e_op_idents = vec![
+ id_ext("syntax"),
+ id_ext("ast"),
+ id_ext("KleeneOp"),
+ id_ext(e_op),
+ ];
+ let e_op = cx.expr_path(cx.path_global(sp, e_op_idents));
let fields = vec![cx.field_imm(sp, id_ext("tts"), e_tts),
cx.field_imm(sp, id_ext("separator"), e_separator),
cx.field_imm(sp, id_ext("op"), e_op),
let stmts = imports.iter().map(|path| {
// make item: `use ...;`
let path = path.iter().map(|s| s.to_string()).collect();
- cx.stmt_item(sp, cx.item_use_glob(sp, ast::Inherited, ids_ext(path)))
+ cx.stmt_item(sp, cx.item_use_glob(sp, ast::Visibility::Inherited, ids_ext(path)))
}).chain(Some(stmt_let_ext_cx)).collect();
cx.expr_block(cx.block_all(sp, stmts, Some(expr)))
let filename = format!("{}", file.display());
cx.codemap().new_filemap_and_lines(&filename, "");
- base::MacEager::expr(cx.expr_lit(sp, ast::LitByteStr(Rc::new(bytes))))
+ base::MacEager::expr(cx.expr_lit(sp, ast::LitKind::ByteStr(Rc::new(bytes))))
}
}
}
match ei.top_elts.get_tt(idx) {
/* need to descend into sequence */
TokenTree::Sequence(sp, seq) => {
- if seq.op == ast::ZeroOrMore {
+ if seq.op == ast::KleeneOp::ZeroOrMore {
let mut new_ei = ei.clone();
new_ei.match_cur += seq.num_captures;
new_ei.idx += 1;
TokenTree::Token(DUMMY_SP, token::FatArrow),
TokenTree::Token(DUMMY_SP, match_rhs_tok)],
separator: Some(token::Semi),
- op: ast::OneOrMore,
+ op: ast::KleeneOp::OneOrMore,
num_captures: 2
})),
//to phase into semicolon-termination instead of
Rc::new(ast::SequenceRepetition {
tts: vec![TokenTree::Token(DUMMY_SP, token::Semi)],
separator: None,
- op: ast::ZeroOrMore,
+ op: ast::KleeneOp::ZeroOrMore,
num_captures: 0
})));
forest: TokenTree::Sequence(DUMMY_SP, Rc::new(ast::SequenceRepetition {
tts: src,
// doesn't matter. This merely holds the root unzipping.
- separator: None, op: ast::ZeroOrMore, num_captures: 0
+ separator: None, op: ast::KleeneOp::ZeroOrMore, num_captures: 0
})),
idx: 0,
dotdotdoted: false,
}
LisConstraint(len, _) => {
if len == 0 {
- if seq.op == ast::OneOrMore {
+ if seq.op == ast::KleeneOp::OneOrMore {
// FIXME #2887 blame invoker
panic!(r.sp_diag.span_fatal(sp.clone(),
"this must repeat at least once"));
// But we keep these checks as a pre-expansion check to catch
// uses in e.g. conditionalized code.
- if let ast::ExprBox(_) = e.node {
+ if let ast::ExprKind::Box(_) = e.node {
self.context.gate_feature("box_syntax", e.span, EXPLAIN_BOX_SYNTAX);
}
- if let ast::ExprInPlace(..) = e.node {
+ if let ast::ExprKind::InPlace(..) = e.node {
self.context.gate_feature("placement_in_syntax", e.span, EXPLAIN_PLACEMENT_IN);
}
fn visit_item(&mut self, i: &ast::Item) {
match i.node {
- ast::ItemExternCrate(_) => {
+ ast::ItemKind::ExternCrate(_) => {
if attr::contains_name(&i.attrs[..], "macro_reexport") {
self.gate_feature("macro_reexport", i.span,
"macros reexports are experimental \
}
}
- ast::ItemForeignMod(ref foreign_module) => {
+ ast::ItemKind::ForeignMod(ref foreign_module) => {
if attr::contains_name(&i.attrs[..], "link_args") {
self.gate_feature("link_args", i.span,
"the `link_args` attribute is not portable \
}
}
- ast::ItemFn(..) => {
+ ast::ItemKind::Fn(..) => {
if attr::contains_name(&i.attrs[..], "plugin_registrar") {
self.gate_feature("plugin_registrar", i.span,
"compiler plugins are experimental and possibly buggy");
}
}
- ast::ItemStruct(..) => {
+ ast::ItemKind::Struct(..) => {
if attr::contains_name(&i.attrs[..], "simd") {
self.gate_feature("simd", i.span,
"SIMD types are experimental and possibly buggy");
}
}
- ast::ItemDefaultImpl(..) => {
+ ast::ItemKind::DefaultImpl(..) => {
self.gate_feature("optin_builtin_traits",
i.span,
"default trait implementations are experimental \
and possibly buggy");
}
- ast::ItemImpl(_, polarity, _, _, _, _) => {
+ ast::ItemKind::Impl(_, polarity, _, _, _, _) => {
match polarity {
ast::ImplPolarity::Negative => {
self.gate_feature("optin_builtin_traits",
fn visit_expr(&mut self, e: &ast::Expr) {
match e.node {
- ast::ExprBox(_) => {
+ ast::ExprKind::Box(_) => {
self.gate_feature("box_syntax",
e.span,
"box expression syntax is experimental; \
you can call `Box::new` instead.");
}
- ast::ExprType(..) => {
+ ast::ExprKind::Type(..) => {
self.gate_feature("type_ascription", e.span,
"type ascription is experimental");
}
fn visit_trait_item(&mut self, ti: &'v ast::TraitItem) {
match ti.node {
- ast::ConstTraitItem(..) => {
+ ast::TraitItemKind::Const(..) => {
self.gate_feature("associated_consts",
ti.span,
"associated constants are experimental")
}
- ast::MethodTraitItem(ref sig, _) => {
+ ast::TraitItemKind::Method(ref sig, _) => {
if sig.constness == ast::Constness::Const {
self.gate_feature("const_fn", ti.span, "const fn is unstable");
}
}
- ast::TypeTraitItem(_, Some(_)) => {
+ ast::TraitItemKind::Type(_, Some(_)) => {
self.gate_feature("associated_type_defaults", ti.span,
"associated type defaults are unstable");
}
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 \
noop_fold_struct_field(sf, self)
}
- fn fold_item_underscore(&mut self, i: Item_) -> Item_ {
- noop_fold_item_underscore(i, self)
+ fn fold_item_kind(&mut self, i: ItemKind) -> ItemKind {
+ noop_fold_item_kind(i, self)
}
fn fold_trait_item(&mut self, i: P<TraitItem>) -> SmallVector<P<TraitItem>> {
noop_fold_explicit_self(es, self)
}
- fn fold_explicit_self_underscore(&mut self, es: ExplicitSelf_) -> ExplicitSelf_ {
- noop_fold_explicit_self_underscore(es, self)
+ fn fold_explicit_self_kind(&mut self, es: SelfKind) -> SelfKind {
+ noop_fold_explicit_self_kind(es, self)
}
fn fold_lifetime(&mut self, l: Lifetime) -> Lifetime {
path_list_idents.move_map(|path_list_ident| {
Spanned {
node: match path_list_ident.node {
- PathListIdent { id, name, rename } =>
- PathListIdent {
+ PathListItemKind::Ident { id, name, rename } =>
+ PathListItemKind::Ident {
id: fld.new_id(id),
rename: rename,
name: name
},
- PathListMod { id, rename } =>
- PathListMod {
+ PathListItemKind::Mod { id, rename } =>
+ PathListItemKind::Mod {
id: fld.new_id(id),
rename: rename
}
pub fn noop_fold_decl<T: Folder>(d: P<Decl>, fld: &mut T) -> SmallVector<P<Decl>> {
d.and_then(|Spanned {node, span}| match node {
- DeclLocal(l) => SmallVector::one(P(Spanned {
- node: DeclLocal(fld.fold_local(l)),
+ DeclKind::Local(l) => SmallVector::one(P(Spanned {
+ node: DeclKind::Local(fld.fold_local(l)),
span: fld.new_span(span)
})),
- DeclItem(it) => fld.fold_item(it).into_iter().map(|i| P(Spanned {
- node: DeclItem(i),
+ DeclKind::Item(it) => fld.fold_item(it).into_iter().map(|i| P(Spanned {
+ node: DeclKind::Item(i),
span: fld.new_span(span)
})).collect()
})
t.map(|Ty {id, node, span}| Ty {
id: fld.new_id(id),
node: match node {
- TyInfer => node,
- TyVec(ty) => TyVec(fld.fold_ty(ty)),
- TyPtr(mt) => TyPtr(fld.fold_mt(mt)),
- TyRptr(region, mt) => {
- TyRptr(fld.fold_opt_lifetime(region), fld.fold_mt(mt))
+ TyKind::Infer => node,
+ TyKind::Vec(ty) => TyKind::Vec(fld.fold_ty(ty)),
+ TyKind::Ptr(mt) => TyKind::Ptr(fld.fold_mt(mt)),
+ TyKind::Rptr(region, mt) => {
+ TyKind::Rptr(fld.fold_opt_lifetime(region), fld.fold_mt(mt))
}
- TyBareFn(f) => {
- TyBareFn(f.map(|BareFnTy {lifetimes, unsafety, abi, decl}| BareFnTy {
+ TyKind::BareFn(f) => {
+ TyKind::BareFn(f.map(|BareFnTy {lifetimes, unsafety, abi, decl}| BareFnTy {
lifetimes: fld.fold_lifetime_defs(lifetimes),
unsafety: unsafety,
abi: abi,
decl: fld.fold_fn_decl(decl)
}))
}
- TyTup(tys) => TyTup(tys.move_map(|ty| fld.fold_ty(ty))),
- TyParen(ty) => TyParen(fld.fold_ty(ty)),
- TyPath(qself, path) => {
+ TyKind::Tup(tys) => TyKind::Tup(tys.move_map(|ty| fld.fold_ty(ty))),
+ TyKind::Paren(ty) => TyKind::Paren(fld.fold_ty(ty)),
+ TyKind::Path(qself, path) => {
let qself = qself.map(|QSelf { ty, position }| {
QSelf {
ty: fld.fold_ty(ty),
position: position
}
});
- TyPath(qself, fld.fold_path(path))
+ TyKind::Path(qself, fld.fold_path(path))
}
- TyObjectSum(ty, bounds) => {
- TyObjectSum(fld.fold_ty(ty),
+ TyKind::ObjectSum(ty, bounds) => {
+ TyKind::ObjectSum(fld.fold_ty(ty),
fld.fold_bounds(bounds))
}
- TyFixedLengthVec(ty, e) => {
- TyFixedLengthVec(fld.fold_ty(ty), fld.fold_expr(e))
+ TyKind::FixedLengthVec(ty, e) => {
+ TyKind::FixedLengthVec(fld.fold_ty(ty), fld.fold_expr(e))
}
- TyTypeof(expr) => {
- TyTypeof(fld.fold_expr(expr))
+ TyKind::Typeof(expr) => {
+ TyKind::Typeof(fld.fold_expr(expr))
}
- TyPolyTraitRef(bounds) => {
- TyPolyTraitRef(bounds.move_map(|b| fld.fold_ty_param_bound(b)))
+ TyKind::PolyTraitRef(bounds) => {
+ TyKind::PolyTraitRef(bounds.move_map(|b| fld.fold_ty_param_bound(b)))
}
- TyMac(mac) => {
- TyMac(fld.fold_mac(mac))
+ TyKind::Mac(mac) => {
+ TyKind::Mac(fld.fold_mac(mac))
}
},
span: fld.new_span(span)
})
}
-pub fn noop_fold_explicit_self_underscore<T: Folder>(es: ExplicitSelf_, fld: &mut T)
- -> ExplicitSelf_ {
+pub fn noop_fold_explicit_self_kind<T: Folder>(es: SelfKind, fld: &mut T)
+ -> SelfKind {
match es {
- SelfStatic | SelfValue(_) => es,
- SelfRegion(lifetime, m, ident) => {
- SelfRegion(fld.fold_opt_lifetime(lifetime), m, ident)
+ SelfKind::Static | SelfKind::Value(_) => es,
+ SelfKind::Region(lifetime, m, ident) => {
+ SelfKind::Region(fld.fold_opt_lifetime(lifetime), m, ident)
}
- SelfExplicit(typ, ident) => {
- SelfExplicit(fld.fold_ty(typ), ident)
+ SelfKind::Explicit(typ, ident) => {
+ SelfKind::Explicit(fld.fold_ty(typ), ident)
}
}
}
pub fn noop_fold_explicit_self<T: Folder>(Spanned {span, node}: ExplicitSelf, fld: &mut T)
-> ExplicitSelf {
Spanned {
- node: fld.fold_explicit_self_underscore(node),
+ node: fld.fold_explicit_self_kind(node),
span: fld.new_span(span)
}
}
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)
})
decl.map(|FnDecl {inputs, output, variadic}| FnDecl {
inputs: inputs.move_map(|x| fld.fold_arg(x)),
output: match output {
- Return(ty) => Return(fld.fold_ty(ty)),
- DefaultReturn(span) => DefaultReturn(span),
- NoReturn(span) => NoReturn(span)
+ FunctionRetTy::Ty(ty) => FunctionRetTy::Ty(fld.fold_ty(ty)),
+ FunctionRetTy::Default(span) => FunctionRetTy::Default(span),
+ FunctionRetTy::None(span) => FunctionRetTy::None(span),
},
variadic: variadic
})
})
}
-pub fn noop_fold_item_underscore<T: Folder>(i: Item_, folder: &mut T) -> Item_ {
+pub fn noop_fold_item_kind<T: Folder>(i: ItemKind, folder: &mut T) -> ItemKind {
match i {
- ItemExternCrate(string) => ItemExternCrate(string),
- ItemUse(view_path) => {
- ItemUse(folder.fold_view_path(view_path))
+ ItemKind::ExternCrate(string) => ItemKind::ExternCrate(string),
+ ItemKind::Use(view_path) => {
+ ItemKind::Use(folder.fold_view_path(view_path))
}
- ItemStatic(t, m, e) => {
- ItemStatic(folder.fold_ty(t), m, folder.fold_expr(e))
+ ItemKind::Static(t, m, e) => {
+ ItemKind::Static(folder.fold_ty(t), m, folder.fold_expr(e))
}
- ItemConst(t, e) => {
- ItemConst(folder.fold_ty(t), folder.fold_expr(e))
+ ItemKind::Const(t, e) => {
+ ItemKind::Const(folder.fold_ty(t), folder.fold_expr(e))
}
- ItemFn(decl, unsafety, constness, abi, generics, body) => {
- ItemFn(
+ ItemKind::Fn(decl, unsafety, constness, abi, generics, body) => {
+ ItemKind::Fn(
folder.fold_fn_decl(decl),
unsafety,
constness,
folder.fold_block(body)
)
}
- ItemMod(m) => ItemMod(folder.fold_mod(m)),
- ItemForeignMod(nm) => ItemForeignMod(folder.fold_foreign_mod(nm)),
- ItemTy(t, generics) => {
- ItemTy(folder.fold_ty(t), folder.fold_generics(generics))
+ ItemKind::Mod(m) => ItemKind::Mod(folder.fold_mod(m)),
+ ItemKind::ForeignMod(nm) => ItemKind::ForeignMod(folder.fold_foreign_mod(nm)),
+ ItemKind::Ty(t, generics) => {
+ ItemKind::Ty(folder.fold_ty(t), folder.fold_generics(generics))
}
- ItemEnum(enum_definition, generics) => {
- ItemEnum(
+ ItemKind::Enum(enum_definition, generics) => {
+ ItemKind::Enum(
ast::EnumDef {
variants: enum_definition.variants.move_map(|x| folder.fold_variant(x)),
},
folder.fold_generics(generics))
}
- ItemStruct(struct_def, generics) => {
+ ItemKind::Struct(struct_def, generics) => {
let struct_def = folder.fold_variant_data(struct_def);
- ItemStruct(struct_def, folder.fold_generics(generics))
+ ItemKind::Struct(struct_def, folder.fold_generics(generics))
}
- ItemDefaultImpl(unsafety, ref trait_ref) => {
- ItemDefaultImpl(unsafety, folder.fold_trait_ref((*trait_ref).clone()))
+ ItemKind::DefaultImpl(unsafety, ref trait_ref) => {
+ ItemKind::DefaultImpl(unsafety, folder.fold_trait_ref((*trait_ref).clone()))
}
- ItemImpl(unsafety, polarity, generics, ifce, ty, impl_items) => {
+ ItemKind::Impl(unsafety, polarity, generics, ifce, ty, impl_items) => {
let new_impl_items = impl_items.move_flat_map(|item| {
folder.fold_impl_item(item)
});
Some(folder.fold_trait_ref((*trait_ref).clone()))
}
};
- ItemImpl(unsafety,
+ ItemKind::Impl(unsafety,
polarity,
folder.fold_generics(generics),
ifce,
folder.fold_ty(ty),
new_impl_items)
}
- ItemTrait(unsafety, generics, bounds, items) => {
+ ItemKind::Trait(unsafety, generics, bounds, items) => {
let bounds = folder.fold_bounds(bounds);
let items = items.move_flat_map(|item| {
folder.fold_trait_item(item)
});
- ItemTrait(unsafety,
+ ItemKind::Trait(unsafety,
folder.fold_generics(generics),
bounds,
items)
}
- ItemMac(m) => ItemMac(folder.fold_mac(m)),
+ ItemKind::Mac(m) => ItemKind::Mac(folder.fold_mac(m)),
}
}
ident: folder.fold_ident(ident),
attrs: fold_attrs(attrs, folder),
node: match node {
- ConstTraitItem(ty, default) => {
- ConstTraitItem(folder.fold_ty(ty),
+ TraitItemKind::Const(ty, default) => {
+ TraitItemKind::Const(folder.fold_ty(ty),
default.map(|x| folder.fold_expr(x)))
}
- MethodTraitItem(sig, body) => {
- MethodTraitItem(noop_fold_method_sig(sig, folder),
+ TraitItemKind::Method(sig, body) => {
+ TraitItemKind::Method(noop_fold_method_sig(sig, folder),
body.map(|x| folder.fold_block(x)))
}
- TypeTraitItem(bounds, default) => {
- TypeTraitItem(folder.fold_bounds(bounds),
+ TraitItemKind::Type(bounds, default) => {
+ TraitItemKind::Type(folder.fold_bounds(bounds),
default.map(|x| folder.fold_ty(x)))
}
},
ident: token::special_idents::invalid,
attrs: attrs,
id: ast::DUMMY_NODE_ID,
- vis: ast::Public,
+ vis: ast::Visibility::Public,
span: span,
- node: ast::ItemMod(module),
+ node: ast::ItemKind::Mod(module),
})).into_iter();
let (module, attrs, span) = match items.next() {
"a crate cannot expand to more than one item");
item.and_then(|ast::Item { attrs, span, node, .. }| {
match node {
- ast::ItemMod(m) => (m, attrs, span),
+ ast::ItemKind::Mod(m) => (m, attrs, span),
_ => panic!("fold converted a module to not a module"),
}
})
pub fn noop_fold_item_simple<T: Folder>(Item {id, ident, attrs, node, vis, span}: Item,
folder: &mut T) -> Item {
let id = folder.new_id(id);
- let node = folder.fold_item_underscore(node);
+ let node = folder.fold_item_kind(node);
let ident = match node {
// The node may have changed, recompute the "pretty" impl name.
- ItemImpl(_, _, _, ref maybe_trait, ref ty, _) => {
+ ItemKind::Impl(_, _, _, ref maybe_trait, ref ty, _) => {
ast_util::impl_pretty_name(maybe_trait, Some(&**ty))
}
_ => ident
ident: folder.fold_ident(ident),
attrs: fold_attrs(attrs, folder),
node: match node {
- ForeignItemFn(fdec, generics) => {
- ForeignItemFn(folder.fold_fn_decl(fdec), folder.fold_generics(generics))
+ ForeignItemKind::Fn(fdec, generics) => {
+ ForeignItemKind::Fn(folder.fold_fn_decl(fdec), folder.fold_generics(generics))
}
- ForeignItemStatic(t, m) => {
- ForeignItemStatic(folder.fold_ty(t), m)
+ ForeignItemKind::Static(t, m) => {
+ ForeignItemKind::Static(folder.fold_ty(t), m)
}
},
vis: vis,
Expr {
id: folder.new_id(id),
node: match node {
- ExprBox(e) => {
- ExprBox(folder.fold_expr(e))
+ ExprKind::Box(e) => {
+ ExprKind::Box(folder.fold_expr(e))
}
- ExprInPlace(p, e) => {
- ExprInPlace(folder.fold_expr(p), folder.fold_expr(e))
+ ExprKind::InPlace(p, e) => {
+ ExprKind::InPlace(folder.fold_expr(p), folder.fold_expr(e))
}
- ExprVec(exprs) => {
- ExprVec(folder.fold_exprs(exprs))
+ ExprKind::Vec(exprs) => {
+ ExprKind::Vec(folder.fold_exprs(exprs))
}
- ExprRepeat(expr, count) => {
- ExprRepeat(folder.fold_expr(expr), folder.fold_expr(count))
+ ExprKind::Repeat(expr, count) => {
+ ExprKind::Repeat(folder.fold_expr(expr), folder.fold_expr(count))
}
- ExprTup(exprs) => ExprTup(folder.fold_exprs(exprs)),
- ExprCall(f, args) => {
- ExprCall(folder.fold_expr(f),
+ ExprKind::Tup(exprs) => ExprKind::Tup(folder.fold_exprs(exprs)),
+ ExprKind::Call(f, args) => {
+ ExprKind::Call(folder.fold_expr(f),
folder.fold_exprs(args))
}
- ExprMethodCall(i, tps, args) => {
- ExprMethodCall(
+ ExprKind::MethodCall(i, tps, args) => {
+ ExprKind::MethodCall(
respan(folder.new_span(i.span), folder.fold_ident(i.node)),
tps.move_map(|x| folder.fold_ty(x)),
folder.fold_exprs(args))
}
- ExprBinary(binop, lhs, rhs) => {
- ExprBinary(binop,
+ ExprKind::Binary(binop, lhs, rhs) => {
+ ExprKind::Binary(binop,
folder.fold_expr(lhs),
folder.fold_expr(rhs))
}
- ExprUnary(binop, ohs) => {
- ExprUnary(binop, folder.fold_expr(ohs))
+ ExprKind::Unary(binop, ohs) => {
+ ExprKind::Unary(binop, folder.fold_expr(ohs))
}
- ExprLit(l) => ExprLit(l),
- ExprCast(expr, ty) => {
- ExprCast(folder.fold_expr(expr), folder.fold_ty(ty))
+ ExprKind::Lit(l) => ExprKind::Lit(l),
+ ExprKind::Cast(expr, ty) => {
+ ExprKind::Cast(folder.fold_expr(expr), folder.fold_ty(ty))
}
- ExprType(expr, ty) => {
- ExprType(folder.fold_expr(expr), folder.fold_ty(ty))
+ ExprKind::Type(expr, ty) => {
+ ExprKind::Type(folder.fold_expr(expr), folder.fold_ty(ty))
}
- ExprAddrOf(m, ohs) => ExprAddrOf(m, folder.fold_expr(ohs)),
- ExprIf(cond, tr, fl) => {
- ExprIf(folder.fold_expr(cond),
+ ExprKind::AddrOf(m, ohs) => ExprKind::AddrOf(m, folder.fold_expr(ohs)),
+ ExprKind::If(cond, tr, fl) => {
+ ExprKind::If(folder.fold_expr(cond),
folder.fold_block(tr),
fl.map(|x| folder.fold_expr(x)))
}
- ExprIfLet(pat, expr, tr, fl) => {
- ExprIfLet(folder.fold_pat(pat),
+ ExprKind::IfLet(pat, expr, tr, fl) => {
+ ExprKind::IfLet(folder.fold_pat(pat),
folder.fold_expr(expr),
folder.fold_block(tr),
fl.map(|x| folder.fold_expr(x)))
}
- ExprWhile(cond, body, opt_ident) => {
- ExprWhile(folder.fold_expr(cond),
+ ExprKind::While(cond, body, opt_ident) => {
+ ExprKind::While(folder.fold_expr(cond),
folder.fold_block(body),
opt_ident.map(|i| folder.fold_ident(i)))
}
- ExprWhileLet(pat, expr, body, opt_ident) => {
- ExprWhileLet(folder.fold_pat(pat),
+ ExprKind::WhileLet(pat, expr, body, opt_ident) => {
+ ExprKind::WhileLet(folder.fold_pat(pat),
folder.fold_expr(expr),
folder.fold_block(body),
opt_ident.map(|i| folder.fold_ident(i)))
}
- ExprForLoop(pat, iter, body, opt_ident) => {
- ExprForLoop(folder.fold_pat(pat),
+ ExprKind::ForLoop(pat, iter, body, opt_ident) => {
+ ExprKind::ForLoop(folder.fold_pat(pat),
folder.fold_expr(iter),
folder.fold_block(body),
opt_ident.map(|i| folder.fold_ident(i)))
}
- ExprLoop(body, opt_ident) => {
- ExprLoop(folder.fold_block(body),
+ ExprKind::Loop(body, opt_ident) => {
+ ExprKind::Loop(folder.fold_block(body),
opt_ident.map(|i| folder.fold_ident(i)))
}
- ExprMatch(expr, arms) => {
- ExprMatch(folder.fold_expr(expr),
+ ExprKind::Match(expr, arms) => {
+ ExprKind::Match(folder.fold_expr(expr),
arms.move_map(|x| folder.fold_arm(x)))
}
- ExprClosure(capture_clause, decl, body) => {
- ExprClosure(capture_clause,
+ ExprKind::Closure(capture_clause, decl, body) => {
+ ExprKind::Closure(capture_clause,
folder.fold_fn_decl(decl),
folder.fold_block(body))
}
- ExprBlock(blk) => ExprBlock(folder.fold_block(blk)),
- ExprAssign(el, er) => {
- ExprAssign(folder.fold_expr(el), folder.fold_expr(er))
+ ExprKind::Block(blk) => ExprKind::Block(folder.fold_block(blk)),
+ ExprKind::Assign(el, er) => {
+ ExprKind::Assign(folder.fold_expr(el), folder.fold_expr(er))
}
- ExprAssignOp(op, el, er) => {
- ExprAssignOp(op,
+ ExprKind::AssignOp(op, el, er) => {
+ ExprKind::AssignOp(op,
folder.fold_expr(el),
folder.fold_expr(er))
}
- ExprField(el, ident) => {
- ExprField(folder.fold_expr(el),
+ ExprKind::Field(el, ident) => {
+ ExprKind::Field(folder.fold_expr(el),
respan(folder.new_span(ident.span),
folder.fold_ident(ident.node)))
}
- ExprTupField(el, ident) => {
- ExprTupField(folder.fold_expr(el),
+ ExprKind::TupField(el, ident) => {
+ ExprKind::TupField(folder.fold_expr(el),
respan(folder.new_span(ident.span),
folder.fold_usize(ident.node)))
}
- ExprIndex(el, er) => {
- ExprIndex(folder.fold_expr(el), folder.fold_expr(er))
+ ExprKind::Index(el, er) => {
+ ExprKind::Index(folder.fold_expr(el), folder.fold_expr(er))
}
- ExprRange(e1, e2) => {
- ExprRange(e1.map(|x| folder.fold_expr(x)),
+ ExprKind::Range(e1, e2) => {
+ ExprKind::Range(e1.map(|x| folder.fold_expr(x)),
e2.map(|x| folder.fold_expr(x)))
}
- ExprPath(qself, path) => {
+ ExprKind::Path(qself, path) => {
let qself = qself.map(|QSelf { ty, position }| {
QSelf {
ty: folder.fold_ty(ty),
position: position
}
});
- ExprPath(qself, folder.fold_path(path))
+ ExprKind::Path(qself, folder.fold_path(path))
}
- ExprBreak(opt_ident) => ExprBreak(opt_ident.map(|label|
+ ExprKind::Break(opt_ident) => ExprKind::Break(opt_ident.map(|label|
respan(folder.new_span(label.span),
folder.fold_ident(label.node)))
),
- ExprAgain(opt_ident) => ExprAgain(opt_ident.map(|label|
+ ExprKind::Again(opt_ident) => ExprKind::Again(opt_ident.map(|label|
respan(folder.new_span(label.span),
folder.fold_ident(label.node)))
),
- ExprRet(e) => ExprRet(e.map(|x| folder.fold_expr(x))),
- ExprInlineAsm(InlineAsm {
+ ExprKind::Ret(e) => ExprKind::Ret(e.map(|x| folder.fold_expr(x))),
+ ExprKind::InlineAsm(InlineAsm {
inputs,
outputs,
asm,
alignstack,
dialect,
expn_id,
- }) => ExprInlineAsm(InlineAsm {
+ }) => ExprKind::InlineAsm(InlineAsm {
inputs: inputs.move_map(|(c, input)| {
(c, folder.fold_expr(input))
}),
dialect: dialect,
expn_id: expn_id,
}),
- ExprMac(mac) => ExprMac(folder.fold_mac(mac)),
- ExprStruct(path, fields, maybe_expr) => {
- ExprStruct(folder.fold_path(path),
+ ExprKind::Mac(mac) => ExprKind::Mac(folder.fold_mac(mac)),
+ ExprKind::Struct(path, fields, maybe_expr) => {
+ ExprKind::Struct(folder.fold_path(path),
fields.move_map(|x| folder.fold_field(x)),
maybe_expr.map(|x| folder.fold_expr(x)))
},
- ExprParen(ex) => ExprParen(folder.fold_expr(ex))
+ ExprKind::Paren(ex) => ExprKind::Paren(folder.fold_expr(ex))
},
span: folder.new_span(span),
attrs: attrs.map_thin_attrs(|v| fold_attrs(v, folder)),
-> SmallVector<P<Stmt>> {
let span = folder.new_span(span);
match node {
- StmtDecl(d, id) => {
+ StmtKind::Decl(d, id) => {
let id = folder.new_id(id);
folder.fold_decl(d).into_iter().map(|d| P(Spanned {
- node: StmtDecl(d, id),
+ node: StmtKind::Decl(d, id),
span: span
})).collect()
}
- StmtExpr(e, id) => {
+ StmtKind::Expr(e, id) => {
let id = folder.new_id(id);
if let Some(e) = folder.fold_opt_expr(e) {
SmallVector::one(P(Spanned {
- node: StmtExpr(e, id),
+ node: StmtKind::Expr(e, id),
span: span
}))
} else {
SmallVector::zero()
}
}
- StmtSemi(e, id) => {
+ StmtKind::Semi(e, id) => {
let id = folder.new_id(id);
if let Some(e) = folder.fold_opt_expr(e) {
SmallVector::one(P(Spanned {
- node: StmtSemi(e, id),
+ node: StmtKind::Semi(e, id),
span: span
}))
} else {
SmallVector::zero()
}
}
- StmtMac(mac, semi, attrs) => SmallVector::one(P(Spanned {
- node: StmtMac(mac.map(|m| folder.fold_mac(m)),
- semi,
- attrs.map_thin_attrs(|v| fold_attrs(v, folder))),
+ StmtKind::Mac(mac, semi, attrs) => SmallVector::one(P(Spanned {
+ node: StmtKind::Mac(mac.map(|m| folder.fold_mac(m)),
+ semi,
+ attrs.map_thin_attrs(|v| fold_attrs(v, folder))),
span: span
}))
}
// FIXME #623 Non-string meta items are not serialized correctly;
// just forbid them for now
match lit.node {
- ast::LitStr(..) => {}
+ ast::LitKind::Str(..) => {}
_ => {
self.span_err(lit.span,
"non-string literals are not allowed in meta-items");
}
}
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))))
}
}
}
// Predicates on exprs and stmts that the pretty-printer and parser use
-use ast;
+use ast::{self, BlockCheckMode};
/// Does this expression require a semicolon to be treated
/// as a statement? The negation of this: 'can this expression
/// isn't parsed as (if true {...} else {...} | x) | 5
pub fn expr_requires_semi_to_be_stmt(e: &ast::Expr) -> bool {
match e.node {
- ast::ExprIf(..) |
- ast::ExprIfLet(..) |
- ast::ExprMatch(..) |
- ast::ExprBlock(_) |
- ast::ExprWhile(..) |
- ast::ExprWhileLet(..) |
- ast::ExprLoop(..) |
- ast::ExprForLoop(..) => false,
+ ast::ExprKind::If(..) |
+ ast::ExprKind::IfLet(..) |
+ ast::ExprKind::Match(..) |
+ ast::ExprKind::Block(_) |
+ ast::ExprKind::While(..) |
+ ast::ExprKind::WhileLet(..) |
+ ast::ExprKind::Loop(..) |
+ ast::ExprKind::ForLoop(..) => false,
_ => true,
}
}
pub fn expr_is_simple_block(e: &ast::Expr) -> bool {
match e.node {
- ast::ExprBlock(ref block) => block.rules == ast::DefaultBlock,
+ ast::ExprKind::Block(ref block) => block.rules == BlockCheckMode::Default,
_ => false,
}
}
/// this statement requires a semicolon after it.
/// note that in one case (stmt_semi), we've already
/// seen the semicolon, and thus don't need another.
-pub fn stmt_ends_with_semi(stmt: &ast::Stmt_) -> bool {
+pub fn stmt_ends_with_semi(stmt: &ast::StmtKind) -> bool {
match *stmt {
- ast::StmtDecl(ref d, _) => {
+ ast::StmtKind::Decl(ref d, _) => {
match d.node {
- ast::DeclLocal(_) => true,
- ast::DeclItem(_) => false,
+ ast::DeclKind::Local(_) => true,
+ ast::DeclKind::Item(_) => false,
}
}
- ast::StmtExpr(ref e, _) => expr_requires_semi_to_be_stmt(e),
- ast::StmtSemi(..) => false,
- ast::StmtMac(..) => false,
+ ast::StmtKind::Expr(ref e, _) => expr_requires_semi_to_be_stmt(e),
+ ast::StmtKind::Semi(..) => false,
+ ast::StmtKind::Mac(..) => false,
}
}
}
fn filtered_float_lit(data: token::InternedString, suffix: Option<&str>,
- sd: &Handler, sp: Span) -> ast::Lit_ {
+ sd: &Handler, sp: Span) -> ast::LitKind {
debug!("filtered_float_lit: {}, {:?}", data, suffix);
match suffix.as_ref().map(|s| &**s) {
- Some("f32") => ast::LitFloat(data, ast::TyF32),
- Some("f64") => ast::LitFloat(data, ast::TyF64),
+ Some("f32") => ast::LitKind::Float(data, ast::FloatTy::F32),
+ Some("f64") => ast::LitKind::Float(data, ast::FloatTy::F64),
Some(suf) => {
if suf.len() >= 2 && looks_like_width_suffix(&['f'], suf) {
// if it looks like a width, lets try to be helpful.
.emit();
}
- ast::LitFloatUnsuffixed(data)
+ ast::LitKind::FloatUnsuffixed(data)
}
- None => ast::LitFloatUnsuffixed(data)
+ None => ast::LitKind::FloatUnsuffixed(data)
}
}
pub fn float_lit(s: &str, suffix: Option<InternedString>,
- sd: &Handler, sp: Span) -> ast::Lit_ {
+ sd: &Handler, sp: Span) -> 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>();
suffix: Option<InternedString>,
sd: &Handler,
sp: Span)
- -> ast::Lit_ {
+ -> ast::LitKind {
// s can only be ascii, byte indexing is fine
let s2 = s.chars().filter(|&c| c != '_').collect::<String>();
let mut base = 10;
let orig = s;
- let mut ty = ast::UnsuffixedIntLit(ast::Plus);
+ let mut ty = ast::LitIntType::Unsuffixed;
if char_at(s, 0) == '0' && s.len() > 1 {
match char_at(s, 1) {
if let Some(ref suf) = suffix {
if suf.is_empty() { sd.span_bug(sp, "found empty literal suffix in Some")}
ty = match &**suf {
- "isize" => ast::SignedIntLit(ast::TyIs, ast::Plus),
- "i8" => ast::SignedIntLit(ast::TyI8, ast::Plus),
- "i16" => ast::SignedIntLit(ast::TyI16, ast::Plus),
- "i32" => ast::SignedIntLit(ast::TyI32, ast::Plus),
- "i64" => ast::SignedIntLit(ast::TyI64, ast::Plus),
- "usize" => ast::UnsignedIntLit(ast::TyUs),
- "u8" => ast::UnsignedIntLit(ast::TyU8),
- "u16" => ast::UnsignedIntLit(ast::TyU16),
- "u32" => ast::UnsignedIntLit(ast::TyU32),
- "u64" => ast::UnsignedIntLit(ast::TyU64),
+ "isize" => ast::LitIntType::Signed(ast::IntTy::Is),
+ "i8" => ast::LitIntType::Signed(ast::IntTy::I8),
+ "i16" => ast::LitIntType::Signed(ast::IntTy::I16),
+ "i32" => ast::LitIntType::Signed(ast::IntTy::I32),
+ "i64" => ast::LitIntType::Signed(ast::IntTy::I64),
+ "usize" => ast::LitIntType::Unsigned(ast::UintTy::Us),
+ "u8" => ast::LitIntType::Unsigned(ast::UintTy::U8),
+ "u16" => ast::LitIntType::Unsigned(ast::UintTy::U16),
+ "u32" => ast::LitIntType::Unsigned(ast::UintTy::U32),
+ "u64" => ast::LitIntType::Unsigned(ast::UintTy::U64),
_ => {
// i<digits> and u<digits> look like widths, so lets
// give an error message along those lines
debug!("integer_lit: the type is {:?}, base {:?}, the new string is {:?}, the original \
string was {:?}, the original suffix was {:?}", ty, base, s, orig, suffix);
- let res = match u64::from_str_radix(s, base).ok() {
- Some(r) => r,
- None => {
+ match u64::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
// might be `0b10201`. This will cause the conversion above to fail,
// but these cases have errors in the lexer: we don't want to emit
if !already_errored {
sd.span_err(sp, "int literal is too large");
}
- 0
+ ast::LitKind::Int(0, ty)
}
- };
-
- // adjust the sign
- let sign = ast::Sign::new(res);
- match ty {
- ast::SignedIntLit(t, _) => ast::LitInt(res, ast::SignedIntLit(t, sign)),
- ast::UnsuffixedIntLit(_) => ast::LitInt(res, ast::UnsuffixedIntLit(sign)),
- us@ast::UnsignedIntLit(_) => ast::LitInt(res, us)
}
}
use std::rc::Rc;
use codemap::{Span, BytePos, Pos, Spanned, NO_EXPANSION};
use ast::{self, TokenTree};
- use abi;
+ use abi::Abi;
use attr::{first_attr_value_str_by_name, AttrMetaMethods};
use parse;
use parse::parser::Parser;
assert!(string_to_expr("a".to_string()) ==
P(ast::Expr{
id: ast::DUMMY_NODE_ID,
- node: ast::ExprPath(None, ast::Path {
+ node: ast::ExprKind::Path(None, ast::Path {
span: sp(0, 1),
global: false,
segments: vec!(
assert!(string_to_expr("::a::b".to_string()) ==
P(ast::Expr {
id: ast::DUMMY_NODE_ID,
- node: ast::ExprPath(None, ast::Path {
+ node: ast::ExprKind::Path(None, ast::Path {
span: sp(0, 6),
global: true,
segments: vec!(
assert!(string_to_expr("return d".to_string()) ==
P(ast::Expr{
id: ast::DUMMY_NODE_ID,
- node:ast::ExprRet(Some(P(ast::Expr{
+ node:ast::ExprKind::Ret(Some(P(ast::Expr{
id: ast::DUMMY_NODE_ID,
- node:ast::ExprPath(None, ast::Path{
+ node:ast::ExprKind::Path(None, ast::Path{
span: sp(7, 8),
global: false,
segments: vec!(
#[test] fn parse_stmt_1 () {
assert!(string_to_stmt("b;".to_string()) ==
Some(P(Spanned{
- node: ast::StmtExpr(P(ast::Expr {
+ node: ast::StmtKind::Expr(P(ast::Expr {
id: ast::DUMMY_NODE_ID,
- node: ast::ExprPath(None, ast::Path {
+ node: ast::ExprKind::Path(None, ast::Path {
span:sp(0,1),
global:false,
segments: vec!(
assert!(panictry!(parser.parse_pat())
== P(ast::Pat{
id: ast::DUMMY_NODE_ID,
- node: ast::PatIdent(ast::BindingMode::ByValue(ast::MutImmutable),
+ node: ast::PatIdent(ast::BindingMode::ByValue(ast::Mutability::Immutable),
Spanned{ span:sp(0, 1),
node: str_to_ident("b")
},
P(ast::Item{ident:str_to_ident("a"),
attrs:Vec::new(),
id: ast::DUMMY_NODE_ID,
- node: ast::ItemFn(P(ast::FnDecl {
+ node: ast::ItemKind::Fn(P(ast::FnDecl {
inputs: vec!(ast::Arg{
ty: P(ast::Ty{id: ast::DUMMY_NODE_ID,
- node: ast::TyPath(None, ast::Path{
+ node: ast::TyKind::Path(None, ast::Path{
span:sp(10,13),
global:false,
segments: vec!(
pat: P(ast::Pat {
id: ast::DUMMY_NODE_ID,
node: ast::PatIdent(
- ast::BindingMode::ByValue(ast::MutImmutable),
+ ast::BindingMode::ByValue(ast::Mutability::Immutable),
Spanned{
span: sp(6,7),
node: str_to_ident("b")},
}),
id: ast::DUMMY_NODE_ID
}),
- output: ast::DefaultReturn(sp(15, 15)),
+ output: ast::FunctionRetTy::Default(sp(15, 15)),
variadic: false
}),
ast::Unsafety::Normal,
ast::Constness::NotConst,
- abi::Rust,
+ Abi::Rust,
ast::Generics{ // no idea on either of these:
lifetimes: Vec::new(),
ty_params: P::empty(),
},
P(ast::Block {
stmts: vec!(P(Spanned{
- node: ast::StmtSemi(P(ast::Expr{
+ node: ast::StmtKind::Semi(P(ast::Expr{
id: ast::DUMMY_NODE_ID,
- node: ast::ExprPath(None,
+ node: ast::ExprKind::Path(None,
ast::Path{
span:sp(17,18),
global:false,
span: sp(17,19)})),
expr: None,
id: ast::DUMMY_NODE_ID,
- rules: ast::DefaultBlock, // no idea
+ rules: ast::BlockCheckMode::Default, // no idea
span: sp(15,21),
})),
- vis: ast::Inherited,
+ vis: ast::Visibility::Inherited,
span: sp(0,21)})));
}
"foo!( fn main() { body } )".to_string(), vec![], &sess);
let tts = match expr.node {
- ast::ExprMac(ref mac) => mac.node.tts.clone(),
+ ast::ExprKind::Mac(ref mac) => mac.node.tts.clone(),
_ => panic!("not a macro"),
};
pub use self::PathParsingMode::*;
-use abi;
+use abi::{self, Abi};
use ast::BareFnTy;
use ast::{RegionTyParamBound, TraitTyParamBound, TraitBoundModifier};
-use ast::{Public, Unsafety};
-use ast::{Mod, BiAdd, Arg, Arm, Attribute, BindingMode};
-use ast::{BiBitAnd, BiBitOr, BiBitXor, BiRem, BiLt, Block};
-use ast::{BlockCheckMode, CaptureByRef, CaptureByValue, CaptureClause};
-use ast::{Constness, ConstTraitItem, Crate, CrateConfig};
-use ast::{Decl, DeclItem, DeclLocal, DefaultBlock, DefaultReturn};
-use ast::{UnDeref, BiDiv, EMPTY_CTXT, EnumDef, ExplicitSelf};
-use ast::{Expr, Expr_, ExprAddrOf, ExprMatch, ExprAgain};
-use ast::{ExprAssign, ExprAssignOp, ExprBinary, ExprBlock, ExprBox};
-use ast::{ExprBreak, ExprCall, ExprCast, ExprInPlace};
-use ast::{ExprField, ExprTupField, ExprClosure, ExprIf, ExprIfLet, ExprIndex};
-use ast::{ExprLit, ExprLoop, ExprMac, ExprRange};
-use ast::{ExprMethodCall, ExprParen, ExprPath};
-use ast::{ExprRepeat, ExprRet, ExprStruct, ExprTup, ExprType, ExprUnary};
-use ast::{ExprVec, ExprWhile, ExprWhileLet, ExprForLoop, Field, FnDecl};
-use ast::{ForeignItem, ForeignItemStatic, ForeignItemFn, FunctionRetTy};
-use ast::{Ident, Inherited, ImplItem, Item, Item_, ItemStatic};
-use ast::{ItemEnum, ItemFn, ItemForeignMod, ItemImpl, ItemConst};
-use ast::{ItemMac, ItemMod, ItemStruct, ItemTrait, ItemTy, ItemDefaultImpl};
-use ast::{ItemExternCrate, ItemUse};
-use ast::{Lit, Lit_};
-use ast::{LitBool, LitChar, LitByte, LitByteStr};
-use ast::{LitStr, LitInt, Local};
-use ast::{MacStmtWithBraces, MacStmtWithSemicolon, MacStmtWithoutBraces};
-use ast::{MutImmutable, MutMutable, Mac_};
-use ast::{MutTy, BiMul, Mutability};
-use ast::{NamedField, UnNeg, NoReturn, UnNot};
+use ast::Unsafety;
+use ast::{Mod, Arg, Arm, Attribute, BindingMode, TraitItemKind};
+use ast::Block;
+use ast::{BlockCheckMode, CaptureBy};
+use ast::{Constness, Crate, CrateConfig};
+use ast::{Decl, DeclKind};
+use ast::{EMPTY_CTXT, EnumDef, ExplicitSelf};
+use ast::{Expr, ExprKind};
+use ast::{Field, FnDecl};
+use ast::{ForeignItem, ForeignItemKind, FunctionRetTy};
+use ast::{Ident, ImplItem, Item, ItemKind};
+use ast::{Lit, LitKind, UintTy};
+use ast::Local;
+use ast::MacStmtStyle;
+use ast::Mac_;
+use ast::{MutTy, Mutability};
+use ast::NamedField;
use ast::{Pat, PatBox, PatEnum, PatIdent, PatLit, PatQPath, PatMac, PatRange};
use ast::{PatRegion, PatStruct, PatTup, PatVec, PatWild};
use ast::{PolyTraitRef, QSelf};
-use ast::{Return, BiShl, BiShr, Stmt, StmtDecl};
-use ast::{StmtExpr, StmtSemi, StmtMac, VariantData, StructField};
-use ast::{BiSub, StrStyle};
-use ast::{SelfExplicit, SelfRegion, SelfStatic, SelfValue};
+use ast::{Stmt, StmtKind};
+use ast::{VariantData, StructField};
+use ast::StrStyle;
+use ast::SelfKind;
use ast::{Delimited, SequenceRepetition, TokenTree, TraitItem, TraitRef};
-use ast::{Ty, Ty_, TypeBinding, TyMac};
-use ast::{TyFixedLengthVec, TyBareFn, TyTypeof, TyInfer};
-use ast::{TyParam, TyParamBounds, TyParen, TyPath, TyPtr};
-use ast::{TyRptr, TyTup, TyU32, TyVec};
-use ast::TypeTraitItem;
-use ast::{UnnamedField, UnsafeBlock};
+use ast::{Ty, TyKind, TypeBinding, TyParam, TyParamBounds};
+use ast::UnnamedField;
use ast::{ViewPath, ViewPathGlob, ViewPathList, ViewPathSimple};
use ast::{Visibility, WhereClause};
use attr::{ThinAttributes, ThinAttributesExt, AttributesExt};
+use ast::{BinOpKind, UnOp};
use ast;
use ast_util::{self, ident_to_path};
use codemap::{self, Span, BytePos, Spanned, spanned, mk_sp, CodeMap};
}
}
-type ItemInfo = (Ident, Item
_, Option<Vec<Attribute> >);
+type ItemInfo = (Ident, Item
Kind, Option<Vec<Attribute> >);
/// How to parse a path. There are four different kinds of paths, all of which
/// are parsed somewhat differently.
_ => unreachable!()
};
let span = $p.span;
- Some($p.mk_expr(span.lo, span.hi, ExprPath(None, pt), None))
+ Some($p.mk_expr(span.lo, span.hi, ExprKind::Path(None, pt), None))
}
token::Interpolated(token::NtBlock(_)) => {
// FIXME: The following avoids an issue with lexical borrowck scopes,
_ => unreachable!()
};
let span = $p.span;
- Some($p.mk_expr(span.lo, span.hi, ExprBlock(b), None))
+ Some($p.mk_expr(span.lo, span.hi, ExprKind::Block(b), None))
}
_ => None
};
pub fn commit_expr(&mut self, e: &Expr, edible: &[token::Token],
inedible: &[token::Token]) -> PResult<'a, ()> {
debug!("commit_expr {:?}", e);
- if let ExprPath(..) = e.node {
+ if let ExprKind::Path(..) = e.node {
// might be unit-struct construction; check for recoverableinput error.
let expected = edible.iter()
.cloned()
let lo = self.span.lo;
let node = if self.eat_keyword(keywords::SelfValue) {
let rename = try!(self.parse_rename());
- ast::PathListMod { id: ast::DUMMY_NODE_ID, rename: rename }
+ ast::PathListItemKind::Mod { id: ast::DUMMY_NODE_ID, rename: rename }
} else {
let ident = try!(self.parse_ident());
let rename = try!(self.parse_rename());
- ast::PathListIdent { name: ident, rename: rename, id: ast::DUMMY_NODE_ID }
+ ast::PathListItemKind::Ident { name: ident, rename: rename, id: ast::DUMMY_NODE_ID }
};
let hi = self.last_span.hi;
Ok(spanned(lo, hi, node))
token::AndAnd => {
let span = self.span;
let lo = span.lo + BytePos(1);
- Ok(self.replace_token(token::BinOp(token::And), lo, span.hi))
+ Ok(self.bump_with(token::BinOp(token::And), lo, span.hi))
}
_ => self.unexpected()
}
token::BinOp(token::Shl) => {
let span = self.span;
let lo = span.lo + BytePos(1);
- self.replace_token(token::Lt, lo, span.hi);
+ self.bump_with(token::Lt, lo, span.hi);
true
}
_ => false,
token::BinOp(token::Shr) => {
let span = self.span;
let lo = span.lo + BytePos(1);
- Ok(self.replace_token(token::Gt, lo, span.hi))
+ Ok(self.bump_with(token::Gt, lo, span.hi))
}
token::BinOpEq(token::Shr) => {
let span = self.span;
let lo = span.lo + BytePos(1);
- Ok(self.replace_token(token::Ge, lo, span.hi))
+ Ok(self.bump_with(token::Ge, lo, span.hi))
}
token::Ge => {
let span = self.span;
let lo = span.lo + BytePos(1);
- Ok(self.replace_token(token::Eq, lo, span.hi))
+ Ok(self.bump_with(token::Eq, lo, span.hi))
}
_ => {
let gt_str = Parser::token_to_string(&token::Gt);
old_token
}
- /// EFFECT: replace the current token and span with the given one
- pub fn replace_token(&mut self,
- next: token::Token,
- lo: BytePos,
- hi: BytePos) {
+ /// Advance the parser using provided token as a next one. Use this when
+ /// consuming a part of a token. For example a single `<` from `<<`.
+ pub fn bump_with(&mut self,
+ next: token::Token,
+ lo: BytePos,
+ hi: BytePos) {
self.last_span = mk_sp(self.span.lo, lo);
- self.token = next;
+ // It would be incorrect to just stash current token, but fortunately
+ // for tokens currently using `bump_with`, last_token will be of no
+ // use anyway.
+ self.last_token = None;
+ self.last_token_interpolated = false;
self.span = mk_sp(lo, hi);
+ self.token = next;
+ self.expected_tokens.clear();
}
+
pub fn buffer_length(&mut self) -> isize {
if self.buffer_start <= self.buffer_end {
return self.buffer_end - self.buffer_start;
}
}
- pub fn parse_for_in_type(&mut self) -> PResult<'a, Ty_> {
+ pub fn parse_for_in_type(&mut self) -> PResult<'a, TyKind> {
/*
Parses whatever can come after a `for` keyword in a type.
The `for` has already been consumed.
Some(TraitTyParamBound(poly_trait_ref, TraitBoundModifier::None)).into_iter()
.chain(other_bounds.into_vec())
.collect();
- Ok(ast::TyPolyTraitRef(all_bounds))
+ Ok(ast::TyKind::PolyTraitRef(all_bounds))
}
}
- pub fn parse_ty_path(&mut self) -> PResult<'a, Ty_> {
- Ok(TyPath(None, try!(self.parse_path(LifetimeAndTypesWithoutColons))))
+ pub fn parse_ty_path(&mut self) -> PResult<'a, TyKind> {
+ Ok(TyKind::Path(None, try!(self.parse_path(LifetimeAndTypesWithoutColons))))
}
- /// parse a TyBareFn type:
- pub fn parse_ty_bare_fn(&mut self, lifetime_defs: Vec<ast::LifetimeDef>) -> PResult<'a, Ty_> {
+ /// parse a TyKind::BareFn type:
+ pub fn parse_ty_bare_fn(&mut self, lifetime_defs: Vec<ast::LifetimeDef>)
+ -> PResult<'a, TyKind> {
/*
[unsafe] [extern "ABI"] fn <'lt> (S) -> T
let unsafety = try!(self.parse_unsafety());
let abi = if self.eat_keyword(keywords::Extern) {
- try!(self.parse_opt_abi()).unwrap_or(abi::C)
+ try!(self.parse_opt_abi()).unwrap_or(Abi::C)
} else {
- abi::Rust
+ Abi::Rust
};
try!(self.expect_keyword(keywords::Fn));
output: ret_ty,
variadic: variadic
});
- Ok(TyBareFn(P(BareFnTy {
+ Ok(TyKind::BareFn(P(BareFnTy {
abi: abi,
unsafety: unsafety,
lifetimes: lifetime_defs,
let (name, node) = if p.eat_keyword(keywords::Type) {
let TyParam {ident, bounds, default, ..} = try!(p.parse_ty_param());
try!(p.expect(&token::Semi));
- (ident, TypeTraitItem(bounds, default))
+ (ident, TraitItemKind::Type(bounds, default))
} else if p.is_const_item() {
try!(p.expect_keyword(keywords::Const));
let ident = try!(p.parse_ident());
try!(p.expect(&token::Semi));
None
};
- (ident, ConstTraitItem(ty, default))
+ (ident, TraitItemKind::Const(ty, default))
} else {
let (constness, unsafety, abi) = try!(p.parse_fn_front_matter());
token_str)[..]))
}
};
- (ident, ast::MethodTraitItem(sig, body))
+ (ident, ast::TraitItemKind::Method(sig, body))
};
Ok(P(TraitItem {
pub fn parse_ret_ty(&mut self) -> PResult<'a, FunctionRetTy> {
if self.eat(&token::RArrow) {
if self.eat(&token::Not) {
- Ok(NoReturn(self.last_span))
+ Ok(FunctionRetTy::None(self.last_span))
} else {
- Ok(Return(try!(self.parse_ty())))
+ Ok(FunctionRetTy::Ty(try!(self.parse_ty())))
}
} else {
let pos = self.span.lo;
- Ok(DefaultReturn(mk_sp(pos, pos)))
+ Ok(FunctionRetTy::Default(mk_sp(pos, pos)))
}
}
}
let sp = mk_sp(lo, self.last_span.hi);
- let sum = ast::TyObjectSum(lhs, bounds);
+ let sum = ast::TyKind::ObjectSum(lhs, bounds);
Ok(P(Ty {id: ast::DUMMY_NODE_ID, node: sum, span: sp}))
}
try!(self.expect(&token::CloseDelim(token::Paren)));
if ts.len() == 1 && !last_comma {
- TyParen(ts.into_iter().nth(0).unwrap())
+ TyKind::Paren(ts.into_iter().nth(0).unwrap())
} else {
- TyTup(ts)
+ TyKind::Tup(ts)
}
} else if self.check(&token::BinOp(token::Star)) {
// STAR POINTER (bare pointer?)
self.bump();
- TyPtr(try!(self.parse_ptr()))
+ TyKind::Ptr(try!(self.parse_ptr()))
} else if self.check(&token::OpenDelim(token::Bracket)) {
// VECTOR
try!(self.expect(&token::OpenDelim(token::Bracket)));
// Parse the `; e` in `[ i32; e ]`
// where `e` is a const expression
let t = match try!(self.maybe_parse_fixed_length_of_vec()) {
- None => TyVec(t),
- Some(suffix) => TyFixedLengthVec(t, suffix)
+ None => TyKind::Vec(t),
+ Some(suffix) => TyKind::FixedLengthVec(t, suffix)
};
try!(self.expect(&token::CloseDelim(token::Bracket)));
t
try!(self.expect(&token::OpenDelim(token::Paren)));
let e = try!(self.parse_expr());
try!(self.expect(&token::CloseDelim(token::Paren)));
- TyTypeof(e)
+ TyKind::Typeof(e)
} else if self.eat_lt() {
let (qself, path) =
try!(self.parse_qualified_path(NoTypesAllowed));
- TyPath(Some(qself), path)
+ TyKind::Path(Some(qself), path)
} else if self.check(&token::ModSep) ||
self.token.is_ident() ||
self.token.is_path() {
seq_sep_none(),
|p| p.parse_token_tree()));
let hi = self.span.hi;
- TyMac(spanned(lo, hi, Mac_ { path: path, tts: tts, ctxt: EMPTY_CTXT }))
+ TyKind::Mac(spanned(lo, hi, Mac_ { path: path, tts: tts, ctxt: EMPTY_CTXT }))
} else {
// NAMED TYPE
- TyPath(None, path)
+ TyKind::Path(None, path)
}
} else if self.eat(&token::Underscore) {
// TYPE TO BE INFERRED
- TyInfer
+ TyKind::Infer
} else {
let this_token_str = self.this_token_to_string();
let msg = format!("expected type, found `{}`", this_token_str);
Ok(P(Ty {id: ast::DUMMY_NODE_ID, node: t, span: sp}))
}
- pub fn parse_borrowed_pointee(&mut self) -> PResult<'a, Ty_> {
+ pub fn parse_borrowed_pointee(&mut self) -> PResult<'a, TyKind> {
// look for `&'lt` or `&'foo ` and interpret `foo` as the region name:
let opt_lifetime = try!(self.parse_opt_lifetime());
let mt = try!(self.parse_mt());
- return Ok(TyRptr(opt_lifetime, mt));
+ return Ok(TyKind::Rptr(opt_lifetime, mt));
}
pub fn parse_ptr(&mut self) -> PResult<'a, MutTy> {
let mutbl = if self.eat_keyword(keywords::Mut) {
- MutMutable
+ Mutability::Mutable
} else if self.eat_keyword(keywords::Const) {
- MutImmutable
+ Mutability::Immutable
} else {
let span = self.last_span;
self.span_err(span,
"bare raw pointers are no longer allowed, you should \
likely use `*mut T`, but otherwise `*T` is now \
known as `*const T`");
- MutImmutable
+ Mutability::Immutable
};
let t = try!(self.parse_ty());
Ok(MutTy { ty: t, mutbl: mutbl })
} else {
P(Ty {
id: ast::DUMMY_NODE_ID,
- node: TyInfer,
+ node: TyKind::Infer,
span: mk_sp(self.span.lo, self.span.hi),
})
};
}
/// Matches token_lit = LIT_INTEGER | ...
- pub fn lit_from_token(&self, tok: &token::Token) -> PResult<'a, Lit_> {
+ pub fn lit_from_token(&self, tok: &token::Token) -> PResult<'a, LitKind> {
match *tok {
token::Interpolated(token::NtExpr(ref v)) => {
match v.node {
- ExprLit(ref lit) => { Ok(lit.node.clone()) }
+ ExprKind::Lit(ref lit) => { Ok(lit.node.clone()) }
_ => { return self.unexpected_last(tok); }
}
}
token::Literal(lit, suf) => {
let (suffix_illegal, out) = match lit {
- token::Byte(i) => (true, LitByte(parse::byte_lit(&i.as_str()).0)),
- token::Char(i) => (true, LitChar(parse::char_lit(&i.as_str()).0)),
+ 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
token::Str_(s) => {
(true,
- LitStr(token::intern_and_get_ident(&parse::str_lit(&s.as_str())),
- ast::CookedStr))
+ LitKind::Str(token::intern_and_get_ident(&parse::str_lit(&s.as_str())),
+ ast::StrStyle::Cooked))
}
token::StrRaw(s, n) => {
(true,
- LitStr(
+ LitKind::Str(
token::intern_and_get_ident(&parse::raw_str_lit(&s.as_str())),
- ast::RawStr(n)))
+ ast::StrStyle::Raw(n)))
}
token::ByteStr(i) =>
- (true, LitByteStr(parse::byte_str_lit(&i.as_str()))),
+ (true, LitKind::ByteStr(parse::byte_str_lit(&i.as_str()))),
token::ByteStrRaw(i, _) =>
(true,
- LitByteStr(Rc::new(i.to_string().into_bytes()))),
+ LitKind::ByteStr(Rc::new(i.to_string().into_bytes()))),
};
if suffix_illegal {
pub fn parse_lit(&mut self) -> PResult<'a, Lit> {
let lo = self.span.lo;
let lit = if self.eat_keyword(keywords::True) {
- LitBool(true)
+ LitKind::Bool(true)
} else if self.eat_keyword(keywords::False) {
- LitBool(false)
+ LitKind::Bool(false)
} else {
let token = self.bump_and_get();
let lit = try!(self.lit_from_token(&token));
let lo = self.span.lo;
let literal = P(try!(self.parse_lit()));
let hi = self.last_span.hi;
- let expr = self.mk_expr(lo, hi, ExprLit(literal), None);
+ let expr = self.mk_expr(lo, hi, ExprKind::Lit(literal), None);
if minus_present {
let minus_hi = self.last_span.hi;
- let unary = self.mk_unary(UnNeg, expr);
+ let unary = self.mk_unary(UnOp::Neg, expr);
Ok(self.mk_expr(minus_lo, minus_hi, unary, None))
} else {
Ok(expr)
/// Parse mutability declaration (mut/const/imm)
pub fn parse_mutability(&mut self) -> PResult<'a, Mutability> {
if self.eat_keyword(keywords::Mut) {
- Ok(MutMutable)
+ Ok(Mutability::Mutable)
} else {
- Ok(MutImmutable)
+ Ok(Mutability::Immutable)
}
}
}
pub fn mk_expr(&mut self, lo: BytePos, hi: BytePos,
- node: Expr_, attrs: ThinAttributes) -> P<Expr> {
+ node: ExprKind, attrs: ThinAttributes) -> P<Expr> {
P(Expr {
id: ast::DUMMY_NODE_ID,
node: node,
})
}
- pub fn mk_unary(&mut self, unop: ast::UnOp, expr: P<Expr>) -> ast::Expr_ {
- ExprUnary(unop, expr)
+ pub fn mk_unary(&mut self, unop: ast::UnOp, expr: P<Expr>) -> ast::ExprKind {
+ ExprKind::Unary(unop, expr)
}
- pub fn mk_binary(&mut self, binop: ast::BinOp, lhs: P<Expr>, rhs: P<Expr>) -> ast::Expr_ {
- ExprBinary(binop, lhs, rhs)
+ pub fn mk_binary(&mut self, binop: ast::BinOp, lhs: P<Expr>, rhs: P<Expr>) -> ast::ExprKind {
+ ExprKind::Binary(binop, lhs, rhs)
}
- pub fn mk_call(&mut self, f: P<Expr>, args: Vec<P<Expr>>) -> ast::Expr_ {
- ExprCall(f, args)
+ pub fn mk_call(&mut self, f: P<Expr>, args: Vec<P<Expr>>) -> ast::ExprKind {
+ ExprKind::Call(f, args)
}
fn mk_method_call(&mut self,
ident: ast::SpannedIdent,
tps: Vec<P<Ty>>,
args: Vec<P<Expr>>)
- -> ast::Expr_ {
- ExprMethodCall(ident, tps, args)
+ -> ast::ExprKind {
+ ExprKind::MethodCall(ident, tps, args)
}
- pub fn mk_index(&mut self, expr: P<Expr>, idx: P<Expr>) -> ast::Expr_ {
- ExprIndex(expr, idx)
+ pub fn mk_index(&mut self, expr: P<Expr>, idx: P<Expr>) -> ast::ExprKind {
+ ExprKind::Index(expr, idx)
}
pub fn mk_range(&mut self,
start: Option<P<Expr>>,
end: Option<P<Expr>>)
- -> ast::Expr_ {
- ExprRange(start, end)
+ -> ast::ExprKind {
+ ExprKind::Range(start, end)
}
- pub fn mk_field(&mut self, expr: P<Expr>, ident: ast::SpannedIdent) -> ast::Expr_ {
- ExprField(expr, ident)
+ pub fn mk_field(&mut self, expr: P<Expr>, ident: ast::SpannedIdent) -> ast::ExprKind {
+ ExprKind::Field(expr, ident)
}
- pub fn mk_tup_field(&mut self, expr: P<Expr>, idx: codemap::Spanned<usize>) -> ast::Expr_ {
- ExprTupField(expr, idx)
+ pub fn mk_tup_field(&mut self, expr: P<Expr>, idx: codemap::Spanned<usize>) -> ast::ExprKind {
+ ExprKind::TupField(expr, idx)
}
pub fn mk_assign_op(&mut self, binop: ast::BinOp,
- lhs: P<Expr>, rhs: P<Expr>) -> ast::Expr_ {
- ExprAssignOp(binop, lhs, rhs)
+ lhs: P<Expr>, rhs: P<Expr>) -> ast::ExprKind {
+ ExprKind::AssignOp(binop, lhs, rhs)
}
pub fn mk_mac_expr(&mut self, lo: BytePos, hi: BytePos,
m: Mac_, attrs: ThinAttributes) -> P<Expr> {
P(Expr {
id: ast::DUMMY_NODE_ID,
- node: ExprMac(codemap::Spanned {node: m, span: mk_sp(lo, hi)}),
+ node: ExprKind::Mac(codemap::Spanned {node: m, span: mk_sp(lo, hi)}),
span: mk_sp(lo, hi),
attrs: attrs,
})
pub fn mk_lit_u32(&mut self, i: u32, attrs: ThinAttributes) -> P<Expr> {
let span = &self.span;
let lv_lit = P(codemap::Spanned {
- node: LitInt(i as u64, ast::UnsignedIntLit(TyU32)),
+ node: LitKind::Int(i as u64, ast::LitIntType::Unsigned(UintTy::U32)),
span: *span
});
P(Expr {
id: ast::DUMMY_NODE_ID,
- node: ExprLit(lv_lit),
+ node: ExprKind::Lit(lv_lit),
span: *span,
attrs: attrs,
})
let lo = self.span.lo;
let mut hi = self.span.hi;
- let ex: Expr_;
+ let ex: ExprKind;
// Note: when adding new syntax here, don't forget to adjust Token::can_begin_expr().
match self.token {
hi = self.last_span.hi;
return if es.len() == 1 && !trailing_comma {
- Ok(self.mk_expr(lo, hi, ExprParen(es.into_iter().nth(0).unwrap()), attrs))
+ Ok(self.mk_expr(lo, hi, ExprKind::Paren(es.into_iter().nth(0).unwrap()), attrs))
} else {
- Ok(self.mk_expr(lo, hi, ExprTup(es), attrs))
+ Ok(self.mk_expr(lo, hi, ExprKind::Tup(es), attrs))
}
},
token::OpenDelim(token::Brace) => {
- return self.parse_block_expr(lo, DefaultBlock, attrs);
+ return self.parse_block_expr(lo, BlockCheckMode::Default, attrs);
},
token::BinOp(token::Or) | token::OrOr => {
let lo = self.span.lo;
- return self.parse_lambda_expr(lo, CaptureByRef, attrs);
+ return self.parse_lambda_expr(lo, CaptureBy::Ref, attrs);
},
token::Ident(id @ ast::Ident {
name: token::SELF_KEYWORD_NAME,
}, token::Plain) => {
self.bump();
let path = ast_util::ident_to_path(mk_sp(lo, hi), id);
- ex = ExprPath(None, path);
+ ex = ExprKind::Path(None, path);
hi = self.last_span.hi;
}
token::OpenDelim(token::Bracket) => {
if self.check(&token::CloseDelim(token::Bracket)) {
// Empty vector.
self.bump();
- ex = ExprVec(Vec::new());
+ ex = ExprKind::Vec(Vec::new());
} else {
// Nonempty vector.
let first_expr = try!(self.parse_expr());
self.bump();
let count = try!(self.parse_expr());
try!(self.expect(&token::CloseDelim(token::Bracket)));
- ex = ExprRepeat(first_expr, count);
+ ex = ExprKind::Repeat(first_expr, count);
} else if self.check(&token::Comma) {
// Vector with two or more elements.
self.bump();
));
let mut exprs = vec!(first_expr);
exprs.extend(remaining_exprs);
- ex = ExprVec(exprs);
+ ex = ExprKind::Vec(exprs);
} else {
// Vector with one element.
try!(self.expect(&token::CloseDelim(token::Bracket)));
- ex = ExprVec(vec!(first_expr));
+ ex = ExprKind::Vec(vec!(first_expr));
}
}
hi = self.last_span.hi;
let (qself, path) =
try!(self.parse_qualified_path(LifetimeAndTypesWithColons));
hi = path.span.hi;
- return Ok(self.mk_expr(lo, hi, ExprPath(Some(qself), path), attrs));
+ return Ok(self.mk_expr(lo, hi, ExprKind::Path(Some(qself), path), attrs));
}
if self.eat_keyword(keywords::Move) {
let lo = self.last_span.lo;
- return self.parse_lambda_expr(lo, CaptureByValue, attrs);
+ return self.parse_lambda_expr(lo, CaptureBy::Value, attrs);
}
if self.eat_keyword(keywords::If) {
return self.parse_if_expr(attrs);
}
if self.eat_keyword(keywords::Continue) {
let ex = if self.token.is_lifetime() {
- let ex = ExprAgain(Some(Spanned{
+ let ex = ExprKind::Again(Some(Spanned{
node: self.get_lifetime(),
span: self.span
}));
self.bump();
ex
} else {
- ExprAgain(None)
+ ExprKind::Again(None)
};
let hi = self.last_span.hi;
return Ok(self.mk_expr(lo, hi, ex, attrs));
if self.eat_keyword(keywords::Unsafe) {
return self.parse_block_expr(
lo,
- UnsafeBlock(ast::UserProvided),
+ BlockCheckMode::Unsafe(ast::UserProvided),
attrs);
}
if self.eat_keyword(keywords::Return) {
if self.token.can_begin_expr() {
let e = try!(self.parse_expr());
hi = e.span.hi;
- ex = ExprRet(Some(e));
+ ex = ExprKind::Ret(Some(e));
} else {
- ex = ExprRet(None);
+ ex = ExprKind::Ret(None);
}
} else if self.eat_keyword(keywords::Break) {
if self.token.is_lifetime() {
- ex = ExprBreak(Some(Spanned {
+ ex = ExprKind::Break(Some(Spanned {
node: self.get_lifetime(),
span: self.span
}));
self.bump();
} else {
- ex = ExprBreak(None);
+ ex = ExprKind::Break(None);
}
hi = self.last_span.hi;
} else if self.token.is_keyword(keywords::Let) {
hi = self.span.hi;
try!(self.expect(&token::CloseDelim(token::Brace)));
- ex = ExprStruct(pth, fields, base);
+ ex = ExprKind::Struct(pth, fields, base);
return Ok(self.mk_expr(lo, hi, ex, attrs));
}
}
hi = pth.span.hi;
- ex = ExprPath(None, pth);
+ ex = ExprKind::Path(None, pth);
} else {
// other literal expression
let lit = try!(self.parse_lit());
hi = lit.span.hi;
- ex = ExprLit(P(lit));
+ ex = ExprKind::Lit(P(lit));
}
}
}
let attrs = outer_attrs.append(inner_attrs);
let blk = try!(self.parse_block_tail(lo, blk_mode));
- return Ok(self.mk_expr(blk.span.lo, blk.span.hi, ExprBlock(blk), attrs));
+ return Ok(self.mk_expr(blk.span.lo, blk.span.hi, ExprKind::Block(blk), attrs));
}
/// parse a.b or a(13) or a[4] or just a
expr.map(|mut expr| {
expr.attrs.update(|a| a.prepend(attrs));
match expr.node {
- ExprIf(..) | ExprIfLet(..) => {
+ ExprKind::If(..) | ExprKind::IfLet(..) => {
if !expr.attrs.as_attr_slice().is_empty() {
// Just point to the first attribute in there...
let span = expr.attrs.as_attr_slice()[0].span;
match parser.token {
token::BinOp(token::Star) => {
parser.bump();
- Ok(Some(ast::ZeroOrMore))
+ Ok(Some(ast::KleeneOp::ZeroOrMore))
},
token::BinOp(token::Plus) => {
parser.bump();
- Ok(Some(ast::OneOrMore))
+ Ok(Some(ast::KleeneOp::OneOrMore))
},
_ => Ok(None)
}
let e = self.parse_prefix_expr(None);
let (span, e) = try!(self.interpolated_or_expr_span(e));
hi = span.hi;
- self.mk_unary(UnNot, e)
+ self.mk_unary(UnOp::Not, e)
}
token::BinOp(token::Minus) => {
self.bump();
let e = self.parse_prefix_expr(None);
let (span, e) = try!(self.interpolated_or_expr_span(e));
hi = span.hi;
- self.mk_unary(UnNeg, e)
+ self.mk_unary(UnOp::Neg, e)
}
token::BinOp(token::Star) => {
self.bump();
let e = self.parse_prefix_expr(None);
let (span, e) = try!(self.interpolated_or_expr_span(e));
hi = span.hi;
- self.mk_unary(UnDeref, e)
+ self.mk_unary(UnOp::Deref, e)
}
token::BinOp(token::And) | token::AndAnd => {
try!(self.expect_and());
let e = self.parse_prefix_expr(None);
let (span, e) = try!(self.interpolated_or_expr_span(e));
hi = span.hi;
- ExprAddrOf(m, e)
+ ExprKind::AddrOf(m, e)
}
token::Ident(..) if self.token.is_keyword(keywords::In) => {
self.bump();
let blk = try!(self.parse_block());
let span = blk.span;
hi = span.hi;
- let blk_expr = self.mk_expr(span.lo, span.hi, ExprBlock(blk),
+ let blk_expr = self.mk_expr(span.lo, span.hi, ExprKind::Block(blk),
None);
- ExprInPlace(place, blk_expr)
+ ExprKind::InPlace(place, blk_expr)
}
token::Ident(..) if self.token.is_keyword(keywords::Box) => {
self.bump();
let e = self.parse_prefix_expr(None);
let (span, e) = try!(self.interpolated_or_expr_span(e));
hi = span.hi;
- ExprBox(e)
+ ExprKind::Box(e)
}
_ => return self.parse_dot_or_call_expr(Some(attrs))
};
if op == AssocOp::As {
let rhs = try!(self.parse_ty());
lhs = self.mk_expr(lhs_span.lo, rhs.span.hi,
- ExprCast(lhs, rhs), None);
+ ExprKind::Cast(lhs, rhs), None);
continue
} else if op == AssocOp::Colon {
let rhs = try!(self.parse_ty());
lhs = self.mk_expr(lhs_span.lo, rhs.span.hi,
- ExprType(lhs, rhs), None);
+ ExprKind::Type(lhs, rhs), None);
continue
} else if op == AssocOp::DotDot {
// If we didn’t have to handle `x..`, it would be pretty easy to generalise
self.mk_expr(lhs_span.lo, rhs_span.hi, binary, None)
}
AssocOp::Assign =>
- self.mk_expr(lhs_span.lo, rhs.span.hi, ExprAssign(lhs, rhs), None),
+ self.mk_expr(lhs_span.lo, rhs.span.hi, ExprKind::Assign(lhs, rhs), None),
AssocOp::Inplace =>
- self.mk_expr(lhs_span.lo, rhs.span.hi, ExprInPlace(lhs, rhs), None),
+ self.mk_expr(lhs_span.lo, rhs.span.hi, ExprKind::InPlace(lhs, rhs), None),
AssocOp::AssignOp(k) => {
let aop = match k {
- token::Plus => BiAdd,
- token::Minus => BiSub,
- token::Star => BiMul,
- token::Slash => BiDiv,
- token::Percent => BiRem,
- token::Caret => BiBitXor,
- token::And => BiBitAnd,
- token::Or => BiBitOr,
- token::Shl => BiShl,
- token::Shr => BiShr
+ token::Plus => BinOpKind::Add,
+ token::Minus => BinOpKind::Sub,
+ token::Star => BinOpKind::Mul,
+ token::Slash => BinOpKind::Div,
+ token::Percent => BinOpKind::Rem,
+ token::Caret => BinOpKind::BitXor,
+ token::And => BinOpKind::BitAnd,
+ token::Or => BinOpKind::BitOr,
+ token::Shl => BinOpKind::Shl,
+ token::Shr => BinOpKind::Shr,
};
let (lhs_span, rhs_span) = (lhs_span, rhs.span);
let aopexpr = self.mk_assign_op(codemap::respan(cur_op_span, aop), lhs, rhs);
fn check_no_chained_comparison(&mut self, lhs: &Expr, outer_op: &AssocOp) {
debug_assert!(outer_op.is_comparison());
match lhs.node {
- ExprBinary(op, _, _) if op.node.is_comparison() => {
+ ExprKind::Binary(op, _, _) if op.node.is_comparison() => {
// respan to include both operators
let op_span = mk_sp(op.span.lo, self.span.hi);
let mut err = self.diagnostic().struct_span_err(op_span,
"chained comparison operators require parentheses");
- if op.node == BiLt && *outer_op == AssocOp::Greater {
+ if op.node == BinOpKind::Lt && *outer_op == AssocOp::Greater {
err.fileline_help(op_span,
"use `::<...>` instead of `<...>` if you meant to specify type arguments");
}
hi = elexpr.span.hi;
els = Some(elexpr);
}
- Ok(self.mk_expr(lo, hi, ExprIf(cond, thn, els), attrs))
+ Ok(self.mk_expr(lo, hi, ExprKind::If(cond, thn, els), attrs))
}
/// Parse an 'if let' expression ('if' token already eaten)
} else {
(thn.span.hi, None)
};
- Ok(self.mk_expr(lo, hi, ExprIfLet(pat, expr, thn, els), attrs))
+ Ok(self.mk_expr(lo, hi, ExprKind::IfLet(pat, expr, thn, els), attrs))
}
// `|args| expr`
pub fn parse_lambda_expr(&mut self, lo: BytePos,
- capture_clause: CaptureClause,
+ capture_clause: CaptureBy,
attrs: ThinAttributes)
-> PResult<'a, P<Expr>>
{
let decl = try!(self.parse_fn_block_decl());
let body = match decl.output {
- DefaultReturn(_) => {
+ FunctionRetTy::Default(_) => {
// If no explicit return type is given, parse any
// expr and wrap it up in a dummy block:
let body_expr = try!(self.parse_expr());
stmts: vec![],
span: body_expr.span,
expr: Some(body_expr),
- rules: DefaultBlock,
+ rules: BlockCheckMode::Default,
})
}
_ => {
Ok(self.mk_expr(
lo,
body.span.hi,
- ExprClosure(capture_clause, decl, body), attrs))
+ ExprKind::Closure(capture_clause, decl, body), attrs))
}
// `else` token already eaten
return self.parse_if_expr(None);
} else {
let blk = try!(self.parse_block());
- return Ok(self.mk_expr(blk.span.lo, blk.span.hi, ExprBlock(blk), None));
+ return Ok(self.mk_expr(blk.span.lo, blk.span.hi, ExprKind::Block(blk), None));
}
}
let hi = self.last_span.hi;
Ok(self.mk_expr(span_lo, hi,
- ExprForLoop(pat, expr, loop_block, opt_ident),
+ ExprKind::ForLoop(pat, expr, loop_block, opt_ident),
attrs))
}
let (iattrs, body) = try!(self.parse_inner_attrs_and_block());
let attrs = attrs.append(iattrs.into_thin_attrs());
let hi = body.span.hi;
- return Ok(self.mk_expr(span_lo, hi, ExprWhile(cond, body, opt_ident),
+ return Ok(self.mk_expr(span_lo, hi, ExprKind::While(cond, body, opt_ident),
attrs));
}
let (iattrs, body) = try!(self.parse_inner_attrs_and_block());
let attrs = attrs.append(iattrs.into_thin_attrs());
let hi = body.span.hi;
- return Ok(self.mk_expr(span_lo, hi, ExprWhileLet(pat, expr, body, opt_ident), attrs));
+ return Ok(self.mk_expr(span_lo, hi, ExprKind::WhileLet(pat, expr, body, opt_ident), attrs));
}
// parse `loop {...}`, `loop` token already eaten
let (iattrs, body) = try!(self.parse_inner_attrs_and_block());
let attrs = attrs.append(iattrs.into_thin_attrs());
let hi = body.span.hi;
- Ok(self.mk_expr(span_lo, hi, ExprLoop(body, opt_ident), attrs))
+ Ok(self.mk_expr(span_lo, hi, ExprKind::Loop(body, opt_ident), attrs))
}
// `match` token already eaten
}
let hi = self.span.hi;
self.bump();
- return Ok(self.mk_expr(lo, hi, ExprMatch(discriminant, arms), attrs));
+ return Ok(self.mk_expr(lo, hi, ExprKind::Match(discriminant, arms), attrs));
}
pub fn parse_arm(&mut self) -> PResult<'a, Arm> {
hi = self.last_span.hi;
let bind_type = match (is_ref, is_mut) {
- (true, true) => BindingMode::ByRef(MutMutable),
- (true, false) => BindingMode::ByRef(MutImmutable),
- (false, true) => BindingMode::ByValue(MutMutable),
- (false, false) => BindingMode::ByValue(MutImmutable),
+ (true, true) => BindingMode::ByRef(Mutability::Mutable),
+ (true, false) => BindingMode::ByRef(Mutability::Immutable),
+ (false, true) => BindingMode::ByValue(Mutability::Mutable),
+ (false, false) => BindingMode::ByValue(Mutability::Immutable),
};
let fieldpath = codemap::Spanned{span:self.last_span, node:fieldname};
let fieldpat = P(ast::Pat{
(None, try!(self.parse_path(LifetimeAndTypesWithColons)))
};
let hi = self.last_span.hi;
- Ok(self.mk_expr(lo, hi, ExprPath(qself, path), None))
+ Ok(self.mk_expr(lo, hi, ExprKind::Path(qself, path), None))
} else {
self.parse_pat_literal_maybe_minus()
}
// At this point, token != _, &, &&, (, [
if self.eat_keyword(keywords::Mut) {
// Parse mut ident @ pat
- pat = try!(self.parse_pat_ident(BindingMode::ByValue(MutMutable)));
+ pat = try!(self.parse_pat_ident(BindingMode::ByValue(Mutability::Mutable)));
} else if self.eat_keyword(keywords::Ref) {
// Parse ref ident @ pat / ref mut ident @ pat
let mutbl = try!(self.parse_mutability());
// Parse ident @ pat
// This can give false positives and parse nullary enums,
// they are dealt with later in resolve
- pat = try!(self.parse_pat_ident(BindingMode::ByValue(MutImmutable)));
+ let binding_mode = BindingMode::ByValue(Mutability::Immutable);
+ pat = try!(self.parse_pat_ident(binding_mode));
}
} else {
let (qself, path) = if self.eat_lt() {
token::DotDotDot => {
// Parse range
let hi = self.last_span.hi;
- let begin = self.mk_expr(lo, hi, ExprPath(qself, path), None);
+ let begin = self.mk_expr(lo, hi, ExprKind::Path(qself, path), None);
self.bump();
let end = try!(self.parse_pat_range_end());
pat = PatRange(begin, end);
fn parse_let(&mut self, attrs: ThinAttributes) -> PResult<'a, P<Decl>> {
let lo = self.span.lo;
let local = try!(self.parse_local(attrs));
- Ok(P(spanned(lo, self.last_span.hi, DeclLocal(local))))
+ Ok(P(spanned(lo, self.last_span.hi, DeclKind::Local(local))))
}
/// Parse a structure field
fn parse_name_and_ty(&mut self, pr: Visibility,
attrs: Vec<Attribute> ) -> PResult<'a, StructField> {
let lo = match pr {
- Inherited => self.span.lo,
- Public => self.last_span.lo,
+ Visibility::Inherited => self.span.lo,
+ Visibility::Public => self.last_span.lo,
};
if !self.token.is_plain_ident() {
return Err(self.fatal("expected ident"));
try!(self.expect_keyword(keywords::Let));
let decl = try!(self.parse_let(attrs.into_thin_attrs()));
let hi = decl.span.hi;
- let stmt = StmtDecl(decl, ast::DUMMY_NODE_ID);
+ let stmt = StmtKind::Decl(decl, ast::DUMMY_NODE_ID);
spanned(lo, hi, stmt)
} else if self.token.is_ident()
&& !self.token.is_any_keyword()
let hi = self.last_span.hi;
let style = if delim == token::Brace {
- MacStmtWithBraces
+ MacStmtStyle::Braces
} else {
- MacStmtWithoutBraces
+ MacStmtStyle::NoBraces
};
if id.name == token::special_idents::invalid.name {
- let stmt = StmtMac(P(spanned(lo,
- hi,
- Mac_ { path: pth, tts: tts, ctxt: EMPTY_CTXT })),
- style,
- attrs.into_thin_attrs());
+ let mac = P(spanned(lo, hi, Mac_ { path: pth, tts: tts, ctxt: EMPTY_CTXT }));
+ let stmt = StmtKind::Mac(mac, style, attrs.into_thin_attrs());
spanned(lo, hi, stmt)
} else {
// if it has a special ident, it's definitely an item
//
// Require a semicolon or braces.
- if style != MacStmtWithBraces {
+ if style != MacStmtStyle::Braces {
if !self.eat(&token::Semi) {
let last_span = self.last_span;
self.span_err(last_span,
followed by a semicolon");
}
}
- spanned(lo, hi, StmtDecl(
- P(spanned(lo, hi, DeclItem(
+ spanned(lo, hi, StmtKind::Decl(
+ P(spanned(lo, hi, DeclKind::Item(
self.mk_item(
lo, hi, id /*id is good here*/,
- ItemMac(spanned(lo, hi,
+ ItemKind::Mac(spanned(lo, hi,
Mac_ { path: pth, tts: tts, ctxt: EMPTY_CTXT })),
- Inherited, attrs)))),
+ Visibility::Inherited, attrs)))),
ast::DUMMY_NODE_ID))
}
} else {
match try!(self.parse_item_(attrs.clone(), false, true)) {
Some(i) => {
let hi = i.span.hi;
- let decl = P(spanned(lo, hi, DeclItem(i)));
- spanned(lo, hi, StmtDecl(decl, ast::DUMMY_NODE_ID))
+ let decl = P(spanned(lo, hi, DeclKind::Item(i)));
+ spanned(lo, hi, StmtKind::Decl(decl, ast::DUMMY_NODE_ID))
}
None => {
let unused_attrs = |attrs: &[_], s: &mut Self| {
let e = try!(self.parse_expr_res(
Restrictions::RESTRICTION_STMT_EXPR, Some(attrs.into_thin_attrs())));
let hi = e.span.hi;
- let stmt = StmtExpr(e, ast::DUMMY_NODE_ID);
+ let stmt = StmtKind::Expr(e, ast::DUMMY_NODE_ID);
spanned(lo, hi, stmt)
}
}
"place this code inside a block"));
}
- self.parse_block_tail(lo, DefaultBlock)
+ self.parse_block_tail(lo, BlockCheckMode::Default)
}
/// Parse a block. Inner attrs are allowed.
let lo = self.span.lo;
try!(self.expect(&token::OpenDelim(token::Brace)));
Ok((try!(self.parse_inner_attributes()),
- try!(self.parse_block_tail(lo, DefaultBlock))))
+ try!(self.parse_block_tail(lo, BlockCheckMode::Default))))
}
/// Parse the rest of a block expression or function body
continue;
};
match node {
- StmtExpr(e, _) => {
+ StmtKind::Expr(e, _) => {
try!(self.handle_expression_like_statement(e, span, &mut stmts, &mut expr));
}
- StmtMac(mac, MacStmtWithoutBraces, attrs) => {
+ StmtKind::Mac(mac, MacStmtStyle::NoBraces, attrs) => {
// statement macro without braces; might be an
// expr depending on whether a semicolon follows
match self.token {
token::Semi => {
stmts.push(P(Spanned {
- node: StmtMac(mac, MacStmtWithSemicolon, attrs),
+ node: StmtKind::Mac(mac, MacStmtStyle::Semicolon, attrs),
span: mk_sp(span.lo, self.span.hi),
}));
self.bump();
}
}
}
- StmtMac(m, style, attrs) => {
+ StmtKind::Mac(m, style, attrs) => {
// statement macro; might be an expr
match self.token {
token::Semi => {
stmts.push(P(Spanned {
- node: StmtMac(m, MacStmtWithSemicolon, attrs),
+ node: StmtKind::Mac(m, MacStmtStyle::Semicolon, attrs),
span: mk_sp(span.lo, self.span.hi),
}));
self.bump();
}
_ => {
stmts.push(P(Spanned {
- node: StmtMac(m, style, attrs),
+ node: StmtKind::Mac(m, style, attrs),
span: span
}));
}
expn_id: span.expn_id,
};
stmts.push(P(Spanned {
- node: StmtSemi(e, ast::DUMMY_NODE_ID),
+ node: StmtKind::Semi(e, ast::DUMMY_NODE_ID),
span: span_with_semi,
}));
}
token::CloseDelim(token::Brace) => *last_block_expr = Some(e),
_ => {
stmts.push(P(Spanned {
- node: StmtExpr(e, ast::DUMMY_NODE_ID),
+ node: StmtKind::Expr(e, ast::DUMMY_NODE_ID),
span: span
}));
}
F: FnMut(&mut Parser<'a>) -> PResult<'a, Arg>,
{
fn maybe_parse_borrowed_explicit_self<'b>(this: &mut Parser<'b>)
- -> PResult<'b, ast::ExplicitSelf_> {
+ -> PResult<'b, ast::SelfKind> {
// The following things are possible to see here:
//
// fn(&mut self)
if this.look_ahead(1, |t| t.is_keyword(keywords::SelfValue)) {
this.bump();
- Ok(SelfRegion(None, MutImmutable, try!(this.expect_self_ident())))
+ Ok(SelfKind::Region(None, Mutability::Immutable, try!(this.expect_self_ident())))
} else if this.look_ahead(1, |t| t.is_mutability()) &&
this.look_ahead(2, |t| t.is_keyword(keywords::SelfValue)) {
this.bump();
let mutability = try!(this.parse_mutability());
- Ok(SelfRegion(None, mutability, try!(this.expect_self_ident())))
+ Ok(SelfKind::Region(None, mutability, try!(this.expect_self_ident())))
} else if this.look_ahead(1, |t| t.is_lifetime()) &&
this.look_ahead(2, |t| t.is_keyword(keywords::SelfValue)) {
this.bump();
let lifetime = try!(this.parse_lifetime());
- Ok(SelfRegion(Some(lifetime), MutImmutable, try!(this.expect_self_ident())))
+ let ident = try!(this.expect_self_ident());
+ Ok(SelfKind::Region(Some(lifetime), Mutability::Immutable, ident))
} else if this.look_ahead(1, |t| t.is_lifetime()) &&
this.look_ahead(2, |t| t.is_mutability()) &&
this.look_ahead(3, |t| t.is_keyword(keywords::SelfValue)) {
this.bump();
let lifetime = try!(this.parse_lifetime());
let mutability = try!(this.parse_mutability());
- Ok(SelfRegion(Some(lifetime), mutability, try!(this.expect_self_ident())))
+ Ok(SelfKind::Region(Some(lifetime), mutability, try!(this.expect_self_ident())))
} else {
- Ok(SelfStatic)
+ Ok(SelfKind::Static)
}
}
let mut self_ident_lo = self.span.lo;
let mut self_ident_hi = self.span.hi;
- let mut mutbl_self = MutImmutable;
+ let mut mutbl_self = Mutability::Immutable;
let explicit_self = match self.token {
token::BinOp(token::And) => {
let eself = try!(maybe_parse_borrowed_explicit_self(self));
let _mutability = if self.token.is_mutability() {
try!(self.parse_mutability())
} else {
- MutImmutable
+ Mutability::Immutable
};
if self.is_self_ident() {
let span = self.span;
self.bump();
}
// error case, making bogus self ident:
- SelfValue(special_idents::self_)
+ SelfKind::Value(special_idents::self_)
}
token::Ident(..) => {
if self.is_self_ident() {
// Determine whether this is the fully explicit form, `self:
// TYPE`.
if self.eat(&token::Colon) {
- SelfExplicit(try!(self.parse_ty_sum()), self_ident)
+ SelfKind::Explicit(try!(self.parse_ty_sum()), self_ident)
} else {
- SelfValue(self_ident)
+ SelfKind::Value(self_ident)
}
} else if self.token.is_mutability() &&
self.look_ahead(1, |t| t.is_keyword(keywords::SelfValue)) {
// Determine whether this is the fully explicit form,
// `self: TYPE`.
if self.eat(&token::Colon) {
- SelfExplicit(try!(self.parse_ty_sum()), self_ident)
+ SelfKind::Explicit(try!(self.parse_ty_sum()), self_ident)
} else {
- SelfValue(self_ident)
+ SelfKind::Value(self_ident)
}
} else {
- SelfStatic
+ SelfKind::Static
}
}
- _ => SelfStatic,
+ _ => SelfKind::Static,
};
let explicit_self_sp = mk_sp(self_ident_lo, self_ident_hi);
}
let fn_inputs = match explicit_self {
- SelfStatic => {
+ SelfKind::Static => {
let sep = seq_sep_trailing_allowed(token::Comma);
try!(self.parse_seq_to_before_end(&token::CloseDelim(token::Paren),
sep, parse_arg_fn))
}
- SelfValue(id) => parse_remaining_arguments!(id),
- SelfRegion(_,_,id) => parse_remaining_arguments!(id),
- SelfExplicit(_,id) => parse_remaining_arguments!(id),
+ SelfKind::Value(id) => parse_remaining_arguments!(id),
+ SelfKind::Region(_,_,id) => parse_remaining_arguments!(id),
+ SelfKind::Explicit(_,id) => parse_remaining_arguments!(id),
};
}
fn mk_item(&mut self, lo: BytePos, hi: BytePos, ident: Ident,
- node: Item_, vis: Visibility,
+ node: ItemKind, vis: Visibility,
attrs: Vec<Attribute>) -> P<Item> {
P(Item {
ident: ident,
let decl = try!(self.parse_fn_decl(false));
generics.where_clause = try!(self.parse_where_clause());
let (inner_attrs, body) = try!(self.parse_inner_attrs_and_block());
- Ok((ident, ItemFn(decl, unsafety, constness, abi, generics, body), Some(inner_attrs)))
+ Ok((ident, ItemKind::Fn(decl, unsafety, constness, abi, generics, body), Some(inner_attrs)))
}
/// true if we are looking at `const ID`, false for things like `const fn` etc
let is_const_fn = self.eat_keyword(keywords::Const);
let unsafety = try!(self.parse_unsafety());
let (constness, unsafety, abi) = if is_const_fn {
- (Constness::Const, unsafety, abi::Rust)
+ (Constness::Const, unsafety, Abi::Rust)
} else {
let abi = if self.eat_keyword(keywords::Extern) {
- try!(self.parse_opt_abi()).unwrap_or(abi::C)
+ try!(self.parse_opt_abi()).unwrap_or(Abi::C)
} else {
- abi::Rust
+ Abi::Rust
};
(Constness::NotConst, unsafety, abi)
};
fn complain_if_pub_macro(&mut self, visa: Visibility, span: Span) {
match visa {
- Public => {
+ Visibility::Public => {
let is_macro_rules: bool = match self.token {
token::Ident(sid, _) => sid.name == intern("macro_rules"),
_ => false,
.emit();
}
}
- Inherited => (),
+ Visibility::Inherited => (),
}
}
tps.where_clause = try!(self.parse_where_clause());
let meths = try!(self.parse_trait_items());
- Ok((ident, ItemTrait(unsafety, tps, bounds, meths), None))
+ Ok((ident, ItemKind::Trait(unsafety, tps, bounds, meths), None))
}
/// Parses items implementations variants
let opt_trait = if could_be_trait && self.eat_keyword(keywords::For) {
// New-style trait. Reinterpret the type as a trait.
match ty.node {
- TyPath(None, ref path) => {
+ TyKind::Path(None, ref path) => {
Some(TraitRef {
path: (*path).clone(),
ref_id: ty.id,
try!(self.expect(&token::OpenDelim(token::Brace)));
try!(self.expect(&token::CloseDelim(token::Brace)));
Ok((ast_util::impl_pretty_name(&opt_trait, None),
- ItemDefaultImpl(unsafety, opt_trait.unwrap()), None))
+ ItemKind::DefaultImpl(unsafety, opt_trait.unwrap()), None))
} else {
if opt_trait.is_some() {
ty = try!(self.parse_ty_sum());
}
Ok((ast_util::impl_pretty_name(&opt_trait, Some(&*ty)),
- ItemImpl(unsafety, polarity, generics, opt_trait, ty, impl_items),
+ ItemKind::Impl(unsafety, polarity, generics, opt_trait, ty, impl_items),
Some(attrs)))
}
}
name, found `{}`", token_str)))
};
- Ok((class_name, ItemStruct(vdata, generics), None))
+ Ok((class_name, ItemKind::Struct(vdata, generics), None))
}
pub fn parse_record_struct_body(&mut self,
if parse_pub == ParsePub::Yes {
try!(p.parse_visibility())
} else {
- Inherited
+ Visibility::Inherited
}
),
id: ast::DUMMY_NODE_ID,
let span = self.last_span;
self.span_err(span, "`pub` is not allowed here");
}
- return self.parse_single_struct_field(Public, attrs);
+ return self.parse_single_struct_field(Visibility::Public, attrs);
}
- return self.parse_single_struct_field(Inherited, attrs);
+ return self.parse_single_struct_field(Visibility::Inherited, attrs);
}
/// Parse visibility: PUB or nothing
fn parse_visibility(&mut self) -> PResult<'a, Visibility> {
- if self.eat_keyword(keywords::Pub) { Ok(Public) }
- else { Ok(Inherited) }
+ if self.eat_keyword(keywords::Pub) { Ok(Visibility::Public) }
+ else { Ok(Visibility::Inherited) }
}
/// Given a termination token, parse all of the items in a module
let e = try!(self.parse_expr());
try!(self.commit_expr_expecting(&*e, token::Semi));
let item = match m {
- Some(m) => ItemStatic(ty, m, e),
- None => ItemConst(ty, e),
+ Some(m) => ItemKind::Static(ty, m, e),
+ None => ItemKind::Const(ty, e),
};
Ok((id, item, None))
}
let m = try!(self.parse_mod_items(&token::CloseDelim(token::Brace), mod_inner_lo));
self.owns_directory = old_owns_directory;
self.pop_mod_path();
- Ok((id, ItemMod(m), Some(attrs)))
+ Ok((id, ItemKind::Mod(m), Some(attrs)))
}
}
id: ast::Ident,
outer_attrs: &[ast::Attribute],
id_sp: Span)
- -> PResult<'a, (ast::Item
_, Vec<ast::Attribute> )> {
+ -> PResult<'a, (ast::Item
Kind, Vec<ast::Attribute> )> {
let ModulePathSuccess { path, owns_directory } = try!(self.submod_path(id,
outer_attrs,
id_sp));
path: PathBuf,
owns_directory: bool,
name: String,
- id_sp: Span) -> PResult<'a, (ast::Item
_, Vec<ast::Attribute> )> {
+ id_sp: Span) -> PResult<'a, (ast::Item
Kind, Vec<ast::Attribute> )> {
let mut included_mod_stack = self.sess.included_mod_stack.borrow_mut();
match included_mod_stack.iter().position(|p| *p == path) {
Some(i) => {
let mod_attrs = try!(p0.parse_inner_attributes());
let m0 = try!(p0.parse_mod_items(&token::Eof, mod_inner_lo));
self.sess.included_mod_stack.borrow_mut().pop();
- Ok((ast::ItemMod(m0), mod_attrs))
+ Ok((ast::ItemKind::Mod(m0), mod_attrs))
}
/// Parse a function declaration from a foreign module
Ok(P(ast::ForeignItem {
ident: ident,
attrs: attrs,
- node: ForeignItemFn(decl, generics),
+ node: ForeignItemKind::Fn(decl, generics),
id: ast::DUMMY_NODE_ID,
span: mk_sp(lo, hi),
vis: vis
Ok(P(ForeignItem {
ident: ident,
attrs: attrs,
- node: ForeignItemStatic(ty, mutbl),
+ node: ForeignItemKind::Static(ty, mutbl),
id: ast::DUMMY_NODE_ID,
span: mk_sp(lo, hi),
vis: vis
let last_span = self.last_span;
- if visibility == ast::Public {
+ if visibility == ast::Visibility::Public {
self.span_warn(mk_sp(lo, last_span.hi),
"`pub extern crate` does not work as expected and should not be used. \
Likely to become an error. Prefer `extern crate` and `pub use`.");
Ok(self.mk_item(lo,
last_span.hi,
ident,
- ItemExternCrate(maybe_path),
+ ItemKind::ExternCrate(maybe_path),
visibility,
attrs))
}
-> PResult<'a, P<Item>> {
try!(self.expect(&token::OpenDelim(token::Brace)));
- let abi = opt_abi.unwrap_or(abi::C);
+ let abi = opt_abi.unwrap_or(Abi::C);
attrs.extend(try!(self.parse_inner_attributes()));
Ok(self.mk_item(lo,
last_span.hi,
special_idents::invalid,
- ItemForeignMod(m),
+ ItemKind::ForeignMod(m),
visibility,
attrs))
}
try!(self.expect(&token::Eq));
let ty = try!(self.parse_ty_sum());
try!(self.expect(&token::Semi));
- Ok((ident, ItemTy(ty, tps), None))
+ Ok((ident, ItemKind::Ty(ty, tps), None))
}
/// Parse the part of an "enum" decl following the '{'
try!(self.expect(&token::OpenDelim(token::Brace)));
let enum_definition = try!(self.parse_enum_def(&generics));
- Ok((id, ItemEnum(enum_definition, generics), None))
+ Ok((id, ItemKind::Enum(enum_definition, generics), None))
}
/// Parses a string as an ABI spec on an extern type or module. Consumes
if self.eat_keyword(keywords::Use) {
// USE ITEM
- let item_ = ItemUse(try!(self.parse_view_path()));
+ let item_ = ItemKind::Use(try!(self.parse_view_path()));
try!(self.expect(&token::Semi));
let last_span = self.last_span;
if self.eat_keyword(keywords::Fn) {
// EXTERN FUNCTION ITEM
- let abi = opt_abi.unwrap_or(abi::C);
+ let abi = opt_abi.unwrap_or(Abi::C);
let (ident, item_, extra_attrs) =
try!(self.parse_item_fn(Unsafety::Normal, Constness::NotConst, abi));
let last_span = self.last_span;
if self.eat_keyword(keywords::Static) {
// STATIC ITEM
- let m = if self.eat_keyword(keywords::Mut) {MutMutable} else {MutImmutable};
+ let m = if self.eat_keyword(keywords::Mut) {
+ Mutability::Mutable
+ } else {
+ Mutability::Immutable
+ };
let (ident, item_, extra_attrs) = try!(self.parse_item_const(Some(m)));
let last_span = self.last_span;
let item = self.mk_item(lo,
};
self.bump();
let (ident, item_, extra_attrs) =
- try!(self.parse_item_fn(unsafety, Constness::Const, abi::Rust));
+ try!(self.parse_item_fn(unsafety, Constness::Const, Abi::Rust));
let last_span = self.last_span;
let item = self.mk_item(lo,
last_span.hi,
// FUNCTION ITEM
self.bump();
let (ident, item_, extra_attrs) =
- try!(self.parse_item_fn(Unsafety::Normal, Constness::NotConst, abi::Rust));
+ try!(self.parse_item_fn(Unsafety::Normal, Constness::NotConst, Abi::Rust));
let last_span = self.last_span;
let item = self.mk_item(lo,
last_span.hi,
// UNSAFE FUNCTION ITEM
self.bump();
let abi = if self.eat_keyword(keywords::Extern) {
- try!(self.parse_opt_abi()).unwrap_or(abi::C)
+ try!(self.parse_opt_abi()).unwrap_or(Abi::C)
} else {
- abi::Rust
+ Abi::Rust
};
try!(self.expect_keyword(keywords::Fn));
let (ident, item_, extra_attrs) =
}
}
- let item_ = ItemMac(m);
+ let item_ = ItemKind::Mac(m);
let last_span = self.last_span;
let item = self.mk_item(lo,
last_span.hi,
// FAILURE TO PARSE ITEM
match visibility {
- Inherited => {}
- Public => {
+ Visibility::Inherited => {}
+ Visibility::Public => {
let last_span = self.last_span;
return Err(self.span_fatal(last_span, "unmatched visibility `pub`"));
}
Option<ast::Name>)> {
let ret = match self.token {
token::Literal(token::Str_(s), suf) => {
- (self.id_to_interned_str(ast::Ident::with_empty_ctxt(s)), ast::CookedStr, suf)
+ let s = self.id_to_interned_str(ast::Ident::with_empty_ctxt(s));
+ (s, ast::StrStyle::Cooked, suf)
}
token::Literal(token::StrRaw(s, n), suf) => {
- (self.id_to_interned_str(ast::Ident::with_empty_ctxt(s)), ast::RawStr(n), suf)
+ let s = self.id_to_interned_str(ast::Ident::with_empty_ctxt(s));
+ (s, ast::StrStyle::Raw(n), suf)
}
_ => return None
};
pub use self::Lit::*;
pub use self::Token::*;
-use ast;
+use ast::{self, BinOpKind};
use ext::mtwt;
use ptr::P;
use util::interner::{RcStr, StrInterner};
}
/// Maps a token to its corresponding binary operator.
- pub fn to_binop(&self) -> Option<ast::BinOp_> {
+ pub fn to_binop(&self) -> Option<BinOpKind> {
match *self {
- BinOp(Star) => Some(ast::BiMul),
- BinOp(Slash) => Some(ast::BiDiv),
- BinOp(Percent) => Some(ast::BiRem),
- BinOp(Plus) => Some(ast::BiAdd),
- BinOp(Minus) => Some(ast::BiSub),
- BinOp(Shl) => Some(ast::BiShl),
- BinOp(Shr) => Some(ast::BiShr),
- BinOp(And) => Some(ast::BiBitAnd),
- BinOp(Caret) => Some(ast::BiBitXor),
- BinOp(Or) => Some(ast::BiBitOr),
- Lt => Some(ast::BiLt),
- Le => Some(ast::BiLe),
- Ge => Some(ast::BiGe),
- Gt => Some(ast::BiGt),
- EqEq => Some(ast::BiEq),
- Ne => Some(ast::BiNe),
- AndAnd => Some(ast::BiAnd),
- OrOr => Some(ast::BiOr),
+ BinOp(Star) => Some(BinOpKind::Mul),
+ BinOp(Slash) => Some(BinOpKind::Div),
+ BinOp(Percent) => Some(BinOpKind::Rem),
+ BinOp(Plus) => Some(BinOpKind::Add),
+ BinOp(Minus) => Some(BinOpKind::Sub),
+ BinOp(Shl) => Some(BinOpKind::Shl),
+ BinOp(Shr) => Some(BinOpKind::Shr),
+ BinOp(And) => Some(BinOpKind::BitAnd),
+ BinOp(Caret) => Some(BinOpKind::BitXor),
+ BinOp(Or) => Some(BinOpKind::BitOr),
+ Lt => Some(BinOpKind::Lt),
+ Le => Some(BinOpKind::Le),
+ Ge => Some(BinOpKind::Ge),
+ Gt => Some(BinOpKind::Gt),
+ EqEq => Some(BinOpKind::Eq),
+ Ne => Some(BinOpKind::Ne),
+ AndAnd => Some(BinOpKind::And),
+ OrOr => Some(BinOpKind::Or),
_ => None,
}
}
pub use self::AnnNode::*;
-use abi;
-use ast::{self, TokenTree};
+use abi::{self, Abi};
+use ast::{self, TokenTree, BlockCheckMode};
use ast::{RegionTyParamBound, TraitTyParamBound, TraitBoundModifier};
use ast::Attribute;
use attr::ThinAttributesExt;
unsafety: ast::Unsafety,
constness: ast::Constness,
name: ast::Ident,
- opt_explicit_self: Option<&ast::ExplicitSelf_>,
+ opt_explicit_self: Option<&ast::SelfKind>,
generics: &ast::Generics)
-> String {
to_string(|s| {
try!(s.head(""));
- try!(s.print_fn(decl, unsafety, constness, abi::Rust, Some(name),
- generics, opt_explicit_self, ast::Inherited));
+ try!(s.print_fn(decl, unsafety, constness, Abi::Rust, Some(name),
+ generics, opt_explicit_self, ast::Visibility::Inherited));
try!(s.end()); // Close the head box
s.end() // Close the outer box
})
to_string(|s| s.print_literal(l))
}
-pub fn explicit_self_to_string(explicit_self: &ast::ExplicitSelf_) -> String {
- to_string(|s| s.print_explicit_self(explicit_self, ast::MutImmutable).map(|_| {}))
+pub fn explicit_self_to_string(explicit_self: &ast::SelfKind) -> String {
+ to_string(|s| s.print_explicit_self(explicit_self, ast::Mutability::Immutable).map(|_| {}))
}
pub fn variant_to_string(var: &ast::Variant) -> String {
pub fn visibility_qualified(vis: ast::Visibility, s: &str) -> String {
match vis {
- ast::Public => format!("pub {}", s),
- ast::Inherited => s.to_string()
+ ast::Visibility::Public => format!("pub {}", s),
+ ast::Visibility::Inherited => s.to_string()
}
}
fn needs_parentheses(expr: &ast::Expr) -> bool {
match expr.node {
- ast::ExprAssign(..) | ast::ExprBinary(..) |
- ast::ExprClosure(..) |
- ast::ExprAssignOp(..) | ast::ExprCast(..) |
- ast::ExprInPlace(..) | ast::ExprType(..) => true,
+ ast::ExprKind::Assign(..) | ast::ExprKind::Binary(..) |
+ ast::ExprKind::Closure(..) |
+ ast::ExprKind::AssignOp(..) | ast::ExprKind::Cast(..) |
+ ast::ExprKind::InPlace(..) | ast::ExprKind::Type(..) => true,
_ => false,
}
}
_ => ()
}
match lit.node {
- ast::LitStr(ref st, style) => self.print_string(&st, style),
- ast::LitByte(byte) => {
+ ast::LitKind::Str(ref st, style) => self.print_string(&st, style),
+ ast::LitKind::Byte(byte) => {
let mut res = String::from("b'");
res.extend(ascii::escape_default(byte).map(|c| c as char));
res.push('\'');
word(self.writer(), &res[..])
}
- ast::LitChar(ch) => {
+ ast::LitKind::Char(ch) => {
let mut res = String::from("'");
res.extend(ch.escape_default());
res.push('\'');
word(self.writer(), &res[..])
}
- ast::LitInt(i, t) => {
+ ast::LitKind::Int(i, t) => {
match t {
- ast::SignedIntLit(st, ast::Plus) => {
+ ast::LitIntType::Signed(st) => {
word(self.writer(),
&st.val_to_string(i as i64))
}
- ast::SignedIntLit(st, ast::Minus) => {
- let istr = st.val_to_string(-(i as i64));
- word(self.writer(),
- &format!("-{}", istr))
- }
- ast::UnsignedIntLit(ut) => {
+ ast::LitIntType::Unsigned(ut) => {
word(self.writer(), &ut.val_to_string(i))
}
- ast::UnsuffixedIntLit(ast::Plus) => {
+ ast::LitIntType::Unsuffixed => {
word(self.writer(), &format!("{}", i))
}
- ast::UnsuffixedIntLit(ast::Minus) => {
- word(self.writer(), &format!("-{}", i))
- }
}
}
- ast::LitFloat(ref f, t) => {
+ ast::LitKind::Float(ref f, t) => {
word(self.writer(),
&format!(
"{}{}",
&f,
t.ty_to_string()))
}
- ast::LitFloatUnsuffixed(ref f) => word(self.writer(), &f[..]),
- ast::LitBool(val) => {
+ ast::LitKind::FloatUnsuffixed(ref f) => word(self.writer(), &f[..]),
+ ast::LitKind::Bool(val) => {
if val { word(self.writer(), "true") } else { word(self.writer(), "false") }
}
- ast::LitByteStr(ref v) => {
+ ast::LitKind::ByteStr(ref v) => {
let mut escaped: String = String::new();
for &ch in v.iter() {
escaped.extend(ascii::escape_default(ch)
fn print_string(&mut self, st: &str,
style: ast::StrStyle) -> io::Result<()> {
let st = match style {
- ast::CookedStr => {
+ ast::StrStyle::Cooked => {
(format!("\"{}\"", st.escape_default()))
}
- ast::RawStr(n) => {
+ ast::StrStyle::Raw(n) => {
(format!("r{delim}\"{string}\"{delim}",
delim=repeat("#", n),
string=st))
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,
try!(self.maybe_print_comment(ty.span.lo));
try!(self.ibox(0));
match ty.node {
- ast::TyVec(ref ty) => {
+ ast::TyKind::Vec(ref ty) => {
try!(word(&mut self.s, "["));
try!(self.print_type(&**ty));
try!(word(&mut self.s, "]"));
}
- ast::TyPtr(ref mt) => {
+ ast::TyKind::Ptr(ref mt) => {
try!(word(&mut self.s, "*"));
match mt.mutbl {
- ast::MutMutable => try!(self.word_nbsp("mut")),
- ast::MutImmutable => try!(self.word_nbsp("const")),
+ ast::Mutability::Mutable => try!(self.word_nbsp("mut")),
+ ast::Mutability::Immutable => try!(self.word_nbsp("const")),
}
try!(self.print_type(&*mt.ty));
}
- ast::TyRptr(ref lifetime, ref mt) => {
+ ast::TyKind::Rptr(ref lifetime, ref mt) => {
try!(word(&mut self.s, "&"));
try!(self.print_opt_lifetime(lifetime));
try!(self.print_mt(mt));
}
- ast::TyTup(ref elts) => {
+ ast::TyKind::Tup(ref elts) => {
try!(self.popen());
try!(self.commasep(Inconsistent, &elts[..],
|s, ty| s.print_type(&**ty)));
}
try!(self.pclose());
}
- ast::TyParen(ref typ) => {
+ ast::TyKind::Paren(ref typ) => {
try!(self.popen());
try!(self.print_type(&**typ));
try!(self.pclose());
}
- ast::TyBareFn(ref f) => {
+ ast::TyKind::BareFn(ref f) => {
let generics = ast::Generics {
lifetimes: f.lifetimes.clone(),
ty_params: P::empty(),
&generics,
None));
}
- ast::TyPath(None, ref path) => {
+ ast::TyKind::Path(None, ref path) => {
try!(self.print_path(path, false, 0));
}
- ast::TyPath(Some(ref qself), ref path) => {
+ ast::TyKind::Path(Some(ref qself), ref path) => {
try!(self.print_qpath(path, qself, false))
}
- ast::TyObjectSum(ref ty, ref bounds) => {
+ ast::TyKind::ObjectSum(ref ty, ref bounds) => {
try!(self.print_type(&**ty));
try!(self.print_bounds("+", &bounds[..]));
}
- ast::TyPolyTraitRef(ref bounds) => {
+ ast::TyKind::PolyTraitRef(ref bounds) => {
try!(self.print_bounds("", &bounds[..]));
}
- ast::TyFixedLengthVec(ref ty, ref v) => {
+ ast::TyKind::FixedLengthVec(ref ty, ref v) => {
try!(word(&mut self.s, "["));
try!(self.print_type(&**ty));
try!(word(&mut self.s, "; "));
try!(self.print_expr(&**v));
try!(word(&mut self.s, "]"));
}
- ast::TyTypeof(ref e) => {
+ ast::TyKind::Typeof(ref e) => {
try!(word(&mut self.s, "typeof("));
try!(self.print_expr(&**e));
try!(word(&mut self.s, ")"));
}
- ast::TyInfer => {
+ ast::TyKind::Infer => {
try!(word(&mut self.s, "_"));
}
- ast::TyMac(ref m) => {
+ ast::TyKind::Mac(ref m) => {
try!(self.print_mac(m, token::Paren));
}
}
try!(self.maybe_print_comment(item.span.lo));
try!(self.print_outer_attributes(&item.attrs));
match item.node {
- ast::ForeignItemFn(ref decl, ref generics) => {
+ ast::ForeignItemKind::Fn(ref decl, ref generics) => {
try!(self.head(""));
try!(self.print_fn(decl, ast::Unsafety::Normal,
ast::Constness::NotConst,
- abi::Rust, Some(item.ident),
+ Abi::Rust, Some(item.ident),
generics, None, item.vis));
try!(self.end()); // end head-ibox
try!(word(&mut self.s, ";"));
self.end() // end the outer fn box
}
- ast::ForeignItemStatic(ref t, m) => {
+ ast::ForeignItemKind::Static(ref t, m) => {
try!(self.head(&visibility_qualified(item.vis,
"static")));
if m {
try!(self.print_outer_attributes(&item.attrs));
try!(self.ann.pre(self, NodeItem(item)));
match item.node {
- ast::ItemExternCrate(ref optional_path) => {
+ ast::ItemKind::ExternCrate(ref optional_path) => {
try!(self.head(&visibility_qualified(item.vis,
"extern crate")));
if let Some(p) = *optional_path {
let val = p.as_str();
if val.contains("-") {
- try!(self.print_string(&val, ast::CookedStr));
+ try!(self.print_string(&val, ast::StrStyle::Cooked));
} else {
try!(self.print_name(p));
}
try!(self.end()); // end inner head-block
try!(self.end()); // end outer head-block
}
- ast::ItemUse(ref vp) => {
+ ast::ItemKind::Use(ref vp) => {
try!(self.head(&visibility_qualified(item.vis,
"use")));
try!(self.print_view_path(&**vp));
try!(self.end()); // end inner head-block
try!(self.end()); // end outer head-block
}
- ast::ItemStatic(ref ty, m, ref expr) => {
+ ast::ItemKind::Static(ref ty, m, ref expr) => {
try!(self.head(&visibility_qualified(item.vis,
"static")));
- if m == ast::MutMutable {
+ if m == ast::Mutability::Mutable {
try!(self.word_space("mut"));
}
try!(self.print_ident(item.ident));
try!(word(&mut self.s, ";"));
try!(self.end()); // end the outer cbox
}
- ast::ItemConst(ref ty, ref expr) => {
+ ast::ItemKind::Const(ref ty, ref expr) => {
try!(self.head(&visibility_qualified(item.vis,
"const")));
try!(self.print_ident(item.ident));
try!(word(&mut self.s, ";"));
try!(self.end()); // end the outer cbox
}
- ast::ItemFn(ref decl, unsafety, constness, abi, ref typarams, ref body) => {
+ ast::ItemKind::Fn(ref decl, unsafety, constness, abi, ref typarams, ref body) => {
try!(self.head(""));
try!(self.print_fn(
decl,
try!(word(&mut self.s, " "));
try!(self.print_block_with_attrs(&**body, &item.attrs));
}
- ast::ItemMod(ref _mod) => {
+ ast::ItemKind::Mod(ref _mod) => {
try!(self.head(&visibility_qualified(item.vis,
"mod")));
try!(self.print_ident(item.ident));
try!(self.print_mod(_mod, &item.attrs));
try!(self.bclose(item.span));
}
- ast::ItemForeignMod(ref nmod) => {
+ ast::ItemKind::ForeignMod(ref nmod) => {
try!(self.head("extern"));
try!(self.word_nbsp(&nmod.abi.to_string()));
try!(self.bopen());
try!(self.print_foreign_mod(nmod, &item.attrs));
try!(self.bclose(item.span));
}
- ast::ItemTy(ref ty, ref params) => {
+ ast::ItemKind::Ty(ref ty, ref params) => {
try!(self.ibox(INDENT_UNIT));
try!(self.ibox(0));
try!(self.word_nbsp(&visibility_qualified(item.vis, "type")));
try!(word(&mut self.s, ";"));
try!(self.end()); // end the outer ibox
}
- ast::ItemEnum(ref enum_definition, ref params) => {
+ ast::ItemKind::Enum(ref enum_definition, ref params) => {
try!(self.print_enum_def(
enum_definition,
params,
item.vis
));
}
- ast::ItemStruct(ref struct_def, ref generics) => {
+ ast::ItemKind::Struct(ref struct_def, ref generics) => {
try!(self.head(&visibility_qualified(item.vis,"struct")));
try!(self.print_struct(&struct_def, generics, item.ident, item.span, true));
}
- ast::ItemDefaultImpl(unsafety, ref trait_ref) => {
+ ast::ItemKind::DefaultImpl(unsafety, ref trait_ref) => {
try!(self.head(""));
try!(self.print_visibility(item.vis));
try!(self.print_unsafety(unsafety));
try!(self.bopen());
try!(self.bclose(item.span));
}
- ast::ItemImpl(unsafety,
+ ast::ItemKind::Impl(unsafety,
polarity,
ref generics,
ref opt_trait,
}
try!(self.bclose(item.span));
}
- ast::ItemTrait(unsafety, ref generics, ref bounds, ref trait_items) => {
+ ast::ItemKind::Trait(unsafety, ref generics, ref bounds, ref trait_items) => {
try!(self.head(""));
try!(self.print_visibility(item.vis));
try!(self.print_unsafety(unsafety));
}
try!(self.bclose(item.span));
}
- ast::ItemMac(codemap::Spanned { ref node, .. }) => {
+ ast::ItemKind::Mac(codemap::Spanned { ref node, .. }) => {
try!(self.print_visibility(item.vis));
try!(self.print_path(&node.path, false, 0));
try!(word(&mut self.s, "! "));
pub fn print_visibility(&mut self, vis: ast::Visibility) -> io::Result<()> {
match vis {
- ast::Public => self.word_nbsp("pub"),
- ast::Inherited => Ok(())
+ ast::Visibility::Public => self.word_nbsp("pub"),
+ ast::Visibility::Inherited => Ok(())
}
}
None => {},
}
match seq.op {
- ast::ZeroOrMore => word(&mut self.s, "*"),
- ast::OneOrMore => word(&mut self.s, "+"),
+ ast::KleeneOp::ZeroOrMore => word(&mut self.s, "*"),
+ ast::KleeneOp::OneOrMore => word(&mut self.s, "+"),
}
}
}
try!(self.maybe_print_comment(ti.span.lo));
try!(self.print_outer_attributes(&ti.attrs));
match ti.node {
- ast::ConstTraitItem(ref ty, ref default) => {
+ ast::TraitItemKind::Const(ref ty, ref default) => {
try!(self.print_associated_const(ti.ident, &ty,
default.as_ref().map(|expr| &**expr),
- ast::Inherited));
+ ast::Visibility::Inherited));
}
- ast::MethodTraitItem(ref sig, ref body) => {
+ ast::TraitItemKind::Method(ref sig, ref body) => {
if body.is_some() {
try!(self.head(""));
}
- try!(self.print_method_sig(ti.ident, sig, ast::Inherited));
+ try!(self.print_method_sig(ti.ident, sig, ast::Visibility::Inherited));
if let Some(ref body) = *body {
try!(self.nbsp());
try!(self.print_block_with_attrs(body, &ti.attrs));
try!(word(&mut self.s, ";"));
}
}
- ast::TypeTraitItem(ref bounds, ref default) => {
+ ast::TraitItemKind::Type(ref bounds, ref default) => {
try!(self.print_associated_type(ti.ident, Some(bounds),
default.as_ref().map(|ty| &**ty)));
}
try!(self.print_associated_type(ii.ident, None, Some(ty)));
}
ast::ImplItemKind::Macro(codemap::Spanned { ref node, .. }) => {
- // code copied from ItemMac:
+ // code copied from ItemKind::Mac:
try!(self.print_path(&node.path, false, 0));
try!(word(&mut self.s, "! "));
try!(self.cbox(INDENT_UNIT));
pub fn print_stmt(&mut self, st: &ast::Stmt) -> io::Result<()> {
try!(self.maybe_print_comment(st.span.lo));
match st.node {
- ast::StmtDecl(ref decl, _) => {
+ ast::StmtKind::Decl(ref decl, _) => {
try!(self.print_decl(&**decl));
}
- ast::StmtExpr(ref expr, _) => {
+ ast::StmtKind::Expr(ref expr, _) => {
try!(self.space_if_not_bol());
try!(self.print_expr_outer_attr_style(&**expr, false));
}
- ast::StmtSemi(ref expr, _) => {
+ ast::StmtKind::Semi(ref expr, _) => {
try!(self.space_if_not_bol());
try!(self.print_expr_outer_attr_style(&**expr, false));
try!(word(&mut self.s, ";"));
}
- ast::StmtMac(ref mac, style, ref attrs) => {
+ ast::StmtKind::Mac(ref mac, style, ref attrs) => {
try!(self.space_if_not_bol());
try!(self.print_outer_attributes(attrs.as_attr_slice()));
let delim = match style {
- ast::MacStmtWithBraces => token::Brace,
+ ast::MacStmtStyle::Braces => token::Brace,
_ => token::Paren
};
try!(self.print_mac(&**mac, delim));
match style {
- ast::MacStmtWithBraces => {}
+ ast::MacStmtStyle::Braces => {}
_ => try!(word(&mut self.s, ";")),
}
}
attrs: &[ast::Attribute],
close_box: bool) -> io::Result<()> {
match blk.rules {
- ast::UnsafeBlock(..) => try!(self.word_space("unsafe")),
- ast::DefaultBlock => ()
+ BlockCheckMode::Unsafe(..) => try!(self.word_space("unsafe")),
+ BlockCheckMode::Default => ()
}
try!(self.maybe_print_comment(blk.span.lo));
try!(self.ann.pre(self, NodeBlock(blk)));
Some(_else) => {
match _else.node {
// "another else-if"
- ast::ExprIf(ref i, ref then, ref e) => {
+ ast::ExprKind::If(ref i, ref then, ref e) => {
try!(self.cbox(INDENT_UNIT - 1));
try!(self.ibox(0));
try!(word(&mut self.s, " else if "));
self.print_else(e.as_ref().map(|e| &**e))
}
// "another else-if-let"
- ast::ExprIfLet(ref pat, ref expr, ref then, ref e) => {
+ ast::ExprKind::IfLet(ref pat, ref expr, ref then, ref e) => {
try!(self.cbox(INDENT_UNIT - 1));
try!(self.ibox(0));
try!(word(&mut self.s, " else if let "));
self.print_else(e.as_ref().map(|e| &**e))
}
// "final else"
- ast::ExprBlock(ref b) => {
+ ast::ExprKind::Block(ref b) => {
try!(self.cbox(INDENT_UNIT - 1));
try!(self.ibox(0));
try!(word(&mut self.s, " else "));
pub fn check_expr_bin_needs_paren(&mut self, sub_expr: &ast::Expr,
binop: ast::BinOp) -> bool {
match sub_expr.node {
- ast::ExprBinary(ref sub_op, _, _) => {
+ ast::ExprKind::Binary(ref sub_op, _, _) => {
if AssocOp::from_ast_binop(sub_op.node).precedence() <
AssocOp::from_ast_binop(binop.node).precedence() {
true
try!(self.ibox(INDENT_UNIT));
try!(self.ann.pre(self, NodeExpr(expr)));
match expr.node {
- ast::ExprBox(ref expr) => {
+ ast::ExprKind::Box(ref expr) => {
try!(self.word_space("box"));
try!(self.print_expr(expr));
}
- ast::ExprInPlace(ref place, ref expr) => {
+ ast::ExprKind::InPlace(ref place, ref expr) => {
try!(self.print_expr_in_place(place, expr));
}
- ast::ExprVec(ref exprs) => {
+ ast::ExprKind::Vec(ref exprs) => {
try!(self.print_expr_vec(&exprs[..], attrs));
}
- ast::ExprRepeat(ref element, ref count) => {
+ ast::ExprKind::Repeat(ref element, ref count) => {
try!(self.print_expr_repeat(&**element, &**count, attrs));
}
- ast::ExprStruct(ref path, ref fields, ref wth) => {
+ ast::ExprKind::Struct(ref path, ref fields, ref wth) => {
try!(self.print_expr_struct(path, &fields[..], wth, attrs));
}
- ast::ExprTup(ref exprs) => {
+ ast::ExprKind::Tup(ref exprs) => {
try!(self.print_expr_tup(&exprs[..], attrs));
}
- ast::ExprCall(ref func, ref args) => {
+ ast::ExprKind::Call(ref func, ref args) => {
try!(self.print_expr_call(&**func, &args[..]));
}
- ast::ExprMethodCall(ident, ref tys, ref args) => {
+ ast::ExprKind::MethodCall(ident, ref tys, ref args) => {
try!(self.print_expr_method_call(ident, &tys[..], &args[..]));
}
- ast::ExprBinary(op, ref lhs, ref rhs) => {
+ ast::ExprKind::Binary(op, ref lhs, ref rhs) => {
try!(self.print_expr_binary(op, &**lhs, &**rhs));
}
- ast::ExprUnary(op, ref expr) => {
+ ast::ExprKind::Unary(op, ref expr) => {
try!(self.print_expr_unary(op, &**expr));
}
- ast::ExprAddrOf(m, ref expr) => {
+ ast::ExprKind::AddrOf(m, ref expr) => {
try!(self.print_expr_addr_of(m, &**expr));
}
- ast::ExprLit(ref lit) => {
+ ast::ExprKind::Lit(ref lit) => {
try!(self.print_literal(&**lit));
}
- ast::ExprCast(ref expr, ref ty) => {
- if let ast::ExprCast(..) = expr.node {
+ ast::ExprKind::Cast(ref expr, ref ty) => {
+ if let ast::ExprKind::Cast(..) = expr.node {
try!(self.print_expr(&**expr));
} else {
try!(self.print_expr_maybe_paren(&**expr));
try!(self.word_space("as"));
try!(self.print_type(&**ty));
}
- ast::ExprType(ref expr, ref ty) => {
+ ast::ExprKind::Type(ref expr, ref ty) => {
try!(self.print_expr(&**expr));
try!(self.word_space(":"));
try!(self.print_type(&**ty));
}
- ast::ExprIf(ref test, ref blk, ref elseopt) => {
+ ast::ExprKind::If(ref test, ref blk, ref elseopt) => {
try!(self.print_if(&**test, &**blk, elseopt.as_ref().map(|e| &**e)));
}
- ast::ExprIfLet(ref pat, ref expr, ref blk, ref elseopt) => {
+ ast::ExprKind::IfLet(ref pat, ref expr, ref blk, ref elseopt) => {
try!(self.print_if_let(&**pat, &**expr, &** blk, elseopt.as_ref().map(|e| &**e)));
}
- ast::ExprWhile(ref test, ref blk, opt_ident) => {
+ ast::ExprKind::While(ref test, ref blk, opt_ident) => {
if let Some(ident) = opt_ident {
try!(self.print_ident(ident));
try!(self.word_space(":"));
try!(space(&mut self.s));
try!(self.print_block_with_attrs(&**blk, attrs));
}
- ast::ExprWhileLet(ref pat, ref expr, ref blk, opt_ident) => {
+ ast::ExprKind::WhileLet(ref pat, ref expr, ref blk, opt_ident) => {
if let Some(ident) = opt_ident {
try!(self.print_ident(ident));
try!(self.word_space(":"));
try!(space(&mut self.s));
try!(self.print_block_with_attrs(&**blk, attrs));
}
- ast::ExprForLoop(ref pat, ref iter, ref blk, opt_ident) => {
+ ast::ExprKind::ForLoop(ref pat, ref iter, ref blk, opt_ident) => {
if let Some(ident) = opt_ident {
try!(self.print_ident(ident));
try!(self.word_space(":"));
try!(space(&mut self.s));
try!(self.print_block_with_attrs(&**blk, attrs));
}
- ast::ExprLoop(ref blk, opt_ident) => {
+ ast::ExprKind::Loop(ref blk, opt_ident) => {
if let Some(ident) = opt_ident {
try!(self.print_ident(ident));
try!(self.word_space(":"));
try!(space(&mut self.s));
try!(self.print_block_with_attrs(&**blk, attrs));
}
- ast::ExprMatch(ref expr, ref arms) => {
+ ast::ExprKind::Match(ref expr, ref arms) => {
try!(self.cbox(INDENT_UNIT));
try!(self.ibox(4));
try!(self.word_nbsp("match"));
}
try!(self.bclose_(expr.span, INDENT_UNIT));
}
- ast::ExprClosure(capture_clause, ref decl, ref body) => {
+ ast::ExprKind::Closure(capture_clause, ref decl, ref body) => {
try!(self.print_capture_clause(capture_clause));
try!(self.print_fn_block_args(&**decl));
try!(space(&mut self.s));
let default_return = match decl.output {
- ast::DefaultReturn(..) => true,
+ ast::FunctionRetTy::Default(..) => true,
_ => false
};
// we extract the block, so as not to create another set of boxes
let i_expr = body.expr.as_ref().unwrap();
match i_expr.node {
- ast::ExprBlock(ref blk) => {
+ ast::ExprKind::Block(ref blk) => {
try!(self.print_block_unclosed_with_attrs(
&**blk,
i_expr.attrs.as_attr_slice()));
// empty box to satisfy the close.
try!(self.ibox(0));
}
- ast::ExprBlock(ref blk) => {
+ ast::ExprKind::Block(ref blk) => {
// containing cbox, will be closed by print-block at }
try!(self.cbox(INDENT_UNIT));
// head-box, will be closed by print-block after {
try!(self.ibox(0));
try!(self.print_block_with_attrs(&**blk, attrs));
}
- ast::ExprAssign(ref lhs, ref rhs) => {
+ ast::ExprKind::Assign(ref lhs, ref rhs) => {
try!(self.print_expr(&**lhs));
try!(space(&mut self.s));
try!(self.word_space("="));
try!(self.print_expr(&**rhs));
}
- ast::ExprAssignOp(op, ref lhs, ref rhs) => {
+ ast::ExprKind::AssignOp(op, ref lhs, ref rhs) => {
try!(self.print_expr(&**lhs));
try!(space(&mut self.s));
try!(word(&mut self.s, op.node.to_string()));
try!(self.word_space("="));
try!(self.print_expr(&**rhs));
}
- ast::ExprField(ref expr, id) => {
+ ast::ExprKind::Field(ref expr, id) => {
try!(self.print_expr(&**expr));
try!(word(&mut self.s, "."));
try!(self.print_ident(id.node));
}
- ast::ExprTupField(ref expr, id) => {
+ ast::ExprKind::TupField(ref expr, id) => {
try!(self.print_expr(&**expr));
try!(word(&mut self.s, "."));
try!(self.print_usize(id.node));
}
- ast::ExprIndex(ref expr, ref index) => {
+ ast::ExprKind::Index(ref expr, ref index) => {
try!(self.print_expr(&**expr));
try!(word(&mut self.s, "["));
try!(self.print_expr(&**index));
try!(word(&mut self.s, "]"));
}
- ast::ExprRange(ref start, ref end) => {
+ ast::ExprKind::Range(ref start, ref end) => {
if let &Some(ref e) = start {
try!(self.print_expr(&**e));
}
try!(self.print_expr(&**e));
}
}
- ast::ExprPath(None, ref path) => {
+ ast::ExprKind::Path(None, ref path) => {
try!(self.print_path(path, true, 0))
}
- ast::ExprPath(Some(ref qself), ref path) => {
+ ast::ExprKind::Path(Some(ref qself), ref path) => {
try!(self.print_qpath(path, qself, true))
}
- ast::ExprBreak(opt_ident) => {
+ ast::ExprKind::Break(opt_ident) => {
try!(word(&mut self.s, "break"));
try!(space(&mut self.s));
if let Some(ident) = opt_ident {
try!(space(&mut self.s));
}
}
- ast::ExprAgain(opt_ident) => {
+ ast::ExprKind::Again(opt_ident) => {
try!(word(&mut self.s, "continue"));
try!(space(&mut self.s));
if let Some(ident) = opt_ident {
try!(space(&mut self.s))
}
}
- ast::ExprRet(ref result) => {
+ ast::ExprKind::Ret(ref result) => {
try!(word(&mut self.s, "return"));
match *result {
Some(ref expr) => {
_ => ()
}
}
- ast::ExprInlineAsm(ref a) => {
+ ast::ExprKind::InlineAsm(ref a) => {
try!(word(&mut self.s, "asm!"));
try!(self.popen());
try!(self.print_string(&a.asm, a.asm_str_style));
match out.constraint.slice_shift_char() {
Some(('=', operand)) if out.is_rw => {
try!(s.print_string(&format!("+{}", operand),
- ast::CookedStr))
+ ast::StrStyle::Cooked))
}
- _ => try!(s.print_string(&out.constraint, ast::CookedStr))
+ _ => try!(s.print_string(&out.constraint, ast::StrStyle::Cooked))
}
try!(s.popen());
try!(s.print_expr(&*out.expr));
try!(self.commasep(Inconsistent, &a.inputs,
|s, &(ref co, ref o)| {
- try!(s.print_string(&co, ast::CookedStr));
+ try!(s.print_string(&co, ast::StrStyle::Cooked));
try!(s.popen());
try!(s.print_expr(&**o));
try!(s.pclose());
try!(self.commasep(Inconsistent, &a.clobbers,
|s, co| {
- try!(s.print_string(&co, ast::CookedStr));
+ try!(s.print_string(&co, ast::StrStyle::Cooked));
Ok(())
}));
try!(self.word_space(":"));
try!(self.commasep(Inconsistent, &*options,
|s, &co| {
- try!(s.print_string(co, ast::CookedStr));
+ try!(s.print_string(co, ast::StrStyle::Cooked));
Ok(())
}));
}
try!(self.pclose());
}
- ast::ExprMac(ref m) => try!(self.print_mac(m, token::Paren)),
- ast::ExprParen(ref e) => {
+ ast::ExprKind::Mac(ref m) => try!(self.print_mac(m, token::Paren)),
+ ast::ExprKind::Paren(ref e) => {
try!(self.popen());
try!(self.print_inner_attributes_inline(attrs));
try!(self.print_expr(&**e));
pub fn print_decl(&mut self, decl: &ast::Decl) -> io::Result<()> {
try!(self.maybe_print_comment(decl.span.lo));
match decl.node {
- ast::DeclLocal(ref loc) => {
+ ast::DeclKind::Local(ref loc) => {
try!(self.print_outer_attributes(loc.attrs.as_attr_slice()));
try!(self.space_if_not_bol());
try!(self.ibox(INDENT_UNIT));
}
self.end()
}
- ast::DeclItem(ref item) => self.print_item(&**item)
+ ast::DeclKind::Item(ref item) => self.print_item(&**item)
}
}
try!(self.word_nbsp("ref"));
try!(self.print_mutability(mutbl));
}
- ast::BindingMode::ByValue(ast::MutImmutable) => {}
- ast::BindingMode::ByValue(ast::MutMutable) => {
+ ast::BindingMode::ByValue(ast::Mutability::Immutable) => {}
+ ast::BindingMode::ByValue(ast::Mutability::Mutable) => {
try!(self.word_nbsp("mut"));
}
}
}
ast::PatRegion(ref inner, mutbl) => {
try!(word(&mut self.s, "&"));
- if mutbl == ast::MutMutable {
+ if mutbl == ast::Mutability::Mutable {
try!(word(&mut self.s, "mut "));
}
try!(self.print_pat(&**inner));
try!(self.word_space("=>"));
match arm.body.node {
- ast::ExprBlock(ref blk) => {
+ ast::ExprKind::Block(ref blk) => {
// the block will close the pattern's ibox
try!(self.print_block_unclosed_indent(&**blk, INDENT_UNIT));
// If it is a user-provided unsafe block, print a comma after it
- if let ast::UnsafeBlock(ast::UserProvided) = blk.rules {
+ if let BlockCheckMode::Unsafe(ast::UserProvided) = blk.rules {
try!(word(&mut self.s, ","));
}
}
// Returns whether it printed anything
fn print_explicit_self(&mut self,
- explicit_self: &ast::ExplicitSelf_,
+ explicit_self: &ast::SelfKind,
mutbl: ast::Mutability) -> io::Result<bool> {
try!(self.print_mutability(mutbl));
match *explicit_self {
- ast::SelfStatic => { return Ok(false); }
- ast::SelfValue(_) => {
+ ast::SelfKind::Static => { return Ok(false); }
+ ast::SelfKind::Value(_) => {
try!(word(&mut self.s, "self"));
}
- ast::SelfRegion(ref lt, m, _) => {
+ ast::SelfKind::Region(ref lt, m, _) => {
try!(word(&mut self.s, "&"));
try!(self.print_opt_lifetime(lt));
try!(self.print_mutability(m));
try!(word(&mut self.s, "self"));
}
- ast::SelfExplicit(ref typ, _) => {
+ ast::SelfKind::Explicit(ref typ, _) => {
try!(word(&mut self.s, "self"));
try!(self.word_space(":"));
try!(self.print_type(&**typ));
abi: abi::Abi,
name: Option<ast::Ident>,
generics: &ast::Generics,
- opt_explicit_self: Option<&ast::ExplicitSelf_>,
+ opt_explicit_self: Option<&ast::SelfKind>,
vis: ast::Visibility) -> io::Result<()> {
try!(self.print_fn_header_info(unsafety, constness, abi, vis));
}
pub fn print_fn_args(&mut self, decl: &ast::FnDecl,
- opt_explicit_self: Option<&ast::ExplicitSelf_>,
+ opt_explicit_self: Option<&ast::SelfKind>,
is_closure: bool) -> io::Result<()> {
// It is unfortunate to duplicate the commasep logic, but we want the
// self type and the args all in the same box.
let mut first = true;
if let Some(explicit_self) = opt_explicit_self {
let m = match *explicit_self {
- ast::SelfStatic => ast::MutImmutable,
+ ast::SelfKind::Static => ast::Mutability::Immutable,
_ => match decl.inputs[0].pat.node {
ast::PatIdent(ast::BindingMode::ByValue(m), _, _) => m,
- _ => ast::MutImmutable
+ _ => ast::Mutability::Immutable
}
};
first = !try!(self.print_explicit_self(explicit_self, m));
}
pub fn print_fn_args_and_ret(&mut self, decl: &ast::FnDecl,
- opt_explicit_self: Option<&ast::ExplicitSelf_>)
+ opt_explicit_self: Option<&ast::SelfKind>)
-> io::Result<()> {
try!(self.popen());
try!(self.print_fn_args(decl, opt_explicit_self, false));
try!(self.print_fn_args(decl, None, true));
try!(word(&mut self.s, "|"));
- if let ast::DefaultReturn(..) = decl.output {
+ if let ast::FunctionRetTy::Default(..) = decl.output {
return Ok(());
}
try!(self.space_if_not_bol());
try!(self.word_space("->"));
match decl.output {
- ast::Return(ref ty) => {
+ ast::FunctionRetTy::Ty(ref ty) => {
try!(self.print_type(&**ty));
self.maybe_print_comment(ty.span.lo)
}
- ast::DefaultReturn(..) => unreachable!(),
- ast::NoReturn(span) => {
+ ast::FunctionRetTy::Default(..) => unreachable!(),
+ ast::FunctionRetTy::None(span) => {
try!(self.word_nbsp("!"));
self.maybe_print_comment(span.lo)
}
}
}
- pub fn print_capture_clause(&mut self, capture_clause: ast::CaptureClause)
+ pub fn print_capture_clause(&mut self, capture_clause: ast::CaptureBy)
-> io::Result<()> {
match capture_clause {
- ast::CaptureByValue => self.word_space("move"),
- ast::CaptureByRef => Ok(()),
+ ast::CaptureBy::Value => self.word_space("move"),
+ ast::CaptureBy::Ref => Ok(()),
}
}
}
try!(self.commasep(Inconsistent, &idents[..], |s, w| {
match w.node {
- ast::PathListIdent { name, rename, .. } => {
+ ast::PathListItemKind::Ident { name, rename, .. } => {
try!(s.print_ident(name));
if let Some(ident) = rename {
try!(space(&mut s.s));
}
Ok(())
},
- ast::PathListMod { rename, .. } => {
+ ast::PathListItemKind::Mod { rename, .. } => {
try!(word(&mut s.s, "self"));
if let Some(ident) = rename {
try!(space(&mut s.s));
pub fn print_mutability(&mut self,
mutbl: ast::Mutability) -> io::Result<()> {
match mutbl {
- ast::MutMutable => self.word_nbsp("mut"),
- ast::MutImmutable => Ok(()),
+ ast::Mutability::Mutable => self.word_nbsp("mut"),
+ ast::Mutability::Immutable => Ok(()),
}
}
pub fn print_arg(&mut self, input: &ast::Arg, is_closure: bool) -> io::Result<()> {
try!(self.ibox(INDENT_UNIT));
match input.ty.node {
- ast::TyInfer if is_closure => try!(self.print_pat(&*input.pat)),
+ ast::TyKind::Infer if is_closure => try!(self.print_pat(&*input.pat)),
_ => {
match input.pat.node {
ast::PatIdent(_, ref path1, _) if
}
pub fn print_fn_output(&mut self, decl: &ast::FnDecl) -> io::Result<()> {
- if let ast::DefaultReturn(..) = decl.output {
+ if let ast::FunctionRetTy::Default(..) = decl.output {
return Ok(());
}
try!(self.ibox(INDENT_UNIT));
try!(self.word_space("->"));
match decl.output {
- ast::NoReturn(_) =>
+ ast::FunctionRetTy::None(_) =>
try!(self.word_nbsp("!")),
- ast::DefaultReturn(..) => unreachable!(),
- ast::Return(ref ty) =>
+ ast::FunctionRetTy::Default(..) => unreachable!(),
+ ast::FunctionRetTy::Ty(ref ty) =>
try!(self.print_type(&**ty))
}
try!(self.end());
match decl.output {
- ast::Return(ref output) => self.maybe_print_comment(output.span.lo),
+ ast::FunctionRetTy::Ty(ref output) => self.maybe_print_comment(output.span.lo),
_ => Ok(())
}
}
decl: &ast::FnDecl,
name: Option<ast::Ident>,
generics: &ast::Generics,
- opt_explicit_self: Option<&ast::ExplicitSelf_>)
+ opt_explicit_self: Option<&ast::SelfKind>)
-> io::Result<()> {
try!(self.ibox(INDENT_UNIT));
if !generics.lifetimes.is_empty() || !generics.ty_params.is_empty() {
name,
&generics,
opt_explicit_self,
- ast::Inherited));
+ ast::Visibility::Inherited));
self.end()
}
}
pub fn print_opt_abi_and_extern_if_nondefault(&mut self,
- opt_abi: Option<abi::Abi>)
+ opt_abi: Option<Abi>)
-> io::Result<()> {
match opt_abi {
- Some(abi::Rust) => Ok(()),
+ Some(Abi::Rust) => Ok(()),
Some(abi) => {
try!(self.word_nbsp("extern"));
self.word_nbsp(&abi.to_string())
}
pub fn print_extern_opt_abi(&mut self,
- opt_abi: Option<abi::Abi>) -> io::Result<()> {
+ opt_abi: Option<Abi>) -> io::Result<()> {
match opt_abi {
Some(abi) => {
try!(self.word_nbsp("extern"));
pub fn print_fn_header_info(&mut self,
unsafety: ast::Unsafety,
constness: ast::Constness,
- abi: abi::Abi,
+ abi: Abi,
vis: ast::Visibility) -> io::Result<()> {
try!(word(&mut self.s, &visibility_qualified(vis, "")));
try!(self.print_unsafety(unsafety));
- if abi != abi::Rust {
+ if abi != Abi::Rust {
try!(self.word_nbsp("extern"));
try!(self.word_nbsp(&abi.to_string()));
}
let decl = ast::FnDecl {
inputs: Vec::new(),
- output: ast::DefaultReturn(codemap::DUMMY_SP),
+ output: ast::FunctionRetTy::Default(codemap::DUMMY_SP),
variadic: false
};
let generics = ast::Generics::default();
let varstr = variant_to_string(&var);
assert_eq!(varstr, "principal_skinner");
}
-
- #[test]
- fn test_signed_int_to_string() {
- let pos_int = ast::LitInt(42, ast::SignedIntLit(ast::TyI32, ast::Plus));
- let neg_int = ast::LitInt((!42 + 1) as u64, ast::SignedIntLit(ast::TyI32, ast::Minus));
- assert_eq!(format!("-{}", lit_to_string(&codemap::dummy_spanned(pos_int))),
- lit_to_string(&codemap::dummy_spanned(neg_int)));
- }
}
//!
//! * **Identity**: sharing AST nodes is problematic for the various analysis
//! passes (e.g. one may be able to bypass the borrow checker with a shared
-//! `ExprAddrOf` node taking a mutable borrow). The only reason `@T` in the
+//! `ExprKind::AddrOf` node taking a mutable borrow). The only reason `@T` in the
//! AST hasn't caused issues is because of inefficient folding passes which
//! would always deduplicate any such shared nodes. Even if the AST were to
//! switch to an arena, this would still hold, i.e. it couldn't use `&'a T`,
attrs: vec!(
attr::mk_attr_outer(attr::mk_attr_id(), attr::mk_word_item(
InternedString::new("macro_use")))),
- node: ast::ItemExternCrate(Some(self.crate_name)),
- vis: ast::Inherited,
+ node: ast::ItemKind::ExternCrate(Some(self.crate_name)),
+ vis: ast::Visibility::Inherited,
span: DUMMY_SP
}));
mod_.items.insert(0, P(ast::Item {
id: ast::DUMMY_NODE_ID,
ident: special_idents::invalid,
- node: ast::ItemUse(vp),
+ node: ast::ItemKind::Use(vp),
attrs: vec![ast::Attribute {
span: self.span,
node: ast::Attribute_ {
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,
},
}],
- vis: ast::Inherited,
+ vis: ast::Visibility::Inherited,
span: self.span,
}));
let i = if is_test_fn(&self.cx, &*i) || is_bench_fn(&self.cx, &*i) {
match i.node {
- ast::ItemFn(_, ast::Unsafety::Unsafe, _, _, _, _) => {
+ ast::ItemKind::Fn(_, ast::Unsafety::Unsafe, _, _, _, _) => {
let diag = self.cx.span_diagnostic;
panic!(diag.span_fatal(i.span, "unsafe functions cannot be used for tests"));
}
// the module (note that the tests are re-exported and must
// be made public themselves to avoid privacy errors).
i.map(|mut i| {
- i.vis = ast::Public;
+ i.vis = ast::Visibility::Public;
i
})
}
// We don't want to recurse into anything other than mods, since
// mods or tests inside of functions will break things
let res = match i.node {
- ast::ItemMod(..) => fold::noop_fold_item(i, self),
+ ast::ItemKind::Mod(..) => fold::noop_fold_item(i, self),
_ => SmallVector::one(i),
};
if ident.name != token::special_idents::invalid.name {
let super_ = token::str_to_ident("super");
let items = tests.into_iter().map(|r| {
- cx.ext_cx.item_use_simple(DUMMY_SP, ast::Public,
+ cx.ext_cx.item_use_simple(DUMMY_SP, ast::Visibility::Public,
cx.ext_cx.path(DUMMY_SP, vec![super_, r]))
}).chain(tested_submods.into_iter().map(|(r, sym)| {
let path = cx.ext_cx.path(DUMMY_SP, vec![super_, r, sym]);
- cx.ext_cx.item_use_simple_(DUMMY_SP, ast::Public, r, path)
+ cx.ext_cx.item_use_simple_(DUMMY_SP, ast::Visibility::Public, r, path)
}));
let reexport_mod = ast::Mod {
ident: sym.clone(),
attrs: Vec::new(),
id: ast::DUMMY_NODE_ID,
- node: ast::ItemMod(reexport_mod),
- vis: ast::Public,
+ node: ast::ItemKind::Mod(reexport_mod),
+ vis: ast::Visibility::Public,
span: DUMMY_SP,
});
fn has_test_signature(i: &ast::Item) -> HasTestSignature {
match i.node {
- ast::ItemFn(ref decl, _, _, _, ref generics, _) => {
+ ast::ItemKind::Fn(ref decl, _, _, _, ref generics, _) => {
let no_output = match decl.output {
- ast::DefaultReturn(..) => true,
- ast::Return(ref t) if t.node == ast::TyTup(vec![]) => true,
+ ast::FunctionRetTy::Default(..) => true,
+ ast::FunctionRetTy::Ty(ref t) if t.node == ast::TyKind::Tup(vec![]) => true,
_ => false
};
if decl.inputs.is_empty()
fn has_test_signature(i: &ast::Item) -> bool {
match i.node {
- ast::ItemFn(ref decl, _, _, _, ref generics, _) => {
+ ast::ItemKind::Fn(ref decl, _, _, _, ref generics, _) => {
let input_cnt = decl.inputs.len();
let no_output = match decl.output {
- ast::DefaultReturn(..) => true,
- ast::Return(ref t) if t.node == ast::TyTup(vec![]) => true,
+ ast::FunctionRetTy::Default(..) => true,
+ ast::FunctionRetTy::Ty(ref t) if t.node == ast::TyKind::Tup(vec![]) => true,
_ => false
};
let tparm_cnt = generics.ty_params.len();
fn mk_std(cx: &TestCtxt) -> P<ast::Item> {
let id_test = token::str_to_ident("test");
let (vi, vis, ident) = if cx.is_test_crate {
- (ast::ItemUse(
+ (ast::ItemKind::Use(
P(nospan(ast::ViewPathSimple(id_test,
path_node(vec!(id_test)))))),
- ast::Public, token::special_idents::invalid)
+ ast::Visibility::Public, token::special_idents::invalid)
} else {
- (ast::ItemExternCrate(None), ast::Inherited, id_test)
+ (ast::ItemKind::ExternCrate(None), ast::Visibility::Inherited, id_test)
};
P(ast::Item {
id: ast::DUMMY_NODE_ID,
let main_meta = ecx.meta_word(sp, token::intern_and_get_ident("main"));
let main_attr = ecx.attribute(sp, main_meta);
// pub fn main() { ... }
- let main_ret_ty = ecx.ty(sp, ast::TyTup(vec![]));
+ let main_ret_ty = ecx.ty(sp, ast::TyKind::Tup(vec![]));
let main_body = ecx.block_all(sp, vec![call_test_main], None);
- let main = ast::ItemFn(ecx.fn_decl(vec![], main_ret_ty),
+ let main = ast::ItemKind::Fn(ecx.fn_decl(vec![], main_ret_ty),
ast::Unsafety::Normal,
ast::Constness::NotConst,
- ::abi::Rust, ast::Generics::default(), main_body);
+ ::abi::Abi::Rust, ast::Generics::default(), main_body);
let main = P(ast::Item {
ident: token::str_to_ident("main"),
attrs: vec![main_attr],
id: ast::DUMMY_NODE_ID,
node: main,
- vis: ast::Public,
+ vis: ast::Visibility::Public,
span: sp
});
inner: DUMMY_SP,
items: vec![import, mainfn, tests],
};
- let item_ = ast::ItemMod(testmod);
+ let item_ = ast::ItemKind::Mod(testmod);
let mod_ident = token::gensym_ident("__test");
let item = P(ast::Item {
ident: mod_ident,
attrs: vec![],
node: item_,
- vis: ast::Public,
+ vis: ast::Visibility::Public,
span: DUMMY_SP,
});
let reexport = cx.reexport_test_harness_main.as_ref().map(|s| {
id: ast::DUMMY_NODE_ID,
ident: token::special_idents::invalid,
attrs: vec![],
- node: ast::ItemUse(P(use_path)),
- vis: ast::Inherited,
+ node: ast::ItemKind::Use(P(use_path)),
+ vis: ast::Visibility::Inherited,
span: DUMMY_SP
})
});
let static_lt = ecx.lifetime(sp, token::special_idents::static_lifetime.name);
// &'static [self::test::TestDescAndFn]
let static_type = ecx.ty_rptr(sp,
- ecx.ty(sp, ast::TyVec(struct_type)),
+ ecx.ty(sp, ast::TyKind::Vec(struct_type)),
Some(static_lt),
- ast::MutImmutable);
+ ast::Mutability::Immutable);
// static TESTS: $static_type = &[...];
ecx.item_const(sp,
ecx.ident_of("TESTS"),
P(ast::Expr {
id: ast::DUMMY_NODE_ID,
- node: ast::ExprAddrOf(ast::MutImmutable,
+ node: ast::ExprKind::AddrOf(ast::Mutability::Immutable,
P(ast::Expr {
id: ast::DUMMY_NODE_ID,
- node: ast::ExprVec(cx.testfns.iter().map(|test| {
+ node: ast::ExprKind::Vec(cx.testfns.iter().map(|test| {
mk_test_desc_and_fn_rec(cx, test)
}).collect()),
span: DUMMY_SP,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use parse::token::{Token, BinOpToken, keywords};
-use ast;
+use ast::BinOpKind;
/// Associative operator with precedence.
///
}
}
- /// Create a new AssocOp from ast::BinOp_.
- pub fn from_ast_binop(op: ast::BinOp_) -> Self {
+ /// Create a new AssocOp from ast::BinOpKind.
+ pub fn from_ast_binop(op: BinOpKind) -> Self {
use self::AssocOp::*;
match op {
- ast::BiLt => Less,
- ast::BiGt => Greater,
- ast::BiLe => LessEqual,
- ast::BiGe => GreaterEqual,
- ast::BiEq => Equal,
- ast::BiNe => NotEqual,
- ast::BiMul => Multiply,
- ast::BiDiv => Divide,
- ast::BiRem => Modulus,
- ast::BiAdd => Add,
- ast::BiSub => Subtract,
- ast::BiShl => ShiftLeft,
- ast::BiShr => ShiftRight,
- ast::BiBitAnd => BitAnd,
- ast::BiBitXor => BitXor,
- ast::BiBitOr => BitOr,
- ast::BiAnd => LAnd,
- ast::BiOr => LOr
+ BinOpKind::Lt => Less,
+ BinOpKind::Gt => Greater,
+ BinOpKind::Le => LessEqual,
+ BinOpKind::Ge => GreaterEqual,
+ BinOpKind::Eq => Equal,
+ BinOpKind::Ne => NotEqual,
+ BinOpKind::Mul => Multiply,
+ BinOpKind::Div => Divide,
+ BinOpKind::Rem => Modulus,
+ BinOpKind::Add => Add,
+ BinOpKind::Sub => Subtract,
+ BinOpKind::Shl => ShiftLeft,
+ BinOpKind::Shr => ShiftRight,
+ BinOpKind::BitAnd => BitAnd,
+ BinOpKind::BitXor => BitXor,
+ BinOpKind::BitOr => BitOr,
+ BinOpKind::And => LAnd,
+ BinOpKind::Or => LOr
}
}
}
}
- pub fn to_ast_binop(&self) -> Option<ast::BinOp_> {
+ pub fn to_ast_binop(&self) -> Option<BinOpKind> {
use self::AssocOp::*;
match *self {
- Less => Some(ast::BiLt),
- Greater => Some(ast::BiGt),
- LessEqual => Some(ast::BiLe),
- GreaterEqual => Some(ast::BiGe),
- Equal => Some(ast::BiEq),
- NotEqual => Some(ast::BiNe),
- Multiply => Some(ast::BiMul),
- Divide => Some(ast::BiDiv),
- Modulus => Some(ast::BiRem),
- Add => Some(ast::BiAdd),
- Subtract => Some(ast::BiSub),
- ShiftLeft => Some(ast::BiShl),
- ShiftRight => Some(ast::BiShr),
- BitAnd => Some(ast::BiBitAnd),
- BitXor => Some(ast::BiBitXor),
- BitOr => Some(ast::BiBitOr),
- LAnd => Some(ast::BiAnd),
- LOr => Some(ast::BiOr),
+ Less => Some(BinOpKind::Lt),
+ Greater => Some(BinOpKind::Gt),
+ LessEqual => Some(BinOpKind::Le),
+ GreaterEqual => Some(BinOpKind::Ge),
+ Equal => Some(BinOpKind::Eq),
+ NotEqual => Some(BinOpKind::Ne),
+ Multiply => Some(BinOpKind::Mul),
+ Divide => Some(BinOpKind::Div),
+ Modulus => Some(BinOpKind::Rem),
+ Add => Some(BinOpKind::Add),
+ Subtract => Some(BinOpKind::Sub),
+ ShiftLeft => Some(BinOpKind::Shl),
+ ShiftRight => Some(BinOpKind::Shr),
+ BitAnd => Some(BinOpKind::BitAnd),
+ BitXor => Some(BinOpKind::BitXor),
+ BitOr => Some(BinOpKind::BitOr),
+ LAnd => Some(BinOpKind::And),
+ LOr => Some(BinOpKind::Or),
Inplace | Assign | AssignOp(_) | As | DotDot | Colon => None
}
}
pub fn walk_explicit_self<'v, V: Visitor<'v>>(visitor: &mut V,
explicit_self: &'v ExplicitSelf) {
match explicit_self.node {
- SelfStatic => {},
- SelfValue(ident) => {
+ SelfKind::Static => {},
+ SelfKind::Value(ident) => {
visitor.visit_ident(explicit_self.span, ident)
}
- SelfRegion(ref opt_lifetime, _, ident) => {
+ SelfKind::Region(ref opt_lifetime, _, ident) => {
visitor.visit_ident(explicit_self.span, ident);
walk_list!(visitor, visit_lifetime, opt_lifetime);
}
- SelfExplicit(ref typ, ident) => {
+ SelfKind::Explicit(ref typ, ident) => {
visitor.visit_ident(explicit_self.span, ident);
visitor.visit_ty(typ)
}
pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
visitor.visit_ident(item.span, item.ident);
match item.node {
- ItemExternCrate(opt_name) => {
+ ItemKind::ExternCrate(opt_name) => {
walk_opt_name(visitor, item.span, opt_name)
}
- ItemUse(ref vp) => {
+ ItemKind::Use(ref vp) => {
match vp.node {
ViewPathSimple(ident, ref path) => {
visitor.visit_ident(vp.span, ident);
}
}
}
- ItemStatic(ref typ, _, ref expr) |
- ItemConst(ref typ, ref expr) => {
+ ItemKind::Static(ref typ, _, ref expr) |
+ ItemKind::Const(ref typ, ref expr) => {
visitor.visit_ty(typ);
visitor.visit_expr(expr);
}
- ItemFn(ref declaration, unsafety, constness, abi, ref generics, ref body) => {
+ ItemKind::Fn(ref declaration, unsafety, constness, abi, ref generics, ref body) => {
visitor.visit_fn(FnKind::ItemFn(item.ident, generics, unsafety,
constness, abi, item.vis),
declaration,
item.span,
item.id)
}
- ItemMod(ref module) => {
+ ItemKind::Mod(ref module) => {
visitor.visit_mod(module, item.span, item.id)
}
- ItemForeignMod(ref foreign_module) => {
+ ItemKind::ForeignMod(ref foreign_module) => {
walk_list!(visitor, visit_foreign_item, &foreign_module.items);
}
- ItemTy(ref typ, ref type_parameters) => {
+ ItemKind::Ty(ref typ, ref type_parameters) => {
visitor.visit_ty(typ);
visitor.visit_generics(type_parameters)
}
- ItemEnum(ref enum_definition, ref type_parameters) => {
+ ItemKind::Enum(ref enum_definition, ref type_parameters) => {
visitor.visit_generics(type_parameters);
visitor.visit_enum_def(enum_definition, type_parameters, item.id, item.span)
}
- ItemDefaultImpl(_, ref trait_ref) => {
+ ItemKind::DefaultImpl(_, ref trait_ref) => {
visitor.visit_trait_ref(trait_ref)
}
- ItemImpl(_, _,
+ ItemKind::Impl(_, _,
ref type_parameters,
ref opt_trait_reference,
ref typ,
visitor.visit_ty(typ);
walk_list!(visitor, visit_impl_item, impl_items);
}
- ItemStruct(ref struct_definition, ref generics) => {
+ ItemKind::Struct(ref struct_definition, ref generics) => {
visitor.visit_generics(generics);
visitor.visit_variant_data(struct_definition, item.ident,
generics, item.id, item.span);
}
- ItemTrait(_, ref generics, ref bounds, ref methods) => {
+ ItemKind::Trait(_, ref generics, ref bounds, ref methods) => {
visitor.visit_generics(generics);
walk_list!(visitor, visit_ty_param_bound, bounds);
walk_list!(visitor, visit_trait_item, methods);
}
- ItemMac(ref mac) => visitor.visit_mac(mac),
+ ItemKind::Mac(ref mac) => visitor.visit_mac(mac),
}
walk_list!(visitor, visit_attribute, &item.attrs);
}
pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty) {
match typ.node {
- TyVec(ref ty) | TyParen(ref ty) => {
+ TyKind::Vec(ref ty) | TyKind::Paren(ref ty) => {
visitor.visit_ty(ty)
}
- TyPtr(ref mutable_type) => {
+ TyKind::Ptr(ref mutable_type) => {
visitor.visit_ty(&mutable_type.ty)
}
- TyRptr(ref opt_lifetime, ref mutable_type) => {
+ TyKind::Rptr(ref opt_lifetime, ref mutable_type) => {
walk_list!(visitor, visit_lifetime, opt_lifetime);
visitor.visit_ty(&mutable_type.ty)
}
- TyTup(ref tuple_element_types) => {
+ TyKind::Tup(ref tuple_element_types) => {
walk_list!(visitor, visit_ty, tuple_element_types);
}
- TyBareFn(ref function_declaration) => {
+ TyKind::BareFn(ref function_declaration) => {
walk_fn_decl(visitor, &function_declaration.decl);
walk_list!(visitor, visit_lifetime_def, &function_declaration.lifetimes);
}
- TyPath(ref maybe_qself, ref path) => {
+ TyKind::Path(ref maybe_qself, ref path) => {
if let Some(ref qself) = *maybe_qself {
visitor.visit_ty(&qself.ty);
}
visitor.visit_path(path, typ.id);
}
- TyObjectSum(ref ty, ref bounds) => {
+ TyKind::ObjectSum(ref ty, ref bounds) => {
visitor.visit_ty(ty);
walk_list!(visitor, visit_ty_param_bound, bounds);
}
- TyFixedLengthVec(ref ty, ref expression) => {
+ TyKind::FixedLengthVec(ref ty, ref expression) => {
visitor.visit_ty(ty);
visitor.visit_expr(expression)
}
- TyPolyTraitRef(ref bounds) => {
+ TyKind::PolyTraitRef(ref bounds) => {
walk_list!(visitor, visit_ty_param_bound, bounds);
}
- TyTypeof(ref expression) => {
+ TyKind::Typeof(ref expression) => {
visitor.visit_expr(expression)
}
- TyInfer => {}
- TyMac(ref mac) => {
+ TyKind::Infer => {}
+ TyKind::Mac(ref mac) => {
visitor.visit_mac(mac)
}
}
visitor.visit_ident(foreign_item.span, foreign_item.ident);
match foreign_item.node {
- ForeignItemFn(ref function_declaration, ref generics) => {
+ ForeignItemKind::Fn(ref function_declaration, ref generics) => {
walk_fn_decl(visitor, function_declaration);
visitor.visit_generics(generics)
}
- ForeignItemStatic(ref typ, _) => visitor.visit_ty(typ),
+ ForeignItemKind::Static(ref typ, _) => visitor.visit_ty(typ),
}
walk_list!(visitor, visit_attribute, &foreign_item.attrs);
}
pub fn walk_fn_ret_ty<'v, V: Visitor<'v>>(visitor: &mut V, ret_ty: &'v FunctionRetTy) {
- if let Return(ref output_ty) = *ret_ty {
+ if let FunctionRetTy::Ty(ref output_ty) = *ret_ty {
visitor.visit_ty(output_ty)
}
}
visitor.visit_ident(trait_item.span, trait_item.ident);
walk_list!(visitor, visit_attribute, &trait_item.attrs);
match trait_item.node {
- ConstTraitItem(ref ty, ref default) => {
+ TraitItemKind::Const(ref ty, ref default) => {
visitor.visit_ty(ty);
walk_list!(visitor, visit_expr, default);
}
- MethodTraitItem(ref sig, None) => {
+ TraitItemKind::Method(ref sig, None) => {
visitor.visit_explicit_self(&sig.explicit_self);
visitor.visit_generics(&sig.generics);
walk_fn_decl(visitor, &sig.decl);
}
- MethodTraitItem(ref sig, Some(ref body)) => {
+ TraitItemKind::Method(ref sig, Some(ref body)) => {
visitor.visit_fn(FnKind::Method(trait_item.ident, sig, None), &sig.decl,
body, trait_item.span, trait_item.id);
}
- TypeTraitItem(ref bounds, ref default) => {
+ TraitItemKind::Type(ref bounds, ref default) => {
walk_list!(visitor, visit_ty_param_bound, bounds);
walk_list!(visitor, visit_ty, default);
}
pub fn walk_stmt<'v, V: Visitor<'v>>(visitor: &mut V, statement: &'v Stmt) {
match statement.node {
- StmtDecl(ref declaration, _) => visitor.visit_decl(declaration),
- StmtExpr(ref expression, _) | StmtSemi(ref expression, _) => {
+ StmtKind::Decl(ref declaration, _) => visitor.visit_decl(declaration),
+ StmtKind::Expr(ref expression, _) | StmtKind::Semi(ref expression, _) => {
visitor.visit_expr(expression)
}
- StmtMac(ref mac, _, ref attrs) => {
+ StmtKind::Mac(ref mac, _, ref attrs) => {
visitor.visit_mac(mac);
for attr in attrs.as_attr_slice() {
visitor.visit_attribute(attr);
pub fn walk_decl<'v, V: Visitor<'v>>(visitor: &mut V, declaration: &'v Decl) {
match declaration.node {
- DeclLocal(ref local) => visitor.visit_local(local),
- DeclItem(ref item) => visitor.visit_item(item),
+ DeclKind::Local(ref local) => visitor.visit_local(local),
+ DeclKind::Item(ref item) => visitor.visit_item(item),
}
}
pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) {
match expression.node {
- ExprBox(ref subexpression) => {
+ ExprKind::Box(ref subexpression) => {
visitor.visit_expr(subexpression)
}
- ExprInPlace(ref place, ref subexpression) => {
+ ExprKind::InPlace(ref place, ref subexpression) => {
visitor.visit_expr(place);
visitor.visit_expr(subexpression)
}
- ExprVec(ref subexpressions) => {
+ ExprKind::Vec(ref subexpressions) => {
walk_list!(visitor, visit_expr, subexpressions);
}
- ExprRepeat(ref element, ref count) => {
+ ExprKind::Repeat(ref element, ref count) => {
visitor.visit_expr(element);
visitor.visit_expr(count)
}
- ExprStruct(ref path, ref fields, ref optional_base) => {
+ ExprKind::Struct(ref path, ref fields, ref optional_base) => {
visitor.visit_path(path, expression.id);
for field in fields {
visitor.visit_ident(field.ident.span, field.ident.node);
}
walk_list!(visitor, visit_expr, optional_base);
}
- ExprTup(ref subexpressions) => {
+ ExprKind::Tup(ref subexpressions) => {
walk_list!(visitor, visit_expr, subexpressions);
}
- ExprCall(ref callee_expression, ref arguments) => {
+ ExprKind::Call(ref callee_expression, ref arguments) => {
walk_list!(visitor, visit_expr, arguments);
visitor.visit_expr(callee_expression)
}
- ExprMethodCall(ref ident, ref types, ref arguments) => {
+ ExprKind::MethodCall(ref ident, ref types, ref arguments) => {
visitor.visit_ident(ident.span, ident.node);
walk_list!(visitor, visit_expr, arguments);
walk_list!(visitor, visit_ty, types);
}
- ExprBinary(_, ref left_expression, ref right_expression) => {
+ ExprKind::Binary(_, ref left_expression, ref right_expression) => {
visitor.visit_expr(left_expression);
visitor.visit_expr(right_expression)
}
- ExprAddrOf(_, ref subexpression) | ExprUnary(_, ref subexpression) => {
+ ExprKind::AddrOf(_, ref subexpression) | ExprKind::Unary(_, ref subexpression) => {
visitor.visit_expr(subexpression)
}
- ExprLit(_) => {}
- ExprCast(ref subexpression, ref typ) | ExprType(ref subexpression, ref typ) => {
+ ExprKind::Lit(_) => {}
+ ExprKind::Cast(ref subexpression, ref typ) | ExprKind::Type(ref subexpression, ref typ) => {
visitor.visit_expr(subexpression);
visitor.visit_ty(typ)
}
- ExprIf(ref head_expression, ref if_block, ref optional_else) => {
+ ExprKind::If(ref head_expression, ref if_block, ref optional_else) => {
visitor.visit_expr(head_expression);
visitor.visit_block(if_block);
walk_list!(visitor, visit_expr, optional_else);
}
- ExprWhile(ref subexpression, ref block, opt_ident) => {
+ ExprKind::While(ref subexpression, ref block, opt_ident) => {
visitor.visit_expr(subexpression);
visitor.visit_block(block);
walk_opt_ident(visitor, expression.span, opt_ident)
}
- ExprIfLet(ref pattern, ref subexpression, ref if_block, ref optional_else) => {
+ ExprKind::IfLet(ref pattern, ref subexpression, ref if_block, ref optional_else) => {
visitor.visit_pat(pattern);
visitor.visit_expr(subexpression);
visitor.visit_block(if_block);
walk_list!(visitor, visit_expr, optional_else);
}
- ExprWhileLet(ref pattern, ref subexpression, ref block, opt_ident) => {
+ ExprKind::WhileLet(ref pattern, ref subexpression, ref block, opt_ident) => {
visitor.visit_pat(pattern);
visitor.visit_expr(subexpression);
visitor.visit_block(block);
walk_opt_ident(visitor, expression.span, opt_ident)
}
- ExprForLoop(ref pattern, ref subexpression, ref block, opt_ident) => {
+ ExprKind::ForLoop(ref pattern, ref subexpression, ref block, opt_ident) => {
visitor.visit_pat(pattern);
visitor.visit_expr(subexpression);
visitor.visit_block(block);
walk_opt_ident(visitor, expression.span, opt_ident)
}
- ExprLoop(ref block, opt_ident) => {
+ ExprKind::Loop(ref block, opt_ident) => {
visitor.visit_block(block);
walk_opt_ident(visitor, expression.span, opt_ident)
}
- ExprMatch(ref subexpression, ref arms) => {
+ ExprKind::Match(ref subexpression, ref arms) => {
visitor.visit_expr(subexpression);
walk_list!(visitor, visit_arm, arms);
}
- ExprClosure(_, ref function_declaration, ref body) => {
+ ExprKind::Closure(_, ref function_declaration, ref body) => {
visitor.visit_fn(FnKind::Closure,
function_declaration,
body,
expression.span,
expression.id)
}
- ExprBlock(ref block) => visitor.visit_block(block),
- ExprAssign(ref left_hand_expression, ref right_hand_expression) => {
+ ExprKind::Block(ref block) => visitor.visit_block(block),
+ ExprKind::Assign(ref left_hand_expression, ref right_hand_expression) => {
visitor.visit_expr(right_hand_expression);
visitor.visit_expr(left_hand_expression)
}
- ExprAssignOp(_, ref left_expression, ref right_expression) => {
+ ExprKind::AssignOp(_, ref left_expression, ref right_expression) => {
visitor.visit_expr(right_expression);
visitor.visit_expr(left_expression)
}
- ExprField(ref subexpression, ref ident) => {
+ ExprKind::Field(ref subexpression, ref ident) => {
visitor.visit_expr(subexpression);
visitor.visit_ident(ident.span, ident.node);
}
- ExprTupField(ref subexpression, _) => {
+ ExprKind::TupField(ref subexpression, _) => {
visitor.visit_expr(subexpression);
}
- ExprIndex(ref main_expression, ref index_expression) => {
+ ExprKind::Index(ref main_expression, ref index_expression) => {
visitor.visit_expr(main_expression);
visitor.visit_expr(index_expression)
}
- ExprRange(ref start, ref end) => {
+ ExprKind::Range(ref start, ref end) => {
walk_list!(visitor, visit_expr, start);
walk_list!(visitor, visit_expr, end);
}
- ExprPath(ref maybe_qself, ref path) => {
+ ExprKind::Path(ref maybe_qself, ref path) => {
if let Some(ref qself) = *maybe_qself {
visitor.visit_ty(&qself.ty);
}
visitor.visit_path(path, expression.id)
}
- ExprBreak(ref opt_sp_ident) | ExprAgain(ref opt_sp_ident) => {
+ ExprKind::Break(ref opt_sp_ident) | ExprKind::Again(ref opt_sp_ident) => {
for sp_ident in opt_sp_ident {
visitor.visit_ident(sp_ident.span, sp_ident.node);
}
}
- ExprRet(ref optional_expression) => {
+ ExprKind::Ret(ref optional_expression) => {
walk_list!(visitor, visit_expr, optional_expression);
}
- ExprMac(ref mac) => visitor.visit_mac(mac),
- ExprParen(ref subexpression) => {
+ ExprKind::Mac(ref mac) => visitor.visit_mac(mac),
+ ExprKind::Paren(ref subexpression) => {
visitor.visit_expr(subexpression)
}
- ExprInlineAsm(ref ia) => {
+ ExprKind::InlineAsm(ref ia) => {
for &(_, ref input) in &ia.inputs {
visitor.visit_expr(&input)
}
MacEager::expr(P(ast::Expr {
id: ast::DUMMY_NODE_ID,
- node: ast::ExprInlineAsm(ast::InlineAsm {
+ node: ast::ExprKind::InlineAsm(ast::InlineAsm {
asm: token::intern_and_get_ident(&asm),
asm_str_style: asm_str_style.unwrap(),
outputs: outputs,
let mut accumulator = String::new();
for e in es {
match e.node {
- ast::ExprLit(ref lit) => {
+ ast::ExprKind::Lit(ref lit) => {
match lit.node {
- ast::LitStr(ref s, _) |
- ast::LitFloat(ref s, _) |
- ast::LitFloatUnsuffixed(ref s) => {
+ ast::LitKind::Str(ref s, _) |
+ ast::LitKind::Float(ref s, _) |
+ ast::LitKind::FloatUnsuffixed(ref s) => {
accumulator.push_str(&s);
}
- ast::LitChar(c) => {
+ ast::LitKind::Char(c) => {
accumulator.push(c);
}
- ast::LitInt(i, ast::UnsignedIntLit(_)) |
- ast::LitInt(i, ast::SignedIntLit(_, ast::Plus)) |
- ast::LitInt(i, ast::UnsuffixedIntLit(ast::Plus)) => {
+ ast::LitKind::Int(i, ast::LitIntType::Unsigned(_)) |
+ ast::LitKind::Int(i, ast::LitIntType::Signed(_)) |
+ ast::LitKind::Int(i, ast::LitIntType::Unsuffixed) => {
accumulator.push_str(&format!("{}", i));
}
- ast::LitInt(i, ast::SignedIntLit(_, ast::Minus)) |
- ast::LitInt(i, ast::UnsuffixedIntLit(ast::Minus)) => {
- accumulator.push_str(&format!("-{}", i));
- }
- ast::LitBool(b) => {
+ ast::LitKind::Bool(b) => {
accumulator.push_str(&format!("{}", b));
}
- ast::LitByte(..) |
- ast::LitByteStr(..) => {
+ ast::LitKind::Byte(..) |
+ ast::LitKind::ByteStr(..) => {
cx.span_err(e.span, "cannot concatenate a byte string literal");
}
}
let e = P(ast::Expr {
id: ast::DUMMY_NODE_ID,
- node: ast::ExprPath(None,
+ node: ast::ExprKind::Path(None,
ast::Path {
span: sp,
global: false,
use deriving::generic::*;
use deriving::generic::ty::*;
-use syntax::ast;
-use syntax::ast::{MetaItem, Expr};
+use syntax::ast::{MetaItem, Expr, BinOpKind, self};
use syntax::codemap::Span;
use syntax::ext::base::{ExtCtxt, Annotatable};
use syntax::ext::build::AstBuilder;
let assign = cx.stmt_let(span, false, test_id, new);
- let cond = cx.expr_binary(span, ast::BiEq,
+ let cond = cx.expr_binary(span, BinOpKind::Eq,
cx.expr_ident(span, test_id),
cx.expr_path(equals_path.clone()));
let if_ = cx.expr_if(span,
use deriving::generic::*;
use deriving::generic::ty::*;
-use syntax::ast::{MetaItem, Expr, self};
+use syntax::ast::{MetaItem, Expr, BinOpKind};
use syntax::codemap::Span;
use syntax::ext::base::{ExtCtxt, Annotatable};
use syntax::ext::build::AstBuilder;
_ => cx.span_bug(span, "not exactly 2 arguments in `derive(PartialEq)`")
};
- let eq = cx.expr_binary(span, ast::BiEq, self_f, other_f.clone());
+ let eq = cx.expr_binary(span, BinOpKind::Eq, self_f, other_f.clone());
- cx.expr_binary(span, ast::BiAnd, subexpr, eq)
+ cx.expr_binary(span, BinOpKind::And, subexpr, eq)
},
cx.expr_bool(span, true),
Box::new(|cx, span, _, _| cx.expr_bool(span, false)),
_ => cx.span_bug(span, "not exactly 2 arguments in `derive(PartialEq)`")
};
- let eq = cx.expr_binary(span, ast::BiNe, self_f, other_f.clone());
+ let eq = cx.expr_binary(span, BinOpKind::Ne, self_f, other_f.clone());
- cx.expr_binary(span, ast::BiOr, subexpr, eq)
+ cx.expr_binary(span, BinOpKind::Or, subexpr, eq)
},
cx.expr_bool(span, false),
Box::new(|cx, span, _, _| cx.expr_bool(span, true)),
use deriving::generic::*;
use deriving::generic::ty::*;
-use syntax::ast;
-use syntax::ast::{MetaItem, Expr};
+use syntax::ast::{MetaItem, Expr, BinOpKind, self};
use syntax::codemap::Span;
use syntax::ext::base::{ExtCtxt, Annotatable};
use syntax::ext::build::AstBuilder;
let assign = cx.stmt_let(span, false, test_id, new);
- let cond = cx.expr_binary(span, ast::BiEq,
+ let cond = cx.expr_binary(span, BinOpKind::Eq,
cx.expr_ident(span, test_id),
equals_expr.clone());
let if_ = cx.expr_if(span,
/// Strict inequality.
fn cs_op(less: bool, equal: bool, cx: &mut ExtCtxt,
span: Span, substr: &Substructure) -> P<Expr> {
- let op = if less {ast::BiLt} else {ast::BiGt};
+ let op = if less { BinOpKind::Lt } else { BinOpKind::Gt };
cs_fold(
false, // need foldr,
|cx, span, subexpr, self_f, other_fs| {
let cmp = cx.expr_binary(span, op, self_f.clone(), other_f.clone());
- let not_cmp = cx.expr_unary(span, ast::UnNot,
+ let not_cmp = cx.expr_unary(span, ast::UnOp::Not,
cx.expr_binary(span, op, other_f.clone(), self_f));
- let and = cx.expr_binary(span, ast::BiAnd, not_cmp, subexpr);
- cx.expr_binary(span, ast::BiOr, cmp, and)
+ let and = cx.expr_binary(span, BinOpKind::And, not_cmp, subexpr);
+ cx.expr_binary(span, BinOpKind::Or, cmp, and)
},
cx.expr_bool(span, equal),
Box::new(|cx, span, (self_args, tag_tuple), _non_self_args| {
{
// &mut ::std::fmt::Formatter
let fmtr = Ptr(Box::new(Literal(path_std!(cx, core::fmt::Formatter))),
- Borrowed(None, ast::MutMutable));
+ Borrowed(None, ast::Mutability::Mutable));
let trait_def = TraitDef {
span: span,
// We want to make sure we have the expn_id set so that we can use unstable methods
let span = Span { expn_id: cx.backtrace(), .. span };
- let name = cx.expr_lit(span, ast::Lit_::LitStr(ident.name.as_str(),
- ast::StrStyle::CookedStr));
+ let name = cx.expr_lit(span, ast::LitKind::Str(ident.name.as_str(), ast::StrStyle::Cooked));
let builder = token::str_to_ident("builder");
let builder_expr = cx.expr_ident(span, builder.clone());
stmts.push(cx.stmt_let(DUMMY_SP, true, builder, expr));
for field in fields {
- let name = cx.expr_lit(field.span, ast::Lit_::LitStr(
+ let name = cx.expr_lit(field.span, ast::LitKind::Str(
field.name.unwrap().name.as_str(),
- ast::StrStyle::CookedStr));
+ ast::StrStyle::Cooked));
// Use double indirection to make sure this works for unsized types
let field = cx.expr_addr_of(field.span, field.self_.clone());
span: sp,
attrs: None,
});
- let decl = respan(sp, ast::DeclLocal(local));
- P(respan(sp, ast::StmtDecl(P(decl), ast::DUMMY_NODE_ID)))
+ let decl = respan(sp, ast::DeclKind::Local(local));
+ P(respan(sp, ast::StmtKind::Decl(P(decl), ast::DUMMY_NODE_ID)))
}
use deriving::generic::ty::*;
use syntax::ast;
-use syntax::ast::{MetaItem, Expr, MutMutable};
+use syntax::ast::{MetaItem, Expr, Mutability};
use syntax::codemap::Span;
use syntax::ext::base::{ExtCtxt, Annotatable};
use syntax::ext::build::AstBuilder;
},
explicit_self: None,
args: vec!(Ptr(Box::new(Literal(Path::new_local("__D"))),
- Borrowed(None, MutMutable))),
+ Borrowed(None, Mutability::Mutable))),
ret_ty: Literal(Path::new_(
pathvec_std!(cx, core::result::Result),
None,
use deriving::generic::*;
use deriving::generic::ty::*;
-use syntax::ast::{MetaItem, Expr, ExprRet, MutMutable};
+use syntax::ast::{MetaItem, Expr, ExprKind, Mutability};
use syntax::codemap::Span;
use syntax::ext::base::{ExtCtxt,Annotatable};
use syntax::ext::build::AstBuilder;
},
explicit_self: borrowed_explicit_self(),
args: vec!(Ptr(Box::new(Literal(Path::new_local("__S"))),
- Borrowed(None, MutMutable))),
+ Borrowed(None, Mutability::Mutable))),
ret_ty: Literal(Path::new_(
pathvec_std!(cx, core::result::Result),
None,
let call = if i != last {
cx.expr_try(span, call)
} else {
- cx.expr(span, ExprRet(Some(call)))
+ cx.expr(span, ExprKind::Ret(Some(call)))
};
stmts.push(cx.stmt_expr(call));
}
// unit structs have no fields and need to return Ok()
if stmts.is_empty() {
- let ret_ok = cx.expr(trait_span,
- ExprRet(Some(cx.expr_ok(trait_span,
- cx.expr_tuple(trait_span, vec![])))));
+ let ok = cx.expr_ok(trait_span, cx.expr_tuple(trait_span, vec![]));
+ let ret_ok = cx.expr(trait_span, ExprKind::Ret(Some(ok)));
stmts.push(cx.stmt_expr(ret_ok));
}
let call = if i != last {
cx.expr_try(span, call)
} else {
- cx.expr(span, ExprRet(Some(call)))
+ cx.expr(span, ExprKind::Ret(Some(call)))
};
stmts.push(cx.stmt_expr(call));
}
} else {
- let ret_ok = cx.expr(trait_span,
- ExprRet(Some(cx.expr_ok(trait_span,
- cx.expr_tuple(trait_span, vec![])))));
+ let ok = cx.expr_ok(trait_span, cx.expr_tuple(trait_span, vec![]));
+ let ret_ok = cx.expr(trait_span, ExprKind::Ret(Some(ok)));
stmts.push(cx.stmt_expr(ret_ok));
}
use std::vec;
use syntax::abi::Abi;
-use syntax::abi;
-use syntax::ast;
-use syntax::ast::{EnumDef, Expr, Ident, Generics, VariantData};
+use syntax::ast::{EnumDef, Expr, Ident, Generics, VariantData, BinOpKind, self};
use syntax::ast_util;
use syntax::attr;
use syntax::attr::AttrMetaMethods;
impl<'a> visit::Visitor<'a> for Visitor<'a> {
fn visit_ty(&mut self, ty: &'a ast::Ty) {
match ty.node {
- ast::TyPath(_, ref path) if !path.global => {
+ ast::TyKind::Path(_, ref path) if !path.global => {
match path.segments.first() {
Some(segment) => {
if self.ty_param_names.contains(&segment.identifier.name) {
match *item {
Annotatable::Item(ref item) => {
let newitem = match item.node {
- ast::ItemStruct(ref struct_def, ref generics) => {
+ ast::ItemKind::Struct(ref struct_def, ref generics) => {
self.expand_struct_def(cx,
&struct_def,
item.ident,
generics)
}
- ast::ItemEnum(ref enum_def, ref generics) => {
+ ast::ItemKind::Enum(ref enum_def, ref generics) => {
self.expand_enum_def(cx,
enum_def,
&item.attrs,
id: ast::DUMMY_NODE_ID,
span: self.span,
ident: ident,
- vis: ast::Inherited,
+ vis: ast::Visibility::Inherited,
attrs: Vec::new(),
node: ast::ImplItemKind::Type(type_def.to_ty(cx,
self.span,
for ty in tys {
// if we have already handled this type, skip it
- if let ast::TyPath(_, ref p) = ty.node {
+ if let ast::TyKind::Path(_, ref p) = ty.node {
if p.segments.len() == 1
&& ty_param_names.contains(&p.segments[0].identifier.name)
|| processed_field_types.contains(&p.segments) {
self.span,
ident,
a,
- ast::ItemImpl(unsafety,
- ast::ImplPolarity::Positive,
- trait_generics,
- opt_trait_ref,
- self_type,
- methods.into_iter().chain(associated_types).collect()))
+ ast::ItemKind::Impl(unsafety,
+ ast::ImplPolarity::Positive,
+ trait_generics,
+ opt_trait_ref,
+ self_type,
+ methods.into_iter().chain(associated_types).collect()))
}
fn expand_struct_def(&self,
self,
type_ident,
generics,
- abi::Rust,
+ Abi::Rust,
explicit_self,
tys,
body)
self,
type_ident,
generics,
- abi::Rust,
+ Abi::Rust,
explicit_self,
tys,
body)
attr::ReprAny | attr::ReprPacked | attr::ReprSimd => continue,
attr::ReprExtern => "i32",
- attr::ReprInt(_, attr::SignedInt(ast::TyIs)) => "isize",
- attr::ReprInt(_, attr::SignedInt(ast::TyI8)) => "i8",
- attr::ReprInt(_, attr::SignedInt(ast::TyI16)) => "i16",
- attr::ReprInt(_, attr::SignedInt(ast::TyI32)) => "i32",
- attr::ReprInt(_, attr::SignedInt(ast::TyI64)) => "i64",
-
- attr::ReprInt(_, attr::UnsignedInt(ast::TyUs)) => "usize",
- attr::ReprInt(_, attr::UnsignedInt(ast::TyU8)) => "u8",
- attr::ReprInt(_, attr::UnsignedInt(ast::TyU16)) => "u16",
- attr::ReprInt(_, attr::UnsignedInt(ast::TyU32)) => "u32",
- attr::ReprInt(_, attr::UnsignedInt(ast::TyU64)) => "u64",
+ attr::ReprInt(_, attr::SignedInt(ast::IntTy::Is)) => "isize",
+ attr::ReprInt(_, attr::SignedInt(ast::IntTy::I8)) => "i8",
+ attr::ReprInt(_, attr::SignedInt(ast::IntTy::I16)) => "i16",
+ attr::ReprInt(_, attr::SignedInt(ast::IntTy::I32)) => "i32",
+ attr::ReprInt(_, attr::SignedInt(ast::IntTy::I64)) => "i64",
+
+ attr::ReprInt(_, attr::UnsignedInt(ast::UintTy::Us)) => "usize",
+ attr::ReprInt(_, attr::UnsignedInt(ast::UintTy::U8)) => "u8",
+ attr::ReprInt(_, attr::UnsignedInt(ast::UintTy::U16)) => "u16",
+ attr::ReprInt(_, attr::UnsignedInt(ast::UintTy::U32)) => "u32",
+ attr::ReprInt(_, attr::UnsignedInt(ast::UintTy::U64)) => "u64",
}
}
}
explicit_self
}
- None => codemap::respan(trait_.span, ast::SelfStatic),
+ None => codemap::respan(trait_.span, ast::SelfKind::Static),
};
for (i, ty) in self.args.iter().enumerate() {
let fn_generics = self.generics.to_generics(cx, trait_.span, type_ident, generics);
let self_arg = match explicit_self.node {
- ast::SelfStatic => None,
+ ast::SelfKind::Static => None,
// creating fresh self id
- _ => Some(ast::Arg::new_self(trait_.span, ast::MutImmutable, special_idents::self_))
+ _ => Some(ast::Arg::new_self(trait_.span,
+ ast::Mutability::Immutable,
+ special_idents::self_))
};
let args = {
let args = arg_types.into_iter().map(|(name, ty)| {
id: ast::DUMMY_NODE_ID,
attrs: self.attributes.clone(),
span: trait_.span,
- vis: ast::Inherited,
+ vis: ast::Visibility::Inherited,
ident: method_ident,
node: ast::ImplItemKind::Method(ast::MethodSig {
generics: fn_generics,
struct_def,
&format!("__self_{}",
i),
- ast::MutImmutable);
+ ast::Mutability::Immutable);
patterns.push(pat);
raw_fields.push(ident_expr);
}
let mut match_arms: Vec<ast::Arm> = variants.iter().enumerate()
.map(|(index, variant)| {
let mk_self_pat = |cx: &mut ExtCtxt, self_arg_name: &str| {
- let (p, idents) = trait_.create_enum_variant_pattern(cx, type_ident,
- &**variant,
- self_arg_name,
- ast::MutImmutable);
- (cx.pat(sp, ast::PatRegion(p, ast::MutImmutable)), idents)
+ let (p, idents) = trait_.create_enum_variant_pattern(
+ cx, type_ident,
+ &**variant,
+ self_arg_name,
+ ast::Mutability::Immutable);
+ (cx.pat(sp, ast::PatRegion(p, ast::Mutability::Immutable)), idents)
};
// A single arm has form (&VariantK, &VariantK, ...) => BodyK
stmts: vec![],
expr: Some(call),
id: ast::DUMMY_NODE_ID,
- rules: ast::UnsafeBlock(ast::CompilerGenerated),
+ rules: ast::BlockCheckMode::Unsafe(ast::CompilerGenerated),
span: sp }));
let target_ty = cx.ty_ident(sp, cx.ident_of(target_type_name));
Some(first) => {
let first_expr = cx.expr_ident(sp, first);
let id = cx.expr_ident(sp, ident);
- let test = cx.expr_binary(sp, ast::BiEq, first_expr, id);
- discriminant_test = cx.expr_binary(sp, ast::BiAnd, discriminant_test, test)
+ let test = cx.expr_binary(sp, BinOpKind::Eq, first_expr, id);
+ discriminant_test = cx.expr_binary(sp, BinOpKind::And,
+ discriminant_test, test)
}
None => {
first_ident = Some(ident);
stmts: vec![],
expr: Some(call),
id: ast::DUMMY_NODE_ID,
- rules: ast::UnsafeBlock(ast::CompilerGenerated),
+ rules: ast::BlockCheckMode::Unsafe(ast::CompilerGenerated),
span: sp }));
match_arms.push(cx.arm(sp, vec![cx.pat_wild(sp)], unreachable));
// expression; here add a layer of borrowing, turning
// `(*self, *__arg_0, ...)` into `(&*self, &*__arg_0, ...)`.
let borrowed_self_args = self_args.move_map(|self_arg| cx.expr_addr_of(sp, self_arg));
- let match_arg = cx.expr(sp, ast::ExprTup(borrowed_self_args));
+ let match_arg = cx.expr(sp, ast::ExprKind::Tup(borrowed_self_args));
//Lastly we create an expression which branches on all discriminants being equal
// if discriminant_test {
// expression; here add a layer of borrowing, turning
// `(*self, *__arg_0, ...)` into `(&*self, &*__arg_0, ...)`.
let borrowed_self_args = self_args.move_map(|self_arg| cx.expr_addr_of(sp, self_arg));
- let match_arg = cx.expr(sp, ast::ExprTup(borrowed_self_args));
+ let match_arg = cx.expr(sp, ast::ExprKind::Tup(borrowed_self_args));
cx.expr_match(sp, match_arg, match_arms)
}
}
};
let ident = cx.ident_of(&format!("{}_{}", prefix, i));
paths.push(codemap::Spanned{span: sp, node: ident});
- let val = cx.expr(
- sp, ast::ExprParen(cx.expr_deref(sp, cx.expr_path(cx.path_ident(sp,ident)))));
+ let val = cx.expr_deref(sp, cx.expr_path(cx.path_ident(sp,ident)));
+ let val = cx.expr(sp, ast::ExprKind::Paren(val));
ident_expr.push((sp, opt_id, val, &struct_field.node.attrs[..]));
}
}
pub fn borrowed_ptrty<'r>() -> PtrTy<'r> {
- Borrowed(None, ast::MutImmutable)
+ Borrowed(None, ast::Mutability::Immutable)
}
pub fn borrowed<'r>(ty: Box<Ty<'r>>) -> Ty<'r> {
Ptr(ty, borrowed_ptrty())
cx.ty_path(self.to_path(cx, span, self_ty, self_generics))
}
Tuple(ref fields) => {
- let ty = ast::TyTup(fields.iter()
+ let ty = ast::TyKind::Tup(fields.iter()
.map(|f| f.to_ty(cx, span, self_ty, self_generics))
.collect());
cx.ty(span, ty)
let self_path = cx.expr_self(span);
match *self_ptr {
None => {
- (self_path, respan(span, ast::SelfValue(special_idents::self_)))
+ (self_path, respan(span, ast::SelfKind::Value(special_idents::self_)))
}
Some(ref ptr) => {
let self_ty = respan(
match *ptr {
Borrowed(ref lt, mutbl) => {
let lt = lt.map(|s| cx.lifetime(span, cx.ident_of(s).name));
- ast::SelfRegion(lt, mutbl, special_idents::self_)
+ ast::SelfKind::Region(lt, mutbl, special_idents::self_)
}
Raw(_) => cx.span_bug(span, "attempted to use *self in deriving definition")
});
use deriving::generic::*;
use deriving::generic::ty::*;
-use syntax::ast::{MetaItem, Expr, MutMutable};
+use syntax::ast::{MetaItem, Expr, Mutability};
use syntax::codemap::Span;
use syntax::ext::base::{ExtCtxt, Annotatable};
use syntax::ext::build::AstBuilder;
vec![path_std!(cx, core::hash::Hasher)])],
},
explicit_self: borrowed_explicit_self(),
- args: vec!(Ptr(Box::new(Literal(arg)), Borrowed(None, MutMutable))),
+ args: vec!(Ptr(Box::new(Literal(arg)), Borrowed(None, Mutability::Mutable))),
ret_ty: nil_ty(),
attributes: vec![],
is_unsafe: 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;
Some(cx.lifetime(sp,
cx.ident_of(
"'static").name)),
- ast::MutImmutable)),
+ ast::Mutability::Immutable)),
Vec::new()))
}
Ok(s) => {
}
// Translate the format
- let fill = self.ecx.expr_lit(sp, ast::LitChar(fill));
+ let fill = self.ecx.expr_lit(sp, ast::LitKind::Char(fill));
let align = |name| {
let mut p = Context::rtpath(self.ecx, "Alignment");
p.push(self.ecx.ident_of(name));
-> P<ast::Expr> {
let sp = piece_ty.span;
let ty = ecx.ty_rptr(sp,
- ecx.ty(sp, ast::TyVec(piece_ty)),
+ ecx.ty(sp, ast::TyKind::Vec(piece_ty)),
Some(ecx.lifetime(sp, special_idents::static_lifetime.name)),
- ast::MutImmutable);
+ ast::Mutability::Immutable);
let slice = ecx.expr_vec_slice(sp, pieces);
// static instead of const to speed up codegen by not requiring this to be inlined
- let st = ast::ItemStatic(ty, ast::MutImmutable, slice);
+ let st = ast::ItemKind::Static(ty, ast::Mutability::Immutable, slice);
let name = ecx.ident_of(name);
let item = ecx.item(sp, name, vec![], st);
- let decl = respan(sp, ast::DeclItem(item));
+ let decl = respan(sp, ast::DeclKind::Item(item));
// Wrap the declaration in a block so that it forms a single expression.
ecx.expr_block(ecx.block(sp,
- vec![P(respan(sp, ast::StmtDecl(P(decl), ast::DUMMY_NODE_ID)))],
+ vec![P(respan(sp, ast::StmtKind::Decl(P(decl), ast::DUMMY_NODE_ID)))],
Some(ecx.expr_ident(sp, name))))
}
self.fmtsp,
self.ecx.ty_ident(self.fmtsp, self.ecx.ident_of("str")),
Some(static_lifetime),
- ast::MutImmutable);
+ ast::Mutability::Immutable);
let pieces = Context::static_array(self.ecx,
"__STATIC_FMTSTR",
piece_ty,
// as series of let's; the first approach does.
let pat = self.ecx.pat_tuple(self.fmtsp, pats);
let arm = self.ecx.arm(self.fmtsp, vec!(pat), args_array);
- let head = self.ecx.expr(self.fmtsp, ast::ExprTup(heads));
+ let head = self.ecx.expr(self.fmtsp, ast::ExprKind::Tup(heads));
let result = self.ecx.expr_match(self.fmtsp, head, vec!(arm));
let args_slice = self.ecx.expr_addr_of(self.fmtsp, result);
let zero = cx.expr_isize(span, 0);
cs_fold(false,
|cx, span, subexpr, field, _| {
- cx.expr_binary(span, ast::BiAdd, subexpr,
+ cx.expr_binary(span, ast::BinOpKind::Add, subexpr,
cx.expr_method_call(span, field,
token::str_to_ident("total_sum"), vec![]))
},
if item.attrs.iter().find(|a| a.check_name("ignore")).is_some() {
acc
} else {
- cx.expr_binary(item.span, ast::BiAdd, acc,
+ cx.expr_binary(item.span, ast::BinOpKind::Add, acc,
cx.expr_method_call(item.span,
item.self_.clone(),
substr.method_ident,
extern crate rustc;
extern crate rustc_plugin;
-use syntax::ast::{self, TokenTree, Item, MetaItem, ImplItem, TraitItem};
+use syntax::ast::{self, TokenTree, Item, MetaItem, ImplItem, TraitItem, ItemKind};
use syntax::codemap::Span;
use syntax::ext::base::*;
use syntax::parse::{self, token};
Annotatable::ImplItem(it) => {
quote_item!(cx, impl X { fn foo(&self) -> i32 { 42 } }).unwrap().and_then(|i| {
match i.node {
- ast::ItemImpl(_, _, _, _, _, mut items) => {
+ ItemKind::Impl(_, _, _, _, _, mut items) => {
Annotatable::ImplItem(items.pop().expect("impl method not found"))
}
_ => unreachable!("impl parsed to something other than impl")
Annotatable::TraitItem(it) => {
quote_item!(cx, trait X { fn foo(&self) -> i32 { 0 } }).unwrap().and_then(|i| {
match i.node {
- ast::ItemTrait(_, _, _, mut items) => {
+ ItemKind::Trait(_, _, _, mut items) => {
Annotatable::TraitItem(items.pop().expect("trait method not found"))
}
_ => unreachable!("trait parsed to something other than trait")
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");
}
fn main() {
- let _ = foo::X; //~ ERROR unresolved name `foo::X`
+ let _ = foo::X;
}
use bar::Baz as x; //~ ERROR unresolved import `bar::Baz`. There is no `Baz` in `bar`. Did you mean to use `Bar`?
-use food::baz; //~ ERROR unresolved import `food::baz`. There is no `baz` in `food`. Did you mean to use the re-exported import `bag`?
+use food::baz; //~ ERROR unresolved import `food::baz`. There is no `baz` in `food`. Did you mean to use `bag`?
-use food::{beens as Foo}; //~ ERROR unresolved import `food::beens`. There is no `beens` in `food`. Did you mean to use the re-exported import `beans`?
+use food::{beens as Foo}; //~ ERROR unresolved import `food::beens`. There is no `beens` in `food`. Did you mean to use `beans`?
mod bar {
pub struct Bar;
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Verify that '>' is not both expected and found at the same time, as it used
+// to happen in #24780. For example, following should be an error:
+// expected one of ..., `>`, ... found `>`
+//
+// compile-flags: -Z parse-only
+
+fn foo() -> Vec<usize>> {
+ //~^ ERROR expected one of `!`, `::`, `where`, or `{`, found `>`
+ Vec::new()
+}
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// ignore-windows - this is a unix-specific test
+
+#![feature(process_exec, libc)]
+
+extern crate libc;
+
+use std::env;
+use std::io::Error;
+use std::os::unix::process::CommandExt;
+use std::process::Command;
+use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+fn main() {
+ if let Some(arg) = env::args().skip(1).next() {
+ match &arg[..] {
+ "test1" => println!("hello2"),
+ "test2" => assert_eq!(env::var("FOO").unwrap(), "BAR"),
+ "test3" => assert_eq!(env::current_dir().unwrap()
+ .to_str().unwrap(), "/"),
+ "empty" => {}
+ _ => panic!("unknown argument: {}", arg),
+ }
+ return
+ }
+
+ let me = env::current_exe().unwrap();
+
+ let output = Command::new(&me).arg("test1").before_exec(|| {
+ println!("hello");
+ Ok(())
+ }).output().unwrap();
+ assert!(output.status.success());
+ assert!(output.stderr.is_empty());
+ assert_eq!(output.stdout, b"hello\nhello2\n");
+
+ let output = Command::new(&me).arg("test2").before_exec(|| {
+ env::set_var("FOO", "BAR");
+ Ok(())
+ }).output().unwrap();
+ assert!(output.status.success());
+ assert!(output.stderr.is_empty());
+ assert!(output.stdout.is_empty());
+
+ let output = Command::new(&me).arg("test3").before_exec(|| {
+ env::set_current_dir("/").unwrap();
+ Ok(())
+ }).output().unwrap();
+ assert!(output.status.success());
+ assert!(output.stderr.is_empty());
+ assert!(output.stdout.is_empty());
+
+ let output = Command::new(&me).arg("bad").before_exec(|| {
+ Err(Error::from_raw_os_error(102))
+ }).output().err().unwrap();
+ assert_eq!(output.raw_os_error(), Some(102));
+
+ let pid = unsafe { libc::getpid() };
+ assert!(pid >= 0);
+ let output = Command::new(&me).arg("empty").before_exec(move || {
+ let child = unsafe { libc::getpid() };
+ assert!(child >= 0);
+ assert!(pid != child);
+ Ok(())
+ }).output().unwrap();
+ assert!(output.status.success());
+ assert!(output.stderr.is_empty());
+ assert!(output.stdout.is_empty());
+
+ let mem = Arc::new(AtomicUsize::new(0));
+ let mem2 = mem.clone();
+ let output = Command::new(&me).arg("empty").before_exec(move || {
+ assert_eq!(mem2.fetch_add(1, Ordering::SeqCst), 0);
+ Ok(())
+ }).output().unwrap();
+ assert!(output.status.success());
+ assert!(output.stderr.is_empty());
+ assert!(output.stdout.is_empty());
+ assert_eq!(mem.load(Ordering::SeqCst), 0);
+}
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// ignore-windows - this is a unix-specific test
+// ignore-pretty
+
+#![feature(process_exec)]
+
+use std::env;
+use std::os::unix::process::CommandExt;
+use std::process::Command;
+
+fn main() {
+ let mut args = env::args();
+ let me = args.next().unwrap();
+
+ if let Some(arg) = args.next() {
+ match &arg[..] {
+ "test1" => println!("passed"),
+
+ "exec-test1" => {
+ let err = Command::new(&me).arg("test1").exec();
+ panic!("failed to spawn: {}", err);
+ }
+
+ "exec-test2" => {
+ Command::new("/path/to/nowhere").exec();
+ println!("passed");
+ }
+
+ "exec-test3" => {
+ Command::new(&me).arg("bad\0").exec();
+ println!("passed");
+ }
+
+ "exec-test4" => {
+ Command::new(&me).current_dir("/path/to/nowhere").exec();
+ println!("passed");
+ }
+
+ _ => panic!("unknown argument: {}", arg),
+ }
+ return
+ }
+
+ let output = Command::new(&me).arg("exec-test1").output().unwrap();
+ assert!(output.status.success());
+ assert!(output.stderr.is_empty());
+ assert_eq!(output.stdout, b"passed\n");
+
+ let output = Command::new(&me).arg("exec-test2").output().unwrap();
+ assert!(output.status.success());
+ assert!(output.stderr.is_empty());
+ assert_eq!(output.stdout, b"passed\n");
+
+ let output = Command::new(&me).arg("exec-test3").output().unwrap();
+ assert!(output.status.success());
+ assert!(output.stderr.is_empty());
+ assert_eq!(output.stdout, b"passed\n");
+
+ let output = Command::new(&me).arg("exec-test4").output().unwrap();
+ assert!(output.status.success());
+ assert!(output.stderr.is_empty());
+ assert_eq!(output.stdout, b"passed\n");
+}
--- /dev/null
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct A<'a> {
+ a: &'a i32,
+ b: &'a i32,
+}
+
+impl <'a> A<'a> {
+ fn foo<'b>(&'b self) {
+ A {
+ a: self.a,
+ b: self.b,
+ };
+ }
+}
+
+fn main() { }
target_os = "netbsd",
target_os = "openbsd",
target_os = "android",
- target_os = "solaris"))]
+ target_os = "solaris",
+ target_os = "emscripten"))]
pub fn main() { }
projects / rust.git / commitdiff