[breaking batch] don't glob export ast::UnOp variants

src/librustc/front/check_attr.rs

@@ -26,9 +26,9 @@ enum Target {
 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,
  }
  }

src/librustc/front/map/mod.rs

@@ -20,7 +20,7 @@ use middle::cstore::InlinedItem;
 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;
@@ -512,7 +512,7 @@ impl<'ast> Map<'ast> {
  }
  }
 
- 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)) => {
@@ -522,7 +522,7 @@ impl<'ast> Map<'ast> {
  }
  }
  /// Wrong but OK, because the only inlined foreign items are intrinsics.
- Some(RootInlinedParent(_)) => Some(abi::RustIntrinsic),
+ Some(RootInlinedParent(_)) => Some(Abi::RustIntrinsic),
  _ => None
  };
  match abi {

src/librustc/lint/context.rs

@@ -374,7 +374,7 @@ pub fn gather_attr(attr: &ast::Attribute)
 
  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;
@@ -383,7 +383,7 @@ pub fn gather_attr(attr: &ast::Attribute)
 
  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),
  });
  }

src/librustc/middle/check_match.rs

@@ -421,7 +421,7 @@ fn check_exhaustive(cx: &MatchCheckCtxt, sp: Span, matrix: &Matrix, source: hir:
 
 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 {

src/librustc/middle/const_eval.rs

@@ -545,34 +545,34 @@ pub enum UintTy { U8, U16, U32, U64 }
 
 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,
  }
  }
 }
@@ -1289,65 +1289,63 @@ fn cast_const<'tcx>(tcx: &ty::ctxt<'tcx>, val: ConstVal, ty: Ty) -> CastResult {
 
  // 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 {
  // FIXME(#31407) this is only necessary because float parsing is buggy
  sess.span_bug(span, "could not evaluate float literal (see issue #31407)");
  }
  }
- ast::LitBool(b) => Bool(b)
+ ast::LitKind::Bool(b) => Bool(b)
  }
 }
 

src/librustc/middle/intrinsicck.rs

@@ -17,7 +17,7 @@ use middle::ty::{self, Ty, TypeFoldable};
 
 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};

src/librustc/middle/reachable.rs

@@ -25,7 +25,7 @@ use session::config;
 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;
@@ -236,7 +236,7 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> {
  // 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);
  }
  }

src/librustc/middle/traits/select.rs

@@ -46,7 +46,7 @@ use middle::ty::relate::TypeRelation;
 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;
@@ -1288,7 +1288,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
  // 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(_),

src/librustc/middle/ty/contents.rs

@@ -180,7 +180,7 @@ impl<'tcx> ty::TyS<'tcx> {
 
  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
  }
 

src/librustc/middle/ty/context.rs

@@ -44,7 +44,7 @@ use std::borrow::Borrow;
 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;
@@ -192,18 +192,18 @@ impl<'tcx> CommonTypes<'tcx> {
  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)),
  }
  }
 }
@@ -840,28 +840,28 @@ impl<'tcx> ctxt<'tcx> {
 
  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,
  }
  }
 
@@ -943,7 +943,7 @@ impl<'tcx> ctxt<'tcx> {
  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),

src/librustc/middle/ty/relate.rs

@@ -105,8 +105,8 @@ impl<'a,'tcx:'a> Relate<'a,'tcx> for ty::TypeAndMut<'tcx> {
  } 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})

src/librustc/middle/ty/sty.rs

@@ -977,7 +977,7 @@ impl<'tcx> TyS<'tcx> {
  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)),
  }
@@ -1068,7 +1068,7 @@ impl<'tcx> TyS<'tcx> {
 
  pub fn is_uint(&self) -> bool {
  match self.sty {
- TyInfer(IntVar(_)) | TyUint(ast::TyUs) => true,
+ TyInfer(IntVar(_)) | TyUint(ast::UintTy::Us) => true,
  _ => false
  }
  }
@@ -1114,7 +1114,7 @@ impl<'tcx> TyS<'tcx> {
 
  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
  }