diff options
| author | Eli Friedman <eli.friedman@gmail.com> | 2015-06-11 16:21:46 -0700 |
|---|---|---|
| committer | Eli Friedman <eli.friedman@gmail.com> | 2015-06-12 11:07:16 -0700 |
| commit | 3c69db4c3c8039ccd313188fa2d0f0d83bba6914 (patch) | |
| tree | ff2c5c96ed81f5a94187601a8426c0f5a496dcde | |
| parent | 0da58cc361577d63afdcb84945a9f011970301e3 (diff) | |
| download | rust-3c69db4c3c8039ccd313188fa2d0f0d83bba6914.tar.gz rust-3c69db4c3c8039ccd313188fa2d0f0d83bba6914.zip | |
Cleanup: rename middle::ty::sty and its variants.
Use camel-case naming, and use names which actually make sense in modern Rust.
89 files changed, 1385 insertions, 1338 deletions
diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 195d993d14b..5a79ef203b4 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -719,7 +719,7 @@ pub fn get_enum_variants<'tcx>(intr: Rc<IdentInterner>, cdata: Cmd, id: ast::Nod item, tcx, cdata); let name = item_name(&*intr, item); let (ctor_ty, arg_tys, arg_names) = match ctor_ty.sty { - ty::ty_bare_fn(_, ref f) => + ty::TyBareFn(_, ref f) => (Some(ctor_ty), f.sig.0.inputs.clone(), None), _ => { // Nullary or struct enum variant. let mut arg_names = Vec::new(); diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index 6d83ab152d5..ad650fcfb11 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -28,7 +28,7 @@ use syntax::abi; use syntax::ast; use syntax::parse::token; -// Compact string representation for Ty values. API ty_str & +// Compact string representation for Ty values. API TyStr & // parse_from_str. Extra parameters are for converting to/from def_ids in the // data buffer. Whatever format you choose should not contain pipe characters. diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs index f5f520720c6..8f78e97c4bb 100644 --- a/src/librustc/metadata/tyencode.rs +++ b/src/librustc/metadata/tyencode.rs @@ -41,7 +41,7 @@ pub struct ctxt<'a, 'tcx: 'a> { pub abbrevs: &'a abbrev_map<'tcx> } -// Compact string representation for Ty values. API ty_str & parse_from_str. +// Compact string representation for Ty values. API TyStr & parse_from_str. // Extra parameters are for converting to/from def_ids in the string rep. // Whatever format you choose should not contain pipe characters. pub struct ty_abbrev { @@ -60,9 +60,9 @@ pub fn enc_ty<'a, 'tcx>(w: &mut Encoder, cx: &ctxt<'a, 'tcx>, t: Ty<'tcx>) { let pos = w.mark_stable_position(); match t.sty { - ty::ty_bool => mywrite!(w, "b"), - ty::ty_char => mywrite!(w, "c"), - ty::ty_int(t) => { + ty::TyBool => mywrite!(w, "b"), + ty::TyChar => mywrite!(w, "c"), + ty::TyInt(t) => { match t { ast::TyIs => mywrite!(w, "is"), ast::TyI8 => mywrite!(w, "MB"), @@ -71,7 +71,7 @@ pub fn enc_ty<'a, 'tcx>(w: &mut Encoder, cx: &ctxt<'a, 'tcx>, t: Ty<'tcx>) { ast::TyI64 => mywrite!(w, "MD") } } - ty::ty_uint(t) => { + ty::TyUint(t) => { match t { ast::TyUs => mywrite!(w, "us"), ast::TyU8 => mywrite!(w, "Mb"), @@ -80,37 +80,37 @@ pub fn enc_ty<'a, 'tcx>(w: &mut Encoder, cx: &ctxt<'a, 'tcx>, t: Ty<'tcx>) { ast::TyU64 => mywrite!(w, "Md") } } - ty::ty_float(t) => { + ty::TyFloat(t) => { match t { ast::TyF32 => mywrite!(w, "Mf"), ast::TyF64 => mywrite!(w, "MF"), } } - ty::ty_enum(def, substs) => { + ty::TyEnum(def, substs) => { mywrite!(w, "t[{}|", (cx.ds)(def)); enc_substs(w, cx, substs); mywrite!(w, "]"); } - ty::ty_trait(box ty::TyTrait { ref principal, + ty::TyTrait(box ty::TraitTy { ref principal, ref bounds }) => { mywrite!(w, "x["); enc_trait_ref(w, cx, principal.0); enc_existential_bounds(w, cx, bounds); mywrite!(w, "]"); } - ty::ty_tup(ref ts) => { + ty::TyTuple(ref ts) => { mywrite!(w, "T["); for t in ts { enc_ty(w, cx, *t); } mywrite!(w, "]"); } - ty::ty_uniq(typ) => { mywrite!(w, "~"); enc_ty(w, cx, typ); } - ty::ty_ptr(mt) => { mywrite!(w, "*"); enc_mt(w, cx, mt); } - ty::ty_rptr(r, mt) => { + ty::TyBox(typ) => { mywrite!(w, "~"); enc_ty(w, cx, typ); } + ty::TyRawPtr(mt) => { mywrite!(w, "*"); enc_mt(w, cx, mt); } + ty::TyRef(r, mt) => { mywrite!(w, "&"); enc_region(w, cx, *r); enc_mt(w, cx, mt); } - ty::ty_vec(t, sz) => { + ty::TyArray(t, sz) => { mywrite!(w, "V"); enc_ty(w, cx, t); mywrite!(w, "/"); @@ -119,40 +119,40 @@ pub fn enc_ty<'a, 'tcx>(w: &mut Encoder, cx: &ctxt<'a, 'tcx>, t: Ty<'tcx>) { None => mywrite!(w, "|"), } } - ty::ty_str => { + ty::TyStr => { mywrite!(w, "v"); } - ty::ty_bare_fn(Some(def_id), f) => { + ty::TyBareFn(Some(def_id), f) => { mywrite!(w, "F"); mywrite!(w, "{}|", (cx.ds)(def_id)); enc_bare_fn_ty(w, cx, f); } - ty::ty_bare_fn(None, f) => { + ty::TyBareFn(None, f) => { mywrite!(w, "G"); enc_bare_fn_ty(w, cx, f); } - ty::ty_infer(_) => { + ty::TyInfer(_) => { cx.diag.handler().bug("cannot encode inference variable types"); } - ty::ty_param(ParamTy {space, idx, name}) => { + ty::TyParam(ParamTy {space, idx, name}) => { mywrite!(w, "p[{}|{}|{}]", idx, space.to_uint(), token::get_name(name)) } - ty::ty_struct(def, substs) => { + ty::TyStruct(def, substs) => { mywrite!(w, "a[{}|", (cx.ds)(def)); enc_substs(w, cx, substs); mywrite!(w, "]"); } - ty::ty_closure(def, substs) => { + ty::TyClosure(def, substs) => { mywrite!(w, "k[{}|", (cx.ds)(def)); enc_substs(w, cx, substs); mywrite!(w, "]"); } - ty::ty_projection(ref data) => { + ty::TyProjection(ref data) => { mywrite!(w, "P["); enc_trait_ref(w, cx, data.trait_ref); mywrite!(w, "{}]", token::get_name(data.item_name)); } - ty::ty_err => { + ty::TyError => { mywrite!(w, "e"); } } diff --git a/src/librustc/middle/cast.rs b/src/librustc/middle/cast.rs index c534a3ca038..34088d5f13e 100644 --- a/src/librustc/middle/cast.rs +++ b/src/librustc/middle/cast.rs @@ -61,16 +61,16 @@ impl<'tcx> CastTy<'tcx> { pub fn from_ty(tcx: &ty::ctxt<'tcx>, t: Ty<'tcx>) -> Option<CastTy<'tcx>> { match t.sty { - ty::ty_bool => Some(CastTy::Int(IntTy::Bool)), - ty::ty_char => Some(CastTy::Int(IntTy::Char)), - ty::ty_int(_) => Some(CastTy::Int(IntTy::I)), - ty::ty_uint(u) => Some(CastTy::Int(IntTy::U(u))), - ty::ty_float(_) => Some(CastTy::Float), - ty::ty_enum(..) if ty::type_is_c_like_enum( + ty::TyBool => Some(CastTy::Int(IntTy::Bool)), + ty::TyChar => Some(CastTy::Int(IntTy::Char)), + ty::TyInt(_) => Some(CastTy::Int(IntTy::I)), + ty::TyUint(u) => Some(CastTy::Int(IntTy::U(u))), + ty::TyFloat(_) => Some(CastTy::Float), + ty::TyEnum(..) if ty::type_is_c_like_enum( tcx, t) => Some(CastTy::Int(IntTy::CEnum)), - ty::ty_ptr(ref mt) => Some(CastTy::Ptr(mt)), - ty::ty_rptr(_, ref mt) => Some(CastTy::RPtr(mt)), - ty::ty_bare_fn(..) => Some(CastTy::FnPtr), + ty::TyRawPtr(ref mt) => Some(CastTy::Ptr(mt)), + ty::TyRef(_, ref mt) => Some(CastTy::RPtr(mt)), + ty::TyBareFn(..) => Some(CastTy::FnPtr), _ => None, } } diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs index 567a67d1bee..2d27e9d2ed6 100644 --- a/src/librustc/middle/check_const.rs +++ b/src/librustc/middle/check_const.rs @@ -423,7 +423,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> { self.visit_expr(&**element); // The count is checked elsewhere (typeck). let count = match node_ty.sty { - ty::ty_vec(_, Some(n)) => n, + ty::TyArray(_, Some(n)) => n, _ => unreachable!() }; // [element; 0] is always zero-sized. @@ -454,7 +454,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> { visit::walk_expr(self, ex); let div_or_rem = op.node == ast::BiDiv || op.node == ast::BiRem; match node_ty.sty { - ty::ty_uint(_) | ty::ty_int(_) if div_or_rem => { + ty::TyUint(_) | ty::TyInt(_) if div_or_rem => { if !self.qualif.intersects(ConstQualif::NOT_CONST) { match const_eval::eval_const_expr_partial(self.tcx, ex, None) { Ok(_) => {} @@ -529,8 +529,8 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> { fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, e: &ast::Expr, node_ty: Ty<'tcx>) { match node_ty.sty { - ty::ty_struct(did, _) | - ty::ty_enum(did, _) if ty::has_dtor(v.tcx, did) => { + ty::TyStruct(did, _) | + ty::TyEnum(did, _) if ty::has_dtor(v.tcx, did) => { v.add_qualif(ConstQualif::NEEDS_DROP); if v.mode != Mode::Var { v.tcx.sess.span_err(e.span, @@ -562,7 +562,7 @@ fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, } ast::ExprUnary(op, ref inner) => { match ty::node_id_to_type(v.tcx, inner.id).sty { - ty::ty_ptr(_) => { + ty::TyRawPtr(_) => { assert!(op == ast::UnDeref); v.add_qualif(ConstQualif::NOT_CONST); @@ -576,7 +576,7 @@ fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, } ast::ExprBinary(op, ref lhs, _) => { match ty::node_id_to_type(v.tcx, lhs.id).sty { - ty::ty_ptr(_) => { + ty::TyRawPtr(_) => { assert!(op.node == ast::BiEq || op.node == ast::BiNe || op.node == ast::BiLe || op.node == ast::BiLt || op.node == ast::BiGe || op.node == ast::BiGt); @@ -612,7 +612,7 @@ fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, v.add_qualif(ConstQualif::NON_ZERO_SIZED); } Some(def::DefStruct(_)) => { - if let ty::ty_bare_fn(..) = node_ty.sty { + if let ty::TyBareFn(..) = node_ty.sty { // Count the function pointer. v.add_qualif(ConstQualif::NON_ZERO_SIZED); } @@ -854,7 +854,7 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for CheckCrateVisitor<'a, 'tcx> { // Mutable slices are the only `&mut` allowed in globals, // but only in `static mut`, nowhere else. match cmt.ty.sty { - ty::ty_vec(_, _) => break, + ty::TyArray(_, _) => break, _ => {} } } diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index 88be86ac37b..f3ba9148ba6 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -234,7 +234,7 @@ fn check_for_bindings_named_the_same_as_variants(cx: &MatchCheckCtxt, pat: &Pat) match p.node { ast::PatIdent(ast::BindByValue(ast::MutImmutable), ident, None) => { let pat_ty = ty::pat_ty(cx.tcx, p); - if let ty::ty_enum(def_id, _) = pat_ty.sty { + if let ty::TyEnum(def_id, _) = pat_ty.sty { let def = cx.tcx.def_map.borrow().get(&p.id).map(|d| d.full_def()); if let Some(DefLocal(_)) = def { if ty::enum_variants(cx.tcx, def_id).iter().any(|variant| @@ -506,9 +506,9 @@ fn construct_witness(cx: &MatchCheckCtxt, ctor: &Constructor, let pats_len = pats.len(); let mut pats = pats.into_iter().map(|p| P((*p).clone())); let pat = match left_ty.sty { - ty::ty_tup(_) => ast::PatTup(pats.collect()), + ty::TyTuple(_) => ast::PatTup(pats.collect()), - ty::ty_enum(cid, _) | ty::ty_struct(cid, _) => { + ty::TyEnum(cid, _) | ty::TyStruct(cid, _) => { let (vid, is_structure) = match ctor { &Variant(vid) => (vid, ty::enum_variant_with_id(cx.tcx, cid, vid).arg_names.is_some()), @@ -535,23 +535,23 @@ fn construct_witness(cx: &MatchCheckCtxt, ctor: &Constructor, } } - ty::ty_rptr(_, ty::mt { ty, mutbl }) => { + ty::TyRef(_, ty::mt { ty, mutbl }) => { match ty.sty { - ty::ty_vec(_, Some(n)) => match ctor { + ty::TyArray(_, Some(n)) => match ctor { &Single => { assert_eq!(pats_len, n); ast::PatVec(pats.collect(), None, vec!()) }, _ => unreachable!() }, - ty::ty_vec(_, None) => match ctor { + ty::TyArray(_, None) => match ctor { &Slice(n) => { assert_eq!(pats_len, n); ast::PatVec(pats.collect(), None, vec!()) }, _ => unreachable!() }, - ty::ty_str => ast::PatWild(ast::PatWildSingle), + ty::TyStr => ast::PatWild(ast::PatWildSingle), _ => { assert_eq!(pats_len, 1); @@ -560,7 +560,7 @@ fn construct_witness(cx: &MatchCheckCtxt, ctor: &Constructor, } } - ty::ty_vec(_, Some(len)) => { + ty::TyArray(_, Some(len)) => { assert_eq!(pats_len, len); ast::PatVec(pats.collect(), None, vec![]) } @@ -597,16 +597,16 @@ fn missing_constructor(cx: &MatchCheckCtxt, &Matrix(ref rows): &Matrix, fn all_constructors(cx: &MatchCheckCtxt, left_ty: Ty, max_slice_length: usize) -> Vec<Constructor> { match left_ty.sty { - ty::ty_bool => + ty::TyBool => [true, false].iter().map(|b| ConstantValue(const_bool(*b))).collect(), - ty::ty_rptr(_, ty::mt { ty, .. }) => match ty.sty { - ty::ty_vec(_, None) => + ty::TyRef(_, ty::mt { ty, .. }) => match ty.sty { + ty::TyArray(_, None) => range_inclusive(0, max_slice_length).map(|length| Slice(length)).collect(), _ => vec!(Single) }, - ty::ty_enum(eid, _) => + ty::TyEnum(eid, _) => ty::enum_variants(cx.tcx, eid) .iter() .map(|va| Variant(va.id)) @@ -779,7 +779,7 @@ fn pat_constructors(cx: &MatchCheckCtxt, p: &Pat, vec!(ConstantRange(eval_const_expr(cx.tcx, &**lo), eval_const_expr(cx.tcx, &**hi))), ast::PatVec(ref before, ref slice, ref after) => match left_ty.sty { - ty::ty_vec(_, Some(_)) => vec!(Single), + ty::TyArray(_, Some(_)) => vec!(Single), _ => if slice.is_some() { range_inclusive(before.len() + after.len(), max_slice_length) .map(|length| Slice(length)) @@ -804,25 +804,25 @@ fn pat_constructors(cx: &MatchCheckCtxt, p: &Pat, /// A struct pattern's arity is the number of fields it contains, etc. pub fn constructor_arity(cx: &MatchCheckCtxt, ctor: &Constructor, ty: Ty) -> usize { match ty.sty { - ty::ty_tup(ref fs) => fs.len(), - ty::ty_uniq(_) => 1, - ty::ty_rptr(_, ty::mt { ty, .. }) => match ty.sty { - ty::ty_vec(_, None) => match *ctor { + ty::TyTuple(ref fs) => fs.len(), + ty::TyBox(_) => 1, + ty::TyRef(_, ty::mt { ty, .. }) => match ty.sty { + ty::TyArray(_, None) => match *ctor { Slice(length) => length, ConstantValue(_) => 0, _ => unreachable!() }, - ty::ty_str => 0, + ty::TyStr => 0, _ => 1 }, - ty::ty_enum(eid, _) => { + ty::TyEnum(eid, _) => { match *ctor { Variant(id) => enum_variant_with_id(cx.tcx, eid, id).args.len(), _ => unreachable!() } } - ty::ty_struct(cid, _) => ty::lookup_struct_fields(cx.tcx, cid).len(), - ty::ty_vec(_, Some(n)) => n, + ty::TyStruct(cid, _) => ty::lookup_struct_fields(cx.tcx, cid).len(), + ty::TyArray(_, Some(n)) => n, _ => 0 } } diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index e35a71be123..f64765f9090 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -732,11 +732,11 @@ pub fn eval_const_expr_with_substs<'tcx, S>(tcx: &ty::ctxt<'tcx>, // bindings so that isize/usize is mapped to a type with an // inherently known bitwidth. let expr_int_type = ety.and_then(|ty| { - if let ty::ty_int(t) = ty.sty { + if let ty::TyInt(t) = ty.sty { Some(IntTy::from(tcx, t)) } else { None } }); let expr_uint_type = ety.and_then(|ty| { - if let ty::ty_uint(t) = ty.sty { + if let ty::TyUint(t) = ty.sty { Some(UintTy::from(tcx, t)) } else { None } }); @@ -1093,33 +1093,33 @@ fn cast_const<'tcx>(tcx: &ty::ctxt<'tcx>, val: const_val, 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::ty_int(ast::TyIs), ast::TyI32, _) => return convert_val!(i32, const_int, i64), - (&ty::ty_int(ast::TyIs), ast::TyI64, _) => return convert_val!(i64, const_int, i64), - (&ty::ty_int(ast::TyIs), _, _) => panic!("unexpected target.int_type"), + (&ty::TyInt(ast::TyIs), ast::TyI32, _) => return convert_val!(i32, const_int, i64), + (&ty::TyInt(ast::TyIs), ast::TyI64, _) => return convert_val!(i64, const_int, i64), + (&ty::TyInt(ast::TyIs), _, _) => panic!("unexpected target.int_type"), - (&ty::ty_uint(ast::TyUs), _, ast::TyU32) => return convert_val!(u32, const_uint, u64), - (&ty::ty_uint(ast::TyUs), _, ast::TyU64) => return convert_val!(u64, const_uint, u64), - (&ty::ty_uint(ast::TyUs), _, _) => panic!("unexpected target.uint_type"), + (&ty::TyUint(ast::TyUs), _, ast::TyU32) => return convert_val!(u32, const_uint, u64), + (&ty::TyUint(ast::TyUs), _, ast::TyU64) => return convert_val!(u64, const_uint, u64), + (&ty::TyUint(ast::TyUs), _, _) => panic!("unexpected target.uint_type"), _ => {} } match ty.sty { - ty::ty_int(ast::TyIs) => unreachable!(), - ty::ty_uint(ast::TyUs) => unreachable!(), + ty::TyInt(ast::TyIs) => unreachable!(), + ty::TyUint(ast::TyUs) => unreachable!(), - ty::ty_int(ast::TyI8) => convert_val!(i8, const_int, i64), - ty::ty_int(ast::TyI16) => convert_val!(i16, const_int, i64), - ty::ty_int(ast::TyI32) => convert_val!(i32, const_int, i64), - ty::ty_int(ast::TyI64) => convert_val!(i64, const_int, i64), + ty::TyInt(ast::TyI8) => convert_val!(i8, const_int, i64), + ty::TyInt(ast::TyI16) => convert_val!(i16, const_int, i64), + ty::TyInt(ast::TyI32) => convert_val!(i32, const_int, i64), + ty::TyInt(ast::TyI64) => convert_val!(i64, const_int, i64), - ty::ty_uint(ast::TyU8) => convert_val!(u8, const_uint, u64), - ty::ty_uint(ast::TyU16) => convert_val!(u16, const_uint, u64), - ty::ty_uint(ast::TyU32) => convert_val!(u32, const_uint, u64), - ty::ty_uint(ast::TyU64) => convert_val!(u64, const_uint, u64), + ty::TyUint(ast::TyU8) => convert_val!(u8, const_uint, u64), + ty::TyUint(ast::TyU16) => convert_val!(u16, const_uint, u64), + ty::TyUint(ast::TyU32) => convert_val!(u32, const_uint, u64), + ty::TyUint(ast::TyU64) => convert_val!(u64, const_uint, u64), - ty::ty_float(ast::TyF32) => convert_val!(f32, const_float, f64), - ty::ty_float(ast::TyF64) => convert_val!(f64, const_float, f64), + ty::TyFloat(ast::TyF32) => convert_val!(f32, const_float, f64), + ty::TyFloat(ast::TyF64) => convert_val!(f64, const_float, f64), _ => Err(ErrKind::CannotCast), } } @@ -1135,7 +1135,7 @@ fn lit_to_const(lit: &ast::Lit, ty_hint: Option<Ty>) -> const_val { ast::LitInt(n, ast::SignedIntLit(_, ast::Plus)) => const_int(n as i64), ast::LitInt(n, ast::UnsuffixedIntLit(ast::Plus)) => { match ty_hint.map(|ty| &ty.sty) { - Some(&ty::ty_uint(_)) => const_uint(n), + Some(&ty::TyUint(_)) => const_uint(n), _ => const_int(n as i64) } } diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index 539c0940b70..5068836b557 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -129,7 +129,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { fn handle_field_access(&mut self, lhs: &ast::Expr, name: ast::Name) { match ty::expr_ty_adjusted(self.tcx, lhs).sty { - ty::ty_struct(id, _) => { + ty::TyStruct(id, _) => { let fields = ty::lookup_struct_fields(self.tcx, id); let field_id = fields.iter() .find(|field| field.name == name).unwrap().id; @@ -141,7 +141,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { fn handle_tup_field_access(&mut self, lhs: &ast::Expr, idx: usize) { match ty::expr_ty_adjusted(self.tcx, lhs).sty { - ty::ty_struct(id, _) => { + ty::TyStruct(id, _) => { let fields = ty::lookup_struct_fields(self.tcx, id); let field_id = fields[idx].id; self.live_symbols.insert(field_id.node); diff --git a/src/librustc/middle/effect.rs b/src/librustc/middle/effect.rs index defdf2ae088..d23c8a4bc1e 100644 --- a/src/librustc/middle/effect.rs +++ b/src/librustc/middle/effect.rs @@ -31,7 +31,7 @@ enum UnsafeContext { fn type_is_unsafe_function(ty: Ty) -> bool { match ty.sty { - ty::ty_bare_fn(_, ref f) => f.unsafety == ast::Unsafety::Unsafe, + ty::TyBareFn(_, ref f) => f.unsafety == ast::Unsafety::Unsafe, _ => false, } } @@ -69,11 +69,11 @@ impl<'a, 'tcx> EffectCheckVisitor<'a, 'tcx> { debug!("effect: checking index with base type {}", ppaux::ty_to_string(self.tcx, base_type)); match base_type.sty { - ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) => if ty::ty_str == ty.sty { + ty::TyBox(ty) | ty::TyRef(_, ty::mt{ty, ..}) => if ty::TyStr == ty.sty { span_err!(self.tcx.sess, e.span, E0134, "modification of string types is not allowed"); }, - ty::ty_str => { + ty::TyStr => { span_err!(self.tcx.sess, e.span, E0135, "modification of string types is not allowed"); } @@ -161,7 +161,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EffectCheckVisitor<'a, 'tcx> { let base_type = ty::node_id_to_type(self.tcx, base.id); debug!("effect: unary case, base type is {}", ppaux::ty_to_string(self.tcx, base_type)); - if let ty::ty_ptr(_) = base_type.sty { + if let ty::TyRawPtr(_) = base_type.sty { self.require_unsafe(expr.span, "dereference of raw pointer") } } diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index 406734ba687..3c9a4def5c8 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -622,10 +622,10 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { callee.repr(self.tcx()), callee_ty.repr(self.tcx())); let call_scope = region::CodeExtent::from_node_id(call.id); match callee_ty.sty { - ty::ty_bare_fn(..) => { + ty::TyBareFn(..) => { self.consume_expr(callee); } - ty::ty_err => { } + ty::TyError => { } _ => { let overloaded_call_type = match self.typer.node_method_origin(MethodCall::expr(call.id)) { @@ -740,7 +740,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { // Select just those fields of the `with` // expression that will actually be used let with_fields = match with_cmt.ty.sty { - ty::ty_struct(did, substs) => { + ty::TyStruct(did, substs) => { ty::struct_fields(self.tcx(), did, substs) } _ => { @@ -826,7 +826,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { let self_ty = ty::no_late_bound_regions(self.tcx(), &self_ty).unwrap(); let (m, r) = match self_ty.sty { - ty::ty_rptr(r, ref m) => (m.mutbl, r), + ty::TyRef(r, ref m) => (m.mutbl, r), _ => self.tcx().sess.span_bug(expr.span, &format!("bad overloaded deref type {}", method_ty.repr(self.tcx()))) diff --git a/src/librustc/middle/fast_reject.rs b/src/librustc/middle/fast_reject.rs index 36065aaca57..ee792989ccf 100644 --- a/src/librustc/middle/fast_reject.rs +++ b/src/librustc/middle/fast_reject.rs @@ -48,51 +48,51 @@ pub fn simplify_type(tcx: &ty::ctxt, -> Option<SimplifiedType> { match ty.sty { - ty::ty_bool => Some(BoolSimplifiedType), - ty::ty_char => Some(CharSimplifiedType), - ty::ty_int(int_type) => Some(IntSimplifiedType(int_type)), - ty::ty_uint(uint_type) => Some(UintSimplifiedType(uint_type)), - ty::ty_float(float_type) => Some(FloatSimplifiedType(float_type)), - ty::ty_enum(def_id, _) => Some(EnumSimplifiedType(def_id)), - ty::ty_str => Some(StrSimplifiedType), - ty::ty_vec(..) => Some(VecSimplifiedType), - ty::ty_ptr(_) => Some(PtrSimplifiedType), - ty::ty_trait(ref trait_info) => { + ty::TyBool => Some(BoolSimplifiedType), + ty::TyChar => Some(CharSimplifiedType), + ty::TyInt(int_type) => Some(IntSimplifiedType(int_type)), + ty::TyUint(uint_type) => Some(UintSimplifiedType(uint_type)), + ty::TyFloat(float_type) => Some(FloatSimplifiedType(float_type)), + ty::TyEnum(def_id, _) => Some(EnumSimplifiedType(def_id)), + ty::TyStr => Some(StrSimplifiedType), + ty::TyArray(..) => Some(VecSimplifiedType), + ty::TyRawPtr(_) => Some(PtrSimplifiedType), + ty::TyTrait(ref trait_info) => { Some(TraitSimplifiedType(trait_info.principal_def_id())) } - ty::ty_struct(def_id, _) => { + ty::TyStruct(def_id, _) => { Some(StructSimplifiedType(def_id)) } - ty::ty_rptr(_, mt) => { + ty::TyRef(_, mt) => { // since we introduce auto-refs during method lookup, we // just treat &T and T as equivalent from the point of // view of possibly unifying simplify_type(tcx, mt.ty, can_simplify_params) } - ty::ty_uniq(_) => { + ty::TyBox(_) => { // treat like we would treat `Box` let def_id = tcx.lang_items.owned_box().unwrap(); Some(StructSimplifiedType(def_id)) } - ty::ty_closure(def_id, _) => { + ty::TyClosure(def_id, _) => { Some(ClosureSimplifiedType(def_id)) } - ty::ty_tup(ref tys) => { + ty::TyTuple(ref tys) => { Some(TupleSimplifiedType(tys.len())) } - ty::ty_bare_fn(_, ref f) => { + ty::TyBareFn(_, ref f) => { Some(FunctionSimplifiedType(f.sig.0.inputs.len())) } - ty::ty_projection(_) => { + ty::TyProjection(_) => { None } - ty::ty_param(_) => { + ty::TyParam(_) => { if can_simplify_params { Some(ParameterSimplifiedType) } else { None } } - ty::ty_infer(_) | ty::ty_err => None, + ty::TyInfer(_) | ty::TyError => None, } } diff --git a/src/librustc/middle/implicator.rs b/src/librustc/middle/implicator.rs index 572478ba3f9..367d5efb54b 100644 --- a/src/librustc/middle/implicator.rs +++ b/src/librustc/middle/implicator.rs @@ -88,61 +88,61 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> { } match ty.sty { - ty::ty_bool | - ty::ty_char | - ty::ty_int(..) | - ty::ty_uint(..) | - ty::ty_float(..) | - ty::ty_bare_fn(..) | - ty::ty_err | - ty::ty_str => { + ty::TyBool | + ty::TyChar | + ty::TyInt(..) | + ty::TyUint(..) | + ty::TyFloat(..) | + ty::TyBareFn(..) | + ty::TyError | + ty::TyStr => { // No borrowed content reachable here. } - ty::ty_closure(def_id, substs) => { + ty::TyClosure(def_id, substs) => { let &(r_a, opt_ty) = self.stack.last().unwrap(); self.out.push(Implication::RegionSubClosure(opt_ty, r_a, def_id, substs)); } - ty::ty_trait(ref t) => { + ty::TyTrait(ref t) => { let required_region_bounds = object_region_bounds(self.tcx(), &t.principal, t.bounds.builtin_bounds); self.accumulate_from_object_ty(ty, t.bounds.region_bound, required_region_bounds) } - ty::ty_enum(def_id, substs) | - ty::ty_struct(def_id, substs) => { + ty::TyEnum(def_id, substs) | + ty::TyStruct(def_id, substs) => { let item_scheme = ty::lookup_item_type(self.tcx(), def_id); self.accumulate_from_adt(ty, def_id, &item_scheme.generics, substs) } - ty::ty_vec(t, _) | - ty::ty_ptr(ty::mt { ty: t, .. }) | - ty::ty_uniq(t) => { + ty::TyArray(t, _) | + ty::TyRawPtr(ty::mt { ty: t, .. }) | + ty::TyBox(t) => { self.accumulate_from_ty(t) } - ty::ty_rptr(r_b, mt) => { + ty::TyRef(r_b, mt) => { self.accumulate_from_rptr(ty, *r_b, mt.ty); } - ty::ty_param(p) => { + ty::TyParam(p) => { self.push_param_constraint_from_top(p); } - ty::ty_projection(ref data) => { + ty::TyProjection(ref data) => { // `<T as TraitRef<..>>::Name` self.push_projection_constraint_from_top(data); } - ty::ty_tup(ref tuptys) => { + ty::TyTuple(ref tuptys) => { for &tupty in tuptys { self.accumulate_from_ty(tupty); } } - ty::ty_infer(_) => { + ty::TyInfer(_) => { // This should not happen, BUT: // // Currently we uncover region relationships on diff --git a/src/librustc/middle/infer/bivariate.rs b/src/librustc/middle/infer/bivariate.rs index 940dc75271c..1ab01453c0f 100644 --- a/src/librustc/middle/infer/bivariate.rs +++ b/src/librustc/middle/infer/bivariate.rs @@ -81,17 +81,17 @@ impl<'a, 'tcx> TypeRelation<'a, 'tcx> for Bivariate<'a, 'tcx> { let a = infcx.type_variables.borrow().replace_if_possible(a); let b = infcx.type_variables.borrow().replace_if_possible(b); match (&a.sty, &b.sty) { - (&ty::ty_infer(TyVar(a_id)), &ty::ty_infer(TyVar(b_id))) => { + (&ty::TyInfer(TyVar(a_id)), &ty::TyInfer(TyVar(b_id))) => { infcx.type_variables.borrow_mut().relate_vars(a_id, BiTo, b_id); Ok(a) } - (&ty::ty_infer(TyVar(a_id)), _) => { + (&ty::TyInfer(TyVar(a_id)), _) => { try!(self.fields.instantiate(b, BiTo, a_id)); Ok(a) } - (_, &ty::ty_infer(TyVar(b_id))) => { + (_, &ty::TyInfer(TyVar(b_id))) => { try!(self.fields.instantiate(a, BiTo, b_id)); Ok(a) } diff --git a/src/librustc/middle/infer/combine.rs b/src/librustc/middle/infer/combine.rs index 86f12b669b3..864e9ed0b97 100644 --- a/src/librustc/middle/infer/combine.rs +++ b/src/librustc/middle/infer/combine.rs @@ -70,44 +70,44 @@ pub fn super_combine_tys<'a,'tcx:'a,R>(infcx: &InferCtxt<'a, 'tcx>, match (&a.sty, &b.sty) { // Relate integral variables to other types - (&ty::ty_infer(ty::IntVar(a_id)), &ty::ty_infer(ty::IntVar(b_id))) => { + (&ty::TyInfer(ty::IntVar(a_id)), &ty::TyInfer(ty::IntVar(b_id))) => { try!(infcx.int_unification_table .borrow_mut() .unify_var_var(a_id, b_id) .map_err(|e| int_unification_error(a_is_expected, e))); Ok(a) } - (&ty::ty_infer(ty::IntVar(v_id)), &ty::ty_int(v)) => { + (&ty::TyInfer(ty::IntVar(v_id)), &ty::TyInt(v)) => { unify_integral_variable(infcx, a_is_expected, v_id, IntType(v)) } - (&ty::ty_int(v), &ty::ty_infer(ty::IntVar(v_id))) => { + (&ty::TyInt(v), &ty::TyInfer(ty::IntVar(v_id))) => { unify_integral_variable(infcx, !a_is_expected, v_id, IntType(v)) } - (&ty::ty_infer(ty::IntVar(v_id)), &ty::ty_uint(v)) => { + (&ty::TyInfer(ty::IntVar(v_id)), &ty::TyUint(v)) => { unify_integral_variable(infcx, a_is_expected, v_id, UintType(v)) } - (&ty::ty_uint(v), &ty::ty_infer(ty::IntVar(v_id))) => { + (&ty::TyUint(v), &ty::TyInfer(ty::IntVar(v_id))) => { unify_integral_variable(infcx, !a_is_expected, v_id, UintType(v)) } // Relate floating-point variables to other types - (&ty::ty_infer(ty::FloatVar(a_id)), &ty::ty_infer(ty::FloatVar(b_id))) => { + (&ty::TyInfer(ty::FloatVar(a_id)), &ty::TyInfer(ty::FloatVar(b_id))) => { try!(infcx.float_unification_table .borrow_mut() .unify_var_var(a_id, b_id) .map_err(|e| float_unification_error(relation.a_is_expected(), e))); Ok(a) } - (&ty::ty_infer(ty::FloatVar(v_id)), &ty::ty_float(v)) => { + (&ty::TyInfer(ty::FloatVar(v_id)), &ty::TyFloat(v)) => { unify_float_variable(infcx, a_is_expected, v_id, v) } - (&ty::ty_float(v), &ty::ty_infer(ty::FloatVar(v_id))) => { + (&ty::TyFloat(v), &ty::TyInfer(ty::FloatVar(v_id))) => { unify_float_variable(infcx, !a_is_expected, v_id, v) } // All other cases of inference are errors - (&ty::ty_infer(_), _) | - (_, &ty::ty_infer(_)) => { + (&ty::TyInfer(_), _) | + (_, &ty::TyInfer(_)) => { Err(ty::terr_sorts(ty_relate::expected_found(relation, &a, &b))) } @@ -262,7 +262,7 @@ impl<'a, 'tcx> CombineFields<'a, 'tcx> { /// Attempts to generalize `ty` for the type variable `for_vid`. This checks for cycle -- that /// is, whether the type `ty` references `for_vid`. If `make_region_vars` is true, it will also - /// replace all regions with fresh variables. Returns `ty_err` in the case of a cycle, `Ok` + /// replace all regions with fresh variables. Returns `TyError` in the case of a cycle, `Ok` /// otherwise. fn generalize(&self, ty: Ty<'tcx>, @@ -308,7 +308,7 @@ impl<'cx, 'tcx> ty_fold::TypeFolder<'tcx> for Generalizer<'cx, 'tcx> { // (In particular, you could have something like `$0 = Box<$1>` // where `$1` has already been instantiated with `Box<$0>`) match t.sty { - ty::ty_infer(ty::TyVar(vid)) => { + ty::TyInfer(ty::TyVar(vid)) => { if vid == self.for_vid { self.cycle_detected = true; self.tcx().types.err diff --git a/src/librustc/middle/infer/equate.rs b/src/librustc/middle/infer/equate.rs index 2003f459d89..da0bca89042 100644 --- a/src/librustc/middle/infer/equate.rs +++ b/src/librustc/middle/infer/equate.rs @@ -53,17 +53,17 @@ impl<'a, 'tcx> TypeRelation<'a,'tcx> for Equate<'a, 'tcx> { let a = infcx.type_variables.borrow().replace_if_possible(a); let b = infcx.type_variables.borrow().replace_if_possible(b); match (&a.sty, &b.sty) { - (&ty::ty_infer(TyVar(a_id)), &ty::ty_infer(TyVar(b_id))) => { + (&ty::TyInfer(TyVar(a_id)), &ty::TyInfer(TyVar(b_id))) => { infcx.type_variables.borrow_mut().relate_vars(a_id, EqTo, b_id); Ok(a) } - (&ty::ty_infer(TyVar(a_id)), _) => { + (&ty::TyInfer(TyVar(a_id)), _) => { try!(self.fields.instantiate(b, EqTo, a_id)); Ok(a) } - (_, &ty::ty_infer(TyVar(b_id))) => { + (_, &ty::TyInfer(TyVar(b_id))) => { try!(self.fields.instantiate(a, EqTo, b_id)); Ok(a) } diff --git a/src/librustc/middle/infer/freshen.rs b/src/librustc/middle/infer/freshen.rs index 8783577945c..6eb4fcce887 100644 --- a/src/librustc/middle/infer/freshen.rs +++ b/src/librustc/middle/infer/freshen.rs @@ -111,14 +111,14 @@ impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, 'tcx> { let tcx = self.infcx.tcx; match t.sty { - ty::ty_infer(ty::TyVar(v)) => { + ty::TyInfer(ty::TyVar(v)) => { self.freshen( self.infcx.type_variables.borrow().probe(v), ty::TyVar(v), ty::FreshTy) } - ty::ty_infer(ty::IntVar(v)) => { + ty::TyInfer(ty::IntVar(v)) => { self.freshen( self.infcx.int_unification_table.borrow_mut() .probe(v) @@ -127,7 +127,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, 'tcx> { ty::FreshIntTy) } - ty::ty_infer(ty::FloatVar(v)) => { + ty::TyInfer(ty::FloatVar(v)) => { self.freshen( self.infcx.float_unification_table.borrow_mut() .probe(v) @@ -136,9 +136,9 @@ impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, 'tcx> { ty::FreshFloatTy) } - ty::ty_infer(ty::FreshTy(c)) | - ty::ty_infer(ty::FreshIntTy(c)) | - ty::ty_infer(ty::FreshFloatTy(c)) => { + ty::TyInfer(ty::FreshTy(c)) | + ty::TyInfer(ty::FreshIntTy(c)) | + ty::TyInfer(ty::FreshFloatTy(c)) => { if c >= self.freshen_count { tcx.sess.bug( &format!("Encountered a freshend type with id {} \ @@ -149,25 +149,25 @@ impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, 'tcx> { t } - ty::ty_bool | - ty::ty_char | - ty::ty_int(..) | - ty::ty_uint(..) | - ty::ty_float(..) | - ty::ty_enum(..) | - ty::ty_uniq(..) | - ty::ty_str | - ty::ty_err | - ty::ty_vec(..) | - ty::ty_ptr(..) | - ty::ty_rptr(..) | - ty::ty_bare_fn(..) | - ty::ty_trait(..) | - ty::ty_struct(..) | - ty::ty_closure(..) | - ty::ty_tup(..) | - ty::ty_projection(..) | - ty::ty_param(..) => { + ty::TyBool | + ty::TyChar | + ty::TyInt(..) | + ty::TyUint(..) | + ty::TyFloat(..) | + ty::TyEnum(..) | + ty::TyBox(..) | + ty::TyStr | + ty::TyError | + ty::TyArray(..) | + ty::TyRawPtr(..) | + ty::TyRef(..) | + ty::TyBareFn(..) | + ty::TyTrait(..) | + ty::TyStruct(..) | + ty::TyClosure(..) | + ty::TyTuple(..) | + ty::TyProjection(..) | + ty::TyParam(..) => { ty_fold::super_fold_ty(self, t) } } diff --git a/src/librustc/middle/infer/lattice.rs b/src/librustc/middle/infer/lattice.rs index 57001083b03..d634b8231eb 100644 --- a/src/librustc/middle/infer/lattice.rs +++ b/src/librustc/middle/infer/lattice.rs @@ -64,15 +64,15 @@ pub fn super_lattice_tys<'a,'tcx,L:LatticeDir<'a,'tcx>>(this: &mut L, let a = infcx.type_variables.borrow().replace_if_possible(a); let b = infcx.type_variables.borrow().replace_if_possible(b); match (&a.sty, &b.sty) { - (&ty::ty_infer(TyVar(..)), &ty::ty_infer(TyVar(..))) + (&ty::TyInfer(TyVar(..)), &ty::TyInfer(TyVar(..))) if infcx.type_var_diverges(a) && infcx.type_var_diverges(b) => { let v = infcx.next_diverging_ty_var(); try!(this.relate_bound(v, a, b)); Ok(v) } - (&ty::ty_infer(TyVar(..)), _) | - (_, &ty::ty_infer(TyVar(..))) => { + (&ty::TyInfer(TyVar(..)), _) | + (_, &ty::TyInfer(TyVar(..))) => { let v = infcx.next_ty_var(); try!(this.relate_bound(v, a, b)); Ok(v) diff --git a/src/librustc/middle/infer/mod.rs b/src/librustc/middle/infer/mod.rs index b3c4dd68dba..c0e3a5e8961 100644 --- a/src/librustc/middle/infer/mod.rs +++ b/src/librustc/middle/infer/mod.rs @@ -440,7 +440,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { pub fn type_var_diverges(&'a self, ty: Ty) -> bool { match ty.sty { - ty::ty_infer(ty::TyVar(vid)) => self.type_variables.borrow().var_diverges(vid), + ty::TyInfer(ty::TyVar(vid)) => self.type_variables.borrow().var_diverges(vid), _ => false } } @@ -452,14 +452,14 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { pub fn type_is_unconstrained_numeric(&'a self, ty: Ty) -> UnconstrainedNumeric { use middle::ty::UnconstrainedNumeric::{Neither, UnconstrainedInt, UnconstrainedFloat}; match ty.sty { - ty::ty_infer(ty::IntVar(vid)) => { + ty::TyInfer(ty::IntVar(vid)) => { if self.int_unification_table.borrow_mut().has_value(vid) { Neither } else { UnconstrainedInt } }, - ty::ty_infer(ty::FloatVar(vid)) => { + ty::TyInfer(ty::FloatVar(vid)) => { if self.float_unification_table.borrow_mut().has_value(vid) { Neither } else { @@ -878,7 +878,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { pub fn shallow_resolve(&self, typ: Ty<'tcx>) -> Ty<'tcx> { match typ.sty { - ty::ty_infer(ty::TyVar(v)) => { + ty::TyInfer(ty::TyVar(v)) => { // Not entirely obvious: if `typ` is a type variable, // it can be resolved to an int/float variable, which // can then be recursively resolved, hence the @@ -894,7 +894,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { .unwrap_or(typ) } - ty::ty_infer(ty::IntVar(v)) => { + ty::TyInfer(ty::IntVar(v)) => { self.int_unification_table .borrow_mut() .probe(v) @@ -902,7 +902,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { .unwrap_or(typ) } - ty::ty_infer(ty::FloatVar(v)) => { + ty::TyInfer(ty::FloatVar(v)) => { self.float_unification_table .borrow_mut() .probe(v) @@ -945,13 +945,13 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { } // [Note-Type-error-reporting] - // An invariant is that anytime the expected or actual type is ty_err (the special + // An invariant is that anytime the expected or actual type is TyError (the special // error type, meaning that an error occurred when typechecking this expression), // this is a derived error. The error cascaded from another error (that was already // reported), so it's not useful to display it to the user. // The following four methods -- type_error_message_str, type_error_message_str_with_expected, // type_error_message, and report_mismatched_types -- implement this logic. - // They check if either the actual or expected type is ty_err, and don't print the error + // They check if either the actual or expected type is TyError, and don't print the error // in this case. The typechecker should only ever report type errors involving mismatched // types using one of these four methods, and should not call span_err directly for such // errors. @@ -1004,7 +1004,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { { let actual_ty = self.resolve_type_vars_if_possible(&actual_ty); - // Don't report an error if actual type is ty_err. + // Don't report an error if actual type is TyError. if ty::type_is_error(actual_ty) { return; } diff --git a/src/librustc/middle/infer/resolve.rs b/src/librustc/middle/infer/resolve.rs index b9025d01068..62e56d2e2d7 100644 --- a/src/librustc/middle/infer/resolve.rs +++ b/src/librustc/middle/infer/resolve.rs @@ -81,19 +81,19 @@ impl<'a, 'tcx> ty_fold::TypeFolder<'tcx> for FullTypeResolver<'a, 'tcx> { } else { let t = self.infcx.shallow_resolve(t); match t.sty { - ty::ty_infer(ty::TyVar(vid)) => { + ty::TyInfer(ty::TyVar(vid)) => { self.err = Some(unresolved_ty(vid)); self.tcx().types.err } - ty::ty_infer(ty::IntVar(vid)) => { + ty::TyInfer(ty::IntVar(vid)) => { self.err = Some(unresolved_int_ty(vid)); self.tcx().types.err } - ty::ty_infer(ty::FloatVar(vid)) => { + ty::TyInfer(ty::FloatVar(vid)) => { self.err = Some(unresolved_float_ty(vid)); self.tcx().types.err } - ty::ty_infer(_) => { + ty::TyInfer(_) => { self.infcx.tcx.sess.bug( &format!("Unexpected type in full type resolver: {}", t.repr(self.infcx.tcx))); diff --git a/src/librustc/middle/infer/sub.rs b/src/librustc/middle/infer/sub.rs index 31b654a5b3f..9d6854eba43 100644 --- a/src/librustc/middle/infer/sub.rs +++ b/src/librustc/middle/infer/sub.rs @@ -57,24 +57,24 @@ impl<'a, 'tcx> TypeRelation<'a, 'tcx> for Sub<'a, 'tcx> { let a = infcx.type_variables.borrow().replace_if_possible(a); let b = infcx.type_variables.borrow().replace_if_possible(b); match (&a.sty, &b.sty) { - (&ty::ty_infer(TyVar(a_id)), &ty::ty_infer(TyVar(b_id))) => { + (&ty::TyInfer(TyVar(a_id)), &ty::TyInfer(TyVar(b_id))) => { infcx.type_variables .borrow_mut() .relate_vars(a_id, SubtypeOf, b_id); Ok(a) } - (&ty::ty_infer(TyVar(a_id)), _) => { + (&ty::TyInfer(TyVar(a_id)), _) => { try!(self.fields .switch_expected() .instantiate(b, SupertypeOf, a_id)); Ok(a) } - (_, &ty::ty_infer(TyVar(b_id))) => { + (_, &ty::TyInfer(TyVar(b_id))) => { try!(self.fields.instantiate(a, SubtypeOf, b_id)); Ok(a) } - (&ty::ty_err, _) | (_, &ty::ty_err) => { + (&ty::TyError, _) | (_, &ty::TyError) => { Ok(self.tcx().types.err) } diff --git a/src/librustc/middle/infer/type_variable.rs b/src/librustc/middle/infer/type_variable.rs index b3e3e016d85..6f1de3ee635 100644 --- a/src/librustc/middle/infer/type_variable.rs +++ b/src/librustc/middle/infer/type_variable.rs @@ -131,7 +131,7 @@ impl<'tcx> TypeVariableTable<'tcx> { pub fn replace_if_possible(&self, t: Ty<'tcx>) -> Ty<'tcx> { match t.sty { - ty::ty_infer(ty::TyVar(v)) => { + ty::TyInfer(ty::TyVar(v)) => { match self.probe(v) { None => t, Some(u) => u diff --git a/src/librustc/middle/intrinsicck.rs b/src/librustc/middle/intrinsicck.rs index d05954c44d5..f76cfebf7b9 100644 --- a/src/librustc/middle/intrinsicck.rs +++ b/src/librustc/middle/intrinsicck.rs @@ -12,7 +12,7 @@ use ast_map::NodeForeignItem; use metadata::csearch; use middle::def::DefFn; use middle::subst::{Subst, Substs, EnumeratedItems}; -use middle::ty::{TransmuteRestriction, ctxt, ty_bare_fn}; +use middle::ty::{TransmuteRestriction, ctxt, TyBareFn}; use middle::ty::{self, Ty}; use util::ppaux::Repr; @@ -54,7 +54,7 @@ struct IntrinsicCheckingVisitor<'a, 'tcx: 'a> { impl<'a, 'tcx> IntrinsicCheckingVisitor<'a, 'tcx> { fn def_id_is_transmute(&self, def_id: DefId) -> bool { let intrinsic = match ty::lookup_item_type(self.tcx, def_id).ty.sty { - ty::ty_bare_fn(_, ref bfty) => bfty.abi == RustIntrinsic, + ty::TyBareFn(_, ref bfty) => bfty.abi == RustIntrinsic, _ => return false }; if def_id.krate == ast::LOCAL_CRATE { @@ -256,7 +256,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for IntrinsicCheckingVisitor<'a, 'tcx> { DefFn(did, _) if self.def_id_is_transmute(did) => { let typ = ty::node_id_to_type(self.tcx, expr.id); match typ.sty { - ty_bare_fn(_, ref bare_fn_ty) if bare_fn_ty.abi == RustIntrinsic => { + TyBareFn(_, ref bare_fn_ty) if bare_fn_ty.abi == RustIntrinsic => { if let ty::FnConverging(to) = bare_fn_ty.sig.0.output { let from = bare_fn_ty.sig.0.inputs[0]; self.check_transmute(expr.span, from, to, expr.id); diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index d4136637e58..9bcc251725c 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -1498,7 +1498,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { fn fn_ret(&self, id: NodeId) -> ty::PolyFnOutput<'tcx> { let fn_ty = ty::node_id_to_type(self.ir.tcx, id); match fn_ty.sty { - ty::ty_closure(closure_def_id, substs) => + ty::TyClosure(closure_def_id, substs) => self.ir.tcx.closure_type(closure_def_id, substs).sig.output(), _ => ty::ty_fn_ret(fn_ty), diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index c0fa868fcd4..d099b71c3f2 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -212,25 +212,25 @@ type DerefKindContext = Option<InteriorOffsetKind>; // pointer adjustment). fn deref_kind(t: Ty, context: DerefKindContext) -> McResult<deref_kind> { match t.sty { - ty::ty_uniq(_) => { + ty::TyBox(_) => { Ok(deref_ptr(Unique)) } - ty::ty_rptr(r, mt) => { + ty::TyRef(r, mt) => { let kind = ty::BorrowKind::from_mutbl(mt.mutbl); Ok(deref_ptr(BorrowedPtr(kind, *r))) } - ty::ty_ptr(ref mt) => { + ty::TyRawPtr(ref mt) => { Ok(deref_ptr(UnsafePtr(mt.mutbl))) } - ty::ty_enum(..) | - ty::ty_struct(..) => { // newtype + ty::TyEnum(..) | + ty::TyStruct(..) => { // newtype Ok(deref_interior(InteriorField(PositionalField(0)))) } - ty::ty_vec(_, _) | ty::ty_str => { + ty::TyArray(_, _) | ty::TyStr => { // no deref of indexed content without supplying InteriorOffsetKind if let Some(context) = context { Ok(deref_interior(InteriorElement(context, element_kind(t)))) @@ -523,7 +523,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { // The index method always returns an `&T`, so // dereference it to find the result type. let elem_ty = match ret_ty.sty { - ty::ty_rptr(_, mt) => mt.ty, + ty::TyRef(_, mt) => mt.ty, _ => { debug!("cat_expr_unadjusted: return type of overloaded index is {}?", ret_ty.repr(self.tcx())); @@ -621,7 +621,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { def::DefUpvar(var_id, fn_node_id) => { let ty = try!(self.node_ty(fn_node_id)); match ty.sty { - ty::ty_closure(closure_id, _) => { + ty::TyClosure(closure_id, _) => { match self.typer.closure_kind(closure_id) { Some(kind) => { self.cat_upvar(id, span, var_id, fn_node_id, kind) @@ -791,7 +791,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { // that the above is actually immutable and // has a ref type. However, nothing should // actually look at the type, so we can get - // away with stuffing a `ty_err` in there + // away with stuffing a `TyError` in there // instead of bothering to construct a proper // one. let cmt_result = cmt_ { @@ -843,7 +843,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { // Only promote `[T; 0]` before an RFC for rvalue promotions // is accepted. let qualif = match expr_ty.sty { - ty::ty_vec(_, Some(0)) => qualif, + ty::TyArray(_, Some(0)) => qualif, _ => check_const::ConstQualif::NOT_CONST }; @@ -1129,8 +1129,8 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { slice_ty: Ty) -> (ast::Mutability, ty::Region) { match slice_ty.sty { - ty::ty_rptr(r, ref mt) => match mt.ty.sty { - ty::ty_vec(_, None) => (mt.mutbl, *r), + ty::TyRef(r, ref mt) => match mt.ty.sty { + ty::TyArray(_, None) => (mt.mutbl, *r), _ => vec_slice_info(tcx, pat, mt.ty), }, @@ -1667,12 +1667,12 @@ impl<'tcx> Repr<'tcx> for InteriorKind { fn element_kind(t: Ty) -> ElementKind { match t.sty { - ty::ty_rptr(_, ty::mt{ty, ..}) | - ty::ty_uniq(ty) => match ty.sty { - ty::ty_vec(_, None) => VecElement, + ty::TyRef(_, ty::mt{ty, ..}) | + ty::TyBox(ty) => match ty.sty { + ty::TyArray(_, None) => VecElement, _ => OtherElement }, - ty::ty_vec(..) => VecElement, + ty::TyArray(..) => VecElement, _ => OtherElement } } diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index 2159e143e61..861fa97d50b 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -387,7 +387,7 @@ pub fn check_expr(tcx: &ty::ctxt, e: &ast::Expr, ast::ExprField(ref base_e, ref field) => { span = field.span; match ty::expr_ty_adjusted(tcx, base_e).sty { - ty::ty_struct(did, _) => { + ty::TyStruct(did, _) => { ty::lookup_struct_fields(tcx, did) .iter() .find(|f| f.name == field.node.name) @@ -404,7 +404,7 @@ pub fn check_expr(tcx: &ty::ctxt, e: &ast::Expr, ast::ExprTupField(ref base_e, ref field) => { span = field.span; match ty::expr_ty_adjusted(tcx, base_e).sty { - ty::ty_struct(did, _) => { + ty::TyStruct(did, _) => { ty::lookup_struct_fields(tcx, did) .get(field.node) .unwrap_or_else(|| { @@ -413,7 +413,7 @@ pub fn check_expr(tcx: &ty::ctxt, e: &ast::Expr, }) .id } - ty::ty_tup(..) => return, + ty::TyTuple(..) => return, _ => tcx.sess.span_bug(e.span, "stability::check_expr: unnamed field access on \ something other than a tuple or struct") @@ -422,7 +422,7 @@ pub fn check_expr(tcx: &ty::ctxt, e: &ast::Expr, ast::ExprStruct(_, ref expr_fields, _) => { let type_ = ty::expr_ty(tcx, e); match type_.sty { - ty::ty_struct(did, _) => { + ty::TyStruct(did, _) => { let struct_fields = ty::lookup_struct_fields(tcx, did); // check the stability of each field that appears // in the construction expression. @@ -445,7 +445,7 @@ pub fn check_expr(tcx: &ty::ctxt, e: &ast::Expr, // we don't look at stability attributes on // struct-like enums (yet...), but it's definitely not // a bug to have construct one. - ty::ty_enum(..) => return, + ty::TyEnum(..) => return, _ => { tcx.sess.span_bug(e.span, &format!("stability::check_expr: struct construction \ @@ -478,7 +478,7 @@ pub fn check_pat(tcx: &ty::ctxt, pat: &ast::Pat, if is_internal(tcx, pat.span) { return; } let did = match ty::pat_ty_opt(tcx, pat) { - Some(&ty::TyS { sty: ty::ty_struct(did, _), .. }) => did, + Some(&ty::TyS { sty: ty::TyStruct(did, _), .. }) => did, Some(_) | None => return, }; let struct_fields = ty::lookup_struct_fields(tcx, did); diff --git a/src/librustc/middle/subst.rs b/src/librustc/middle/subst.rs index 012e3eae889..75af3366397 100644 --- a/src/librustc/middle/subst.rs +++ b/src/librustc/middle/subst.rs @@ -647,7 +647,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for SubstFolder<'a, 'tcx> { self.ty_stack_depth += 1; let t1 = match t.sty { - ty::ty_param(p) => { + ty::TyParam(p) => { self.ty_for_param(p, t) } _ => { diff --git a/src/librustc/middle/traits/coherence.rs b/src/librustc/middle/traits/coherence.rs index 26574e2b80d..ae2454013e8 100644 --- a/src/librustc/middle/traits/coherence.rs +++ b/src/librustc/middle/traits/coherence.rs @@ -265,7 +265,7 @@ fn uncovered_tys<'tcx>(tcx: &ty::ctxt<'tcx>, fn is_type_parameter<'tcx>(ty: Ty<'tcx>) -> bool { match ty.sty { // FIXME(#20590) straighten story about projection types - ty::ty_projection(..) | ty::ty_param(..) => true, + ty::TyProjection(..) | ty::TyParam(..) => true, _ => false, } } @@ -279,11 +279,11 @@ fn ty_is_local<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>, infer_is_local: InferIs fn fundamental_ty<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool { match ty.sty { - ty::ty_uniq(..) | ty::ty_rptr(..) => + ty::TyBox(..) | ty::TyRef(..) => true, - ty::ty_enum(def_id, _) | ty::ty_struct(def_id, _) => + ty::TyEnum(def_id, _) | ty::TyStruct(def_id, _) => ty::has_attr(tcx, def_id, "fundamental"), - ty::ty_trait(ref data) => + ty::TyTrait(ref data) => ty::has_attr(tcx, data.principal_def_id(), "fundamental"), _ => false @@ -298,42 +298,42 @@ fn ty_is_local_constructor<'tcx>(tcx: &ty::ctxt<'tcx>, debug!("ty_is_local_constructor({})", ty.repr(tcx)); match ty.sty { - ty::ty_bool | - ty::ty_char | - ty::ty_int(..) | - ty::ty_uint(..) | - ty::ty_float(..) | - ty::ty_str(..) | - ty::ty_bare_fn(..) | - ty::ty_vec(..) | - ty::ty_ptr(..) | - ty::ty_rptr(..) | - ty::ty_tup(..) | - ty::ty_param(..) | - ty::ty_projection(..) => { + ty::TyBool | + ty::TyChar | + ty::TyInt(..) | + ty::TyUint(..) | + ty::TyFloat(..) | + ty::TyStr(..) | + ty::TyBareFn(..) | + ty::TyArray(..) | + ty::TyRawPtr(..) | + ty::TyRef(..) | + ty::TyTuple(..) | + ty::TyParam(..) | + ty::TyProjection(..) => { false } - ty::ty_infer(..) => { + ty::TyInfer(..) => { infer_is_local.0 } - ty::ty_enum(def_id, _) | - ty::ty_struct(def_id, _) => { + ty::TyEnum(def_id, _) | + ty::TyStruct(def_id, _) => { def_id.krate == ast::LOCAL_CRATE } - ty::ty_uniq(_) => { // Box<T> + ty::TyBox(_) => { // Box<T> let krate = tcx.lang_items.owned_box().map(|d| d.krate); krate == Some(ast::LOCAL_CRATE) } - ty::ty_trait(ref tt) => { + ty::TyTrait(ref tt) => { tt.principal_def_id().krate == ast::LOCAL_CRATE } - ty::ty_closure(..) | - ty::ty_err => { + ty::TyClosure(..) | + ty::TyError => { tcx.sess.bug( &format!("ty_is_local invoked on unexpected type: {}", ty.repr(tcx))) diff --git a/src/librustc/middle/traits/error_reporting.rs b/src/librustc/middle/traits/error_reporting.rs index 2a8dabf006a..2d65c5dd626 100644 --- a/src/librustc/middle/traits/error_reporting.rs +++ b/src/librustc/middle/traits/error_reporting.rs @@ -60,10 +60,10 @@ pub fn report_projection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>, { let predicate = infcx.resolve_type_vars_if_possible(&obligation.predicate); - // The ty_err created by normalize_to_error can end up being unified + // The TyError created by normalize_to_error can end up being unified // into all obligations: for example, if our obligation is something // like `$X = <() as Foo<$X>>::Out` and () does not implement Foo<_>, - // then $X will be unified with ty_err, but the error still needs to be + // then $X will be unified with TyError, but the error still needs to be // reported. if !infcx.tcx.sess.has_errors() || !predicate.references_error() { span_err!(infcx.tcx.sess, obligation.cause.span, E0271, diff --git a/src/librustc/middle/traits/object_safety.rs b/src/librustc/middle/traits/object_safety.rs index 6662cf74383..cf8e391bf54 100644 --- a/src/librustc/middle/traits/object_safety.rs +++ b/src/librustc/middle/traits/object_safety.rs @@ -308,7 +308,7 @@ fn contains_illegal_self_type_reference<'tcx>(tcx: &ty::ctxt<'tcx>, let mut error = false; ty::maybe_walk_ty(ty, |ty| { match ty.sty { - ty::ty_param(ref param_ty) => { + ty::TyParam(ref param_ty) => { if param_ty.space == SelfSpace { error = true; } @@ -316,7 +316,7 @@ fn contains_illegal_self_type_reference<'tcx>(tcx: &ty::ctxt<'tcx>, false // no contained types to walk } - ty::ty_projection(ref data) => { + ty::TyProjection(ref data) => { // This is a projected type `<Foo as SomeTrait>::X`. // Compute supertraits of current trait lazily. @@ -367,7 +367,7 @@ impl<'tcx> Repr<'tcx> for ObjectSafetyViolation<'tcx> { fn is_self<'tcx>(ty: Ty<'tcx>) -> bool { match ty.sty { - ty::ty_param(ref data) => data.space == subst::SelfSpace, + ty::TyParam(ref data) => data.space == subst::SelfSpace, _ => false, } } diff --git a/src/librustc/middle/traits/project.rs b/src/librustc/middle/traits/project.rs index 557a02554c3..1631a33588c 100644 --- a/src/librustc/middle/traits/project.rs +++ b/src/librustc/middle/traits/project.rs @@ -153,7 +153,7 @@ fn consider_unification_despite_ambiguity<'cx,'tcx>(selcx: &mut SelectionContext debug!("consider_unification_despite_ambiguity: self_ty.sty={:?}", self_ty.sty); match self_ty.sty { - ty::ty_closure(closure_def_id, substs) => { + ty::TyClosure(closure_def_id, substs) => { let closure_typer = selcx.closure_typer(); let closure_type = closure_typer.closure_type(closure_def_id, substs); let ty::Binder((_, ret_type)) = @@ -261,7 +261,7 @@ impl<'a,'b,'tcx> TypeFolder<'tcx> for AssociatedTypeNormalizer<'a,'b,'tcx> { let ty = ty_fold::super_fold_ty(self, ty); match ty.sty { - ty::ty_projection(ref data) if !data.has_escaping_regions() => { // (*) + ty::TyProjection(ref data) if !data.has_escaping_regions() => { // (*) // (*) This is kind of hacky -- we need to be able to // handle normalization within binders because @@ -408,11 +408,11 @@ fn opt_normalize_projection_type<'a,'b,'tcx>( } } -/// in various error cases, we just set ty_err and return an obligation +/// in various error cases, we just set TyError and return an obligation /// that, when fulfilled, will lead to an error. /// -/// FIXME: the ty_err created here can enter the obligation we create, -/// leading to error messages involving ty_err. +/// FIXME: the TyError created here can enter the obligation we create, +/// leading to error messages involving TyError. fn normalize_to_error<'a,'tcx>(selcx: &mut SelectionContext<'a,'tcx>, projection_ty: ty::ProjectionTy<'tcx>, cause: ObligationCause<'tcx>, @@ -554,8 +554,8 @@ fn assemble_candidates_from_trait_def<'cx,'tcx>( { // Check whether the self-type is itself a projection. let trait_ref = match obligation_trait_ref.self_ty().sty { - ty::ty_projection(ref data) => data.trait_ref.clone(), - ty::ty_infer(ty::TyVar(_)) => { + ty::TyProjection(ref data) => data.trait_ref.clone(), + ty::TyInfer(ty::TyVar(_)) => { // If the self-type is an inference variable, then it MAY wind up // being a projected type, so induce an ambiguity. candidate_set.ambiguous = true; @@ -625,7 +625,7 @@ fn assemble_candidates_from_object_type<'cx,'tcx>( debug!("assemble_candidates_from_object_type(object_ty={})", object_ty.repr(infcx.tcx)); let data = match object_ty.sty { - ty::ty_trait(ref data) => data, + ty::TyTrait(ref data) => data, _ => { selcx.tcx().sess.span_bug( obligation.cause.span, @@ -883,7 +883,7 @@ fn confirm_impl_candidate<'cx,'tcx>( // definition for the associated type. This error // ought to be reported by the type checker method // `check_impl_items_against_trait`, so here we - // just return ty_err. + // just return TyError. return (selcx.tcx().types.err, vec!()); } } diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs index 7244622a833..ba5f0686f48 100644 --- a/src/librustc/middle/traits/select.rs +++ b/src/librustc/middle/traits/select.rs @@ -350,7 +350,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // lifetimes can appear inside the self-type. let self_ty = self.infcx.shallow_resolve(*obligation.self_ty().skip_binder()); let (closure_def_id, substs) = match self_ty.sty { - ty::ty_closure(id, ref substs) => (id, substs.clone()), + ty::TyClosure(id, ref substs) => (id, substs.clone()), _ => { return; } }; assert!(!substs.has_escaping_regions()); @@ -950,8 +950,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // before we go into the whole skolemization thing, just // quickly check if the self-type is a projection at all. let trait_def_id = match poly_trait_predicate.0.trait_ref.self_ty().sty { - ty::ty_projection(ref data) => data.trait_ref.def_id, - ty::ty_infer(ty::TyVar(_)) => { + ty::TyProjection(ref data) => data.trait_ref.def_id, + ty::TyInfer(ty::TyVar(_)) => { // If the self-type is an inference variable, then it MAY wind up // being a projected type, so induce an ambiguity. // @@ -994,7 +994,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { skol_map.repr(self.tcx())); let projection_trait_ref = match skol_trait_predicate.trait_ref.self_ty().sty { - ty::ty_projection(ref data) => &data.trait_ref, + ty::TyProjection(ref data) => &data.trait_ref, _ => { self.tcx().sess.span_bug( obligation.cause.span, @@ -1134,8 +1134,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // type/region parameters let self_ty = self.infcx.shallow_resolve(*obligation.self_ty().skip_binder()); let (closure_def_id, substs) = match self_ty.sty { - ty::ty_closure(id, substs) => (id, substs), - ty::ty_infer(ty::TyVar(_)) => { + ty::TyClosure(id, substs) => (id, substs), + ty::TyInfer(ty::TyVar(_)) => { debug!("assemble_unboxed_closure_candidates: ambiguous self-type"); candidates.ambiguous = true; return Ok(()); @@ -1179,13 +1179,13 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // ok to skip binder because what we are inspecting doesn't involve bound regions let self_ty = self.infcx.shallow_resolve(*obligation.self_ty().skip_binder()); match self_ty.sty { - ty::ty_infer(ty::TyVar(_)) => { + ty::TyInfer(ty::TyVar(_)) => { debug!("assemble_fn_pointer_candidates: ambiguous self-type"); candidates.ambiguous = true; // could wind up being a fn() type } // provide an impl, but only for suitable `fn` pointers - ty::ty_bare_fn(_, &ty::BareFnTy { + ty::TyBareFn(_, &ty::BareFnTy { unsafety: ast::Unsafety::Normal, abi: abi::Rust, sig: ty::Binder(ty::FnSig { @@ -1241,7 +1241,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { if ty::trait_has_default_impl(self.tcx(), def_id) { match self_ty.sty { - ty::ty_trait(..) => { + ty::TyTrait(..) => { // For object types, we don't know what the closed // over types are. For most traits, this means we // conservatively say nothing; a candidate may be @@ -1255,8 +1255,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { candidates.vec.push(DefaultImplObjectCandidate(def_id)); } } - ty::ty_param(..) | - ty::ty_projection(..) => { + ty::TyParam(..) | + ty::TyProjection(..) => { // In these cases, we don't know what the actual // type is. Therefore, we cannot break it down // into its constituent types. So we don't @@ -1271,7 +1271,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // for an example of a test case that exercises // this path. } - ty::ty_infer(ty::TyVar(_)) => { + ty::TyInfer(ty::TyVar(_)) => { // the defaulted impl might apply, we don't know candidates.ambiguous = true; } @@ -1325,7 +1325,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { let (self_ty, _) = self.infcx().skolemize_late_bound_regions(&bound_self_ty, snapshot); let poly_trait_ref = match self_ty.sty { - ty::ty_trait(ref data) => { + ty::TyTrait(ref data) => { match self.tcx().lang_items.to_builtin_kind(obligation.predicate.def_id()) { Some(bound @ ty::BoundSend) | Some(bound @ ty::BoundSync) => { if data.bounds.builtin_bounds.contains(&bound) { @@ -1340,7 +1340,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { data.principal_trait_ref_with_self_ty(self.tcx(), self_ty) } - ty::ty_infer(ty::TyVar(_)) => { + ty::TyInfer(ty::TyVar(_)) => { debug!("assemble_candidates_from_object_ty: ambiguous"); candidates.ambiguous = true; // could wind up being an object type return Ok(()); @@ -1399,7 +1399,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { let may_apply = match (&source.sty, &target.sty) { // Trait+Kx+'a -> Trait+Ky+'b (upcasts). - (&ty::ty_trait(ref data_a), &ty::ty_trait(ref data_b)) => { + (&ty::TyTrait(ref data_a), &ty::TyTrait(ref data_b)) => { // Upcasts permit two things: // // 1. Dropping builtin bounds, e.g. `Foo+Send` to `Foo` @@ -1416,23 +1416,23 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } // T -> Trait. - (_, &ty::ty_trait(_)) => true, + (_, &ty::TyTrait(_)) => true, // Ambiguous handling is below T -> Trait, because inference // variables can still implement Unsize<Trait> and nested // obligations will have the final say (likely deferred). - (&ty::ty_infer(ty::TyVar(_)), _) | - (_, &ty::ty_infer(ty::TyVar(_))) => { + (&ty::TyInfer(ty::TyVar(_)), _) | + (_, &ty::TyInfer(ty::TyVar(_))) => { debug!("assemble_candidates_for_unsizing: ambiguous"); candidates.ambiguous = true; false } // [T; n] -> [T]. - (&ty::ty_vec(_, Some(_)), &ty::ty_vec(_, None)) => true, + (&ty::TyArray(_, Some(_)), &ty::TyArray(_, None)) => true, // Struct<T> -> Struct<U>. - (&ty::ty_struct(def_id_a, _), &ty::ty_struct(def_id_b, _)) => { + (&ty::TyStruct(def_id_a, _), &ty::TyStruct(def_id_b, _)) => { def_id_a == def_id_b } @@ -1579,19 +1579,19 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { let self_ty = self.infcx.shallow_resolve(obligation.predicate.0.self_ty()); return match self_ty.sty { - ty::ty_infer(ty::IntVar(_)) | - ty::ty_infer(ty::FloatVar(_)) | - ty::ty_uint(_) | - ty::ty_int(_) | - ty::ty_bool | - ty::ty_float(_) | - ty::ty_bare_fn(..) | - ty::ty_char => { + ty::TyInfer(ty::IntVar(_)) | + ty::TyInfer(ty::FloatVar(_)) | + ty::TyUint(_) | + ty::TyInt(_) | + ty::TyBool | + ty::TyFloat(_) | + ty::TyBareFn(..) | + ty::TyChar => { // safe for everything ok_if(Vec::new()) } - ty::ty_uniq(_) => { // Box<T> + ty::TyBox(_) => { // Box<T> match bound { ty::BoundCopy => Err(Unimplemented), @@ -1603,7 +1603,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } } - ty::ty_ptr(..) => { // *const T, *mut T + ty::TyRawPtr(..) => { // *const T, *mut T match bound { ty::BoundCopy | ty::BoundSized => ok_if(Vec::new()), @@ -1613,7 +1613,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } } - ty::ty_trait(ref data) => { + ty::TyTrait(ref data) => { match bound { ty::BoundSized => Err(Unimplemented), ty::BoundCopy => { @@ -1641,7 +1641,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } } - ty::ty_rptr(_, ty::mt { ty: _, mutbl }) => { + ty::TyRef(_, ty::mt { ty: _, mutbl }) => { // &mut T or &T match bound { ty::BoundCopy => { @@ -1662,7 +1662,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } } - ty::ty_vec(element_ty, ref len) => { + ty::TyArray(element_ty, ref len) => { // [T; n] and [T] match bound { ty::BoundCopy => { @@ -1689,7 +1689,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } } - ty::ty_str => { + ty::TyStr => { // Equivalent to [u8] match bound { ty::BoundSync | ty::BoundSend => { @@ -1701,9 +1701,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } // (T1, ..., Tn) -- meets any bound that all of T1...Tn meet - ty::ty_tup(ref tys) => ok_if(tys.clone()), + ty::TyTuple(ref tys) => ok_if(tys.clone()), - ty::ty_closure(def_id, substs) => { + ty::TyClosure(def_id, substs) => { // FIXME -- This case is tricky. In the case of by-ref // closures particularly, we need the results of // inference to decide how to reflect the type of each @@ -1738,7 +1738,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } } - ty::ty_struct(def_id, substs) => { + ty::TyStruct(def_id, substs) => { let types: Vec<Ty> = ty::struct_fields(self.tcx(), def_id, substs).iter() .map(|f| f.mt.ty) @@ -1746,7 +1746,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { nominal(bound, types) } - ty::ty_enum(def_id, substs) => { + ty::TyEnum(def_id, substs) => { let types: Vec<Ty> = ty::substd_enum_variants(self.tcx(), def_id, substs) .iter() @@ -1756,7 +1756,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { nominal(bound, types) } - ty::ty_projection(_) | ty::ty_param(_) => { + ty::TyProjection(_) | ty::TyParam(_) => { // Note: A type parameter is only considered to meet a // particular bound if there is a where clause telling // us that it does, and that case is handled by @@ -1764,7 +1764,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { Ok(ParameterBuiltin) } - ty::ty_infer(ty::TyVar(_)) => { + ty::TyInfer(ty::TyVar(_)) => { // Unbound type variable. Might or might not have // applicable impls and so forth, depending on what // those type variables wind up being bound to. @@ -1772,11 +1772,11 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { Ok(AmbiguousBuiltin) } - ty::ty_err => ok_if(Vec::new()), + ty::TyError => ok_if(Vec::new()), - ty::ty_infer(ty::FreshTy(_)) - | ty::ty_infer(ty::FreshIntTy(_)) - | ty::ty_infer(ty::FreshFloatTy(_)) => { + ty::TyInfer(ty::FreshTy(_)) + | ty::TyInfer(ty::FreshIntTy(_)) + | ty::TyInfer(ty::FreshFloatTy(_)) => { self.tcx().sess.bug( &format!( "asked to assemble builtin bounds of unexpected type: {}", @@ -1820,51 +1820,51 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { /// ``` fn constituent_types_for_ty(&self, t: Ty<'tcx>) -> Option<Vec<Ty<'tcx>>> { match t.sty { - ty::ty_uint(_) | - ty::ty_int(_) | - ty::ty_bool | - ty::ty_float(_) | - ty::ty_bare_fn(..) | - ty::ty_str | - ty::ty_err | - ty::ty_infer(ty::IntVar(_)) | - ty::ty_infer(ty::FloatVar(_)) | - ty::ty_char => { + ty::TyUint(_) | + ty::TyInt(_) | + ty::TyBool | + ty::TyFloat(_) | + ty::TyBareFn(..) | + ty::TyStr | + ty::TyError | + ty::TyInfer(ty::IntVar(_)) | + ty::TyInfer(ty::FloatVar(_)) | + ty::TyChar => { Some(Vec::new()) } - ty::ty_trait(..) | - ty::ty_param(..) | - ty::ty_projection(..) | - ty::ty_infer(ty::TyVar(_)) | - ty::ty_infer(ty::FreshTy(_)) | - ty::ty_infer(ty::FreshIntTy(_)) | - ty::ty_infer(ty::FreshFloatTy(_)) => { + ty::TyTrait(..) | + ty::TyParam(..) | + ty::TyProjection(..) | + ty::TyInfer(ty::TyVar(_)) | + ty::TyInfer(ty::FreshTy(_)) | + ty::TyInfer(ty::FreshIntTy(_)) | + ty::TyInfer(ty::FreshFloatTy(_)) => { self.tcx().sess.bug( &format!( "asked to assemble constituent types of unexpected type: {}", t.repr(self.tcx()))); } - ty::ty_uniq(referent_ty) => { // Box<T> + ty::TyBox(referent_ty) => { // Box<T> Some(vec![referent_ty]) } - ty::ty_ptr(ty::mt { ty: element_ty, ..}) | - ty::ty_rptr(_, ty::mt { ty: element_ty, ..}) => { + ty::TyRawPtr(ty::mt { ty: element_ty, ..}) | + ty::TyRef(_, ty::mt { ty: element_ty, ..}) => { Some(vec![element_ty]) }, - ty::ty_vec(element_ty, _) => { + ty::TyArray(element_ty, _) => { Some(vec![element_ty]) } - ty::ty_tup(ref tys) => { + ty::TyTuple(ref tys) => { // (T1, ..., Tn) -- meets any bound that all of T1...Tn meet Some(tys.clone()) } - ty::ty_closure(def_id, substs) => { + ty::TyClosure(def_id, substs) => { assert_eq!(def_id.krate, ast::LOCAL_CRATE); match self.closure_typer.closure_upvars(def_id, substs) { @@ -1878,19 +1878,19 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } // for `PhantomData<T>`, we pass `T` - ty::ty_struct(def_id, substs) + ty::TyStruct(def_id, substs) if Some(def_id) == self.tcx().lang_items.phantom_data() => { Some(substs.types.get_slice(TypeSpace).to_vec()) } - ty::ty_struct(def_id, substs) => { + ty::TyStruct(def_id, substs) => { Some(ty::struct_fields(self.tcx(), def_id, substs).iter() .map(|f| f.mt.ty) .collect()) } - ty::ty_enum(def_id, substs) => { + ty::TyEnum(def_id, substs) => { Some(ty::substd_enum_variants(self.tcx(), def_id, substs) .iter() .flat_map(|variant| &variant.args) @@ -2169,7 +2169,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // OK to skip binder, it is reintroduced below let self_ty = self.infcx.shallow_resolve(obligation.predicate.skip_binder().self_ty()); match self_ty.sty { - ty::ty_trait(ref data) => { + ty::TyTrait(ref data) => { // OK to skip the binder, it is reintroduced below let input_types = data.principal.skip_binder().substs.types.get_slice(TypeSpace); let assoc_types = data.bounds.projection_bounds @@ -2299,7 +2299,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // case that results. -nmatsakis let self_ty = self.infcx.shallow_resolve(*obligation.self_ty().skip_binder()); let poly_trait_ref = match self_ty.sty { - ty::ty_trait(ref data) => { + ty::TyTrait(ref data) => { data.principal_trait_ref_with_self_ty(self.tcx(), self_ty) } _ => { @@ -2437,7 +2437,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { let mut nested = vec![]; match (&source.sty, &target.sty) { // Trait+Kx+'a -> Trait+Ky+'b (upcasts). - (&ty::ty_trait(ref data_a), &ty::ty_trait(ref data_b)) => { + (&ty::TyTrait(ref data_a), &ty::TyTrait(ref data_b)) => { // See assemble_candidates_for_unsizing for more info. let bounds = ty::ExistentialBounds { region_bound: data_b.bounds.region_bound, @@ -2463,7 +2463,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } // T -> Trait. - (_, &ty::ty_trait(ref data)) => { + (_, &ty::TyTrait(ref data)) => { let object_did = data.principal_def_id(); if !object_safety::is_object_safe(tcx, object_did) { return Err(TraitNotObjectSafe(object_did)); @@ -2510,7 +2510,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } // [T; n] -> [T]. - (&ty::ty_vec(a, Some(_)), &ty::ty_vec(b, None)) => { + (&ty::TyArray(a, Some(_)), &ty::TyArray(b, None)) => { let origin = infer::Misc(obligation.cause.span); if self.infcx.sub_types(false, origin, a, b).is_err() { return Err(Unimplemented); @@ -2518,7 +2518,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } // Struct<T> -> Struct<U>. - (&ty::ty_struct(def_id, substs_a), &ty::ty_struct(_, substs_b)) => { + (&ty::TyStruct(def_id, substs_a), &ty::TyStruct(_, substs_b)) => { let fields = ty::lookup_struct_fields(tcx, def_id).iter().map(|f| { ty::lookup_field_type_unsubstituted(tcx, def_id, f.id) }).collect::<Vec<_>>(); @@ -2531,7 +2531,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { }; let mut ty_params = vec![]; ty::walk_ty(field, |ty| { - if let ty::ty_param(p) = ty.sty { + if let ty::TyParam(p) = ty.sty { assert!(p.space == TypeSpace); let idx = p.idx as usize; if !ty_params.contains(&idx) { @@ -2544,7 +2544,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } // Replace type parameters used in unsizing with - // ty_err and ensure they do not affect any other fields. + // TyError and ensure they do not affect any other fields. // This could be checked after type collection for any struct // with a potentially unsized trailing field. let mut new_substs = substs_a.clone(); diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 5c5229fd1e7..42bc399e822 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -30,7 +30,7 @@ pub use self::ImplOrTraitItemContainer::*; pub use self::BorrowKind::*; pub use self::ImplOrTraitItem::*; pub use self::BoundRegion::*; -pub use self::sty::*; +pub use self::TypeVariants::*; pub use self::IntVarValue::*; pub use self::MethodOrigin::*; pub use self::CopyImplementationError::*; @@ -844,6 +844,7 @@ macro_rules! sty_debug_print { ($ctxt: expr, $($variant: ident),*) => {{ // curious inner module to allow variant names to be used as // variable names. + #[allow(non_snake_case)] mod inner { use middle::ty; #[derive(Copy, Clone)] @@ -864,9 +865,9 @@ macro_rules! sty_debug_print { for (_, t) in tcx.interner.borrow().iter() { let variant = match t.sty { - ty::ty_bool | ty::ty_char | ty::ty_int(..) | ty::ty_uint(..) | - ty::ty_float(..) | ty::ty_str => continue, - ty::ty_err => /* unimportant */ continue, + ty::TyBool | ty::TyChar | ty::TyInt(..) | ty::TyUint(..) | + ty::TyFloat(..) | ty::TyStr => continue, + ty::TyError => /* unimportant */ continue, $(ty::$variant(..) => &mut $variant,)* }; let region = t.flags.get().intersects(ty::TypeFlags::HAS_RE_INFER); @@ -905,8 +906,8 @@ impl<'tcx> ctxt<'tcx> { pub fn print_debug_stats(&self) { sty_debug_print!( self, - ty_enum, ty_uniq, ty_vec, ty_ptr, ty_rptr, ty_bare_fn, ty_trait, - ty_struct, ty_closure, ty_tup, ty_param, ty_infer, ty_projection); + TyEnum, TyBox, TyArray, TyRawPtr, TyRef, TyBareFn, TyTrait, + TyStruct, TyClosure, TyTuple, TyParam, TyInfer, TyProjection); println!("Substs interner: #{}", self.substs_interner.borrow().len()); println!("BareFnTy interner: #{}", self.bare_fn_interner.borrow().len()); @@ -917,7 +918,7 @@ impl<'tcx> ctxt<'tcx> { #[derive(Debug)] pub struct TyS<'tcx> { - pub sty: sty<'tcx>, + pub sty: TypeVariants<'tcx>, pub flags: Cell<TypeFlags>, // the maximal depth of any bound regions appearing in this type. @@ -967,8 +968,8 @@ impl<'tcx> Hash for InternedTy<'tcx> { } } -impl<'tcx> Borrow<sty<'tcx>> for InternedTy<'tcx> { - fn borrow<'a>(&'a self) -> &'a sty<'tcx> { +impl<'tcx> Borrow<TypeVariants<'tcx>> for InternedTy<'tcx> { + fn borrow<'a>(&'a self) -> &'a TypeVariants<'tcx> { &self.ty.sty } } @@ -1335,53 +1336,101 @@ pub enum BoundRegion { // NB: If you change this, you'll probably want to change the corresponding // AST structure in libsyntax/ast.rs as well. #[derive(Clone, PartialEq, Eq, Hash, Debug)] -pub enum sty<'tcx> { - ty_bool, - ty_char, - ty_int(ast::IntTy), - ty_uint(ast::UintTy), - ty_float(ast::FloatTy), - /// Substs here, possibly against intuition, *may* contain `ty_param`s. +pub enum TypeVariants<'tcx> { + /// The primitive boolean type. Written as `bool`. + TyBool, + + /// The primitive character type; holds a Unicode scalar value + /// (a non-surrogate code point). Written as `char`. + TyChar, + + /// A primitive signed integer type. For example, `i32`. + TyInt(ast::IntTy), + + /// A primitive unsigned integer type. For example, `u32`. + TyUint(ast::UintTy), + + /// A primitive floating-point type. For example, `f64`. + TyFloat(ast::FloatTy), + + /// An enumerated type, defined with `enum`. + /// + /// Substs here, possibly against intuition, *may* contain `TyParam`s. /// That is, even after substitution it is possible that there are type - /// variables. This happens when the `ty_enum` corresponds to an enum - /// definition and not a concrete use of it. To get the correct `ty_enum` + /// variables. This happens when the `TyEnum` corresponds to an enum + /// definition and not a concrete use of it. To get the correct `TyEnum` /// from the tcx, use the `NodeId` from the `ast::Ty` and look it up in - /// the `ast_ty_to_ty_cache`. This is probably true for `ty_struct` as + /// the `ast_ty_to_ty_cache`. This is probably true for `TyStruct` as /// well. - ty_enum(DefId, &'tcx Substs<'tcx>), - ty_uniq(Ty<'tcx>), - ty_str, - ty_vec(Ty<'tcx>, Option<usize>), // Second field is length. - ty_ptr(mt<'tcx>), - ty_rptr(&'tcx Region, mt<'tcx>), + TyEnum(DefId, &'tcx Substs<'tcx>), + + /// A structure type, defined with `struct`. + /// + /// See warning about substitutions for enumerated types. + TyStruct(DefId, &'tcx Substs<'tcx>), + + /// `Box<T>`; this is nominally a struct in the documentation, but is + /// special-cased internally. For example, it is possible to implicitly + /// move the contents of a box out of that box, and methods of any type + /// can have type `Box<Self>`. + TyBox(Ty<'tcx>), + + /// The pointee of a string slice. Written as `str`. + TyStr, + + /// An array with the given length, or the pointee + /// of an array slice. Written as `[T; n]`, or `[T]`. + /// FIXME: It probably makes sense to separate these. + TyArray(Ty<'tcx>, Option<usize>), + + /// A raw pointer. Written as `*mut T` or `*const T` + TyRawPtr(mt<'tcx>), + + /// A reference; a pointer with an associated lifetime. Written as + /// `&a mut T` or `&'a T`. + TyRef(&'tcx Region, mt<'tcx>), + + /// If the def-id is Some(_), then this is the type of a specific + /// fn item. Otherwise, if None(_), it a fn pointer type. + /// + /// FIXME: Conflating function pointers and the type of a + /// function is probably a terrible idea; a function pointer is a + /// value with a specific type, but a function can be polymorphic + /// or dynamically dispatched. + TyBareFn(Option<DefId>, &'tcx BareFnTy<'tcx>), + + /// A trait, defined with `trait`. + TyTrait(Box<TraitTy<'tcx>>), - // If the def-id is Some(_), then this is the type of a specific - // fn item. Otherwise, if None(_), it a fn pointer type. - ty_bare_fn(Option<DefId>, &'tcx BareFnTy<'tcx>), + /// The anonymous type of a closure. Used to represent the type of + /// `|a| a`. + TyClosure(DefId, &'tcx Substs<'tcx>), - ty_trait(Box<TyTrait<'tcx>>), - ty_struct(DefId, &'tcx Substs<'tcx>), + /// A tuple type. For example, `(i32, bool)`. + TyTuple(Vec<Ty<'tcx>>), - ty_closure(DefId, &'tcx Substs<'tcx>), + /// The projection of an associated type. For example, + /// `<T as Trait<..>>::N`. + TyProjection(ProjectionTy<'tcx>), - ty_tup(Vec<Ty<'tcx>>), + /// A type parameter; for example, `T` in `fn f<T>(x: T) {} + TyParam(ParamTy), - ty_projection(ProjectionTy<'tcx>), - ty_param(ParamTy), // type parameter + /// A type variable used during type-checking. + TyInfer(InferTy), - ty_infer(InferTy), // something used only during inference/typeck - ty_err, // Also only used during inference/typeck, to represent - // the type of an erroneous expression (helps cut down - // on non-useful type error messages) + /// A placeholder for a type which could not be computed; this is + /// propagated to avoid useless error messages. + TyError, } #[derive(Clone, PartialEq, Eq, Hash, Debug)] -pub struct TyTrait<'tcx> { +pub struct TraitTy<'tcx> { pub principal: ty::PolyTraitRef<'tcx>, pub bounds: ExistentialBounds<'tcx>, } -impl<'tcx> TyTrait<'tcx> { +impl<'tcx> TraitTy<'tcx> { pub fn principal_def_id(&self) -> ast::DefId { self.principal.0.def_id } @@ -2695,21 +2744,21 @@ impl<'tcx> CommonTypes<'tcx> { -> CommonTypes<'tcx> { CommonTypes { - bool: intern_ty(arena, interner, ty_bool), - char: intern_ty(arena, interner, ty_char), - err: intern_ty(arena, interner, ty_err), - isize: intern_ty(arena, interner, ty_int(ast::TyIs)), - i8: intern_ty(arena, interner, ty_int(ast::TyI8)), - i16: intern_ty(arena, interner, ty_int(ast::TyI16)), - i32: intern_ty(arena, interner, ty_int(ast::TyI32)), - i64: intern_ty(arena, interner, ty_int(ast::TyI64)), - usize: intern_ty(arena, interner, ty_uint(ast::TyUs)), - u8: intern_ty(arena, interner, ty_uint(ast::TyU8)), - u16: intern_ty(arena, interner, ty_uint(ast::TyU16)), - u32: intern_ty(arena, interner, ty_uint(ast::TyU32)), - u64: intern_ty(arena, interner, ty_uint(ast::TyU64)), - f32: intern_ty(arena, interner, ty_float(ast::TyF32)), - f64: intern_ty(arena, interner, ty_float(ast::TyF64)), + bool: intern_ty(arena, interner, TyBool), + char: intern_ty(arena, interner, TyChar), + err: intern_ty(arena, interner, TyError), + isize: intern_ty(arena, interner, TyInt(ast::TyIs)), + i8: intern_ty(arena, interner, TyInt(ast::TyI8)), + i16: intern_ty(arena, interner, TyInt(ast::TyI16)), + i32: intern_ty(arena, interner, TyInt(ast::TyI32)), + i64: intern_ty(arena, interner, TyInt(ast::TyI64)), + usize: intern_ty(arena, interner, TyUint(ast::TyUs)), + u8: intern_ty(arena, interner, TyUint(ast::TyU8)), + u16: intern_ty(arena, interner, TyUint(ast::TyU16)), + u32: intern_ty(arena, interner, TyUint(ast::TyU32)), + u64: intern_ty(arena, interner, TyUint(ast::TyU64)), + f32: intern_ty(arena, interner, TyFloat(ast::TyF32)), + f64: intern_ty(arena, interner, TyFloat(ast::TyF64)), } } } @@ -2865,14 +2914,14 @@ impl<'tcx> ctxt<'tcx> { // Interns a type/name combination, stores the resulting box in cx.interner, // and returns the box as cast to an unsafe ptr (see comments for Ty above). -pub fn mk_t<'tcx>(cx: &ctxt<'tcx>, st: sty<'tcx>) -> Ty<'tcx> { +pub fn mk_t<'tcx>(cx: &ctxt<'tcx>, st: TypeVariants<'tcx>) -> Ty<'tcx> { let mut interner = cx.interner.borrow_mut(); intern_ty(&cx.arenas.type_, &mut *interner, st) } fn intern_ty<'tcx>(type_arena: &'tcx TypedArena<TyS<'tcx>>, interner: &mut FnvHashMap<InternedTy<'tcx>, Ty<'tcx>>, - st: sty<'tcx>) + st: TypeVariants<'tcx>) -> Ty<'tcx> { match interner.get(&st) { @@ -2908,7 +2957,7 @@ impl FlagComputation { FlagComputation { flags: TypeFlags::empty(), depth: 0 } } - fn for_sty(st: &sty) -> FlagComputation { + fn for_sty(st: &TypeVariants) -> FlagComputation { let mut result = FlagComputation::new(); result.add_sty(st); result @@ -2938,28 +2987,28 @@ impl FlagComputation { } } - fn add_sty(&mut self, st: &sty) { + fn add_sty(&mut self, st: &TypeVariants) { match st { - &ty_bool | - &ty_char | - &ty_int(_) | - &ty_float(_) | - &ty_uint(_) | - &ty_str => { + &TyBool | + &TyChar | + &TyInt(_) | + &TyFloat(_) | + &TyUint(_) | + &TyStr => { } - // You might think that we could just return ty_err for - // any type containing ty_err as a component, and get + // You might think that we could just return TyError for + // any type containing TyError as a component, and get // rid of the TypeFlags::HAS_TY_ERR flag -- likewise for ty_bot (with // the exception of function types that return bot). // But doing so caused sporadic memory corruption, and // neither I (tjc) nor nmatsakis could figure out why, // so we're doing it this way. - &ty_err => { + &TyError => { self.add_flags(TypeFlags::HAS_TY_ERR) } - &ty_param(ref p) => { + &TyParam(ref p) => { if p.space == subst::SelfSpace { self.add_flags(TypeFlags::HAS_SELF); } else { @@ -2967,25 +3016,25 @@ impl FlagComputation { } } - &ty_closure(_, substs) => { + &TyClosure(_, substs) => { self.add_flags(TypeFlags::HAS_TY_CLOSURE); self.add_substs(substs); } - &ty_infer(_) => { + &TyInfer(_) => { self.add_flags(TypeFlags::HAS_TY_INFER) } - &ty_enum(_, substs) | &ty_struct(_, substs) => { + &TyEnum(_, substs) | &TyStruct(_, substs) => { self.add_substs(substs); } - &ty_projection(ref data) => { + &TyProjection(ref data) => { self.add_flags(TypeFlags::HAS_PROJECTION); self.add_projection_ty(data); } - &ty_trait(box TyTrait { ref principal, ref bounds }) => { + &TyTrait(box TraitTy { ref principal, ref bounds }) => { let mut computation = FlagComputation::new(); computation.add_substs(principal.0.substs); for projection_bound in &bounds.projection_bounds { @@ -2998,24 +3047,24 @@ impl FlagComputation { self.add_bounds(bounds); } - &ty_uniq(tt) | &ty_vec(tt, _) => { + &TyBox(tt) | &TyArray(tt, _) => { self.add_ty(tt) } - &ty_ptr(ref m) => { + &TyRawPtr(ref m) => { self.add_ty(m.ty); } - &ty_rptr(r, ref m) => { + &TyRef(r, ref m) => { self.add_region(*r); self.add_ty(m.ty); } - &ty_tup(ref ts) => { + &TyTuple(ref ts) => { self.add_tys(&ts[..]); } - &ty_bare_fn(_, ref f) => { + &TyBareFn(_, ref f) => { self.add_fn_sig(&f.sig); } } @@ -3108,28 +3157,28 @@ pub fn mk_mach_float<'tcx>(tcx: &ctxt<'tcx>, tm: ast::FloatTy) -> Ty<'tcx> { } pub fn mk_str<'tcx>(cx: &ctxt<'tcx>) -> Ty<'tcx> { - mk_t(cx, ty_str) + mk_t(cx, TyStr) } pub fn mk_str_slice<'tcx>(cx: &ctxt<'tcx>, r: &'tcx Region, m: ast::Mutability) -> Ty<'tcx> { mk_rptr(cx, r, mt { - ty: mk_t(cx, ty_str), + ty: mk_t(cx, TyStr), mutbl: m }) } pub fn mk_enum<'tcx>(cx: &ctxt<'tcx>, did: ast::DefId, substs: &'tcx Substs<'tcx>) -> Ty<'tcx> { // take a copy of substs so that we own the vectors inside - mk_t(cx, ty_enum(did, substs)) + mk_t(cx, TyEnum(did, substs)) } -pub fn mk_uniq<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { mk_t(cx, ty_uniq(ty)) } +pub fn mk_uniq<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { mk_t(cx, TyBox(ty)) } -pub fn mk_ptr<'tcx>(cx: &ctxt<'tcx>, tm: mt<'tcx>) -> Ty<'tcx> { mk_t(cx, ty_ptr(tm)) } +pub fn mk_ptr<'tcx>(cx: &ctxt<'tcx>, tm: mt<'tcx>) -> Ty<'tcx> { mk_t(cx, TyRawPtr(tm)) } pub fn mk_rptr<'tcx>(cx: &ctxt<'tcx>, r: &'tcx Region, tm: mt<'tcx>) -> Ty<'tcx> { - mk_t(cx, ty_rptr(r, tm)) + mk_t(cx, TyRef(r, tm)) } pub fn mk_mut_rptr<'tcx>(cx: &ctxt<'tcx>, r: &'tcx Region, ty: Ty<'tcx>) -> Ty<'tcx> { @@ -3152,7 +3201,7 @@ pub fn mk_nil_ptr<'tcx>(cx: &ctxt<'tcx>) -> Ty<'tcx> { } pub fn mk_vec<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>, sz: Option<usize>) -> Ty<'tcx> { - mk_t(cx, ty_vec(ty, sz)) + mk_t(cx, TyArray(ty, sz)) } pub fn mk_slice<'tcx>(cx: &ctxt<'tcx>, r: &'tcx Region, tm: mt<'tcx>) -> Ty<'tcx> { @@ -3164,7 +3213,7 @@ pub fn mk_slice<'tcx>(cx: &ctxt<'tcx>, r: &'tcx Region, tm: mt<'tcx>) -> Ty<'tcx } pub fn mk_tup<'tcx>(cx: &ctxt<'tcx>, ts: Vec<Ty<'tcx>>) -> Ty<'tcx> { - mk_t(cx, ty_tup(ts)) + mk_t(cx, TyTuple(ts)) } pub fn mk_nil<'tcx>(cx: &ctxt<'tcx>) -> Ty<'tcx> { @@ -3172,13 +3221,13 @@ pub fn mk_nil<'tcx>(cx: &ctxt<'tcx>) -> Ty<'tcx> { } pub fn mk_bool<'tcx>(cx: &ctxt<'tcx>) -> Ty<'tcx> { - mk_t(cx, ty_bool) + mk_t(cx, TyBool) } pub fn mk_bare_fn<'tcx>(cx: &ctxt<'tcx>, opt_def_id: Option<ast::DefId>, fty: &'tcx BareFnTy<'tcx>) -> Ty<'tcx> { - mk_t(cx, ty_bare_fn(opt_def_id, fty)) + mk_t(cx, TyBareFn(opt_def_id, fty)) } pub fn mk_ctor_fn<'tcx>(cx: &ctxt<'tcx>, @@ -3206,11 +3255,11 @@ pub fn mk_trait<'tcx>(cx: &ctxt<'tcx>, { assert!(bound_list_is_sorted(&bounds.projection_bounds)); - let inner = box TyTrait { + let inner = box TraitTy { principal: principal, bounds: bounds }; - mk_t(cx, ty_trait(inner)) + mk_t(cx, TyTrait(inner)) } fn bound_list_is_sorted(bounds: &[ty::PolyProjectionPredicate]) -> bool { @@ -3229,18 +3278,18 @@ pub fn mk_projection<'tcx>(cx: &ctxt<'tcx>, -> Ty<'tcx> { // take a copy of substs so that we own the vectors inside let inner = ProjectionTy { trait_ref: trait_ref, item_name: item_name }; - mk_t(cx, ty_projection(inner)) + mk_t(cx, TyProjection(inner)) } pub fn mk_struct<'tcx>(cx: &ctxt<'tcx>, struct_id: ast::DefId, substs: &'tcx Substs<'tcx>) -> Ty<'tcx> { // take a copy of substs so that we own the vectors inside - mk_t(cx, ty_struct(struct_id, substs)) + mk_t(cx, TyStruct(struct_id, substs)) } pub fn mk_closure<'tcx>(cx: &ctxt<'tcx>, closure_id: ast::DefId, substs: &'tcx Substs<'tcx>) -> Ty<'tcx> { - mk_t(cx, ty_closure(closure_id, substs)) + mk_t(cx, TyClosure(closure_id, substs)) } pub fn mk_var<'tcx>(cx: &ctxt<'tcx>, v: TyVid) -> Ty<'tcx> { @@ -3256,14 +3305,14 @@ pub fn mk_float_var<'tcx>(cx: &ctxt<'tcx>, v: FloatVid) -> Ty<'tcx> { } pub fn mk_infer<'tcx>(cx: &ctxt<'tcx>, it: InferTy) -> Ty<'tcx> { - mk_t(cx, ty_infer(it)) + mk_t(cx, TyInfer(it)) } pub fn mk_param<'tcx>(cx: &ctxt<'tcx>, space: subst::ParamSpace, index: u32, name: ast::Name) -> Ty<'tcx> { - mk_t(cx, ty_param(ParamTy { space: space, idx: index, name: name })) + mk_t(cx, TyParam(ParamTy { space: space, idx: index, name: name })) } pub fn mk_self_type<'tcx>(cx: &ctxt<'tcx>) -> Ty<'tcx> { @@ -3298,14 +3347,14 @@ impl<'tcx> TyS<'tcx> { pub fn as_opt_param_ty(&self) -> Option<ty::ParamTy> { match self.sty { - ty::ty_param(ref d) => Some(d.clone()), + ty::TyParam(ref d) => Some(d.clone()), _ => None, } } pub fn is_param(&self, space: ParamSpace, index: u32) -> bool { match self.sty { - ty::ty_param(ref data) => data.space == space && data.idx == index, + ty::TyParam(ref data) => data.space == space && data.idx == index, _ => false, } } @@ -3395,7 +3444,7 @@ impl<'tcx> ParamBounds<'tcx> { pub fn type_is_nil(ty: Ty) -> bool { match ty.sty { - ty_tup(ref tys) => tys.is_empty(), + TyTuple(ref tys) => tys.is_empty(), _ => false } } @@ -3414,24 +3463,24 @@ pub fn trait_ref_contains_error(tref: &ty::TraitRef) -> bool { pub fn type_is_ty_var(ty: Ty) -> bool { match ty.sty { - ty_infer(TyVar(_)) => true, + TyInfer(TyVar(_)) => true, _ => false } } -pub fn type_is_bool(ty: Ty) -> bool { ty.sty == ty_bool } +pub fn type_is_bool(ty: Ty) -> bool { ty.sty == TyBool } pub fn type_is_self(ty: Ty) -> bool { match ty.sty { - ty_param(ref p) => p.space == subst::SelfSpace, + TyParam(ref p) => p.space == subst::SelfSpace, _ => false } } fn type_is_slice(ty: Ty) -> bool { match ty.sty { - ty_ptr(mt) | ty_rptr(_, mt) => match mt.ty.sty { - ty_vec(_, None) | ty_str => true, + TyRawPtr(mt) | TyRef(_, mt) => match mt.ty.sty { + TyArray(_, None) | TyStr => true, _ => false, }, _ => false @@ -3440,10 +3489,10 @@ fn type_is_slice(ty: Ty) -> bool { pub fn type_is_vec(ty: Ty) -> bool { match ty.sty { - ty_vec(..) => true, - ty_ptr(mt{ty, ..}) | ty_rptr(_, mt{ty, ..}) | - ty_uniq(ty) => match ty.sty { - ty_vec(_, None) => true, + TyArray(..) => true, + TyRawPtr(mt{ty, ..}) | TyRef(_, mt{ty, ..}) | + TyBox(ty) => match ty.sty { + TyArray(_, None) => true, _ => false }, _ => false @@ -3452,23 +3501,23 @@ pub fn type_is_vec(ty: Ty) -> bool { pub fn type_is_structural(ty: Ty) -> bool { match ty.sty { - ty_struct(..) | ty_tup(_) | ty_enum(..) | - ty_vec(_, Some(_)) | ty_closure(..) => true, + TyStruct(..) | TyTuple(_) | TyEnum(..) | + TyArray(_, Some(_)) | TyClosure(..) => true, _ => type_is_slice(ty) | type_is_trait(ty) } } pub fn type_is_simd(cx: &ctxt, ty: Ty) -> bool { match ty.sty { - ty_struct(did, _) => lookup_simd(cx, did), + TyStruct(did, _) => lookup_simd(cx, did), _ => false } } pub fn sequence_element_type<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { match ty.sty { - ty_vec(ty, _) => ty, - ty_str => mk_mach_uint(cx, ast::TyU8), + TyArray(ty, _) => ty, + TyStr => mk_mach_uint(cx, ast::TyU8), _ => cx.sess.bug(&format!("sequence_element_type called on non-sequence value: {}", ty_to_string(cx, ty))), } @@ -3476,7 +3525,7 @@ pub fn sequence_element_type<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { pub fn simd_type<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { match ty.sty { - ty_struct(did, substs) => { + TyStruct(did, substs) => { let fields = lookup_struct_fields(cx, did); lookup_field_type(cx, did, fields[0].id, substs) } @@ -3486,7 +3535,7 @@ pub fn simd_type<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { pub fn simd_size(cx: &ctxt, ty: Ty) -> usize { match ty.sty { - ty_struct(did, _) => { + TyStruct(did, _) => { let fields = lookup_struct_fields(cx, did); fields.len() } @@ -3496,35 +3545,35 @@ pub fn simd_size(cx: &ctxt, ty: Ty) -> usize { pub fn type_is_region_ptr(ty: Ty) -> bool { match ty.sty { - ty_rptr(..) => true, + TyRef(..) => true, _ => false } } pub fn type_is_unsafe_ptr(ty: Ty) -> bool { match ty.sty { - ty_ptr(_) => return true, + TyRawPtr(_) => return true, _ => return false } } pub fn type_is_unique(ty: Ty) -> bool { match ty.sty { - ty_uniq(_) => true, + TyBox(_) => true, _ => false } } /* A scalar type is one that denotes an atomic datum, with no sub-components. - (A ty_ptr is scalar because it represents a non-managed pointer, so its + (A TyRawPtr is scalar because it represents a non-managed pointer, so its contents are abstract to rustc.) */ pub fn type_is_scalar(ty: Ty) -> bool { match ty.sty { - ty_bool | ty_char | ty_int(_) | ty_float(_) | ty_uint(_) | - ty_infer(IntVar(_)) | ty_infer(FloatVar(_)) | - ty_bare_fn(..) | ty_ptr(_) => true, + TyBool | TyChar | TyInt(_) | TyFloat(_) | TyUint(_) | + TyInfer(IntVar(_)) | TyInfer(FloatVar(_)) | + TyBareFn(..) | TyRawPtr(_) => true, _ => false } } @@ -3532,8 +3581,8 @@ pub fn type_is_scalar(ty: Ty) -> bool { /// Returns true if this type is a floating point type and false otherwise. pub fn type_is_floating_point(ty: Ty) -> bool { match ty.sty { - ty_float(_) | - ty_infer(FloatVar(_)) => + TyFloat(_) | + TyInfer(FloatVar(_)) => true, _ => @@ -3738,51 +3787,51 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents { let result = match ty.sty { // usize and isize are ffi-unsafe - ty_uint(ast::TyUs) | ty_int(ast::TyIs) => { + TyUint(ast::TyUs) | TyInt(ast::TyIs) => { TC::ReachesFfiUnsafe } // Scalar and unique types are sendable, and durable - ty_infer(ty::FreshIntTy(_)) | ty_infer(ty::FreshFloatTy(_)) | - ty_bool | ty_int(_) | ty_uint(_) | ty_float(_) | - ty_bare_fn(..) | ty::ty_char => { + TyInfer(ty::FreshIntTy(_)) | TyInfer(ty::FreshFloatTy(_)) | + TyBool | TyInt(_) | TyUint(_) | TyFloat(_) | + TyBareFn(..) | ty::TyChar => { TC::None } - ty_uniq(typ) => { + TyBox(typ) => { TC::ReachesFfiUnsafe | match typ.sty { - ty_str => TC::OwnsOwned, + TyStr => TC::OwnsOwned, _ => tc_ty(cx, typ, cache).owned_pointer(), } } - ty_trait(box TyTrait { ref bounds, .. }) => { + TyTrait(box TraitTy { ref bounds, .. }) => { object_contents(bounds) | TC::ReachesFfiUnsafe | TC::Nonsized } - ty_ptr(ref mt) => { + TyRawPtr(ref mt) => { tc_ty(cx, mt.ty, cache).unsafe_pointer() } - ty_rptr(r, ref mt) => { + TyRef(r, ref mt) => { TC::ReachesFfiUnsafe | match mt.ty.sty { - ty_str => borrowed_contents(*r, ast::MutImmutable), - ty_vec(..) => tc_ty(cx, mt.ty, cache).reference(borrowed_contents(*r, + TyStr => borrowed_contents(*r, ast::MutImmutable), + TyArray(..) => tc_ty(cx, mt.ty, cache).reference(borrowed_contents(*r, mt.mutbl)), _ => tc_ty(cx, mt.ty, cache).reference(borrowed_contents(*r, mt.mutbl)), } } - ty_vec(ty, Some(_)) => { + TyArray(ty, Some(_)) => { tc_ty(cx, ty, cache) } - ty_vec(ty, None) => { + TyArray(ty, None) => { tc_ty(cx, ty, cache) | TC::Nonsized } - ty_str => TC::Nonsized, + TyStr => TC::Nonsized, - ty_struct(did, substs) => { + TyStruct(did, substs) => { let flds = struct_fields(cx, did, substs); let mut res = TypeContents::union(&flds[..], @@ -3798,19 +3847,19 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents { apply_lang_items(cx, did, res) } - ty_closure(did, substs) => { + TyClosure(did, substs) => { // FIXME(#14449): `borrowed_contents` below assumes `&mut` closure. let param_env = ty::empty_parameter_environment(cx); let upvars = closure_upvars(¶m_env, did, substs).unwrap(); TypeContents::union(&upvars, |f| tc_ty(cx, &f.ty, cache)) } - ty_tup(ref tys) => { + TyTuple(ref tys) => { TypeContents::union(&tys[..], |ty| tc_ty(cx, *ty, cache)) } - ty_enum(did, substs) => { + TyEnum(did, substs) => { let variants = substd_enum_variants(cx, did, substs); let mut res = TypeContents::union(&variants[..], |variant| { @@ -3852,7 +3901,7 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents { if variants[data_idx].args.len() == 1 { match variants[data_idx].args[0].sty { - ty_bare_fn(..) => { res = res - TC::ReachesFfiUnsafe; } + TyBareFn(..) => { res = res - TC::ReachesFfiUnsafe; } _ => { } } } @@ -3865,13 +3914,13 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents { apply_lang_items(cx, did, res) } - ty_projection(..) | - ty_param(_) => { + TyProjection(..) | + TyParam(_) => { TC::All } - ty_infer(_) | - ty_err => { + TyInfer(_) | + TyError => { cx.sess.bug("asked to compute contents of error type"); } }; @@ -3963,18 +4012,18 @@ pub fn type_moves_by_default<'a,'tcx>(param_env: &ParameterEnvironment<'a,'tcx>, // Fast-path for primitive types let result = match ty.sty { - ty_bool | ty_char | ty_int(..) | ty_uint(..) | ty_float(..) | - ty_ptr(..) | ty_bare_fn(..) | ty_rptr(_, mt { + TyBool | TyChar | TyInt(..) | TyUint(..) | TyFloat(..) | + TyRawPtr(..) | TyBareFn(..) | TyRef(_, mt { mutbl: ast::MutImmutable, .. }) => Some(false), - ty_str | ty_uniq(..) | ty_rptr(_, mt { + TyStr | TyBox(..) | TyRef(_, mt { mutbl: ast::MutMutable, .. }) => Some(true), - ty_vec(..) | ty_trait(..) | ty_tup(..) | - ty_closure(..) | ty_enum(..) | ty_struct(..) | - ty_projection(..) | ty_param(..) | ty_infer(..) | ty_err => None + TyArray(..) | TyTrait(..) | TyTuple(..) | + TyClosure(..) | TyEnum(..) | TyStruct(..) | + TyProjection(..) | TyParam(..) | TyInfer(..) | TyError => None }.unwrap_or_else(|| !type_impls_bound(Some(param_env), param_env.tcx, ty, @@ -4015,14 +4064,14 @@ fn type_is_sized_uncached<'a,'tcx>(param_env: Option<&ParameterEnvironment<'a,'t // Fast-path for primitive types let result = match ty.sty { - ty_bool | ty_char | ty_int(..) | ty_uint(..) | ty_float(..) | - ty_uniq(..) | ty_ptr(..) | ty_rptr(..) | ty_bare_fn(..) | - ty_vec(_, Some(..)) | ty_tup(..) | ty_closure(..) => Some(true), + TyBool | TyChar | TyInt(..) | TyUint(..) | TyFloat(..) | + TyBox(..) | TyRawPtr(..) | TyRef(..) | TyBareFn(..) | + TyArray(_, Some(..)) | TyTuple(..) | TyClosure(..) => Some(true), - ty_str | ty_trait(..) | ty_vec(_, None) => Some(false), + TyStr | TyTrait(..) | TyArray(_, None) => Some(false), - ty_enum(..) | ty_struct(..) | ty_projection(..) | ty_param(..) | - ty_infer(..) | ty_err => None + TyEnum(..) | TyStruct(..) | TyProjection(..) | TyParam(..) | + TyInfer(..) | TyError => None }.unwrap_or_else(|| type_impls_bound(param_env, tcx, ty, ty::BoundSized, span)); if !type_has_params(ty) && !type_has_self(ty) { @@ -4067,41 +4116,41 @@ pub fn is_instantiable<'tcx>(cx: &ctxt<'tcx>, r_ty: Ty<'tcx>) -> bool { // fixed length vectors need special treatment compared to // normal vectors, since they don't necessarily have the // possibility to have length zero. - ty_vec(_, Some(0)) => false, // don't need no contents - ty_vec(ty, Some(_)) => type_requires(cx, seen, r_ty, ty), - - ty_bool | - ty_char | - ty_int(_) | - ty_uint(_) | - ty_float(_) | - ty_str | - ty_bare_fn(..) | - ty_param(_) | - ty_projection(_) | - ty_vec(_, None) => { + TyArray(_, Some(0)) => false, // don't need no contents + TyArray(ty, Some(_)) => type_requires(cx, seen, r_ty, ty), + + TyBool | + TyChar | + TyInt(_) | + TyUint(_) | + TyFloat(_) | + TyStr | + TyBareFn(..) | + TyParam(_) | + TyProjection(_) | + TyArray(_, None) => { false } - ty_uniq(typ) => { + TyBox(typ) => { type_requires(cx, seen, r_ty, typ) } - ty_rptr(_, ref mt) => { + TyRef(_, ref mt) => { type_requires(cx, seen, r_ty, mt.ty) } - ty_ptr(..) => { + TyRawPtr(..) => { false // unsafe ptrs can always be NULL } - ty_trait(..) => { + TyTrait(..) => { false } - ty_struct(ref did, _) if seen.contains(did) => { + TyStruct(ref did, _) if seen.contains(did) => { false } - ty_struct(did, substs) => { + TyStruct(did, substs) => { seen.push(did); let fields = struct_fields(cx, did, substs); let r = fields.iter().any(|f| type_requires(cx, seen, r_ty, f.mt.ty)); @@ -4109,23 +4158,23 @@ pub fn is_instantiable<'tcx>(cx: &ctxt<'tcx>, r_ty: Ty<'tcx>) -> bool { r } - ty_err | - ty_infer(_) | - ty_closure(..) => { + TyError | + TyInfer(_) | + TyClosure(..) => { // this check is run on type definitions, so we don't expect to see // inference by-products or closure types cx.sess.bug(&format!("requires check invoked on inapplicable type: {:?}", ty)) } - ty_tup(ref ts) => { + TyTuple(ref ts) => { ts.iter().any(|ty| type_requires(cx, seen, r_ty, *ty)) } - ty_enum(ref did, _) if seen.contains(did) => { + TyEnum(ref did, _) if seen.contains(did) => { false } - ty_enum(did, substs) => { + TyEnum(did, substs) => { seen.push(did); let vs = enum_variants(cx, did); let r = !vs.is_empty() && vs.iter().all(|variant| { @@ -4184,19 +4233,19 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>) seen: &mut Vec<Ty<'tcx>>, ty: Ty<'tcx>) -> Representability { match ty.sty { - ty_tup(ref ts) => { + TyTuple(ref ts) => { find_nonrepresentable(cx, sp, seen, ts.iter().cloned()) } // Fixed-length vectors. // FIXME(#11924) Behavior undecided for zero-length vectors. - ty_vec(ty, Some(_)) => { + TyArray(ty, Some(_)) => { is_type_structurally_recursive(cx, sp, seen, ty) } - ty_struct(did, substs) => { + TyStruct(did, substs) => { let fields = struct_fields(cx, did, substs); find_nonrepresentable(cx, sp, seen, fields.iter().map(|f| f.mt.ty)) } - ty_enum(did, substs) => { + TyEnum(did, substs) => { let vs = enum_variants(cx, did); let iter = vs.iter() .flat_map(|variant| &variant.args) @@ -4204,7 +4253,7 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>) find_nonrepresentable(cx, sp, seen, iter) } - ty_closure(..) => { + TyClosure(..) => { // this check is run on type definitions, so we don't expect // to see closure types cx.sess.bug(&format!("requires check invoked on inapplicable type: {:?}", ty)) @@ -4215,7 +4264,7 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>) fn same_struct_or_enum_def_id(ty: Ty, did: DefId) -> bool { match ty.sty { - ty_struct(ty_did, _) | ty_enum(ty_did, _) => { + TyStruct(ty_did, _) | TyEnum(ty_did, _) => { ty_did == did } _ => false @@ -4224,8 +4273,8 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>) fn same_type<'tcx>(a: Ty<'tcx>, b: Ty<'tcx>) -> bool { match (&a.sty, &b.sty) { - (&ty_struct(did_a, ref substs_a), &ty_struct(did_b, ref substs_b)) | - (&ty_enum(did_a, ref substs_a), &ty_enum(did_b, ref substs_b)) => { + (&TyStruct(did_a, ref substs_a), &TyStruct(did_b, ref substs_b)) | + (&TyEnum(did_a, ref substs_a), &TyEnum(did_b, ref substs_b)) => { if did_a != did_b { return false; } @@ -4252,7 +4301,7 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>) ::util::ppaux::ty_to_string(cx, ty)); match ty.sty { - ty_struct(did, _) | ty_enum(did, _) => { + TyStruct(did, _) | TyEnum(did, _) => { { // Iterate through stack of previously seen types. let mut iter = seen.iter(); @@ -4325,58 +4374,58 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>) pub fn type_is_trait(ty: Ty) -> bool { match ty.sty { - ty_trait(..) => true, + TyTrait(..) => true, _ => false } } pub fn type_is_integral(ty: Ty) -> bool { match ty.sty { - ty_infer(IntVar(_)) | ty_int(_) | ty_uint(_) => true, + TyInfer(IntVar(_)) | TyInt(_) | TyUint(_) => true, _ => false } } pub fn type_is_fresh(ty: Ty) -> bool { match ty.sty { - ty_infer(FreshTy(_)) => true, - ty_infer(FreshIntTy(_)) => true, - ty_infer(FreshFloatTy(_)) => true, + TyInfer(FreshTy(_)) => true, + TyInfer(FreshIntTy(_)) => true, + TyInfer(FreshFloatTy(_)) => true, _ => false } } pub fn type_is_uint(ty: Ty) -> bool { match ty.sty { - ty_infer(IntVar(_)) | ty_uint(ast::TyUs) => true, + TyInfer(IntVar(_)) | TyUint(ast::TyUs) => true, _ => false } } pub fn type_is_char(ty: Ty) -> bool { match ty.sty { - ty_char => true, + TyChar => true, _ => false } } pub fn type_is_bare_fn(ty: Ty) -> bool { match ty.sty { - ty_bare_fn(..) => true, + TyBareFn(..) => true, _ => false } } pub fn type_is_bare_fn_item(ty: Ty) -> bool { match ty.sty { - ty_bare_fn(Some(_), _) => true, + TyBareFn(Some(_), _) => true, _ => false } } pub fn type_is_fp(ty: Ty) -> bool { match ty.sty { - ty_infer(FloatVar(_)) | ty_float(_) => true, + TyInfer(FloatVar(_)) | TyFloat(_) => true, _ => false } } @@ -4387,15 +4436,15 @@ pub fn type_is_numeric(ty: Ty) -> bool { pub fn type_is_signed(ty: Ty) -> bool { match ty.sty { - ty_int(_) => true, + TyInt(_) => true, _ => false } } pub fn type_is_machine(ty: Ty) -> bool { match ty.sty { - ty_int(ast::TyIs) | ty_uint(ast::TyUs) => false, - ty_int(..) | ty_uint(..) | ty_float(..) => true, + TyInt(ast::TyIs) | TyUint(ast::TyUs) => false, + TyInt(..) | TyUint(..) | TyFloat(..) => true, _ => false } } @@ -4404,7 +4453,7 @@ pub fn type_is_machine(ty: Ty) -> bool { // constructors pub fn type_is_c_like_enum(cx: &ctxt, ty: Ty) -> bool { match ty.sty { - ty_enum(did, _) => { + TyEnum(did, _) => { let variants = enum_variants(cx, did); if variants.is_empty() { false @@ -4422,22 +4471,22 @@ pub fn type_is_c_like_enum(cx: &ctxt, ty: Ty) -> bool { // Some types---notably unsafe ptrs---can only be dereferenced explicitly. pub fn deref<'tcx>(ty: Ty<'tcx>, explicit: bool) -> Option<mt<'tcx>> { match ty.sty { - ty_uniq(ty) => { + TyBox(ty) => { Some(mt { ty: ty, mutbl: ast::MutImmutable, }) }, - ty_rptr(_, mt) => Some(mt), - ty_ptr(mt) if explicit => Some(mt), + TyRef(_, mt) => Some(mt), + TyRawPtr(mt) if explicit => Some(mt), _ => None } } pub fn type_content<'tcx>(ty: Ty<'tcx>) -> Ty<'tcx> { match ty.sty { - ty_uniq(ty) => ty, - ty_rptr(_, mt) | ty_ptr(mt) => mt.ty, + TyBox(ty) => ty, + TyRef(_, mt) | TyRawPtr(mt) => mt.ty, _ => ty } } @@ -4445,7 +4494,7 @@ pub fn type_content<'tcx>(ty: Ty<'tcx>) -> Ty<'tcx> { // Returns the type of ty[i] pub fn index<'tcx>(ty: Ty<'tcx>) -> Option<Ty<'tcx>> { match ty.sty { - ty_vec(ty, _) => Some(ty), + TyArray(ty, _) => Some(ty), _ => None } } @@ -4455,8 +4504,8 @@ pub fn index<'tcx>(ty: Ty<'tcx>) -> Option<Ty<'tcx>> { // which can't actually be indexed. pub fn array_element_ty<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> { match ty.sty { - ty_vec(ty, _) => Some(ty), - ty_str => Some(tcx.types.u8), + TyArray(ty, _) => Some(ty), + TyStr => Some(tcx.types.u8), _ => None } } @@ -4469,19 +4518,19 @@ pub fn positional_element_ty<'tcx>(cx: &ctxt<'tcx>, variant: Option<ast::DefId>) -> Option<Ty<'tcx>> { match (&ty.sty, variant) { - (&ty_tup(ref v), None) => v.get(i).cloned(), + (&TyTuple(ref v), None) => v.get(i).cloned(), - (&ty_struct(def_id, substs), None) => lookup_struct_fields(cx, def_id) + (&TyStruct(def_id, substs), None) => lookup_struct_fields(cx, def_id) .get(i) .map(|&t|lookup_item_type(cx, t.id).ty.subst(cx, substs)), - (&ty_enum(def_id, substs), Some(variant_def_id)) => { + (&TyEnum(def_id, substs), Some(variant_def_id)) => { let variant_info = enum_variant_with_id(cx, def_id, variant_def_id); variant_info.args.get(i).map(|t|t.subst(cx, substs)) } - (&ty_enum(def_id, substs), None) => { + (&TyEnum(def_id, substs), None) => { assert!(enum_is_univariant(cx, def_id)); let enum_variants = enum_variants(cx, def_id); let variant_info = &(*enum_variants)[0]; @@ -4500,12 +4549,12 @@ pub fn named_element_ty<'tcx>(cx: &ctxt<'tcx>, variant: Option<ast::DefId>) -> Option<Ty<'tcx>> { match (&ty.sty, variant) { - (&ty_struct(def_id, substs), None) => { + (&TyStruct(def_id, substs), None) => { let r = lookup_struct_fields(cx, def_id); r.iter().find(|f| f.name == n) .map(|&f| lookup_field_type(cx, def_id, f.id, substs)) } - (&ty_enum(def_id, substs), Some(variant_def_id)) => { + (&TyEnum(def_id, substs), Some(variant_def_id)) => { let variant_info = enum_variant_with_id(cx, def_id, variant_def_id); variant_info.arg_names.as_ref() .expect("must have struct enum variant if accessing a named fields") @@ -4542,7 +4591,7 @@ pub fn node_id_item_substs<'tcx>(cx: &ctxt<'tcx>, id: ast::NodeId) -> ItemSubsts pub fn fn_is_variadic(fty: Ty) -> bool { match fty.sty { - ty_bare_fn(_, ref f) => f.sig.0.variadic, + TyBareFn(_, ref f) => f.sig.0.variadic, ref s => { panic!("fn_is_variadic() called on non-fn type: {:?}", s) } @@ -4551,7 +4600,7 @@ pub fn fn_is_variadic(fty: Ty) -> bool { pub fn ty_fn_sig<'tcx>(fty: Ty<'tcx>) -> &'tcx PolyFnSig<'tcx> { match fty.sty { - ty_bare_fn(_, ref f) => &f.sig, + TyBareFn(_, ref f) => &f.sig, ref s => { panic!("ty_fn_sig() called on non-fn type: {:?}", s) } @@ -4561,7 +4610,7 @@ pub fn ty_fn_sig<'tcx>(fty: Ty<'tcx>) -> &'tcx PolyFnSig<'tcx> { /// Returns the ABI of the given function. pub fn ty_fn_abi(fty: Ty) -> abi::Abi { match fty.sty { - ty_bare_fn(_, ref f) => f.abi, + TyBareFn(_, ref f) => f.abi, _ => panic!("ty_fn_abi() called on non-fn type"), } } @@ -4573,7 +4622,7 @@ pub fn ty_fn_args<'tcx>(fty: Ty<'tcx>) -> ty::Binder<Vec<Ty<'tcx>>> { pub fn ty_fn_ret<'tcx>(fty: Ty<'tcx>) -> Binder<FnOutput<'tcx>> { match fty.sty { - ty_bare_fn(_, ref f) => f.sig.output(), + TyBareFn(_, ref f) => f.sig.output(), ref s => { panic!("ty_fn_ret() called on non-fn type: {:?}", s) } @@ -4582,7 +4631,7 @@ pub fn ty_fn_ret<'tcx>(fty: Ty<'tcx>) -> Binder<FnOutput<'tcx>> { pub fn is_fn_ty(fty: Ty) -> bool { match fty.sty { - ty_bare_fn(..) => true, + TyBareFn(..) => true, _ => false } } @@ -4591,7 +4640,7 @@ pub fn ty_region(tcx: &ctxt, span: Span, ty: Ty) -> Region { match ty.sty { - ty_rptr(r, _) => *r, + TyRef(r, _) => *r, ref s => { tcx.sess.span_bug( span, @@ -4706,7 +4755,7 @@ pub fn adjust_ty<'tcx, F>(cx: &ctxt<'tcx>, -> Ty<'tcx> where F: FnMut(MethodCall) -> Option<Ty<'tcx>>, { - if let ty_err = unadjusted_ty.sty { + if let TyError = unadjusted_ty.sty { return unadjusted_ty; } @@ -4715,7 +4764,7 @@ pub fn adjust_ty<'tcx, F>(cx: &ctxt<'tcx>, match *adjustment { AdjustReifyFnPointer => { match unadjusted_ty.sty { - ty::ty_bare_fn(Some(_), b) => { + ty::TyBareFn(Some(_), b) => { ty::mk_bare_fn(cx, None, b) } _ => { @@ -4728,7 +4777,7 @@ pub fn adjust_ty<'tcx, F>(cx: &ctxt<'tcx>, AdjustUnsafeFnPointer => { match unadjusted_ty.sty { - ty::ty_bare_fn(None, b) => cx.safe_to_unsafe_fn_ty(b), + ty::TyBareFn(None, b) => cx.safe_to_unsafe_fn_ty(b), ref b => { cx.sess.bug( &format!("AdjustReifyFnPointer adjustment on non-fn-item: \ @@ -4862,7 +4911,7 @@ pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind { def::DefStruct(_) => { match tcx.node_types.borrow().get(&expr.id) { Some(ty) => match ty.sty { - ty_bare_fn(..) => RvalueDatumExpr, + TyBareFn(..) => RvalueDatumExpr, _ => RvalueDpsExpr }, // See ExprCast below for why types might be missing. @@ -5006,43 +5055,43 @@ pub fn impl_or_trait_item_idx(id: ast::Name, trait_items: &[ImplOrTraitItem]) pub fn ty_sort_string<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> String { match ty.sty { - ty_bool | ty_char | ty_int(_) | - ty_uint(_) | ty_float(_) | ty_str => { + TyBool | TyChar | TyInt(_) | + TyUint(_) | TyFloat(_) | TyStr => { ::util::ppaux::ty_to_string(cx, ty) } - ty_tup(ref tys) if tys.is_empty() => ::util::ppaux::ty_to_string(cx, ty), - - ty_enum(id, _) => format!("enum `{}`", item_path_str(cx, id)), - ty_uniq(_) => "box".to_string(), - ty_vec(_, Some(n)) => format!("array of {} elements", n), - ty_vec(_, None) => "slice".to_string(), - ty_ptr(_) => "*-ptr".to_string(), - ty_rptr(_, _) => "&-ptr".to_string(), - ty_bare_fn(Some(_), _) => format!("fn item"), - ty_bare_fn(None, _) => "fn pointer".to_string(), - ty_trait(ref inner) => { + TyTuple(ref tys) if tys.is_empty() => ::util::ppaux::ty_to_string(cx, ty), + + TyEnum(id, _) => format!("enum `{}`", item_path_str(cx, id)), + TyBox(_) => "box".to_string(), + TyArray(_, Some(n)) => format!("array of {} elements", n), + TyArray(_, None) => "slice".to_string(), + TyRawPtr(_) => "*-ptr".to_string(), + TyRef(_, _) => "&-ptr".to_string(), + TyBareFn(Some(_), _) => format!("fn item"), + TyBareFn(None, _) => "fn pointer".to_string(), + TyTrait(ref inner) => { format!("trait {}", item_path_str(cx, inner.principal_def_id())) } - ty_struct(id, _) => { + TyStruct(id, _) => { format!("struct `{}`", item_path_str(cx, id)) } - ty_closure(..) => "closure".to_string(), - ty_tup(_) => "tuple".to_string(), - ty_infer(TyVar(_)) => "inferred type".to_string(), - ty_infer(IntVar(_)) => "integral variable".to_string(), - ty_infer(FloatVar(_)) => "floating-point variable".to_string(), - ty_infer(FreshTy(_)) => "skolemized type".to_string(), - ty_infer(FreshIntTy(_)) => "skolemized integral type".to_string(), - ty_infer(FreshFloatTy(_)) => "skolemized floating-point type".to_string(), - ty_projection(_) => "associated type".to_string(), - ty_param(ref p) => { + TyClosure(..) => "closure".to_string(), + TyTuple(_) => "tuple".to_string(), + TyInfer(TyVar(_)) => "inferred type".to_string(), + TyInfer(IntVar(_)) => "integral variable".to_string(), + TyInfer(FloatVar(_)) => "floating-point variable".to_string(), + TyInfer(FreshTy(_)) => "skolemized type".to_string(), + TyInfer(FreshIntTy(_)) => "skolemized integral type".to_string(), + TyInfer(FreshFloatTy(_)) => "skolemized floating-point type".to_string(), + TyProjection(_) => "associated type".to_string(), + TyParam(ref p) => { if p.space == subst::SelfSpace { "Self".to_string() } else { "type parameter".to_string() } } - ty_err => "type error".to_string(), + TyError => "type error".to_string(), } } @@ -5463,11 +5512,11 @@ pub fn try_add_builtin_trait( pub fn ty_to_def_id(ty: Ty) -> Option<ast::DefId> { match ty.sty { - ty_trait(ref tt) => + TyTrait(ref tt) => Some(tt.principal_def_id()), - ty_struct(id, _) | - ty_enum(id, _) | - ty_closure(id, _) => + TyStruct(id, _) | + TyEnum(id, _) | + TyClosure(id, _) => Some(id), _ => None @@ -5621,7 +5670,7 @@ pub fn enum_is_univariant(cx: &ctxt, id: ast::DefId) -> bool { pub fn type_is_empty(cx: &ctxt, ty: Ty) -> bool { match ty.sty { - ty_enum(did, _) => (*enum_variants(cx, did)).is_empty(), + TyEnum(did, _) => (*enum_variants(cx, did)).is_empty(), _ => false } } @@ -6102,7 +6151,7 @@ pub fn tup_fields<'tcx>(v: &[Ty<'tcx>]) -> Vec<field<'tcx>> { /// if not a structure at all. Corresponds to the only possible unsized /// field, and its type can be used to determine unsizing strategy. pub fn struct_tail<'tcx>(cx: &ctxt<'tcx>, mut ty: Ty<'tcx>) -> Ty<'tcx> { - while let ty_struct(def_id, substs) = ty.sty { + while let TyStruct(def_id, substs) = ty.sty { match struct_fields(cx, def_id, substs).last() { Some(f) => ty = f.mt.ty, None => break @@ -6121,7 +6170,7 @@ pub fn struct_lockstep_tails<'tcx>(cx: &ctxt<'tcx>, target: Ty<'tcx>) -> (Ty<'tcx>, Ty<'tcx>) { let (mut a, mut b) = (source, target); - while let (&ty_struct(a_did, a_substs), &ty_struct(b_did, b_substs)) = (&a.sty, &b.sty) { + while let (&TyStruct(a_did, a_substs), &TyStruct(b_did, b_substs)) = (&a.sty, &b.sty) { if a_did != b_did { continue; } @@ -6553,47 +6602,47 @@ pub fn hash_crate_independent<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh) - }; maybe_walk_ty(ty, |ty| { match ty.sty { - ty_bool => byte!(2), - ty_char => byte!(3), - ty_int(i) => { + TyBool => byte!(2), + TyChar => byte!(3), + TyInt(i) => { byte!(4); hash!(i); } - ty_uint(u) => { + TyUint(u) => { byte!(5); hash!(u); } - ty_float(f) => { + TyFloat(f) => { byte!(6); hash!(f); } - ty_str => { + TyStr => { byte!(7); } - ty_enum(d, _) => { + TyEnum(d, _) => { byte!(8); did(state, d); } - ty_uniq(_) => { + TyBox(_) => { byte!(9); } - ty_vec(_, Some(n)) => { + TyArray(_, Some(n)) => { byte!(10); n.hash(state); } - ty_vec(_, None) => { + TyArray(_, None) => { byte!(11); } - ty_ptr(m) => { + TyRawPtr(m) => { byte!(12); mt(state, m); } - ty_rptr(r, m) => { + TyRef(r, m) => { byte!(13); region(state, *r); mt(state, m); } - ty_bare_fn(opt_def_id, ref b) => { + TyBareFn(opt_def_id, ref b) => { byte!(14); hash!(opt_def_id); hash!(b.unsafety); @@ -6601,7 +6650,7 @@ pub fn hash_crate_independent<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh) - fn_sig(state, &b.sig); return false; } - ty_trait(ref data) => { + TyTrait(ref data) => { byte!(17); did(state, data.principal_def_id()); hash!(data.bounds); @@ -6613,27 +6662,27 @@ pub fn hash_crate_independent<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh) - return false; } - ty_struct(d, _) => { + TyStruct(d, _) => { byte!(18); did(state, d); } - ty_tup(ref inner) => { + TyTuple(ref inner) => { byte!(19); hash!(inner.len()); } - ty_param(p) => { + TyParam(p) => { byte!(20); hash!(p.space); hash!(p.idx); hash!(token::get_name(p.name)); } - ty_infer(_) => unreachable!(), - ty_err => byte!(21), - ty_closure(d, _) => { + TyInfer(_) => unreachable!(), + TyError => byte!(21), + TyClosure(d, _) => { byte!(22); did(state, d); } - ty_projection(ref data) => { + TyProjection(ref data) => { byte!(23); did(state, data.trait_ref.def_id); hash!(token::get_name(data.item_name)); @@ -6897,34 +6946,34 @@ pub fn accumulate_lifetimes_in_type(accumulator: &mut Vec<ty::Region>, ty: Ty) { walk_ty(ty, |ty| { match ty.sty { - ty_rptr(region, _) => { + TyRef(region, _) => { accumulator.push(*region) } - ty_trait(ref t) => { + TyTrait(ref t) => { accumulator.push_all(t.principal.0.substs.regions().as_slice()); } - ty_enum(_, substs) | - ty_struct(_, substs) => { + TyEnum(_, substs) | + TyStruct(_, substs) => { accum_substs(accumulator, substs); } - ty_closure(_, substs) => { + TyClosure(_, substs) => { accum_substs(accumulator, substs); } - ty_bool | - ty_char | - ty_int(_) | - ty_uint(_) | - ty_float(_) | - ty_uniq(_) | - ty_str | - ty_vec(_, _) | - ty_ptr(_) | - ty_bare_fn(..) | - ty_tup(_) | - ty_projection(_) | - ty_param(_) | - ty_infer(_) | - ty_err => { + TyBool | + TyChar | + TyInt(_) | + TyUint(_) | + TyFloat(_) | + TyBox(_) | + TyStr | + TyArray(_, _) | + TyRawPtr(_) | + TyBareFn(..) | + TyTuple(_) | + TyProjection(_) | + TyParam(_) | + TyInfer(_) | + TyError => { } } }); @@ -7136,9 +7185,9 @@ impl<'tcx> Repr<'tcx> for AutoRef<'tcx> { } } -impl<'tcx> Repr<'tcx> for TyTrait<'tcx> { +impl<'tcx> Repr<'tcx> for TraitTy<'tcx> { fn repr(&self, tcx: &ctxt<'tcx>) -> String { - format!("TyTrait({},{})", + format!("TraitTy({},{})", self.principal.repr(tcx), self.bounds.repr(tcx)) } @@ -7196,7 +7245,7 @@ pub fn can_type_implement_copy<'a,'tcx>(param_env: &ParameterEnvironment<'a, 'tc let tcx = param_env.tcx; let did = match self_type.sty { - ty::ty_struct(struct_did, substs) => { + ty::TyStruct(struct_did, substs) => { let fields = ty::struct_fields(tcx, struct_did, substs); for field in &fields { if type_moves_by_default(param_env, span, field.mt.ty) { @@ -7205,7 +7254,7 @@ pub fn can_type_implement_copy<'a,'tcx>(param_env: &ParameterEnvironment<'a, 'tc } struct_did } - ty::ty_enum(enum_did, substs) => { + ty::TyEnum(enum_did, substs) => { let enum_variants = ty::enum_variants(tcx, enum_did); for variant in enum_variants.iter() { for variant_arg_type in &variant.args { diff --git a/src/librustc/middle/ty_fold.rs b/src/librustc/middle/ty_fold.rs index 884fc9571ce..40d5dab15a4 100644 --- a/src/librustc/middle/ty_fold.rs +++ b/src/librustc/middle/ty_fold.rs @@ -590,51 +590,51 @@ pub fn super_fold_ty<'tcx, T: TypeFolder<'tcx>>(this: &mut T, ty: Ty<'tcx>) -> Ty<'tcx> { let sty = match ty.sty { - ty::ty_uniq(typ) => { - ty::ty_uniq(typ.fold_with(this)) + ty::TyBox(typ) => { + ty::TyBox(typ.fold_with(this)) } - ty::ty_ptr(ref tm) => { - ty::ty_ptr(tm.fold_with(this)) + ty::TyRawPtr(ref tm) => { + ty::TyRawPtr(tm.fold_with(this)) } - ty::ty_vec(typ, sz) => { - ty::ty_vec(typ.fold_with(this), sz) + ty::TyArray(typ, sz) => { + ty::TyArray(typ.fold_with(this), sz) } - ty::ty_enum(tid, ref substs) => { + ty::TyEnum(tid, ref substs) => { let substs = substs.fold_with(this); - ty::ty_enum(tid, this.tcx().mk_substs(substs)) + ty::TyEnum(tid, this.tcx().mk_substs(substs)) } - ty::ty_trait(box ty::TyTrait { ref principal, ref bounds }) => { - ty::ty_trait(box ty::TyTrait { + ty::TyTrait(box ty::TraitTy { ref principal, ref bounds }) => { + ty::TyTrait(box ty::TraitTy { principal: principal.fold_with(this), bounds: bounds.fold_with(this), }) } - ty::ty_tup(ref ts) => { - ty::ty_tup(ts.fold_with(this)) + ty::TyTuple(ref ts) => { + ty::TyTuple(ts.fold_with(this)) } - ty::ty_bare_fn(opt_def_id, ref f) => { + ty::TyBareFn(opt_def_id, ref f) => { let bfn = f.fold_with(this); - ty::ty_bare_fn(opt_def_id, this.tcx().mk_bare_fn(bfn)) + ty::TyBareFn(opt_def_id, this.tcx().mk_bare_fn(bfn)) } - ty::ty_rptr(r, ref tm) => { + ty::TyRef(r, ref tm) => { let r = r.fold_with(this); - ty::ty_rptr(this.tcx().mk_region(r), tm.fold_with(this)) + ty::TyRef(this.tcx().mk_region(r), tm.fold_with(this)) } - ty::ty_struct(did, ref substs) => { + ty::TyStruct(did, ref substs) => { let substs = substs.fold_with(this); - ty::ty_struct(did, this.tcx().mk_substs(substs)) + ty::TyStruct(did, this.tcx().mk_substs(substs)) } - ty::ty_closure(did, ref substs) => { + ty::TyClosure(did, ref substs) => { let s = substs.fold_with(this); - ty::ty_closure(did, this.tcx().mk_substs(s)) + ty::TyClosure(did, this.tcx().mk_substs(s)) } - ty::ty_projection(ref data) => { - ty::ty_projection(data.fold_with(this)) + ty::TyProjection(ref data) => { + ty::TyProjection(data.fold_with(this)) } - ty::ty_bool | ty::ty_char | ty::ty_str | - ty::ty_int(_) | ty::ty_uint(_) | ty::ty_float(_) | - ty::ty_err | ty::ty_infer(_) | - ty::ty_param(..) => { + ty::TyBool | ty::TyChar | ty::TyStr | + ty::TyInt(_) | ty::TyUint(_) | ty::TyFloat(_) | + ty::TyError | ty::TyInfer(_) | + ty::TyParam(..) => { ty.sty.clone() } }; diff --git a/src/librustc/middle/ty_match.rs b/src/librustc/middle/ty_match.rs index 526ad0ec1c9..241a27aa0cd 100644 --- a/src/librustc/middle/ty_match.rs +++ b/src/librustc/middle/ty_match.rs @@ -66,18 +66,18 @@ impl<'a, 'tcx> TypeRelation<'a, 'tcx> for Match<'a, 'tcx> { if a == b { return Ok(a); } match (&a.sty, &b.sty) { - (_, &ty::ty_infer(ty::FreshTy(_))) | - (_, &ty::ty_infer(ty::FreshIntTy(_))) | - (_, &ty::ty_infer(ty::FreshFloatTy(_))) => { + (_, &ty::TyInfer(ty::FreshTy(_))) | + (_, &ty::TyInfer(ty::FreshIntTy(_))) | + (_, &ty::TyInfer(ty::FreshFloatTy(_))) => { Ok(a) } - (&ty::ty_infer(_), _) | - (_, &ty::ty_infer(_)) => { + (&ty::TyInfer(_), _) | + (_, &ty::TyInfer(_)) => { Err(ty::terr_sorts(ty_relate::expected_found(self, &a, &b))) } - (&ty::ty_err, _) | (_, &ty::ty_err) => { + (&ty::TyError, _) | (_, &ty::TyError) => { Ok(self.tcx().types.err) } diff --git a/src/librustc/middle/ty_relate/mod.rs b/src/librustc/middle/ty_relate/mod.rs index 92f9e0b6673..c79fe7f5ad1 100644 --- a/src/librustc/middle/ty_relate/mod.rs +++ b/src/librustc/middle/ty_relate/mod.rs @@ -438,87 +438,87 @@ pub fn super_relate_tys<'a,'tcx:'a,R>(relation: &mut R, let b_sty = &b.sty; debug!("super_tys: a_sty={:?} b_sty={:?}", a_sty, b_sty); match (a_sty, b_sty) { - (&ty::ty_infer(_), _) | - (_, &ty::ty_infer(_)) => + (&ty::TyInfer(_), _) | + (_, &ty::TyInfer(_)) => { // The caller should handle these cases! tcx.sess.bug("var types encountered in super_relate_tys") } - (&ty::ty_err, _) | (_, &ty::ty_err) => + (&ty::TyError, _) | (_, &ty::TyError) => { Ok(tcx.types.err) } - (&ty::ty_char, _) | - (&ty::ty_bool, _) | - (&ty::ty_int(_), _) | - (&ty::ty_uint(_), _) | - (&ty::ty_float(_), _) | - (&ty::ty_str, _) + (&ty::TyChar, _) | + (&ty::TyBool, _) | + (&ty::TyInt(_), _) | + (&ty::TyUint(_), _) | + (&ty::TyFloat(_), _) | + (&ty::TyStr, _) if a == b => { Ok(a) } - (&ty::ty_param(ref a_p), &ty::ty_param(ref b_p)) + (&ty::TyParam(ref a_p), &ty::TyParam(ref b_p)) if a_p.idx == b_p.idx && a_p.space == b_p.space => { Ok(a) } - (&ty::ty_enum(a_id, a_substs), &ty::ty_enum(b_id, b_substs)) + (&ty::TyEnum(a_id, a_substs), &ty::TyEnum(b_id, b_substs)) if a_id == b_id => { let substs = try!(relate_item_substs(relation, a_id, a_substs, b_substs)); Ok(ty::mk_enum(tcx, a_id, tcx.mk_substs(substs))) } - (&ty::ty_trait(ref a_), &ty::ty_trait(ref b_)) => + (&ty::TyTrait(ref a_), &ty::TyTrait(ref b_)) => { let principal = try!(relation.relate(&a_.principal, &b_.principal)); let bounds = try!(relation.relate(&a_.bounds, &b_.bounds)); Ok(ty::mk_trait(tcx, principal, bounds)) } - (&ty::ty_struct(a_id, a_substs), &ty::ty_struct(b_id, b_substs)) + (&ty::TyStruct(a_id, a_substs), &ty::TyStruct(b_id, b_substs)) if a_id == b_id => { let substs = try!(relate_item_substs(relation, a_id, a_substs, b_substs)); Ok(ty::mk_struct(tcx, a_id, tcx.mk_substs(substs))) } - (&ty::ty_closure(a_id, a_substs), - &ty::ty_closure(b_id, b_substs)) + (&ty::TyClosure(a_id, a_substs), + &ty::TyClosure(b_id, b_substs)) if a_id == b_id => { - // All ty_closure types with the same id represent + // All TyClosure types with the same id represent // the (anonymous) type of the same closure expression. So // all of their regions should be equated. let substs = try!(relate_substs(relation, None, a_substs, b_substs)); Ok(ty::mk_closure(tcx, a_id, tcx.mk_substs(substs))) } - (&ty::ty_uniq(a_inner), &ty::ty_uniq(b_inner)) => + (&ty::TyBox(a_inner), &ty::TyBox(b_inner)) => { let typ = try!(relation.relate(&a_inner, &b_inner)); Ok(ty::mk_uniq(tcx, typ)) } - (&ty::ty_ptr(ref a_mt), &ty::ty_ptr(ref b_mt)) => + (&ty::TyRawPtr(ref a_mt), &ty::TyRawPtr(ref b_mt)) => { let mt = try!(relation.relate(a_mt, b_mt)); Ok(ty::mk_ptr(tcx, mt)) } - (&ty::ty_rptr(a_r, ref a_mt), &ty::ty_rptr(b_r, ref b_mt)) => + (&ty::TyRef(a_r, ref a_mt), &ty::TyRef(b_r, ref b_mt)) => { let r = try!(relation.relate_with_variance(ty::Contravariant, a_r, b_r)); let mt = try!(relation.relate(a_mt, b_mt)); Ok(ty::mk_rptr(tcx, tcx.mk_region(r), mt)) } - (&ty::ty_vec(a_t, Some(sz_a)), &ty::ty_vec(b_t, Some(sz_b))) => + (&ty::TyArray(a_t, Some(sz_a)), &ty::TyArray(b_t, Some(sz_b))) => { let t = try!(relation.relate(&a_t, &b_t)); if sz_a == sz_b { @@ -528,13 +528,13 @@ pub fn super_relate_tys<'a,'tcx:'a,R>(relation: &mut R, } } - (&ty::ty_vec(a_t, None), &ty::ty_vec(b_t, None)) => + (&ty::TyArray(a_t, None), &ty::TyArray(b_t, None)) => { let t = try!(relation.relate(&a_t, &b_t)); Ok(ty::mk_vec(tcx, t, None)) } - (&ty::ty_tup(ref as_), &ty::ty_tup(ref bs)) => + (&ty::TyTuple(ref as_), &ty::TyTuple(ref bs)) => { if as_.len() == bs.len() { let ts = try!(as_.iter().zip(bs) @@ -549,14 +549,14 @@ pub fn super_relate_tys<'a,'tcx:'a,R>(relation: &mut R, } } - (&ty::ty_bare_fn(a_opt_def_id, a_fty), &ty::ty_bare_fn(b_opt_def_id, b_fty)) + (&ty::TyBareFn(a_opt_def_id, a_fty), &ty::TyBareFn(b_opt_def_id, b_fty)) if a_opt_def_id == b_opt_def_id => { let fty = try!(relation.relate(a_fty, b_fty)); Ok(ty::mk_bare_fn(tcx, a_opt_def_id, tcx.mk_bare_fn(fty))) } - (&ty::ty_projection(ref a_data), &ty::ty_projection(ref b_data)) => + (&ty::TyProjection(ref a_data), &ty::TyProjection(ref b_data)) => { let projection_ty = try!(relation.relate(a_data, b_data)); Ok(ty::mk_projection(tcx, projection_ty.trait_ref, projection_ty.item_name)) diff --git a/src/librustc/middle/ty_walk.rs b/src/librustc/middle/ty_walk.rs index ec09d6dcc1e..50118ed6e9f 100644 --- a/src/librustc/middle/ty_walk.rs +++ b/src/librustc/middle/ty_walk.rs @@ -68,33 +68,33 @@ pub fn walk_shallow<'tcx>(ty: Ty<'tcx>) -> IntoIter<Ty<'tcx>> { fn push_subtypes<'tcx>(stack: &mut Vec<Ty<'tcx>>, parent_ty: Ty<'tcx>) { match parent_ty.sty { - ty::ty_bool | ty::ty_char | ty::ty_int(_) | ty::ty_uint(_) | ty::ty_float(_) | - ty::ty_str | ty::ty_infer(_) | ty::ty_param(_) | ty::ty_err => { + ty::TyBool | ty::TyChar | ty::TyInt(_) | ty::TyUint(_) | ty::TyFloat(_) | + ty::TyStr | ty::TyInfer(_) | ty::TyParam(_) | ty::TyError => { } - ty::ty_uniq(ty) | ty::ty_vec(ty, _) => { + ty::TyBox(ty) | ty::TyArray(ty, _) => { stack.push(ty); } - ty::ty_ptr(ref mt) | ty::ty_rptr(_, ref mt) => { + ty::TyRawPtr(ref mt) | ty::TyRef(_, ref mt) => { stack.push(mt.ty); } - ty::ty_projection(ref data) => { + ty::TyProjection(ref data) => { push_reversed(stack, data.trait_ref.substs.types.as_slice()); } - ty::ty_trait(box ty::TyTrait { ref principal, ref bounds }) => { + ty::TyTrait(box ty::TraitTy { ref principal, ref bounds }) => { push_reversed(stack, principal.substs().types.as_slice()); push_reversed(stack, &bounds.projection_bounds.iter().map(|pred| { pred.0.ty }).collect::<Vec<_>>()); } - ty::ty_enum(_, ref substs) | - ty::ty_struct(_, ref substs) | - ty::ty_closure(_, ref substs) => { + ty::TyEnum(_, ref substs) | + ty::TyStruct(_, ref substs) | + ty::TyClosure(_, ref substs) => { push_reversed(stack, substs.types.as_slice()); } - ty::ty_tup(ref ts) => { + ty::TyTuple(ref ts) => { push_reversed(stack, ts); } - ty::ty_bare_fn(_, ref ft) => { + ty::TyBareFn(_, ref ft) => { push_sig_subtypes(stack, &ft.sig); } } diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 0b55f05072f..5d68c9d9b28 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -19,11 +19,11 @@ use middle::ty::{ReEarlyBound, BrFresh, ctxt}; use middle::ty::{ReFree, ReScope, ReInfer, ReStatic, Region, ReEmpty}; use middle::ty::{ReSkolemized, ReVar, BrEnv}; use middle::ty::{mt, Ty, ParamTy}; -use middle::ty::{ty_bool, ty_char, ty_struct, ty_enum}; -use middle::ty::{ty_err, ty_str, ty_vec, ty_float, ty_bare_fn}; -use middle::ty::{ty_param, ty_ptr, ty_rptr, ty_tup}; -use middle::ty::ty_closure; -use middle::ty::{ty_uniq, ty_trait, ty_int, ty_uint, ty_infer}; +use middle::ty::{TyBool, TyChar, TyStruct, TyEnum}; +use middle::ty::{TyError, TyStr, TyArray, TyFloat, TyBareFn}; +use middle::ty::{TyParam, TyRawPtr, TyRef, TyTuple}; +use middle::ty::TyClosure; +use middle::ty::{TyBox, TyTrait, TyInt, TyUint, TyInfer}; use middle::ty; use middle::ty_fold::{self, TypeFoldable}; @@ -363,24 +363,24 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String { // pretty print the structural type representation: match typ.sty { - ty_bool => "bool".to_string(), - ty_char => "char".to_string(), - ty_int(t) => ast_util::int_ty_to_string(t, None).to_string(), - ty_uint(t) => ast_util::uint_ty_to_string(t, None).to_string(), - ty_float(t) => ast_util::float_ty_to_string(t).to_string(), - ty_uniq(typ) => format!("Box<{}>", ty_to_string(cx, typ)), - ty_ptr(ref tm) => { + TyBool => "bool".to_string(), + TyChar => "char".to_string(), + TyInt(t) => ast_util::int_ty_to_string(t, None).to_string(), + TyUint(t) => ast_util::uint_ty_to_string(t, None).to_string(), + TyFloat(t) => ast_util::float_ty_to_string(t).to_string(), + TyBox(typ) => format!("Box<{}>", ty_to_string(cx, typ)), + TyRawPtr(ref tm) => { format!("*{} {}", match tm.mutbl { ast::MutMutable => "mut", ast::MutImmutable => "const", }, ty_to_string(cx, tm.ty)) } - ty_rptr(r, ref tm) => { + TyRef(r, ref tm) => { let mut buf = region_ptr_to_string(cx, *r); buf.push_str(&mt_to_string(cx, tm)); buf } - ty_tup(ref elems) => { + TyTuple(ref elems) => { let strs = elems .iter() .map(|elem| ty_to_string(cx, *elem)) @@ -390,28 +390,28 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String { strs => format!("({})", strs.connect(", ")) } } - ty_bare_fn(opt_def_id, ref f) => { + TyBareFn(opt_def_id, ref f) => { bare_fn_to_string(cx, opt_def_id, f.unsafety, f.abi, None, &f.sig) } - ty_infer(infer_ty) => infer_ty_to_string(cx, infer_ty), - ty_err => "[type error]".to_string(), - ty_param(ref param_ty) => param_ty.user_string(cx), - ty_enum(did, substs) | ty_struct(did, substs) => { + TyInfer(infer_ty) => infer_ty_to_string(cx, infer_ty), + TyError => "[type error]".to_string(), + TyParam(ref param_ty) => param_ty.user_string(cx), + TyEnum(did, substs) | TyStruct(did, substs) => { let base = ty::item_path_str(cx, did); parameterized(cx, &base, substs, did, &[], || ty::lookup_item_type(cx, did).generics) } - ty_trait(ref data) => { + TyTrait(ref data) => { data.user_string(cx) } - ty::ty_projection(ref data) => { + ty::TyProjection(ref data) => { format!("<{} as {}>::{}", data.trait_ref.self_ty().user_string(cx), data.trait_ref.user_string(cx), data.item_name.user_string(cx)) } - ty_str => "str".to_string(), - ty_closure(ref did, substs) => { + TyStr => "str".to_string(), + TyClosure(ref did, substs) => { let closure_tys = cx.closure_tys.borrow(); closure_tys.get(did).map(|closure_type| { closure_to_string(cx, &closure_type.subst(cx, substs), did) @@ -431,7 +431,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String { } }) } - ty_vec(t, sz) => { + TyArray(t, sz) => { let inner_str = ty_to_string(cx, t); match sz { Some(n) => format!("[{}; {}]", inner_str, n), @@ -701,9 +701,9 @@ impl<'tcx> UserString<'tcx> for TraitAndProjections<'tcx> { } } -impl<'tcx> UserString<'tcx> for ty::TyTrait<'tcx> { +impl<'tcx> UserString<'tcx> for ty::TraitTy<'tcx> { fn user_string(&self, tcx: &ctxt<'tcx>) -> String { - let &ty::TyTrait { ref principal, ref bounds } = self; + let &ty::TraitTy { ref principal, ref bounds } = self; let mut components = vec![]; diff --git a/src/librustc_borrowck/borrowck/check_loans.rs b/src/librustc_borrowck/borrowck/check_loans.rs index 839b39a8ca0..90bc918c4b1 100644 --- a/src/librustc_borrowck/borrowck/check_loans.rs +++ b/src/librustc_borrowck/borrowck/check_loans.rs @@ -752,7 +752,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { } LpExtend(ref lp_base, _, LpInterior(InteriorField(_))) => { match lp_base.to_type().sty { - ty::ty_struct(def_id, _) | ty::ty_enum(def_id, _) => { + ty::TyStruct(def_id, _) | ty::TyEnum(def_id, _) => { if ty::has_dtor(self.tcx(), def_id) { // In the case where the owner implements drop, then // the path must be initialized to prevent a case of diff --git a/src/librustc_borrowck/borrowck/fragments.rs b/src/librustc_borrowck/borrowck/fragments.rs index fa2ff43ecfe..a70b1dfe187 100644 --- a/src/librustc_borrowck/borrowck/fragments.rs +++ b/src/librustc_borrowck/borrowck/fragments.rs @@ -339,7 +339,7 @@ fn add_fragment_siblings_for_extension<'tcx>(this: &MoveData<'tcx>, }; match (&parent_ty.sty, enum_variant_info) { - (&ty::ty_tup(ref v), None) => { + (&ty::TyTuple(ref v), None) => { let tuple_idx = match *origin_field_name { mc::PositionalField(tuple_idx) => tuple_idx, mc::NamedField(_) => @@ -354,7 +354,7 @@ fn add_fragment_siblings_for_extension<'tcx>(this: &MoveData<'tcx>, } } - (&ty::ty_struct(def_id, ref _substs), None) => { + (&ty::TyStruct(def_id, ref _substs), None) => { let fields = ty::lookup_struct_fields(tcx, def_id); match *origin_field_name { mc::NamedField(ast_name) => { @@ -378,7 +378,7 @@ fn add_fragment_siblings_for_extension<'tcx>(this: &MoveData<'tcx>, } } - (&ty::ty_enum(enum_def_id, substs), ref enum_variant_info) => { + (&ty::TyEnum(enum_def_id, substs), ref enum_variant_info) => { let variant_info = { let mut variants = ty::substd_enum_variants(tcx, enum_def_id, substs); match *enum_variant_info { diff --git a/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs b/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs index fef8acf2f7b..43877d592ae 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs @@ -179,7 +179,7 @@ fn check_and_get_illegal_move_origin<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, mc::cat_interior(ref b, mc::InteriorField(_)) | mc::cat_interior(ref b, mc::InteriorElement(Kind::Pattern, _)) => { match b.ty.sty { - ty::ty_struct(did, _) | ty::ty_enum(did, _) => { + ty::TyStruct(did, _) | ty::TyEnum(did, _) => { if ty::has_dtor(bccx.tcx, did) { Some(cmt.clone()) } else { diff --git a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs index de52d2e7b78..d16e0fdc19f 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs @@ -137,8 +137,8 @@ fn report_cannot_move_out_of<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, mc::cat_downcast(ref b, _) | mc::cat_interior(ref b, mc::InteriorField(_)) => { match b.ty.sty { - ty::ty_struct(did, _) | - ty::ty_enum(did, _) if ty::has_dtor(bccx.tcx, did) => { + ty::TyStruct(did, _) | + ty::TyEnum(did, _) if ty::has_dtor(bccx.tcx, did) => { bccx.span_err( move_from.span, &format!("cannot move out of type `{}`, \ diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs index fd7f549a879..4091351b5a5 100644 --- a/src/librustc_driver/test.rs +++ b/src/librustc_driver/test.rs @@ -656,7 +656,7 @@ fn glb_bound_free_infer() { // `&'_ isize` let t_resolve1 = env.infcx.shallow_resolve(t_infer1); match t_resolve1.sty { - ty::ty_rptr(..) => { } + ty::TyRef(..) => { } _ => { panic!("t_resolve1={}", t_resolve1.repr(env.infcx.tcx)); } } }) diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index e1bf37138f3..cc192407160 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -145,7 +145,7 @@ impl LintPass for TypeLimits { _ => { let t = ty::expr_ty(cx.tcx, &**expr); match t.sty { - ty::ty_uint(_) => { + ty::TyUint(_) => { cx.span_lint(UNSIGNED_NEGATION, e.span, "negation of unsigned int variable may \ be unintentional"); @@ -170,8 +170,8 @@ impl LintPass for TypeLimits { if is_shift_binop(binop.node) { let opt_ty_bits = match ty::expr_ty(cx.tcx, &**l).sty { - ty::ty_int(t) => Some(int_ty_bits(t, cx.sess().target.int_type)), - ty::ty_uint(t) => Some(uint_ty_bits(t, cx.sess().target.uint_type)), + ty::TyInt(t) => Some(int_ty_bits(t, cx.sess().target.int_type)), + ty::TyUint(t) => Some(uint_ty_bits(t, cx.sess().target.uint_type)), _ => None }; @@ -195,7 +195,7 @@ impl LintPass for TypeLimits { }, ast::ExprLit(ref lit) => { match ty::expr_ty(cx.tcx, e).sty { - ty::ty_int(t) => { + ty::TyInt(t) => { match lit.node { ast::LitInt(v, ast::SignedIntLit(_, ast::Plus)) | ast::LitInt(v, ast::UnsuffixedIntLit(ast::Plus)) => { @@ -219,7 +219,7 @@ impl LintPass for TypeLimits { _ => panic!() }; }, - ty::ty_uint(t) => { + ty::TyUint(t) => { let uint_type = if let ast::TyUs = t { cx.sess().target.uint_type } else { @@ -236,7 +236,7 @@ impl LintPass for TypeLimits { &*format!("literal out of range for {:?}", t)); } }, - ty::ty_float(t) => { + ty::TyFloat(t) => { let (min, max) = float_ty_range(t); let lit_val: f64 = match lit.node { ast::LitFloat(ref v, _) | @@ -345,7 +345,7 @@ impl LintPass for TypeLimits { binop }; match ty::expr_ty(tcx, expr).sty { - ty::ty_int(int_ty) => { + ty::TyInt(int_ty) => { let (min, max) = int_ty_range(int_ty); let lit_val: i64 = match lit.node { ast::ExprLit(ref li) => match li.node { @@ -359,7 +359,7 @@ impl LintPass for TypeLimits { }; is_valid(norm_binop, lit_val, min, max) } - ty::ty_uint(uint_ty) => { + ty::TyUint(uint_ty) => { let (min, max): (u64, u64) = uint_ty_range(uint_ty); let lit_val: u64 = match lit.node { ast::ExprLit(ref li) => match li.node { @@ -486,7 +486,7 @@ impl BoxPointers { let mut n_uniq: usize = 0; ty::fold_ty(cx.tcx, ty, |t| { match t.sty { - ty::ty_uniq(_) => { + ty::TyBox(_) => { n_uniq += 1; } _ => () @@ -591,8 +591,8 @@ impl LintPass for RawPointerDerive { } match ty::node_id_to_type(cx.tcx, item.id).sty { - ty::ty_enum(did, _) => did, - ty::ty_struct(did, _) => did, + ty::TyEnum(did, _) => did, + ty::TyStruct(did, _) => did, _ => return, } } @@ -736,10 +736,10 @@ impl LintPass for UnusedResults { let t = ty::expr_ty(cx.tcx, expr); let warned = match t.sty { - ty::ty_tup(ref tys) if tys.is_empty() => return, - ty::ty_bool => return, - ty::ty_struct(did, _) | - ty::ty_enum(did, _) => { + ty::TyTuple(ref tys) if tys.is_empty() => return, + ty::TyBool => return, + ty::TyStruct(did, _) | + ty::TyEnum(did, _) => { if ast_util::is_local(did) { if let ast_map::NodeItem(it) = cx.tcx.map.get(did.node) { check_must_use(cx, &it.attrs, s.span) @@ -2162,7 +2162,7 @@ impl LintPass for MutableTransmutes { let msg = "mutating transmuted &mut T from &T may cause undefined behavior,\ consider instead using an UnsafeCell"; match get_transmute_from_to(cx, expr) { - Some((&ty::ty_rptr(_, from_mt), &ty::ty_rptr(_, to_mt))) => { + Some((&ty::TyRef(_, from_mt), &ty::TyRef(_, to_mt))) => { if to_mt.mutbl == ast::Mutability::MutMutable && from_mt.mutbl == ast::Mutability::MutImmutable { cx.span_lint(MUTABLE_TRANSMUTES, expr.span, msg); @@ -2172,7 +2172,7 @@ impl LintPass for MutableTransmutes { } fn get_transmute_from_to<'a, 'tcx>(cx: &Context<'a, 'tcx>, expr: &ast::Expr) - -> Option<(&'tcx ty::sty<'tcx>, &'tcx ty::sty<'tcx>)> { + -> Option<(&'tcx ty::TypeVariants<'tcx>, &'tcx ty::TypeVariants<'tcx>)> { match expr.node { ast::ExprPath(..) => (), _ => return None @@ -2183,7 +2183,7 @@ impl LintPass for MutableTransmutes { } let typ = ty::node_id_to_type(cx.tcx, expr.id); match typ.sty { - ty::ty_bare_fn(_, ref bare_fn) if bare_fn.abi == RustIntrinsic => { + ty::TyBareFn(_, ref bare_fn) if bare_fn.abi == RustIntrinsic => { if let ty::FnConverging(to) = bare_fn.sig.0.output { let from = bare_fn.sig.0.inputs[0]; return Some((&from.sty, &to.sty)); @@ -2197,7 +2197,7 @@ impl LintPass for MutableTransmutes { fn def_id_is_transmute(cx: &Context, def_id: DefId) -> bool { match ty::lookup_item_type(cx.tcx, def_id).ty.sty { - ty::ty_bare_fn(_, ref bfty) if bfty.abi == RustIntrinsic => (), + ty::TyBareFn(_, ref bfty) if bfty.abi == RustIntrinsic => (), _ => return false } ty::with_path(cx.tcx, def_id, |path| match path.last() { @@ -2260,9 +2260,9 @@ impl LintPass for DropWithReprExtern { }; match dtor_self_type.sty { - ty::ty_enum(self_type_did, _) | - ty::ty_struct(self_type_did, _) | - ty::ty_closure(self_type_did, _) => { + ty::TyEnum(self_type_did, _) | + ty::TyStruct(self_type_did, _) | + ty::TyClosure(self_type_did, _) => { let hints = ty::lookup_repr_hints(ctx.tcx, self_type_did); if hints.iter().any(|attr| *attr == attr::ReprExtern) && ty::ty_dtor(ctx.tcx, self_type_did).has_drop_flag() { diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 2e8e576732b..cae93baaf74 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -711,10 +711,10 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { let struct_type = ty::lookup_item_type(self.tcx, id).ty; let struct_desc = match struct_type.sty { - ty::ty_struct(_, _) => + ty::TyStruct(_, _) => format!("struct `{}`", ty::item_path_str(self.tcx, id)), // struct variant fields have inherited visibility - ty::ty_enum(..) => return, + ty::TyEnum(..) => return, _ => self.tcx.sess.span_bug(span, "can't find struct for field") }; let msg = match name { @@ -893,12 +893,12 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { fn visit_expr(&mut self, expr: &ast::Expr) { match expr.node { ast::ExprField(ref base, ident) => { - if let ty::ty_struct(id, _) = ty::expr_ty_adjusted(self.tcx, &**base).sty { + if let ty::TyStruct(id, _) = ty::expr_ty_adjusted(self.tcx, &**base).sty { self.check_field(expr.span, id, NamedField(ident.node.name)); } } ast::ExprTupField(ref base, idx) => { - if let ty::ty_struct(id, _) = ty::expr_ty_adjusted(self.tcx, &**base).sty { + if let ty::TyStruct(id, _) = ty::expr_ty_adjusted(self.tcx, &**base).sty { self.check_field(expr.span, id, UnnamedField(idx.node)); } } @@ -918,7 +918,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { } ast::ExprStruct(_, ref fields, _) => { match ty::expr_ty(self.tcx, expr).sty { - ty::ty_struct(ctor_id, _) => { + ty::TyStruct(ctor_id, _) => { // RFC 736: ensure all unmentioned fields are visible. // Rather than computing the set of unmentioned fields // (i.e. `all_fields - fields`), just check them all. @@ -928,7 +928,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { NamedField(field.name)); } } - ty::ty_enum(_, _) => { + ty::TyEnum(_, _) => { match self.tcx.def_map.borrow().get(&expr.id).unwrap().full_def() { def::DefVariant(_, variant_id, _) => { for field in fields { @@ -995,13 +995,13 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { match pattern.node { ast::PatStruct(_, ref fields, _) => { match ty::pat_ty(self.tcx, pattern).sty { - ty::ty_struct(id, _) => { + ty::TyStruct(id, _) => { for field in fields { self.check_field(pattern.span, id, NamedField(field.node.ident.name)); } } - ty::ty_enum(_, _) => { + ty::TyEnum(_, _) => { match self.tcx.def_map.borrow().get(&pattern.id).map(|d| d.full_def()) { Some(def::DefVariant(_, variant_id, _)) => { for field in fields { @@ -1026,7 +1026,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { // elsewhere). ast::PatEnum(_, Some(ref fields)) => { match ty::pat_ty(self.tcx, pattern).sty { - ty::ty_struct(id, _) => { + ty::TyStruct(id, _) => { for (i, field) in fields.iter().enumerate() { if let ast::PatWild(..) = field.node { continue @@ -1034,7 +1034,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { self.check_field(field.span, id, UnnamedField(i)); } } - ty::ty_enum(..) => { + ty::TyEnum(..) => { // enum fields have no privacy at this time } _ => {} diff --git a/src/librustc_trans/save/dump_csv.rs b/src/librustc_trans/save/dump_csv.rs index 0f090aab878..36901ff0967 100644 --- a/src/librustc_trans/save/dump_csv.rs +++ b/src/librustc_trans/save/dump_csv.rs @@ -903,7 +903,7 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> { let ty = &ty::expr_ty_adjusted(&self.analysis.ty_cx, ex).sty; let struct_def = match *ty { - ty::ty_struct(def_id, _) => { + ty::TyStruct(def_id, _) => { let sub_span = self.span.span_for_last_ident(path.span); self.fmt.ref_str(recorder::StructRef, path.span, @@ -1316,7 +1316,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> { let ty = &ty::expr_ty_adjusted(&self.analysis.ty_cx, &**sub_ex).sty; match *ty { - ty::ty_struct(def_id, _) => { + ty::TyStruct(def_id, _) => { let fields = ty::lookup_struct_fields(&self.analysis.ty_cx, def_id); for (i, f) in fields.iter().enumerate() { if i == idx.node { @@ -1330,7 +1330,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> { } } } - ty::ty_tup(_) => {} + ty::TyTuple(_) => {} _ => self.sess.span_bug(ex.span, &format!("Expected struct or tuple \ type, found {:?}", ty)), diff --git a/src/librustc_trans/save/mod.rs b/src/librustc_trans/save/mod.rs index 1249d22946f..096ee7ad7b3 100644 --- a/src/librustc_trans/save/mod.rs +++ b/src/librustc_trans/save/mod.rs @@ -223,7 +223,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> { ast::ExprField(ref sub_ex, ident) => { let ty = &ty::expr_ty_adjusted(&self.analysis.ty_cx, &sub_ex).sty; match *ty { - ty::ty_struct(def_id, _) => { + ty::TyStruct(def_id, _) => { let fields = ty::lookup_struct_fields(&self.analysis.ty_cx, def_id); for f in &fields { if f.name == ident.node.name { diff --git a/src/librustc_trans/trans/_match.rs b/src/librustc_trans/trans/_match.rs index 2beb4efb3d1..bcf5922fb3d 100644 --- a/src/librustc_trans/trans/_match.rs +++ b/src/librustc_trans/trans/_match.rs @@ -850,10 +850,10 @@ fn compare_values<'blk, 'tcx>(cx: Block<'blk, 'tcx>, } match rhs_t.sty { - ty::ty_rptr(_, mt) => match mt.ty.sty { - ty::ty_str => compare_str(cx, lhs, rhs, rhs_t, debug_loc), - ty::ty_vec(ty, _) => match ty.sty { - ty::ty_uint(ast::TyU8) => { + ty::TyRef(_, mt) => match mt.ty.sty { + ty::TyStr => compare_str(cx, lhs, rhs, rhs_t, debug_loc), + ty::TyArray(ty, _) => match ty.sty { + ty::TyUint(ast::TyU8) => { // 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(); @@ -1092,7 +1092,7 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, ).collect(); match left_ty.sty { - ty::ty_struct(def_id, substs) if !type_is_sized(bcx.tcx(), left_ty) => { + ty::TyStruct(def_id, substs) if !type_is_sized(bcx.tcx(), left_ty) => { // The last field is technically unsized but // since we can only ever match that field behind // a reference we construct a fat ptr here. @@ -1116,7 +1116,7 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, Some(vec!(Load(bcx, val))) } else { match left_ty.sty { - ty::ty_vec(_, Some(n)) => { + ty::TyArray(_, Some(n)) => { let args = extract_vec_elems(bcx, left_ty, n, 0, val); Some(args.vals) } diff --git a/src/librustc_trans/trans/adt.rs b/src/librustc_trans/trans/adt.rs index f94d67c8796..977b2b69c46 100644 --- a/src/librustc_trans/trans/adt.rs +++ b/src/librustc_trans/trans/adt.rs @@ -206,10 +206,10 @@ fn dtor_active(flag: u8) -> bool { fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Repr<'tcx> { match t.sty { - ty::ty_tup(ref elems) => { + ty::TyTuple(ref elems) => { Univariant(mk_struct(cx, &elems[..], false, t), 0) } - ty::ty_struct(def_id, substs) => { + ty::TyStruct(def_id, substs) => { let fields = ty::lookup_struct_fields(cx.tcx(), def_id); let mut ftys = fields.iter().map(|field| { let fty = ty::lookup_field_type(cx.tcx(), def_id, field.id, substs); @@ -223,13 +223,13 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, Univariant(mk_struct(cx, &ftys[..], packed, t), dtor_to_init_u8(dtor)) } - ty::ty_closure(def_id, substs) => { + ty::TyClosure(def_id, substs) => { let typer = NormalizingClosureTyper::new(cx.tcx()); let upvars = typer.closure_upvars(def_id, substs).unwrap(); let upvar_types = upvars.iter().map(|u| u.ty).collect::<Vec<_>>(); Univariant(mk_struct(cx, &upvar_types[..], false, t), 0) } - ty::ty_enum(def_id, substs) => { + ty::TyEnum(def_id, substs) => { let cases = get_cases(cx.tcx(), def_id, substs); let hint = *ty::lookup_repr_hints(cx.tcx(), def_id).get(0) .unwrap_or(&attr::ReprAny); @@ -400,28 +400,28 @@ fn find_discr_field_candidate<'tcx>(tcx: &ty::ctxt<'tcx>, mut path: DiscrField) -> Option<DiscrField> { match ty.sty { // Fat &T/&mut T/Box<T> i.e. T is [T], str, or Trait - ty::ty_rptr(_, ty::mt { ty, .. }) | ty::ty_uniq(ty) if !type_is_sized(tcx, ty) => { + ty::TyRef(_, ty::mt { ty, .. }) | ty::TyBox(ty) if !type_is_sized(tcx, ty) => { path.push(FAT_PTR_ADDR); Some(path) }, // Regular thin pointer: &T/&mut T/Box<T> - ty::ty_rptr(..) | ty::ty_uniq(..) => Some(path), + ty::TyRef(..) | ty::TyBox(..) => Some(path), // Functions are just pointers - ty::ty_bare_fn(..) => Some(path), + ty::TyBareFn(..) => Some(path), // Is this the NonZero lang item wrapping a pointer or integer type? - ty::ty_struct(did, substs) if Some(did) == tcx.lang_items.non_zero() => { + ty::TyStruct(did, substs) if Some(did) == tcx.lang_items.non_zero() => { let nonzero_fields = ty::lookup_struct_fields(tcx, did); assert_eq!(nonzero_fields.len(), 1); let nonzero_field = ty::lookup_field_type(tcx, did, nonzero_fields[0].id, substs); match nonzero_field.sty { - ty::ty_ptr(ty::mt { ty, .. }) if !type_is_sized(tcx, ty) => { + ty::TyRawPtr(ty::mt { ty, .. }) if !type_is_sized(tcx, ty) => { path.push_all(&[0, FAT_PTR_ADDR]); Some(path) }, - ty::ty_ptr(..) | ty::ty_int(..) | ty::ty_uint(..) => { + ty::TyRawPtr(..) | ty::TyInt(..) | ty::TyUint(..) => { path.push(0); Some(path) }, @@ -431,7 +431,7 @@ fn find_discr_field_candidate<'tcx>(tcx: &ty::ctxt<'tcx>, // Perhaps one of the fields of this struct is non-zero // let's recurse and find out - ty::ty_struct(def_id, substs) => { + ty::TyStruct(def_id, substs) => { let fields = ty::lookup_struct_fields(tcx, def_id); for (j, field) in fields.iter().enumerate() { let field_ty = ty::lookup_field_type(tcx, def_id, field.id, substs); @@ -445,7 +445,7 @@ fn find_discr_field_candidate<'tcx>(tcx: &ty::ctxt<'tcx>, // Perhaps one of the upvars of this struct is non-zero // Let's recurse and find out! - ty::ty_closure(def_id, substs) => { + ty::TyClosure(def_id, substs) => { let typer = NormalizingClosureTyper::new(tcx); let upvars = typer.closure_upvars(def_id, substs).unwrap(); let upvar_types = upvars.iter().map(|u| u.ty).collect::<Vec<_>>(); @@ -460,7 +460,7 @@ fn find_discr_field_candidate<'tcx>(tcx: &ty::ctxt<'tcx>, }, // Can we use one of the fields in this tuple? - ty::ty_tup(ref tys) => { + ty::TyTuple(ref tys) => { for (j, &ty) in tys.iter().enumerate() { if let Some(mut fpath) = find_discr_field_candidate(tcx, ty, path.clone()) { fpath.push(j); @@ -472,7 +472,7 @@ fn find_discr_field_candidate<'tcx>(tcx: &ty::ctxt<'tcx>, // Is this a fixed-size array of something non-zero // with at least one element? - ty::ty_vec(ety, Some(d)) if d > 0 => { + ty::TyArray(ety, Some(d)) if d > 0 => { if let Some(mut vpath) = find_discr_field_candidate(tcx, ety, path) { vpath.push(0); Some(vpath) diff --git a/src/librustc_trans/trans/attributes.rs b/src/librustc_trans/trans/attributes.rs index 132947e34d7..d4ce17cc7b5 100644 --- a/src/librustc_trans/trans/attributes.rs +++ b/src/librustc_trans/trans/attributes.rs @@ -128,8 +128,8 @@ pub fn from_fn_type<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_type: ty::Ty<'tcx let function_type; let (fn_sig, abi, env_ty) = match fn_type.sty { - ty::ty_bare_fn(_, ref f) => (&f.sig, f.abi, None), - ty::ty_closure(closure_did, substs) => { + ty::TyBareFn(_, ref f) => (&f.sig, f.abi, None), + ty::TyClosure(closure_did, substs) => { let typer = common::NormalizingClosureTyper::new(ccx.tcx()); function_type = typer.closure_type(closure_did, substs); let self_type = base::self_type_for_closure(ccx, closure_did, fn_type); @@ -146,11 +146,11 @@ pub fn from_fn_type<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_type: ty::Ty<'tcx // These have an odd calling convention, so we need to manually // unpack the input ty's let input_tys = match fn_type.sty { - ty::ty_closure(..) => { + ty::TyClosure(..) => { assert!(abi == abi::RustCall); match fn_sig.inputs[0].sty { - ty::ty_tup(ref inputs) => { + ty::TyTuple(ref inputs) => { let mut full_inputs = vec![env_ty.expect("Missing closure environment")]; full_inputs.push_all(inputs); full_inputs @@ -158,11 +158,11 @@ pub fn from_fn_type<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_type: ty::Ty<'tcx _ => ccx.sess().bug("expected tuple'd inputs") } }, - ty::ty_bare_fn(..) if abi == abi::RustCall => { + ty::TyBareFn(..) if abi == abi::RustCall => { let mut inputs = vec![fn_sig.inputs[0]]; match fn_sig.inputs[1].sty { - ty::ty_tup(ref t_in) => { + ty::TyTuple(ref t_in) => { inputs.push_all(&t_in[..]); inputs } @@ -198,7 +198,7 @@ pub fn from_fn_type<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_type: ty::Ty<'tcx match ret_ty.sty { // `Box` pointer return values never alias because ownership // is transferred - ty::ty_uniq(it) if common::type_is_sized(ccx.tcx(), it) => { + ty::TyBox(it) if common::type_is_sized(ccx.tcx(), it) => { attrs.ret(llvm::Attribute::NoAlias); } _ => {} @@ -207,15 +207,15 @@ pub fn from_fn_type<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_type: ty::Ty<'tcx // We can also mark the return value as `dereferenceable` in certain cases match ret_ty.sty { // These are not really pointers but pairs, (pointer, len) - ty::ty_rptr(_, ty::mt { ty: inner, .. }) - | ty::ty_uniq(inner) if common::type_is_sized(ccx.tcx(), inner) => { + ty::TyRef(_, ty::mt { ty: inner, .. }) + | ty::TyBox(inner) if common::type_is_sized(ccx.tcx(), inner) => { let llret_sz = machine::llsize_of_real(ccx, type_of::type_of(ccx, inner)); attrs.ret(llvm::DereferenceableAttribute(llret_sz)); } _ => {} } - if let ty::ty_bool = ret_ty.sty { + if let ty::TyBool = ret_ty.sty { attrs.ret(llvm::Attribute::ZExt); } } @@ -235,12 +235,12 @@ pub fn from_fn_type<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_type: ty::Ty<'tcx .arg(idx, llvm::DereferenceableAttribute(llarg_sz)); } - ty::ty_bool => { + ty::TyBool => { attrs.arg(idx, llvm::Attribute::ZExt); } // `Box` pointer parameters never alias because ownership is transferred - ty::ty_uniq(inner) => { + ty::TyBox(inner) => { let llsz = machine::llsize_of_real(ccx, type_of::type_of(ccx, inner)); attrs.arg(idx, llvm::Attribute::NoAlias) @@ -252,7 +252,7 @@ pub fn from_fn_type<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_type: ty::Ty<'tcx // `&T` where `T` contains no `UnsafeCell<U>` is immutable, and can be marked as both // `readonly` and `noalias`, as LLVM's definition of `noalias` is based solely on // memory dependencies rather than pointer equality - ty::ty_rptr(b, mt) if mt.mutbl == ast::MutMutable || + ty::TyRef(b, mt) if mt.mutbl == ast::MutMutable || !ty::type_contents(ccx.tcx(), mt.ty).interior_unsafe() => { let llsz = machine::llsize_of_real(ccx, type_of::type_of(ccx, mt.ty)); @@ -270,7 +270,7 @@ pub fn from_fn_type<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_type: ty::Ty<'tcx // When a reference in an argument has no named lifetime, it's impossible for that // reference to escape this function (returned or stored beyond the call by a closure). - ty::ty_rptr(&ReLateBound(_, BrAnon(_)), mt) => { + ty::TyRef(&ReLateBound(_, BrAnon(_)), mt) => { let llsz = machine::llsize_of_real(ccx, type_of::type_of(ccx, mt.ty)); attrs.arg(idx, llvm::Attribute::NoCapture) .arg(idx, llvm::DereferenceableAttribute(llsz)); @@ -278,7 +278,7 @@ pub fn from_fn_type<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_type: ty::Ty<'tcx // & pointer parameters are also never null and we know exactly how // many bytes we can dereference - ty::ty_rptr(_, mt) => { + ty::TyRef(_, mt) => { let llsz = machine::llsize_of_real(ccx, type_of::type_of(ccx, mt.ty)); attrs.arg(idx, llvm::DereferenceableAttribute(llsz)); } diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index aad986cd34a..cdb036bc6a9 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -320,7 +320,7 @@ pub fn compare_scalar_types<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, debug_loc: DebugLoc) -> ValueRef { match t.sty { - ty::ty_tup(ref tys) if tys.is_empty() => { + ty::TyTuple(ref tys) if tys.is_empty() => { // We don't need to do actual comparisons for nil. // () == () holds but () < () does not. match op { @@ -330,16 +330,16 @@ pub fn compare_scalar_types<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, _ => bcx.sess().bug("compare_scalar_types: must be a comparison operator") } } - ty::ty_bare_fn(..) | ty::ty_bool | ty::ty_uint(_) | ty::ty_char => { + ty::TyBareFn(..) | ty::TyBool | ty::TyUint(_) | ty::TyChar => { ICmp(bcx, bin_op_to_icmp_predicate(bcx.ccx(), op, false), lhs, rhs, debug_loc) } - ty::ty_ptr(mt) if common::type_is_sized(bcx.tcx(), mt.ty) => { + ty::TyRawPtr(mt) if common::type_is_sized(bcx.tcx(), mt.ty) => { ICmp(bcx, bin_op_to_icmp_predicate(bcx.ccx(), op, false), lhs, rhs, debug_loc) } - ty::ty_int(_) => { + ty::TyInt(_) => { ICmp(bcx, bin_op_to_icmp_predicate(bcx.ccx(), op, true), lhs, rhs, debug_loc) } - ty::ty_float(_) => { + ty::TyFloat(_) => { FCmp(bcx, bin_op_to_fcmp_predicate(bcx.ccx(), op), lhs, rhs, debug_loc) } // Should never get here, because t is scalar. @@ -355,7 +355,7 @@ pub fn compare_simd_types<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, debug_loc: DebugLoc) -> ValueRef { let signed = match t.sty { - ty::ty_float(_) => { + ty::TyFloat(_) => { // The comparison operators for floating point vectors are challenging. // LLVM outputs a `< size x i1 >`, but if we perform a sign extension // then bitcast to a floating point vector, the result will be `-NaN` @@ -363,8 +363,8 @@ pub fn compare_simd_types<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, bcx.sess().bug("compare_simd_types: comparison operators \ not supported for floating point SIMD types") }, - ty::ty_uint(_) => false, - ty::ty_int(_) => true, + ty::TyUint(_) => false, + ty::TyInt(_) => true, _ => bcx.sess().bug("compare_simd_types: invalid SIMD type"), }; @@ -416,7 +416,7 @@ pub fn iter_structural_ty<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>, let mut cx = cx; match t.sty { - ty::ty_struct(..) => { + ty::TyStruct(..) => { let repr = adt::represent_type(cx.ccx(), t); expr::with_field_tys(cx.tcx(), t, None, |discr, field_tys| { for (i, field_ty) in field_tys.iter().enumerate() { @@ -435,7 +435,7 @@ pub fn iter_structural_ty<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>, } }) } - ty::ty_closure(def_id, substs) => { + ty::TyClosure(def_id, substs) => { let repr = adt::represent_type(cx.ccx(), t); let typer = common::NormalizingClosureTyper::new(cx.tcx()); let upvars = typer.closure_upvars(def_id, substs).unwrap(); @@ -444,23 +444,23 @@ pub fn iter_structural_ty<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>, cx = f(cx, llupvar, upvar.ty); } } - ty::ty_vec(_, Some(n)) => { + ty::TyArray(_, Some(n)) => { let (base, len) = tvec::get_fixed_base_and_len(cx, data_ptr, n); let unit_ty = ty::sequence_element_type(cx.tcx(), t); cx = tvec::iter_vec_raw(cx, base, unit_ty, len, f); } - ty::ty_vec(_, None) | ty::ty_str => { + ty::TyArray(_, None) | ty::TyStr => { let unit_ty = ty::sequence_element_type(cx.tcx(), t); cx = tvec::iter_vec_raw(cx, data_ptr, unit_ty, info.unwrap(), f); } - ty::ty_tup(ref args) => { + ty::TyTuple(ref args) => { let repr = adt::represent_type(cx.ccx(), t); for (i, arg) in args.iter().enumerate() { let llfld_a = adt::trans_field_ptr(cx, &*repr, data_ptr, 0, i); cx = f(cx, llfld_a, *arg); } } - ty::ty_enum(tid, substs) => { + ty::TyEnum(tid, substs) => { let fcx = cx.fcx; let ccx = fcx.ccx; @@ -574,7 +574,7 @@ fn cast_shift_rhs<F, G>(op: ast::BinOp_, pub fn llty_and_min_for_signed_ty<'blk, 'tcx>(cx: Block<'blk, 'tcx>, val_t: Ty<'tcx>) -> (Type, u64) { match val_t.sty { - ty::ty_int(t) => { + 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, @@ -608,15 +608,15 @@ pub fn fail_if_zero_or_overflows<'blk, 'tcx>( let debug_loc = call_info.debug_loc(); let (is_zero, is_signed) = match rhs_t.sty { - ty::ty_int(t) => { + ty::TyInt(t) => { let zero = C_integral(Type::int_from_ty(cx.ccx(), t), 0, false); (ICmp(cx, llvm::IntEQ, rhs, zero, debug_loc), true) } - ty::ty_uint(t) => { + ty::TyUint(t) => { let zero = C_integral(Type::uint_from_ty(cx.ccx(), t), 0, false); (ICmp(cx, llvm::IntEQ, rhs, zero, debug_loc), false) } - ty::ty_struct(_, _) if type_is_simd(cx.tcx(), rhs_t) => { + ty::TyStruct(_, _) if type_is_simd(cx.tcx(), rhs_t) => { let mut res = C_bool(cx.ccx(), false); for i in 0 .. simd_size(cx.tcx(), rhs_t) { res = Or(cx, res, @@ -665,7 +665,7 @@ pub fn trans_external_path<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, did: ast::DefId, t: Ty<'tcx>) -> ValueRef { let name = csearch::get_symbol(&ccx.sess().cstore, did); match t.sty { - ty::ty_bare_fn(_, ref fn_ty) => { + ty::TyBareFn(_, ref fn_ty) => { match ccx.sess().target.target.adjust_abi(fn_ty.abi) { Rust | RustCall => { get_extern_rust_fn(ccx, t, &name[..], did) @@ -1317,7 +1317,7 @@ fn create_datums_for_fn_args_under_call_abi<'blk, 'tcx>( // This is the last argument. Tuple it. match arg_ty.sty { - ty::ty_tup(ref tupled_arg_tys) => { + ty::TyTuple(ref tupled_arg_tys) => { let tuple_args_scope_id = cleanup::CustomScope(arg_scope); let tuple = unpack_datum!(bcx, @@ -1660,7 +1660,7 @@ pub fn trans_named_tuple_constructor<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, let tcx = ccx.tcx(); let result_ty = match ctor_ty.sty { - ty::ty_bare_fn(_, ref bft) => { + ty::TyBareFn(_, ref bft) => { ty::erase_late_bound_regions(bcx.tcx(), &bft.sig.output()).unwrap() } _ => ccx.sess().bug( @@ -1738,7 +1738,7 @@ fn trans_enum_variant_or_tuple_like_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx let ctor_ty = monomorphize::apply_param_substs(ccx.tcx(), param_substs, &ctor_ty); let result_ty = match ctor_ty.sty { - ty::ty_bare_fn(_, ref bft) => { + ty::TyBareFn(_, ref bft) => { ty::erase_late_bound_regions(ccx.tcx(), &bft.sig.output()) } _ => ccx.sess().bug( @@ -2108,7 +2108,7 @@ fn register_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, node_id: ast::NodeId, node_type: Ty<'tcx>) -> ValueRef { - if let ty::ty_bare_fn(_, ref f) = node_type.sty { + if let ty::TyBareFn(_, ref f) = node_type.sty { if f.abi != Rust && f.abi != RustCall { ccx.sess().span_bug(sp, &format!("only the `{}` or `{}` calling conventions are valid \ for this function; `{}` was specified", @@ -2464,7 +2464,7 @@ fn register_method(ccx: &CrateContext, id: ast::NodeId, let sym = exported_name(ccx, id, mty, &attrs); - if let ty::ty_bare_fn(_, ref f) = mty.sty { + if let ty::TyBareFn(_, ref f) = mty.sty { let llfn = if f.abi == Rust || f.abi == RustCall { register_fn(ccx, span, sym, id, mty) } else { diff --git a/src/librustc_trans/trans/callee.rs b/src/librustc_trans/trans/callee.rs index e619ce2f262..0aeb4046dc6 100644 --- a/src/librustc_trans/trans/callee.rs +++ b/src/librustc_trans/trans/callee.rs @@ -107,7 +107,7 @@ fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, expr: &ast::Expr) -> Callee<'blk, 'tcx> { let DatumBlock { bcx, datum, .. } = expr::trans(bcx, expr); match datum.ty.sty { - ty::ty_bare_fn(..) => { + ty::TyBareFn(..) => { let llval = datum.to_llscalarish(bcx); return Callee { bcx: bcx, @@ -156,7 +156,7 @@ fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, expr: &ast::Expr) } } def::DefFn(did, _) if match expr_ty.sty { - ty::ty_bare_fn(_, ref f) => f.abi == synabi::RustIntrinsic, + ty::TyBareFn(_, ref f) => f.abi == synabi::RustIntrinsic, _ => false } => { let substs = common::node_id_substs(bcx.ccx(), @@ -299,7 +299,7 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>( // which is the fn pointer, and `args`, which is the arguments tuple. let (opt_def_id, sig) = match bare_fn_ty.sty { - ty::ty_bare_fn(opt_def_id, + ty::TyBareFn(opt_def_id, &ty::BareFnTy { unsafety: ast::Unsafety::Normal, abi: synabi::Rust, ref sig }) => { @@ -621,7 +621,7 @@ pub fn trans_method_call<'a, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let method_ty = match bcx.tcx().method_map.borrow().get(&method_call) { Some(method) => match method.origin { ty::MethodTraitObject(_) => match method.ty.sty { - ty::ty_bare_fn(_, ref fty) => { + ty::TyBareFn(_, ref fty) => { ty::mk_bare_fn(bcx.tcx(), None, meth::opaque_method_ty(bcx.tcx(), fty)) } _ => method.ty @@ -699,7 +699,7 @@ pub fn trans_call_inner<'a, 'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>, let mut bcx = callee.bcx; let (abi, ret_ty) = match callee_ty.sty { - ty::ty_bare_fn(_, ref f) => { + ty::TyBareFn(_, ref f) => { let output = ty::erase_late_bound_regions(bcx.tcx(), &f.sig.output()); (f.abi, output) } @@ -943,7 +943,7 @@ fn trans_args_under_call_abi<'blk, 'tcx>( let tuple_type = common::node_id_type(bcx, tuple_expr.id); match tuple_type.sty { - ty::ty_tup(ref field_types) => { + ty::TyTuple(ref field_types) => { let tuple_datum = unpack_datum!(bcx, expr::trans(bcx, &**tuple_expr)); let tuple_lvalue_datum = @@ -1002,7 +1002,7 @@ fn trans_overloaded_call_args<'blk, 'tcx>( // Now untuple the rest of the arguments. let tuple_type = arg_tys[1]; match tuple_type.sty { - ty::ty_tup(ref field_types) => { + ty::TyTuple(ref field_types) => { for (i, &field_type) in field_types.iter().enumerate() { let arg_datum = unpack_datum!(bcx, expr::trans(bcx, arg_exprs[i + 1])); diff --git a/src/librustc_trans/trans/closure.rs b/src/librustc_trans/trans/closure.rs index e046b5cb111..27080966fcb 100644 --- a/src/librustc_trans/trans/closure.rs +++ b/src/librustc_trans/trans/closure.rs @@ -143,7 +143,7 @@ pub fn get_or_create_declaration_if_closure<'a, 'tcx>(ccx: &CrateContext<'a, 'tc // duplicate declarations let function_type = erase_regions(ccx.tcx(), &function_type); let params = match function_type.sty { - ty::ty_closure(_, substs) => &substs.types, + ty::TyClosure(_, substs) => &substs.types, _ => unreachable!() }; let mono_id = MonoId { @@ -421,7 +421,7 @@ fn trans_fn_once_adapter_shim<'a, 'tcx>( // the remaining arguments will be packed up in a tuple. let input_tys = match sig.inputs[1].sty { - ty::ty_tup(ref tys) => &**tys, + ty::TyTuple(ref tys) => &**tys, _ => bcx.sess().bug(&format!("trans_fn_once_adapter_shim: not rust-call! \ closure_def_id={}", closure_def_id.repr(tcx))) diff --git a/src/librustc_trans/trans/common.rs b/src/librustc_trans/trans/common.rs index 021321cacaf..7fe879dad0a 100644 --- a/src/librustc_trans/trans/common.rs +++ b/src/librustc_trans/trans/common.rs @@ -125,9 +125,9 @@ pub fn type_is_sized<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool { pub fn type_is_fat_ptr<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool { match ty.sty { - ty::ty_ptr(ty::mt{ty, ..}) | - ty::ty_rptr(_, ty::mt{ty, ..}) | - ty::ty_uniq(ty) => { + ty::TyRawPtr(ty::mt{ty, ..}) | + ty::TyRef(_, ty::mt{ty, ..}) | + ty::TyBox(ty) => { !type_is_sized(cx, ty) } _ => { @@ -158,10 +158,10 @@ pub fn type_needs_unwind_cleanup<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty< let mut needs_unwind_cleanup = false; ty::maybe_walk_ty(ty, |ty| { needs_unwind_cleanup |= match ty.sty { - ty::ty_bool | ty::ty_int(_) | ty::ty_uint(_) | - ty::ty_float(_) | ty::ty_tup(_) | ty::ty_ptr(_) => false, + ty::TyBool | ty::TyInt(_) | ty::TyUint(_) | + ty::TyFloat(_) | ty::TyTuple(_) | ty::TyRawPtr(_) => false, - ty::ty_enum(did, substs) => + ty::TyEnum(did, substs) => ty::enum_variants(tcx, did).iter().any(|v| v.args.iter().any(|&aty| { let t = aty.subst(tcx, substs); @@ -218,7 +218,7 @@ fn type_needs_drop_given_env<'a,'tcx>(cx: &ty::ctxt<'tcx>, fn type_is_newtype_immediate<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool { match ty.sty { - ty::ty_struct(def_id, substs) => { + ty::TyStruct(def_id, substs) => { let fields = ty::lookup_struct_fields(ccx.tcx(), def_id); fields.len() == 1 && { let ty = ty::lookup_field_type(ccx.tcx(), def_id, fields[0].id, substs); @@ -246,8 +246,8 @@ pub fn type_is_immediate<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) - return false; } match ty.sty { - ty::ty_struct(..) | ty::ty_enum(..) | ty::ty_tup(..) | ty::ty_vec(_, Some(_)) | - ty::ty_closure(..) => { + ty::TyStruct(..) | ty::TyEnum(..) | ty::TyTuple(..) | ty::TyArray(_, Some(_)) | + ty::TyClosure(..) => { let llty = sizing_type_of(ccx, ty); llsize_of_alloc(ccx, llty) <= llsize_of_alloc(ccx, ccx.int_type()) } diff --git a/src/librustc_trans/trans/consts.rs b/src/librustc_trans/trans/consts.rs index 0afaf88aaad..50dbeafa7e1 100644 --- a/src/librustc_trans/trans/consts.rs +++ b/src/librustc_trans/trans/consts.rs @@ -59,10 +59,10 @@ pub fn const_lit(cx: &CrateContext, e: &ast::Expr, lit: &ast::Lit) ast::LitInt(i, ast::UnsuffixedIntLit(_)) => { let lit_int_ty = ty::node_id_to_type(cx.tcx(), e.id); match lit_int_ty.sty { - ty::ty_int(t) => { + ty::TyInt(t) => { C_integral(Type::int_from_ty(cx, t), i as u64, true) } - ty::ty_uint(t) => { + ty::TyUint(t) => { C_integral(Type::uint_from_ty(cx, t), i as u64, false) } _ => cx.sess().span_bug(lit.span, @@ -77,7 +77,7 @@ pub fn const_lit(cx: &CrateContext, e: &ast::Expr, lit: &ast::Lit) ast::LitFloatUnsuffixed(ref fs) => { let lit_float_ty = ty::node_id_to_type(cx.tcx(), e.id); match lit_float_ty.sty { - ty::ty_float(t) => { + ty::TyFloat(t) => { C_floating(&fs, Type::float_from_ty(cx, t)) } _ => { @@ -392,7 +392,7 @@ fn check_unary_expr_validity(cx: &CrateContext, e: &ast::Expr, t: Ty, if let ast::ExprLit(_) = inner_e.node { return; } let result = match t.sty { - ty::ty_int(int_type) => { + ty::TyInt(int_type) => { let input = match const_to_opt_int(te) { Some(v) => v, None => return, @@ -400,7 +400,7 @@ fn check_unary_expr_validity(cx: &CrateContext, e: &ast::Expr, t: Ty, const_int_checked_neg( input, e, Some(const_eval::IntTy::from(cx.tcx(), int_type))) } - ty::ty_uint(uint_type) => { + ty::TyUint(uint_type) => { let input = match const_to_opt_uint(te) { Some(v) => v, None => return, @@ -423,7 +423,7 @@ fn check_binary_expr_validity(cx: &CrateContext, e: &ast::Expr, t: Ty, let b = if let ast::ExprBinary(b, _, _) = e.node { b } else { return }; let result = match t.sty { - ty::ty_int(int_type) => { + ty::TyInt(int_type) => { let (lhs, rhs) = match (const_to_opt_int(te1), const_to_opt_int(te2)) { (Some(v1), Some(v2)) => (v1, v2), @@ -442,7 +442,7 @@ fn check_binary_expr_validity(cx: &CrateContext, e: &ast::Expr, t: Ty, _ => return, } } - ty::ty_uint(uint_type) => { + ty::TyUint(uint_type) => { let (lhs, rhs) = match (const_to_opt_uint(te1), const_to_opt_uint(te2)) { (Some(v1), Some(v2)) => (v1, v2), @@ -609,13 +609,13 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, "index is not an integer-constant expression") }; let (arr, len) = match bt.sty { - ty::ty_vec(_, Some(u)) => (bv, C_uint(cx, u)), - ty::ty_vec(_, None) | ty::ty_str => { + ty::TyArray(_, Some(u)) => (bv, C_uint(cx, u)), + ty::TyArray(_, None) | ty::TyStr => { let e1 = const_get_elt(cx, bv, &[0]); (const_deref_ptr(cx, e1), const_get_elt(cx, bv, &[1])) } - ty::ty_rptr(_, mt) => match mt.ty.sty { - ty::ty_vec(_, Some(u)) => { + ty::TyRef(_, mt) => match mt.ty.sty { + ty::TyArray(_, Some(u)) => { (const_deref_ptr(cx, bv), C_uint(cx, u)) }, _ => cx.sess().span_bug(base.span, @@ -631,8 +631,8 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let len = llvm::LLVMConstIntGetZExtValue(len) as u64; let len = match bt.sty { - ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) => match ty.sty { - ty::ty_str => { + ty::TyBox(ty) | ty::TyRef(_, ty::mt{ty, ..}) => match ty.sty { + ty::TyStr => { assert!(len > 0); len - 1 } @@ -842,7 +842,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, } } def::DefStruct(_) => { - if let ty::ty_bare_fn(..) = ety.sty { + if let ty::TyBareFn(..) = ety.sty { // Tuple struct. expr::trans_def_fn_unadjusted(cx, e, def, param_substs).val } else { diff --git a/src/librustc_trans/trans/debuginfo/metadata.rs b/src/librustc_trans/trans/debuginfo/metadata.rs index 72d0159a8cd..551ccfb6650 100644 --- a/src/librustc_trans/trans/debuginfo/metadata.rs +++ b/src/librustc_trans/trans/debuginfo/metadata.rs @@ -171,26 +171,26 @@ impl<'tcx> TypeMap<'tcx> { unique_type_id.push('{'); match type_.sty { - ty::ty_bool | - ty::ty_char | - ty::ty_str | - ty::ty_int(_) | - ty::ty_uint(_) | - ty::ty_float(_) => { + ty::TyBool | + ty::TyChar | + ty::TyStr | + ty::TyInt(_) | + ty::TyUint(_) | + ty::TyFloat(_) => { push_debuginfo_type_name(cx, type_, false, &mut unique_type_id); }, - ty::ty_enum(def_id, substs) => { + ty::TyEnum(def_id, substs) => { unique_type_id.push_str("enum "); from_def_id_and_substs(self, cx, def_id, substs, &mut unique_type_id); }, - ty::ty_struct(def_id, substs) => { + ty::TyStruct(def_id, substs) => { unique_type_id.push_str("struct "); from_def_id_and_substs(self, cx, def_id, substs, &mut unique_type_id); }, - ty::ty_tup(ref component_types) if component_types.is_empty() => { + ty::TyTuple(ref component_types) if component_types.is_empty() => { push_debuginfo_type_name(cx, type_, false, &mut unique_type_id); }, - ty::ty_tup(ref component_types) => { + ty::TyTuple(ref component_types) => { unique_type_id.push_str("tuple "); for &component_type in component_types { let component_type_id = @@ -200,13 +200,13 @@ impl<'tcx> TypeMap<'tcx> { unique_type_id.push_str(&component_type_id[..]); } }, - ty::ty_uniq(inner_type) => { + ty::TyBox(inner_type) => { unique_type_id.push_str("box "); let inner_type_id = self.get_unique_type_id_of_type(cx, inner_type); let inner_type_id = self.get_unique_type_id_as_string(inner_type_id); unique_type_id.push_str(&inner_type_id[..]); }, - ty::ty_ptr(ty::mt { ty: inner_type, mutbl } ) => { + ty::TyRawPtr(ty::mt { ty: inner_type, mutbl } ) => { unique_type_id.push('*'); if mutbl == ast::MutMutable { unique_type_id.push_str("mut"); @@ -216,7 +216,7 @@ impl<'tcx> TypeMap<'tcx> { let inner_type_id = self.get_unique_type_id_as_string(inner_type_id); unique_type_id.push_str(&inner_type_id[..]); }, - ty::ty_rptr(_, ty::mt { ty: inner_type, mutbl }) => { + ty::TyRef(_, ty::mt { ty: inner_type, mutbl }) => { unique_type_id.push('&'); if mutbl == ast::MutMutable { unique_type_id.push_str("mut"); @@ -226,7 +226,7 @@ impl<'tcx> TypeMap<'tcx> { let inner_type_id = self.get_unique_type_id_as_string(inner_type_id); unique_type_id.push_str(&inner_type_id[..]); }, - ty::ty_vec(inner_type, optional_length) => { + ty::TyArray(inner_type, optional_length) => { match optional_length { Some(len) => { unique_type_id.push_str(&format!("[{}]", len)); @@ -240,7 +240,7 @@ impl<'tcx> TypeMap<'tcx> { let inner_type_id = self.get_unique_type_id_as_string(inner_type_id); unique_type_id.push_str(&inner_type_id[..]); }, - ty::ty_trait(ref trait_data) => { + ty::TyTrait(ref trait_data) => { unique_type_id.push_str("trait "); let principal = @@ -253,7 +253,7 @@ impl<'tcx> TypeMap<'tcx> { principal.substs, &mut unique_type_id); }, - ty::ty_bare_fn(_, &ty::BareFnTy{ unsafety, abi, ref sig } ) => { + ty::TyBareFn(_, &ty::BareFnTy{ unsafety, abi, ref sig } ) => { if unsafety == ast::Unsafety::Unsafe { unique_type_id.push_str("unsafe "); } @@ -289,7 +289,7 @@ impl<'tcx> TypeMap<'tcx> { } } }, - ty::ty_closure(def_id, substs) => { + ty::TyClosure(def_id, substs) => { let typer = NormalizingClosureTyper::new(cx.tcx()); let closure_ty = typer.closure_type(def_id, substs); self.get_unique_type_id_of_closure_type(cx, @@ -635,7 +635,7 @@ fn subroutine_type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, // return type signature_metadata.push(match signature.output { ty::FnConverging(ret_ty) => match ret_ty.sty { - ty::ty_tup(ref tys) if tys.is_empty() => ptr::null_mut(), + ty::TyTuple(ref tys) if tys.is_empty() => ptr::null_mut(), _ => type_metadata(cx, ret_ty, span) }, ty::FnDiverging => diverging_type_metadata(cx) @@ -674,7 +674,7 @@ fn trait_pointer_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, // But it does not describe the trait's methods. let def_id = match trait_type.sty { - ty::ty_trait(ref data) => data.principal_def_id(), + ty::TyTrait(ref data) => data.principal_def_id(), _ => { let pp_type_name = ppaux::ty_to_string(cx.tcx(), trait_type); cx.sess().bug(&format!("debuginfo: Unexpected trait-object type in \ @@ -742,39 +742,39 @@ pub fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let sty = &t.sty; let MetadataCreationResult { metadata, already_stored_in_typemap } = match *sty { - ty::ty_bool | - ty::ty_char | - ty::ty_int(_) | - ty::ty_uint(_) | - ty::ty_float(_) => { + ty::TyBool | + ty::TyChar | + ty::TyInt(_) | + ty::TyUint(_) | + ty::TyFloat(_) => { MetadataCreationResult::new(basic_type_metadata(cx, t), false) } - ty::ty_tup(ref elements) if elements.is_empty() => { + ty::TyTuple(ref elements) if elements.is_empty() => { MetadataCreationResult::new(basic_type_metadata(cx, t), false) } - ty::ty_enum(def_id, _) => { + ty::TyEnum(def_id, _) => { prepare_enum_metadata(cx, t, def_id, unique_type_id, usage_site_span).finalize(cx) } - ty::ty_vec(typ, len) => { + ty::TyArray(typ, len) => { fixed_vec_metadata(cx, unique_type_id, typ, len.map(|x| x as u64), usage_site_span) } - ty::ty_str => { + ty::TyStr => { fixed_vec_metadata(cx, unique_type_id, cx.tcx().types.i8, None, usage_site_span) } - ty::ty_trait(..) => { + ty::TyTrait(..) => { MetadataCreationResult::new( trait_pointer_metadata(cx, t, None, unique_type_id), false) } - ty::ty_uniq(ty) | ty::ty_ptr(ty::mt{ty, ..}) | ty::ty_rptr(_, ty::mt{ty, ..}) => { + ty::TyBox(ty) | ty::TyRawPtr(ty::mt{ty, ..}) | ty::TyRef(_, ty::mt{ty, ..}) => { match ty.sty { - ty::ty_vec(typ, None) => { + ty::TyArray(typ, None) => { vec_slice_metadata(cx, t, typ, unique_type_id, usage_site_span) } - ty::ty_str => { + ty::TyStr => { vec_slice_metadata(cx, t, cx.tcx().types.u8, unique_type_id, usage_site_span) } - ty::ty_trait(..) => { + ty::TyTrait(..) => { MetadataCreationResult::new( trait_pointer_metadata(cx, ty, Some(t), unique_type_id), false) @@ -794,15 +794,15 @@ pub fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, } } } - ty::ty_bare_fn(_, ref barefnty) => { + ty::TyBareFn(_, ref barefnty) => { subroutine_type_metadata(cx, unique_type_id, &barefnty.sig, usage_site_span) } - ty::ty_closure(def_id, substs) => { + ty::TyClosure(def_id, substs) => { let typer = NormalizingClosureTyper::new(cx.tcx()); let sig = typer.closure_type(def_id, substs).sig; subroutine_type_metadata(cx, unique_type_id, &sig, usage_site_span) } - ty::ty_struct(def_id, substs) => { + ty::TyStruct(def_id, substs) => { prepare_struct_metadata(cx, t, def_id, @@ -810,7 +810,7 @@ pub fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, unique_type_id, usage_site_span).finalize(cx) } - ty::ty_tup(ref elements) => { + ty::TyTuple(ref elements) => { prepare_tuple_metadata(cx, t, &elements[..], @@ -936,25 +936,25 @@ fn basic_type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, debug!("basic_type_metadata: {:?}", t); let (name, encoding) = match t.sty { - ty::ty_tup(ref elements) if elements.is_empty() => + ty::TyTuple(ref elements) if elements.is_empty() => ("()".to_string(), DW_ATE_unsigned), - ty::ty_bool => ("bool".to_string(), DW_ATE_boolean), - ty::ty_char => ("char".to_string(), DW_ATE_unsigned_char), - ty::ty_int(int_ty) => match int_ty { + ty::TyBool => ("bool".to_string(), DW_ATE_boolean), + ty::TyChar => ("char".to_string(), DW_ATE_unsigned_char), + ty::TyInt(int_ty) => match int_ty { ast::TyIs => ("isize".to_string(), DW_ATE_signed), ast::TyI8 => ("i8".to_string(), DW_ATE_signed), ast::TyI16 => ("i16".to_string(), DW_ATE_signed), ast::TyI32 => ("i32".to_string(), DW_ATE_signed), ast::TyI64 => ("i64".to_string(), DW_ATE_signed) }, - ty::ty_uint(uint_ty) => match uint_ty { + ty::TyUint(uint_ty) => match uint_ty { ast::TyUs => ("usize".to_string(), DW_ATE_unsigned), ast::TyU8 => ("u8".to_string(), DW_ATE_unsigned), ast::TyU16 => ("u16".to_string(), DW_ATE_unsigned), ast::TyU32 => ("u32".to_string(), DW_ATE_unsigned), ast::TyU64 => ("u64".to_string(), DW_ATE_unsigned) }, - ty::ty_float(float_ty) => match float_ty { + ty::TyFloat(float_ty) => match float_ty { ast::TyF32 => ("f32".to_string(), DW_ATE_float), ast::TyF64 => ("f64".to_string(), DW_ATE_float), }, @@ -1179,7 +1179,7 @@ fn prepare_struct_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let mut fields = ty::struct_fields(cx.tcx(), def_id, substs); // The `Ty` values returned by `ty::struct_fields` can still contain - // `ty_projection` variants, so normalize those away. + // `TyProjection` variants, so normalize those away. for field in &mut fields { field.mt.ty = monomorphize::normalize_associated_type(cx.tcx(), &field.mt.ty); } diff --git a/src/librustc_trans/trans/debuginfo/type_names.rs b/src/librustc_trans/trans/debuginfo/type_names.rs index 4d340fcc77c..153170913ed 100644 --- a/src/librustc_trans/trans/debuginfo/type_names.rs +++ b/src/librustc_trans/trans/debuginfo/type_names.rs @@ -40,27 +40,27 @@ pub fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, qualified: bool, output: &mut String) { match t.sty { - ty::ty_bool => output.push_str("bool"), - ty::ty_char => output.push_str("char"), - ty::ty_str => output.push_str("str"), - ty::ty_int(ast::TyIs) => output.push_str("isize"), - ty::ty_int(ast::TyI8) => output.push_str("i8"), - ty::ty_int(ast::TyI16) => output.push_str("i16"), - ty::ty_int(ast::TyI32) => output.push_str("i32"), - ty::ty_int(ast::TyI64) => output.push_str("i64"), - ty::ty_uint(ast::TyUs) => output.push_str("usize"), - ty::ty_uint(ast::TyU8) => output.push_str("u8"), - ty::ty_uint(ast::TyU16) => output.push_str("u16"), - ty::ty_uint(ast::TyU32) => output.push_str("u32"), - ty::ty_uint(ast::TyU64) => output.push_str("u64"), - ty::ty_float(ast::TyF32) => output.push_str("f32"), - ty::ty_float(ast::TyF64) => output.push_str("f64"), - ty::ty_struct(def_id, substs) | - ty::ty_enum(def_id, substs) => { + 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::TyStruct(def_id, substs) | + ty::TyEnum(def_id, substs) => { push_item_name(cx, def_id, qualified, output); push_type_params(cx, substs, output); }, - ty::ty_tup(ref component_types) => { + ty::TyTuple(ref component_types) => { output.push('('); for &component_type in component_types { push_debuginfo_type_name(cx, component_type, true, output); @@ -72,12 +72,12 @@ pub fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, } output.push(')'); }, - ty::ty_uniq(inner_type) => { + ty::TyBox(inner_type) => { output.push_str("Box<"); push_debuginfo_type_name(cx, inner_type, true, output); output.push('>'); }, - ty::ty_ptr(ty::mt { ty: inner_type, mutbl } ) => { + ty::TyRawPtr(ty::mt { ty: inner_type, mutbl } ) => { output.push('*'); match mutbl { ast::MutImmutable => output.push_str("const "), @@ -86,7 +86,7 @@ pub fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, push_debuginfo_type_name(cx, inner_type, true, output); }, - ty::ty_rptr(_, ty::mt { ty: inner_type, mutbl }) => { + ty::TyRef(_, ty::mt { ty: inner_type, mutbl }) => { output.push('&'); if mutbl == ast::MutMutable { output.push_str("mut "); @@ -94,7 +94,7 @@ pub fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, push_debuginfo_type_name(cx, inner_type, true, output); }, - ty::ty_vec(inner_type, optional_length) => { + ty::TyArray(inner_type, optional_length) => { output.push('['); push_debuginfo_type_name(cx, inner_type, true, output); @@ -107,12 +107,12 @@ pub fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, output.push(']'); }, - ty::ty_trait(ref trait_data) => { + ty::TyTrait(ref trait_data) => { let principal = ty::erase_late_bound_regions(cx.tcx(), &trait_data.principal); push_item_name(cx, principal.def_id, false, output); push_type_params(cx, principal.substs, output); }, - ty::ty_bare_fn(_, &ty::BareFnTy{ unsafety, abi, ref sig } ) => { + ty::TyBareFn(_, &ty::BareFnTy{ unsafety, abi, ref sig } ) => { if unsafety == ast::Unsafety::Unsafe { output.push_str("unsafe "); } @@ -156,13 +156,13 @@ pub fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, } } }, - ty::ty_closure(..) => { + ty::TyClosure(..) => { output.push_str("closure"); } - ty::ty_err | - ty::ty_infer(_) | - ty::ty_projection(..) | - ty::ty_param(_) => { + ty::TyError | + ty::TyInfer(_) | + ty::TyProjection(..) | + ty::TyParam(_) => { cx.sess().bug(&format!("debuginfo: Trying to create type name for \ unexpected type: {}", ppaux::ty_to_string(cx.tcx(), t))); } diff --git a/src/librustc_trans/trans/declare.rs b/src/librustc_trans/trans/declare.rs index e0ab5dec98d..935925e5a8f 100644 --- a/src/librustc_trans/trans/declare.rs +++ b/src/librustc_trans/trans/declare.rs @@ -114,10 +114,10 @@ pub fn declare_rust_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, name: &str, let function_type; // placeholder so that the memory ownership works out ok let (sig, abi, env) = match fn_type.sty { - ty::ty_bare_fn(_, ref f) => { + ty::TyBareFn(_, ref f) => { (&f.sig, f.abi, None) } - ty::ty_closure(closure_did, substs) => { + ty::TyClosure(closure_did, substs) => { let typer = common::NormalizingClosureTyper::new(ccx.tcx()); function_type = typer.closure_type(closure_did, substs); let self_type = base::self_type_for_closure(ccx, closure_did, fn_type); diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs index 23d2d8efc33..9fda58db5d2 100644 --- a/src/librustc_trans/trans/expr.rs +++ b/src/librustc_trans/trans/expr.rs @@ -313,14 +313,14 @@ pub fn unsized_info<'ccx, 'tcx>(ccx: &CrateContext<'ccx, 'tcx>, -> ValueRef { let (source, target) = ty::struct_lockstep_tails(ccx.tcx(), source, target); match (&source.sty, &target.sty) { - (&ty::ty_vec(_, Some(len)), &ty::ty_vec(_, None)) => C_uint(ccx, len), - (&ty::ty_trait(_), &ty::ty_trait(_)) => { + (&ty::TyArray(_, Some(len)), &ty::TyArray(_, None)) => C_uint(ccx, len), + (&ty::TyTrait(_), &ty::TyTrait(_)) => { // For now, upcasts are limited to changes in marker // traits, and hence never actually require an actual // change to the vtable. old_info.expect("unsized_info: missing old info for trait upcast") } - (_, &ty::ty_trait(box ty::TyTrait { ref principal, .. })) => { + (_, &ty::TyTrait(box ty::TraitTy { ref principal, .. })) => { // Note that we preserve binding levels here: let substs = principal.0.substs.with_self_ty(source).erase_regions(); let substs = ccx.tcx().mk_substs(substs); @@ -369,7 +369,7 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, // a different region or mutability, but we don't care here). match datum.ty.sty { // Don't skip a conversion from Box<T> to &T, etc. - ty::ty_rptr(..) => { + ty::TyRef(..) => { let method_call = MethodCall::autoderef(expr.id, 0); if bcx.tcx().method_map.borrow().contains_key(&method_call) { // Don't skip an overloaded deref. @@ -442,10 +442,10 @@ fn coerce_unsized<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, target.to_string(bcx.ccx())); match (&source.ty.sty, &target.ty.sty) { - (&ty::ty_uniq(a), &ty::ty_uniq(b)) | - (&ty::ty_rptr(_, ty::mt { ty: a, .. }), &ty::ty_rptr(_, ty::mt { ty: b, .. })) | - (&ty::ty_rptr(_, ty::mt { ty: a, .. }), &ty::ty_ptr(ty::mt { ty: b, .. })) | - (&ty::ty_ptr(ty::mt { ty: a, .. }), &ty::ty_ptr(ty::mt { ty: b, .. })) => { + (&ty::TyBox(a), &ty::TyBox(b)) | + (&ty::TyRef(_, ty::mt { ty: a, .. }), &ty::TyRef(_, ty::mt { ty: b, .. })) | + (&ty::TyRef(_, ty::mt { ty: a, .. }), &ty::TyRawPtr(ty::mt { ty: b, .. })) | + (&ty::TyRawPtr(ty::mt { ty: a, .. }), &ty::TyRawPtr(ty::mt { ty: b, .. })) => { let (inner_source, inner_target) = (a, b); let (base, old_info) = if !type_is_sized(bcx.tcx(), inner_source) { @@ -479,8 +479,8 @@ fn coerce_unsized<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, } // This can be extended to enums and tuples in the future. - // (&ty::ty_enum(def_id_a, _), &ty::ty_enum(def_id_b, _)) | - (&ty::ty_struct(def_id_a, _), &ty::ty_struct(def_id_b, _)) => { + // (&ty::TyEnum(def_id_a, _), &ty::TyEnum(def_id_b, _)) | + (&ty::TyStruct(def_id_a, _), &ty::TyStruct(def_id_b, _)) => { assert_eq!(def_id_a, def_id_b); // The target is already by-ref because it's to be written to. @@ -657,7 +657,7 @@ fn trans_datum_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let box_ty = expr_ty(bcx, expr); let contents_ty = expr_ty(bcx, &**contents); match box_ty.sty { - ty::ty_uniq(..) => { + ty::TyBox(..) => { trans_uniq_expr(bcx, expr, box_ty, &**contents, contents_ty) } _ => bcx.sess().span_bug(expr.span, @@ -1245,7 +1245,7 @@ fn trans_def_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, def::DefStruct(_) => { let ty = expr_ty(bcx, ref_expr); match ty.sty { - ty::ty_struct(did, _) if ty::has_dtor(bcx.tcx(), did) => { + ty::TyStruct(did, _) if ty::has_dtor(bcx.tcx(), did) => { let repr = adt::represent_type(bcx.ccx(), ty); adt::trans_set_discr(bcx, &*repr, lldest, 0); } @@ -1339,17 +1339,17 @@ pub fn with_field_tys<'tcx, R, F>(tcx: &ty::ctxt<'tcx>, F: FnOnce(ty::Disr, &[ty::field<'tcx>]) -> R, { match ty.sty { - ty::ty_struct(did, substs) => { + ty::TyStruct(did, substs) => { let fields = struct_fields(tcx, did, substs); let fields = monomorphize::normalize_associated_type(tcx, &fields); op(0, &fields[..]) } - ty::ty_tup(ref v) => { + ty::TyTuple(ref v) => { op(0, &tup_fields(&v[..])) } - ty::ty_enum(_, substs) => { + ty::TyEnum(_, substs) => { // We want the *variant* ID here, not the enum ID. match node_id_opt { None => { @@ -2253,7 +2253,7 @@ fn deref_once<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, }; let r = match datum.ty.sty { - ty::ty_uniq(content_ty) => { + ty::TyBox(content_ty) => { // Make sure we have an lvalue datum here to get the // proper cleanups scheduled let datum = unpack_datum!( @@ -2274,8 +2274,8 @@ fn deref_once<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, } } - ty::ty_ptr(ty::mt { ty: content_ty, .. }) | - ty::ty_rptr(_, ty::mt { ty: content_ty, .. }) => { + ty::TyRawPtr(ty::mt { ty: content_ty, .. }) | + ty::TyRef(_, ty::mt { ty: content_ty, .. }) => { if type_is_sized(bcx.tcx(), content_ty) { let ptr = datum.to_llscalarish(bcx); @@ -2347,61 +2347,61 @@ impl OverflowOpViaIntrinsic { fn to_intrinsic_name(&self, tcx: &ty::ctxt, ty: Ty) -> &'static str { use syntax::ast::IntTy::*; use syntax::ast::UintTy::*; - use middle::ty::{ty_int, ty_uint}; + use middle::ty::{TyInt, TyUint}; let new_sty = match ty.sty { - ty_int(TyIs) => match &tcx.sess.target.target.target_pointer_width[..] { - "32" => ty_int(TyI32), - "64" => ty_int(TyI64), + TyInt(TyIs) => match &tcx.sess.target.target.target_pointer_width[..] { + "32" => TyInt(TyI32), + "64" => TyInt(TyI64), _ => panic!("unsupported target word size") }, - ty_uint(TyUs) => match &tcx.sess.target.target.target_pointer_width[..] { - "32" => ty_uint(TyU32), - "64" => ty_uint(TyU64), + TyUint(TyUs) => match &tcx.sess.target.target.target_pointer_width[..] { + "32" => TyUint(TyU32), + "64" => TyUint(TyU64), _ => panic!("unsupported target word size") }, - ref t @ ty_uint(_) | ref t @ ty_int(_) => t.clone(), + ref t @ TyUint(_) | ref t @ TyInt(_) => t.clone(), _ => panic!("tried to get overflow intrinsic for {:?} applied to non-int type", *self) }; match *self { OverflowOpViaIntrinsic::Add => match new_sty { - ty_int(TyI8) => "llvm.sadd.with.overflow.i8", - ty_int(TyI16) => "llvm.sadd.with.overflow.i16", - ty_int(TyI32) => "llvm.sadd.with.overflow.i32", - ty_int(TyI64) => "llvm.sadd.with.overflow.i64", + 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", - ty_uint(TyU8) => "llvm.uadd.with.overflow.i8", - ty_uint(TyU16) => "llvm.uadd.with.overflow.i16", - ty_uint(TyU32) => "llvm.uadd.with.overflow.i32", - ty_uint(TyU64) => "llvm.uadd.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", _ => unreachable!(), }, OverflowOpViaIntrinsic::Sub => match new_sty { - ty_int(TyI8) => "llvm.ssub.with.overflow.i8", - ty_int(TyI16) => "llvm.ssub.with.overflow.i16", - ty_int(TyI32) => "llvm.ssub.with.overflow.i32", - ty_int(TyI64) => "llvm.ssub.with.overflow.i64", + 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", - ty_uint(TyU8) => "llvm.usub.with.overflow.i8", - ty_uint(TyU16) => "llvm.usub.with.overflow.i16", - ty_uint(TyU32) => "llvm.usub.with.overflow.i32", - ty_uint(TyU64) => "llvm.usub.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", _ => unreachable!(), }, OverflowOpViaIntrinsic::Mul => match new_sty { - ty_int(TyI8) => "llvm.smul.with.overflow.i8", - ty_int(TyI16) => "llvm.smul.with.overflow.i16", - ty_int(TyI32) => "llvm.smul.with.overflow.i32", - ty_int(TyI64) => "llvm.smul.with.overflow.i64", - - ty_uint(TyU8) => "llvm.umul.with.overflow.i8", - ty_uint(TyU16) => "llvm.umul.with.overflow.i16", - ty_uint(TyU32) => "llvm.umul.with.overflow.i32", - ty_uint(TyU64) => "llvm.umul.with.overflow.i64", + 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", _ => unreachable!(), }, diff --git a/src/librustc_trans/trans/foreign.rs b/src/librustc_trans/trans/foreign.rs index e151ce8fad2..9ad6df5a6ab 100644 --- a/src/librustc_trans/trans/foreign.rs +++ b/src/librustc_trans/trans/foreign.rs @@ -129,7 +129,7 @@ pub fn register_static(ccx: &CrateContext, } }; let llty2 = match ty.sty { - ty::ty_ptr(ref mt) => type_of::type_of(ccx, mt.ty), + ty::TyRawPtr(ref mt) => type_of::type_of(ccx, mt.ty), _ => { ccx.sess().span_fatal(foreign_item.span, "must have type `*T` or `*mut T`"); @@ -243,7 +243,7 @@ pub fn trans_native_call<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, ccx.tn().val_to_string(llretptr)); let (fn_abi, fn_sig) = match callee_ty.sty { - ty::ty_bare_fn(_, ref fn_ty) => (fn_ty.abi, &fn_ty.sig), + ty::TyBareFn(_, ref fn_ty) => (fn_ty.abi, &fn_ty.sig), _ => ccx.sess().bug("trans_native_call called on non-function type") }; let fn_sig = ty::erase_late_bound_regions(ccx.tcx(), fn_sig); @@ -474,7 +474,7 @@ pub fn trans_foreign_mod(ccx: &CrateContext, foreign_mod: &ast::ForeignMod) { abi => { let ty = ty::node_id_to_type(ccx.tcx(), foreign_item.id); match ty.sty { - ty::ty_bare_fn(_, bft) => gate_simd_ffi(ccx.tcx(), &**decl, bft), + ty::TyBareFn(_, bft) => gate_simd_ffi(ccx.tcx(), &**decl, bft), _ => ccx.tcx().sess.span_bug(foreign_item.span, "foreign fn's sty isn't a bare_fn_ty?") } @@ -526,7 +526,7 @@ pub fn decl_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let tys = foreign_types_for_fn_ty(ccx, t); let llfn_ty = lltype_for_fn_from_foreign_types(ccx, &tys); let cconv = match t.sty { - ty::ty_bare_fn(_, ref fn_ty) => { + ty::TyBareFn(_, ref fn_ty) => { llvm_calling_convention(ccx, fn_ty.abi) } _ => panic!("expected bare fn in decl_rust_fn_with_foreign_abi") @@ -550,7 +550,7 @@ pub fn register_rust_fn_with_foreign_abi(ccx: &CrateContext, let llfn_ty = lltype_for_fn_from_foreign_types(ccx, &tys); let t = ty::node_id_to_type(ccx.tcx(), node_id); let cconv = match t.sty { - ty::ty_bare_fn(_, ref fn_ty) => { + ty::TyBareFn(_, ref fn_ty) => { llvm_calling_convention(ccx, fn_ty.abi) } _ => panic!("expected bare fn in register_rust_fn_with_foreign_abi") @@ -606,7 +606,7 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, // Compute the type that the function would have if it were just a // normal Rust function. This will be the type of the wrappee fn. match t.sty { - ty::ty_bare_fn(_, ref f) => { + ty::TyBareFn(_, ref f) => { assert!(f.abi != Rust && f.abi != RustIntrinsic); } _ => { @@ -926,7 +926,7 @@ fn foreign_types_for_id<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn foreign_types_for_fn_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -> ForeignTypes<'tcx> { let fn_sig = match ty.sty { - ty::ty_bare_fn(_, ref fn_ty) => &fn_ty.sig, + ty::TyBareFn(_, ref fn_ty) => &fn_ty.sig, _ => ccx.sess().bug("foreign_types_for_fn_ty called on non-function type") }; let fn_sig = ty::erase_late_bound_regions(ccx.tcx(), fn_sig); diff --git a/src/librustc_trans/trans/glue.rs b/src/librustc_trans/trans/glue.rs index 264957d3651..da1409a8f3d 100644 --- a/src/librustc_trans/trans/glue.rs +++ b/src/librustc_trans/trans/glue.rs @@ -114,7 +114,7 @@ pub fn get_drop_glue_type<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, return tcx.types.i8; } match t.sty { - ty::ty_uniq(typ) if !type_needs_drop(tcx, typ) + ty::TyBox(typ) if !type_needs_drop(tcx, typ) && type_is_sized(tcx, typ) => { let llty = sizing_type_of(ccx, typ); // `Box<ZeroSizeType>` does not allocate. @@ -398,7 +398,7 @@ pub fn size_and_align_of_dst<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, t: Ty<'tcx>, in return (size, align); } match t.sty { - ty::ty_struct(id, substs) => { + ty::TyStruct(id, substs) => { let ccx = bcx.ccx(); // First get the size of all statically known fields. // Don't use type_of::sizing_type_of because that expects t to be sized. @@ -427,7 +427,7 @@ pub fn size_and_align_of_dst<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, t: Ty<'tcx>, in unsized_align); (size, align) } - ty::ty_trait(..) => { + ty::TyTrait(..) => { // info points to the vtable and the second entry in the vtable is the // dynamic size of the object. let info = PointerCast(bcx, info, Type::int(bcx.ccx()).ptr_to()); @@ -435,7 +435,7 @@ pub fn size_and_align_of_dst<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, t: Ty<'tcx>, in let align_ptr = GEPi(bcx, info, &[2]); (Load(bcx, size_ptr), Load(bcx, align_ptr)) } - ty::ty_vec(_, None) | ty::ty_str => { + ty::TyArray(_, None) | ty::TyStr => { let unit_ty = ty::sequence_element_type(bcx.tcx(), t); // The info in this case is the length of the str, so the size is that // times the unit size. @@ -466,10 +466,10 @@ fn make_drop_glue<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, v0: ValueRef, g: DropGlueK let dropped_pattern = C_integral(inttype, adt::dtor_done_usize(bcx.fcx.ccx) as u64, false); match t.sty { - ty::ty_uniq(content_ty) => { - // Support for ty_uniq is built-in and its drop glue is + ty::TyBox(content_ty) => { + // Support for TyBox is built-in and its drop glue is // special. It may move to library and have Drop impl. As - // a safe-guard, assert ty_uniq not used with TyContents. + // a safe-guard, assert TyBox not used with TyContents. assert!(!skip_dtor); if !type_is_sized(bcx.tcx(), content_ty) { let llval = GEPi(bcx, v0, &[0, abi::FAT_PTR_ADDR]); @@ -505,7 +505,7 @@ fn make_drop_glue<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, v0: ValueRef, g: DropGlueK }) } } - ty::ty_struct(did, substs) | ty::ty_enum(did, substs) => { + ty::TyStruct(did, substs) | ty::TyEnum(did, substs) => { let tcx = bcx.tcx(); match (ty::ty_dtor(tcx, did), skip_dtor) { (ty::TraitDtor(dtor, true), false) => { @@ -534,7 +534,7 @@ fn make_drop_glue<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, v0: ValueRef, g: DropGlueK } } } - ty::ty_trait(..) => { + ty::TyTrait(..) => { // No support in vtable for distinguishing destroying with // versus without calling Drop::drop. Assert caller is // okay with always calling the Drop impl, if any. diff --git a/src/librustc_trans/trans/intrinsic.rs b/src/librustc_trans/trans/intrinsic.rs index 4347d1853be..419ab1bb05d 100644 --- a/src/librustc_trans/trans/intrinsic.rs +++ b/src/librustc_trans/trans/intrinsic.rs @@ -163,7 +163,7 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, let _icx = push_ctxt("trans_intrinsic_call"); let ret_ty = match callee_ty.sty { - ty::ty_bare_fn(_, ref f) => { + ty::TyBareFn(_, ref f) => { ty::erase_late_bound_regions(bcx.tcx(), &f.sig.output()) } _ => panic!("expected bare_fn in trans_intrinsic_call") @@ -755,7 +755,7 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, (_, "discriminant_value") => { let val_ty = substs.types.get(FnSpace, 0); match val_ty.sty { - ty::ty_enum(..) => { + ty::TyEnum(..) => { let repr = adt::represent_type(ccx, *val_ty); adt::trans_get_discr(bcx, &*repr, llargs[0], Some(llret_ty)) } diff --git a/src/librustc_trans/trans/meth.rs b/src/librustc_trans/trans/meth.rs index 1934b72eca3..0dc1cca85fb 100644 --- a/src/librustc_trans/trans/meth.rs +++ b/src/librustc_trans/trans/meth.rs @@ -493,7 +493,7 @@ pub fn trans_trait_callee_from_llval<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, // Replace the self type (&Self or Box<Self>) with an opaque pointer. let llcallee_ty = match callee_ty.sty { - ty::ty_bare_fn(_, ref f) if f.abi == Rust || f.abi == RustCall => { + ty::TyBareFn(_, ref f) if f.abi == Rust || f.abi == RustCall => { let fake_sig = ty::Binder(ty::FnSig { inputs: f.sig.0.inputs[1..].to_vec(), @@ -563,7 +563,7 @@ pub fn trans_object_shim<'a, 'tcx>( let object_trait_ref = match object_ty.sty { - ty::ty_trait(ref data) => { + ty::TyTrait(ref data) => { data.principal_trait_ref_with_self_ty(tcx, object_ty) } _ => { @@ -624,7 +624,7 @@ pub fn trans_object_shim<'a, 'tcx>( RustCall => { // unpack the tuple to extract the input type arguments: match sig.inputs[1].sty { - ty::ty_tup(ref tys) => &**tys, + ty::TyTuple(ref tys) => &**tys, _ => { bcx.sess().bug( &format!("rust-call expects a tuple not {}", diff --git a/src/librustc_trans/trans/tvec.rs b/src/librustc_trans/trans/tvec.rs index b02fcb6cf0c..18c123cec28 100644 --- a/src/librustc_trans/trans/tvec.rs +++ b/src/librustc_trans/trans/tvec.rs @@ -310,15 +310,15 @@ pub fn get_base_and_len<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let ccx = bcx.ccx(); match vec_ty.sty { - ty::ty_vec(_, Some(n)) => get_fixed_base_and_len(bcx, llval, n), - ty::ty_vec(_, None) | ty::ty_str => { + ty::TyArray(_, Some(n)) => get_fixed_base_and_len(bcx, llval, n), + ty::TyArray(_, None) | ty::TyStr => { let base = Load(bcx, expr::get_dataptr(bcx, llval)); let len = Load(bcx, expr::get_len(bcx, llval)); (base, len) } // Only used for pattern matching. - ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) => { + ty::TyBox(ty) | ty::TyRef(_, ty::mt{ty, ..}) => { let inner = if type_is_sized(bcx.tcx(), ty) { Load(bcx, llval) } else { diff --git a/src/librustc_trans/trans/type_of.rs b/src/librustc_trans/trans/type_of.rs index 9f015213136..0356bade22d 100644 --- a/src/librustc_trans/trans/type_of.rs +++ b/src/librustc_trans/trans/type_of.rs @@ -79,7 +79,7 @@ pub fn untuple_arguments_if_necessary<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, } match inputs[inputs.len() - 1].sty { - ty::ty_tup(ref tupled_arguments) => { + ty::TyTuple(ref tupled_arguments) => { debug!("untuple_arguments_if_necessary(): untupling arguments"); for &tupled_argument in tupled_arguments { result.push(tupled_argument); @@ -147,7 +147,7 @@ pub fn type_of_rust_fn<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, // Given a function type and a count of ty params, construct an llvm type pub fn type_of_fn_from_ty<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, fty: Ty<'tcx>) -> Type { match fty.sty { - ty::ty_bare_fn(_, ref f) => { + 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 { @@ -184,13 +184,13 @@ pub fn sizing_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Typ Type::struct_(cx, &[Type::i8p(cx), Type::i8p(cx)], false) } - ty::ty_bool => Type::bool(cx), - ty::ty_char => Type::char(cx), - ty::ty_int(t) => Type::int_from_ty(cx, t), - ty::ty_uint(t) => Type::uint_from_ty(cx, t), - ty::ty_float(t) => Type::float_from_ty(cx, t), + ty::TyBool => Type::bool(cx), + ty::TyChar => Type::char(cx), + ty::TyInt(t) => Type::int_from_ty(cx, t), + ty::TyUint(t) => Type::uint_from_ty(cx, t), + ty::TyFloat(t) => Type::float_from_ty(cx, t), - ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) | ty::ty_ptr(ty::mt{ty, ..}) => { + ty::TyBox(ty) | ty::TyRef(_, ty::mt{ty, ..}) | ty::TyRawPtr(ty::mt{ty, ..}) => { if type_is_sized(cx.tcx(), ty) { Type::i8p(cx) } else { @@ -198,25 +198,25 @@ pub fn sizing_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Typ } } - ty::ty_bare_fn(..) => Type::i8p(cx), + ty::TyBareFn(..) => Type::i8p(cx), - ty::ty_vec(ty, Some(size)) => { + ty::TyArray(ty, Some(size)) => { let llty = sizing_type_of(cx, ty); let size = size as u64; ensure_array_fits_in_address_space(cx, llty, size, t); Type::array(&llty, size) } - ty::ty_tup(ref tys) if tys.is_empty() => { + ty::TyTuple(ref tys) if tys.is_empty() => { Type::nil(cx) } - ty::ty_tup(..) | ty::ty_enum(..) | ty::ty_closure(..) => { + ty::TyTuple(..) | ty::TyEnum(..) | ty::TyClosure(..) => { let repr = adt::represent_type(cx, t); adt::sizing_type_of(cx, &*repr, false) } - ty::ty_struct(..) => { + ty::TyStruct(..) => { if ty::type_is_simd(cx.tcx(), t) { let llet = type_of(cx, ty::simd_type(cx.tcx(), t)); let n = ty::simd_size(cx.tcx(), t) as u64; @@ -228,11 +228,11 @@ pub fn sizing_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Typ } } - ty::ty_projection(..) | ty::ty_infer(..) | ty::ty_param(..) | ty::ty_err(..) => { + ty::TyProjection(..) | ty::TyInfer(..) | ty::TyParam(..) | ty::TyError(..) => { cx.sess().bug(&format!("fictitious type {} in sizing_type_of()", ppaux::ty_to_string(cx.tcx(), t))) } - ty::ty_vec(_, None) | ty::ty_trait(..) | ty::ty_str => unreachable!() + ty::TyArray(_, None) | ty::TyTrait(..) | ty::TyStr => unreachable!() }; cx.llsizingtypes().borrow_mut().insert(t, llsizingty); @@ -323,12 +323,12 @@ pub fn in_memory_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> } let mut llty = match t.sty { - ty::ty_bool => Type::bool(cx), - ty::ty_char => Type::char(cx), - ty::ty_int(t) => Type::int_from_ty(cx, t), - ty::ty_uint(t) => Type::uint_from_ty(cx, t), - ty::ty_float(t) => Type::float_from_ty(cx, t), - ty::ty_enum(did, ref substs) => { + ty::TyBool => Type::bool(cx), + ty::TyChar => Type::char(cx), + ty::TyInt(t) => Type::int_from_ty(cx, t), + ty::TyUint(t) => Type::uint_from_ty(cx, t), + ty::TyFloat(t) => Type::float_from_ty(cx, t), + ty::TyEnum(did, ref substs) => { // Only create the named struct, but don't fill it in. We // fill it in *after* placing it into the type cache. This // avoids creating more than one copy of the enum when one @@ -338,7 +338,7 @@ pub fn in_memory_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> let name = llvm_type_name(cx, did, tps); adt::incomplete_type_of(cx, &*repr, &name[..]) } - ty::ty_closure(..) => { + ty::TyClosure(..) => { // Only create the named struct, but don't fill it in. We // fill it in *after* placing it into the type cache. let repr = adt::represent_type(cx, t); @@ -349,9 +349,9 @@ pub fn in_memory_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> adt::incomplete_type_of(cx, &*repr, "closure") } - ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) | ty::ty_ptr(ty::mt{ty, ..}) => { + ty::TyBox(ty) | ty::TyRef(_, ty::mt{ty, ..}) | ty::TyRawPtr(ty::mt{ty, ..}) => { if !type_is_sized(cx.tcx(), ty) { - if let ty::ty_str = ty.sty { + if let ty::TyStr = ty.sty { // This means we get a nicer name in the output (str is always // unsized). cx.tn().find_type("str_slice").unwrap() @@ -359,10 +359,10 @@ pub fn in_memory_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> let ptr_ty = in_memory_type_of(cx, ty).ptr_to(); let unsized_part = ty::struct_tail(cx.tcx(), ty); let info_ty = match unsized_part.sty { - ty::ty_str | ty::ty_vec(..) => { + ty::TyStr | ty::TyArray(..) => { Type::uint_from_ty(cx, ast::TyUs) } - ty::ty_trait(_) => Type::vtable_ptr(cx), + ty::TyTrait(_) => Type::vtable_ptr(cx), _ => panic!("Unexpected type returned from \ struct_tail: {} for ty={}", unsized_part.repr(cx.tcx()), ty.repr(cx.tcx())) @@ -374,7 +374,7 @@ pub fn in_memory_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> } } - ty::ty_vec(ty, Some(size)) => { + ty::TyArray(ty, Some(size)) => { let size = size as u64; let llty = in_memory_type_of(cx, ty); ensure_array_fits_in_address_space(cx, llty, size, t); @@ -385,18 +385,18 @@ pub fn in_memory_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> // traits have the type of u8. This is so that the data pointer inside // fat pointers is of the right type (e.g. for array accesses), even // when taking the address of an unsized field in a struct. - ty::ty_vec(ty, None) => in_memory_type_of(cx, ty), - ty::ty_str | ty::ty_trait(..) => Type::i8(cx), + ty::TyArray(ty, None) => in_memory_type_of(cx, ty), + ty::TyStr | ty::TyTrait(..) => Type::i8(cx), - ty::ty_bare_fn(..) => { + ty::TyBareFn(..) => { type_of_fn_from_ty(cx, t).ptr_to() } - ty::ty_tup(ref tys) if tys.is_empty() => Type::nil(cx), - ty::ty_tup(..) => { + ty::TyTuple(ref tys) if tys.is_empty() => Type::nil(cx), + ty::TyTuple(..) => { let repr = adt::represent_type(cx, t); adt::type_of(cx, &*repr) } - ty::ty_struct(did, ref substs) => { + ty::TyStruct(did, ref substs) => { if ty::type_is_simd(cx.tcx(), t) { let llet = in_memory_type_of(cx, ty::simd_type(cx.tcx(), t)); let n = ty::simd_size(cx.tcx(), t) as u64; @@ -413,10 +413,10 @@ pub fn in_memory_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> } } - ty::ty_infer(..) => cx.sess().bug("type_of with ty_infer"), - ty::ty_projection(..) => cx.sess().bug("type_of with ty_projection"), - ty::ty_param(..) => cx.sess().bug("type_of with ty_param"), - ty::ty_err(..) => cx.sess().bug("type_of with ty_err"), + ty::TyInfer(..) => cx.sess().bug("type_of with TyInfer"), + ty::TyProjection(..) => cx.sess().bug("type_of with TyProjection"), + ty::TyParam(..) => cx.sess().bug("type_of with ty_param"), + ty::TyError(..) => cx.sess().bug("type_of with TyError"), }; debug!("--> mapped t={} {:?} to llty={}", @@ -428,7 +428,7 @@ pub fn in_memory_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> // If this was an enum or struct, fill in the type now. match t.sty { - ty::ty_enum(..) | ty::ty_struct(..) | ty::ty_closure(..) + ty::TyEnum(..) | ty::TyStruct(..) | ty::TyClosure(..) if !ty::type_is_simd(cx.tcx(), t) => { let repr = adt::represent_type(cx, t); adt::finish_type_of(cx, &*repr, &mut llty); diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index fbcfe9f218f..cb3d5bd9bf9 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -1040,7 +1040,7 @@ fn make_object_type<'tcx>(this: &AstConv<'tcx>, bounds: ty::ExistentialBounds<'tcx>) -> Ty<'tcx> { let tcx = this.tcx(); - let object = ty::TyTrait { + let object = ty::TraitTy { principal: principal, bounds: bounds }; @@ -1224,8 +1224,8 @@ fn associated_path_def_to_ty<'tcx>(this: &AstConv<'tcx>, _ => unreachable!() } } - (&ty::ty_param(_), def::DefTyParam(..)) | - (&ty::ty_param(_), def::DefSelfTy(Some(_), None)) => { + (&ty::TyParam(_), def::DefTyParam(..)) | + (&ty::TyParam(_), def::DefSelfTy(Some(_), None)) => { // A type parameter or Self, we need to find the associated item from // a bound. let ty_param_node_id = ty_path_def.local_node_id(); @@ -1471,7 +1471,7 @@ pub fn finish_resolving_def_to_ty<'tcx>(this: &AstConv<'tcx>, let mut def = *def; // If any associated type segments remain, attempt to resolve them. for segment in assoc_segments { - if ty.sty == ty::ty_err { + if ty.sty == ty::TyError { break; } // This is pretty bad (it will fail except for T::A and Self::A). @@ -1529,7 +1529,7 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx>, } ast::TyRptr(ref region, ref mt) => { let r = opt_ast_region_to_region(this, rscope, ast_ty.span, region); - debug!("ty_rptr r={}", r.repr(this.tcx())); + debug!("TyRef r={}", r.repr(this.tcx())); let rscope1 = &ObjectLifetimeDefaultRscope::new( rscope, @@ -1583,7 +1583,7 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx>, &path.segments[..base_ty_end], &path.segments[base_ty_end..]); - if path_res.depth != 0 && ty.sty != ty::ty_err { + if path_res.depth != 0 && ty.sty != ty::TyError { // Write back the new resolution. tcx.def_map.borrow_mut().insert(ast_ty.id, def::PathResolution { base_def: def, @@ -1853,8 +1853,8 @@ fn determine_explicit_self_category<'a, 'tcx>(this: &AstConv<'tcx>, ty::ByValueExplicitSelfCategory } else { match explicit_type.sty { - ty::ty_rptr(r, mt) => ty::ByReferenceExplicitSelfCategory(*r, mt.mutbl), - ty::ty_uniq(_) => ty::ByBoxExplicitSelfCategory, + ty::TyRef(r, mt) => ty::ByReferenceExplicitSelfCategory(*r, mt.mutbl), + ty::TyBox(_) => ty::ByBoxExplicitSelfCategory, _ => ty::ByValueExplicitSelfCategory, } } @@ -1863,8 +1863,8 @@ fn determine_explicit_self_category<'a, 'tcx>(this: &AstConv<'tcx>, fn count_modifiers(ty: Ty) -> usize { match ty.sty { - ty::ty_rptr(_, mt) => count_modifiers(mt.ty) + 1, - ty::ty_uniq(t) => count_modifiers(t) + 1, + ty::TyRef(_, mt) => count_modifiers(mt.ty) + 1, + ty::TyBox(t) => count_modifiers(t) + 1, _ => 0, } } diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs index 0e3280c44be..3df93ee7dbf 100644 --- a/src/librustc_typeck/check/_match.rs +++ b/src/librustc_typeck/check/_match.rs @@ -58,8 +58,8 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, if let ast::ExprLit(ref lt) = lt.node { if let ast::LitBinary(_) = lt.node { let expected_ty = structurally_resolved_type(fcx, pat.span, expected); - if let ty::ty_rptr(_, mt) = expected_ty.sty { - if let ty::ty_vec(_, None) = mt.ty.sty { + if let ty::TyRef(_, mt) = expected_ty.sty { + if let ty::TyArray(_, None) = mt.ty.sty { pat_ty = ty::mk_slice(tcx, tcx.mk_region(ty::ReStatic), ty::mt{ ty: tcx.types.u8, mutbl: ast::MutImmutable }) } @@ -293,7 +293,7 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, let expected_ty = structurally_resolved_type(fcx, pat.span, expected); let inner_ty = fcx.infcx().next_ty_var(); let pat_ty = match expected_ty.sty { - ty::ty_vec(_, Some(size)) => ty::mk_vec(tcx, inner_ty, Some({ + ty::TyArray(_, Some(size)) => ty::mk_vec(tcx, inner_ty, Some({ let min_len = before.len() + after.len(); match *slice { Some(_) => cmp::max(min_len, size), @@ -413,7 +413,7 @@ pub fn check_dereferencable<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, if pat_is_binding(&tcx.def_map, inner) { let expected = fcx.infcx().shallow_resolve(expected); ty::deref(expected, true).map_or(true, |mt| match mt.ty.sty { - ty::ty_trait(_) => { + ty::TyTrait(_) => { // This is "x = SomeTrait" being reduced from // "let &x = &SomeTrait" or "let box x = Box<SomeTrait>", an error. span_err!(tcx.sess, span, E0033, @@ -558,9 +558,9 @@ pub fn check_pat_struct<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, pat: &'tcx ast::Pat, _ => { let def_type = ty::lookup_item_type(tcx, def.def_id()); match def_type.ty.sty { - ty::ty_struct(struct_def_id, _) => + ty::TyStruct(struct_def_id, _) => (struct_def_id, struct_def_id), - ty::ty_enum(enum_def_id, _) + ty::TyEnum(enum_def_id, _) if def == def::DefVariant(enum_def_id, def.def_id(), true) => (enum_def_id, def.def_id()), _ => { @@ -662,7 +662,7 @@ pub fn check_pat_enum<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, let real_path_ty = fcx.node_ty(pat.id); let (arg_tys, kind_name): (Vec<_>, &'static str) = match real_path_ty.sty { - ty::ty_enum(enum_def_id, expected_substs) + ty::TyEnum(enum_def_id, expected_substs) if def == def::DefVariant(enum_def_id, def.def_id(), false) => { let variant = ty::enum_variant_with_id(tcx, enum_def_id, def.def_id()); @@ -671,7 +671,7 @@ pub fn check_pat_enum<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, .collect(), "variant") } - ty::ty_struct(struct_def_id, expected_substs) => { + ty::TyStruct(struct_def_id, expected_substs) => { let struct_fields = ty::struct_fields(tcx, struct_def_id, expected_substs); (struct_fields.iter() .map(|field| fcx.instantiate_type_scheme(pat.span, diff --git a/src/librustc_typeck/check/callee.rs b/src/librustc_typeck/check/callee.rs index 30ebcb756f7..aa2433a362a 100644 --- a/src/librustc_typeck/check/callee.rs +++ b/src/librustc_typeck/check/callee.rs @@ -127,12 +127,12 @@ fn try_overloaded_call_step<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // If the callee is a bare function or a closure, then we're all set. match structurally_resolved_type(fcx, callee_expr.span, adjusted_ty).sty { - ty::ty_bare_fn(..) => { + ty::TyBareFn(..) => { fcx.write_autoderef_adjustment(callee_expr.id, autoderefs); return Some(CallStep::Builtin); } - ty::ty_closure(def_id, substs) => { + ty::TyClosure(def_id, substs) => { assert_eq!(def_id.krate, ast::LOCAL_CRATE); // Check whether this is a call to a closure where we @@ -165,7 +165,7 @@ fn try_overloaded_call_step<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // over the top. The simplest fix by far is to just ignore // this case and deref again, so we wind up with // `FnMut::call_mut(&mut *x, ())`. - ty::ty_rptr(..) if autoderefs == 0 => { + ty::TyRef(..) if autoderefs == 0 => { return None; } @@ -222,7 +222,7 @@ fn confirm_builtin_call<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>, let error_fn_sig; let fn_sig = match callee_ty.sty { - ty::ty_bare_fn(_, &ty::BareFnTy {ref sig, ..}) => { + ty::TyBareFn(_, &ty::BareFnTy {ref sig, ..}) => { sig } _ => { diff --git a/src/librustc_typeck/check/cast.rs b/src/librustc_typeck/check/cast.rs index b8457229292..04a357b6c11 100644 --- a/src/librustc_typeck/check/cast.rs +++ b/src/librustc_typeck/check/cast.rs @@ -74,17 +74,17 @@ fn unsize_kind<'a,'tcx>(fcx: &FnCtxt<'a, 'tcx>, t: Ty<'tcx>) -> Option<UnsizeKind<'tcx>> { match t.sty { - ty::ty_vec(_, None) | ty::ty_str => Some(UnsizeKind::Length), - ty::ty_trait(_) => Some(UnsizeKind::Vtable), - ty::ty_struct(did, substs) => { + ty::TyArray(_, None) | ty::TyStr => Some(UnsizeKind::Length), + ty::TyTrait(_) => Some(UnsizeKind::Vtable), + ty::TyStruct(did, substs) => { match ty::struct_fields(fcx.tcx(), did, substs).pop() { None => None, Some(f) => unsize_kind(fcx, f.mt.ty) } } // We should really try to normalize here. - ty::ty_projection(ref pi) => Some(UnsizeKind::OfProjection(pi)), - ty::ty_param(ref p) => Some(UnsizeKind::OfParam(p)), + ty::TyProjection(ref pi) => Some(UnsizeKind::OfProjection(pi)), + ty::TyParam(ref p) => Some(UnsizeKind::OfParam(p)), _ => None } } @@ -337,7 +337,7 @@ impl<'tcx> CastCheck<'tcx> { // array-ptr-cast. if m_expr.mutbl == ast::MutImmutable && m_cast.mutbl == ast::MutImmutable { - if let ty::ty_vec(ety, Some(_)) = m_expr.ty.sty { + if let ty::TyArray(ety, Some(_)) = m_expr.ty.sty { // Due to the limitations of LLVM global constants, // region pointers end up pointing at copies of // vector elements instead of the original values. diff --git a/src/librustc_typeck/check/closure.rs b/src/librustc_typeck/check/closure.rs index d2a06fcf990..cac0a86124e 100644 --- a/src/librustc_typeck/check/closure.rs +++ b/src/librustc_typeck/check/closure.rs @@ -107,7 +107,7 @@ fn deduce_expectations_from_expected_type<'a,'tcx>( expected_ty.repr(fcx.tcx())); match expected_ty.sty { - ty::ty_trait(ref object_type) => { + ty::TyTrait(ref object_type) => { let proj_bounds = object_type.projection_bounds_with_self_ty(fcx.tcx(), fcx.tcx().types.err); let sig = proj_bounds.iter() @@ -116,7 +116,7 @@ fn deduce_expectations_from_expected_type<'a,'tcx>( let kind = fcx.tcx().lang_items.fn_trait_kind(object_type.principal_def_id()); (sig, kind) } - ty::ty_infer(ty::TyVar(vid)) => { + ty::TyInfer(ty::TyVar(vid)) => { deduce_expectations_from_obligations(fcx, vid) } _ => { @@ -214,7 +214,7 @@ fn deduce_sig_from_projection<'a,'tcx>( debug!("deduce_sig_from_projection: arg_param_ty {}", arg_param_ty.repr(tcx)); let input_tys = match arg_param_ty.sty { - ty::ty_tup(ref tys) => { (*tys).clone() } + ty::TyTuple(ref tys) => { (*tys).clone() } _ => { return None; } }; debug!("deduce_sig_from_projection: input_tys {}", input_tys.repr(tcx)); @@ -244,7 +244,7 @@ fn self_type_matches_expected_vid<'a,'tcx>( trait_ref.repr(fcx.tcx()), self_ty.repr(fcx.tcx())); match self_ty.sty { - ty::ty_infer(ty::TyVar(v)) if expected_vid == v => Some(trait_ref), + ty::TyInfer(ty::TyVar(v)) if expected_vid == v => Some(trait_ref), _ => None, } } diff --git a/src/librustc_typeck/check/coercion.rs b/src/librustc_typeck/check/coercion.rs index c33ed87a5c2..91b31bd0bc9 100644 --- a/src/librustc_typeck/check/coercion.rs +++ b/src/librustc_typeck/check/coercion.rs @@ -121,13 +121,13 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { // Note: does not attempt to resolve type variables we encounter. // See above for details. match b.sty { - ty::ty_ptr(mt_b) => { + ty::TyRawPtr(mt_b) => { return self.unpack_actual_value(a, |a| { self.coerce_unsafe_ptr(a, b, mt_b.mutbl) }); } - ty::ty_rptr(_, mt_b) => { + ty::TyRef(_, mt_b) => { return self.unpack_actual_value(a, |a| { self.coerce_borrowed_pointer(expr_a, a, b, mt_b.mutbl) }); @@ -138,13 +138,13 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { self.unpack_actual_value(a, |a| { match a.sty { - ty::ty_bare_fn(Some(_), a_f) => { + ty::TyBareFn(Some(_), a_f) => { // Function items are coercible to any closure // type; function pointers are not (that would // require double indirection). self.coerce_from_fn_item(a, a_f, b) } - ty::ty_bare_fn(None, a_f) => { + ty::TyBareFn(None, a_f) => { // We permit coercion of fn pointers to drop the // unsafe qualifier. self.coerce_from_fn_pointer(a, a_f, b) @@ -177,7 +177,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { // yield. match a.sty { - ty::ty_rptr(_, mt_a) => { + ty::TyRef(_, mt_a) => { try!(coerce_mutbls(mt_a.mutbl, mutbl_b)); } _ => return self.subtype(a, b) @@ -258,7 +258,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { // Handle reborrows before selecting `Source: CoerceUnsized<Target>`. let (source, reborrow) = match (&source.sty, &target.sty) { - (&ty::ty_rptr(_, mt_a), &ty::ty_rptr(_, mt_b)) => { + (&ty::TyRef(_, mt_a), &ty::TyRef(_, mt_b)) => { try!(coerce_mutbls(mt_a.mutbl, mt_b.mutbl)); let coercion = Coercion(self.origin.span()); @@ -266,7 +266,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { let region = self.tcx().mk_region(r_borrow); (mt_a.ty, Some(ty::AutoPtr(region, mt_b.mutbl))) } - (&ty::ty_rptr(_, mt_a), &ty::ty_ptr(mt_b)) => { + (&ty::TyRef(_, mt_a), &ty::TyRawPtr(mt_b)) => { try!(coerce_mutbls(mt_a.mutbl, mt_b.mutbl)); (mt_a.ty, Some(ty::AutoUnsafe(mt_b.mutbl))) } @@ -355,7 +355,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { debug!("coerce_from_fn_pointer(a={}, b={})", a.repr(self.tcx()), b.repr(self.tcx())); - if let ty::ty_bare_fn(None, fn_ty_b) = b.sty { + if let ty::TyBareFn(None, fn_ty_b) = b.sty { match (fn_ty_a.unsafety, fn_ty_b.unsafety) { (ast::Unsafety::Normal, ast::Unsafety::Unsafe) => { let unsafe_a = self.tcx().safe_to_unsafe_fn_ty(fn_ty_a); @@ -384,7 +384,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { a.repr(self.tcx()), b.repr(self.tcx())); match b.sty { - ty::ty_bare_fn(None, _) => { + ty::TyBareFn(None, _) => { let a_fn_pointer = ty::mk_bare_fn(self.tcx(), None, fn_ty_a); try!(self.subtype(a_fn_pointer, b)); Ok(Some(ty::AdjustReifyFnPointer)) @@ -404,7 +404,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { b.repr(self.tcx())); let mt_a = match a.sty { - ty::ty_rptr(_, mt) | ty::ty_ptr(mt) => mt, + ty::TyRef(_, mt) | ty::TyRawPtr(mt) => mt, _ => { return self.subtype(a, b); } diff --git a/src/librustc_typeck/check/dropck.rs b/src/librustc_typeck/check/dropck.rs index d95bdd01e22..6e6231dec32 100644 --- a/src/librustc_typeck/check/dropck.rs +++ b/src/librustc_typeck/check/dropck.rs @@ -41,9 +41,9 @@ pub fn check_drop_impl(tcx: &ty::ctxt, drop_impl_did: ast::DefId) -> Result<(), ty: ref dtor_self_type } = ty::lookup_item_type(tcx, drop_impl_did); let dtor_predicates = ty::lookup_predicates(tcx, drop_impl_did); match dtor_self_type.sty { - ty::ty_enum(self_type_did, self_to_impl_substs) | - ty::ty_struct(self_type_did, self_to_impl_substs) | - ty::ty_closure(self_type_did, self_to_impl_substs) => { + ty::TyEnum(self_type_did, self_to_impl_substs) | + ty::TyStruct(self_type_did, self_to_impl_substs) | + ty::TyClosure(self_type_did, self_to_impl_substs) => { try!(ensure_drop_params_and_item_params_correspond(tcx, drop_impl_did, dtor_generics, @@ -366,7 +366,7 @@ fn iterate_over_potentially_unsafe_regions_in_type<'a, 'tcx>( // with `T`, the type it represents as owned by the // surrounding context, before doing further analysis. let (typ, xref_depth) = match typ.sty { - ty::ty_struct(struct_did, substs) => { + ty::TyStruct(struct_did, substs) => { if opt_phantom_data_def_id == Some(struct_did) { let item_type = ty::lookup_item_type(rcx.tcx(), struct_did); let tp_def = item_type.generics.types @@ -380,11 +380,11 @@ fn iterate_over_potentially_unsafe_regions_in_type<'a, 'tcx>( } } - // Note: When ty_uniq is removed from compiler, the + // Note: When TyBox is removed from compiler, the // definition of `Box<T>` must carry a PhantomData that // puts us into the previous case. - ty::ty_uniq(new_typ) => { - debug!("replacing ty_uniq {} with {}", + ty::TyBox(new_typ) => { + debug!("replacing TyBox {} with {}", typ.repr(rcx.tcx()), new_typ.repr(rcx.tcx())); (new_typ, xref_depth_orig + 1) } @@ -395,14 +395,14 @@ fn iterate_over_potentially_unsafe_regions_in_type<'a, 'tcx>( }; let dtor_kind = match typ.sty { - ty::ty_enum(def_id, _) | - ty::ty_struct(def_id, _) => { + ty::TyEnum(def_id, _) | + ty::TyStruct(def_id, _) => { match destructor_for_type.get(&def_id) { Some(def_id) => DtorKind::KnownDropMethod(*def_id), None => DtorKind::PureRecur, } } - ty::ty_trait(ref ty_trait) => { + ty::TyTrait(ref ty_trait) => { DtorKind::Unknown(ty_trait.bounds.clone()) } _ => DtorKind::PureRecur, @@ -466,7 +466,7 @@ fn iterate_over_potentially_unsafe_regions_in_type<'a, 'tcx>( // destructor. match typ.sty { - ty::ty_struct(struct_did, substs) => { + ty::TyStruct(struct_did, substs) => { debug!("typ: {} is struct; traverse structure and not type-expression", typ.repr(rcx.tcx())); // Don't recurse; we extract type's substructure, @@ -496,7 +496,7 @@ fn iterate_over_potentially_unsafe_regions_in_type<'a, 'tcx>( } } - ty::ty_enum(enum_did, substs) => { + ty::TyEnum(enum_did, substs) => { debug!("typ: {} is enum; traverse structure and not type-expression", typ.repr(rcx.tcx())); // Don't recurse; we extract type's substructure, @@ -526,7 +526,7 @@ fn iterate_over_potentially_unsafe_regions_in_type<'a, 'tcx>( } } - ty::ty_rptr(..) | ty::ty_ptr(_) | ty::ty_bare_fn(..) => { + ty::TyRef(..) | ty::TyRawPtr(_) | ty::TyBareFn(..) => { // Don't recurse, since references, pointers, // and bare functions don't own instances // of the types appearing within them. diff --git a/src/librustc_typeck/check/method/confirm.rs b/src/librustc_typeck/check/method/confirm.rs index c068bfaa82e..bd482a4c787 100644 --- a/src/librustc_typeck/check/method/confirm.rs +++ b/src/librustc_typeck/check/method/confirm.rs @@ -296,7 +296,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { } fn extract_trait_ref<R, F>(&mut self, self_ty: Ty<'tcx>, mut closure: F) -> R where - F: FnMut(&mut ConfirmContext<'a, 'tcx>, Ty<'tcx>, &ty::TyTrait<'tcx>) -> R, + F: FnMut(&mut ConfirmContext<'a, 'tcx>, Ty<'tcx>, &ty::TraitTy<'tcx>) -> R, { // If we specified that this is an object method, then the // self-type ought to be something that can be dereferenced to @@ -311,7 +311,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { NoPreference, |ty, _| { match ty.sty { - ty::ty_trait(ref data) => Some(closure(self, ty, &**data)), + ty::TyTrait(ref data) => Some(closure(self, ty, &**data)), _ => None, } }); @@ -456,12 +456,12 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { fn fixup_derefs_on_method_receiver_if_necessary(&self, method_callee: &MethodCallee) { let sig = match method_callee.ty.sty { - ty::ty_bare_fn(_, ref f) => f.sig.clone(), + ty::TyBareFn(_, ref f) => f.sig.clone(), _ => return, }; match sig.0.inputs[0].sty { - ty::ty_rptr(_, ty::mt { + ty::TyRef(_, ty::mt { ty: _, mutbl: ast::MutMutable, }) => {} diff --git a/src/librustc_typeck/check/method/mod.rs b/src/librustc_typeck/check/method/mod.rs index 90df0b853a0..bb620c6ecd8 100644 --- a/src/librustc_typeck/check/method/mod.rs +++ b/src/librustc_typeck/check/method/mod.rs @@ -254,7 +254,7 @@ pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // Trait method is fn(&self) or fn(&mut self), need an // autoref. Pull the region etc out of the type of first argument. match transformed_self_ty.sty { - ty::ty_rptr(region, ty::mt { mutbl, ty: _ }) => { + ty::TyRef(region, ty::mt { mutbl, ty: _ }) => { fcx.write_adjustment(self_expr.id, ty::AdjustDerefRef(ty::AutoDerefRef { autoderefs: autoderefs, diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index 1b176015a3a..e7fd6f7834a 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -202,7 +202,7 @@ fn create_steps<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, }); match final_ty.sty { - ty::ty_vec(elem_ty, Some(_)) => { + ty::TyArray(elem_ty, Some(_)) => { let slice_ty = ty::mk_vec(fcx.tcx(), elem_ty, None); steps.push(CandidateStep { self_ty: slice_ty, @@ -210,7 +210,7 @@ fn create_steps<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, unsize: true }); } - ty::ty_err => return None, + ty::TyError => return None, _ => (), } @@ -270,88 +270,88 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { self_ty.repr(self.tcx())); match self_ty.sty { - ty::ty_trait(box ref data) => { + ty::TyTrait(box ref data) => { self.assemble_inherent_candidates_from_object(self_ty, data); self.assemble_inherent_impl_candidates_for_type(data.principal_def_id()); } - ty::ty_enum(did, _) | - ty::ty_struct(did, _) | - ty::ty_closure(did, _) => { + ty::TyEnum(did, _) | + ty::TyStruct(did, _) | + ty::TyClosure(did, _) => { self.assemble_inherent_impl_candidates_for_type(did); } - ty::ty_uniq(_) => { + ty::TyBox(_) => { if let Some(box_did) = self.tcx().lang_items.owned_box() { self.assemble_inherent_impl_candidates_for_type(box_did); } } - ty::ty_param(p) => { + ty::TyParam(p) => { self.assemble_inherent_candidates_from_param(self_ty, p); } - ty::ty_char => { + ty::TyChar => { let lang_def_id = self.tcx().lang_items.char_impl(); self.assemble_inherent_impl_for_primitive(lang_def_id); } - ty::ty_str => { + ty::TyStr => { let lang_def_id = self.tcx().lang_items.str_impl(); self.assemble_inherent_impl_for_primitive(lang_def_id); } - ty::ty_vec(_, None) => { + ty::TyArray(_, None) => { let lang_def_id = self.tcx().lang_items.slice_impl(); self.assemble_inherent_impl_for_primitive(lang_def_id); } - ty::ty_ptr(ty::mt { ty: _, mutbl: ast::MutImmutable }) => { + ty::TyRawPtr(ty::mt { ty: _, mutbl: ast::MutImmutable }) => { let lang_def_id = self.tcx().lang_items.const_ptr_impl(); self.assemble_inherent_impl_for_primitive(lang_def_id); } - ty::ty_ptr(ty::mt { ty: _, mutbl: ast::MutMutable }) => { + ty::TyRawPtr(ty::mt { ty: _, mutbl: ast::MutMutable }) => { let lang_def_id = self.tcx().lang_items.mut_ptr_impl(); self.assemble_inherent_impl_for_primitive(lang_def_id); } - ty::ty_int(ast::TyI8) => { + ty::TyInt(ast::TyI8) => { let lang_def_id = self.tcx().lang_items.i8_impl(); self.assemble_inherent_impl_for_primitive(lang_def_id); } - ty::ty_int(ast::TyI16) => { + ty::TyInt(ast::TyI16) => { let lang_def_id = self.tcx().lang_items.i16_impl(); self.assemble_inherent_impl_for_primitive(lang_def_id); } - ty::ty_int(ast::TyI32) => { + ty::TyInt(ast::TyI32) => { let lang_def_id = self.tcx().lang_items.i32_impl(); self.assemble_inherent_impl_for_primitive(lang_def_id); } - ty::ty_int(ast::TyI64) => { + ty::TyInt(ast::TyI64) => { let lang_def_id = self.tcx().lang_items.i64_impl(); self.assemble_inherent_impl_for_primitive(lang_def_id); } - ty::ty_int(ast::TyIs) => { + ty::TyInt(ast::TyIs) => { let lang_def_id = self.tcx().lang_items.isize_impl(); self.assemble_inherent_impl_for_primitive(lang_def_id); } - ty::ty_uint(ast::TyU8) => { + ty::TyUint(ast::TyU8) => { let lang_def_id = self.tcx().lang_items.u8_impl(); self.assemble_inherent_impl_for_primitive(lang_def_id); } - ty::ty_uint(ast::TyU16) => { + ty::TyUint(ast::TyU16) => { let lang_def_id = self.tcx().lang_items.u16_impl(); self.assemble_inherent_impl_for_primitive(lang_def_id); } - ty::ty_uint(ast::TyU32) => { + ty::TyUint(ast::TyU32) => { let lang_def_id = self.tcx().lang_items.u32_impl(); self.assemble_inherent_impl_for_primitive(lang_def_id); } - ty::ty_uint(ast::TyU64) => { + ty::TyUint(ast::TyU64) => { let lang_def_id = self.tcx().lang_items.u64_impl(); self.assemble_inherent_impl_for_primitive(lang_def_id); } - ty::ty_uint(ast::TyUs) => { + ty::TyUint(ast::TyUs) => { let lang_def_id = self.tcx().lang_items.usize_impl(); self.assemble_inherent_impl_for_primitive(lang_def_id); } - ty::ty_float(ast::TyF32) => { + ty::TyFloat(ast::TyF32) => { let lang_def_id = self.tcx().lang_items.f32_impl(); self.assemble_inherent_impl_for_primitive(lang_def_id); } - ty::ty_float(ast::TyF64) => { + ty::TyFloat(ast::TyF64) => { let lang_def_id = self.tcx().lang_items.f64_impl(); self.assemble_inherent_impl_for_primitive(lang_def_id); } @@ -413,7 +413,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { fn assemble_inherent_candidates_from_object(&mut self, self_ty: Ty<'tcx>, - data: &ty::TyTrait<'tcx>) { + data: &ty::TraitTy<'tcx>) { debug!("assemble_inherent_candidates_from_object(self_ty={})", self_ty.repr(self.tcx())); @@ -460,7 +460,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { match *predicate { ty::Predicate::Trait(ref trait_predicate) => { match trait_predicate.0.trait_ref.self_ty().sty { - ty::ty_param(ref p) if *p == param_ty => { + ty::TyParam(ref p) if *p == param_ty => { Some(trait_predicate.to_poly_trait_ref()) } _ => None @@ -702,7 +702,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { let steps = self.steps.clone(); for step in steps.iter() { let closure_def_id = match step.self_ty.sty { - ty::ty_closure(a, _) => a, + ty::TyClosure(a, _) => a, _ => continue, }; @@ -759,7 +759,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { step.repr(self.tcx())); let projection_trait_ref = match step.self_ty.sty { - ty::ty_projection(ref data) => &data.trait_ref, + ty::TyProjection(ref data) => &data.trait_ref, _ => continue, }; @@ -924,7 +924,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { pick.autoderefs = step.autoderefs; // Insert a `&*` or `&mut *` if this is a reference type: - if let ty::ty_rptr(_, mt) = step.self_ty.sty { + if let ty::TyRef(_, mt) = step.self_ty.sty { pick.autoderefs += 1; pick.autoref = Some(mt.mutbl); } diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs index 93239df60e1..8a48ef543cc 100644 --- a/src/librustc_typeck/check/method/suggest.rs +++ b/src/librustc_typeck/check/method/suggest.rs @@ -61,7 +61,7 @@ pub fn report_error<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, None); // If the item has the name of a field, give a help note - if let (&ty::ty_struct(did, _), Some(_)) = (&rcvr_ty.sty, rcvr_expr) { + if let (&ty::TyStruct(did, _), Some(_)) = (&rcvr_ty.sty, rcvr_expr) { let fields = ty::lookup_struct_fields(cx, did); if fields.iter().any(|f| f.name == item_name) { cx.sess.span_note(span, @@ -238,11 +238,11 @@ fn type_derefs_to_local<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, rcvr_expr: Option<&ast::Expr>) -> bool { fn is_local(ty: Ty) -> bool { match ty.sty { - ty::ty_enum(did, _) | ty::ty_struct(did, _) => ast_util::is_local(did), + ty::TyEnum(did, _) | ty::TyStruct(did, _) => ast_util::is_local(did), - ty::ty_trait(ref tr) => ast_util::is_local(tr.principal_def_id()), + ty::TyTrait(ref tr) => ast_util::is_local(tr.principal_def_id()), - ty::ty_param(_) => true, + ty::TyParam(_) => true, // everything else (primitive types etc.) is effectively // non-local (there are "edge" cases, e.g. (LocalType,), but diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 601db229c41..8493715aa4b 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -506,7 +506,7 @@ fn check_bare_fn<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, param_env: ty::ParameterEnvironment<'a, 'tcx>) { match raw_fty.sty { - ty::ty_bare_fn(_, ref fn_ty) => { + ty::TyBareFn(_, ref fn_ty) => { let inh = Inherited::new(ccx.tcx, param_env); // Compute the fty from point of view of inside fn. @@ -1142,7 +1142,7 @@ fn report_cast_to_unsized_type<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, format!("cast to unsized type: `{}` as `{}`", actual, tstr) }, t_expr, None); match t_expr.sty { - ty::ty_rptr(_, ty::mt { mutbl: mt, .. }) => { + ty::TyRef(_, ty::mt { mutbl: mt, .. }) => { let mtstr = match mt { ast::MutMutable => "mut ", ast::MutImmutable => "" @@ -1164,7 +1164,7 @@ fn report_cast_to_unsized_type<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, mtstr, tstr); } } - ty::ty_uniq(..) => { + ty::TyBox(..) => { match fcx.tcx().sess.codemap().span_to_snippet(t_span) { Ok(s) => { fcx.tcx().sess.span_suggestion(t_span, @@ -1920,8 +1920,8 @@ impl LvaluePreference { /// Whether `autoderef` requires types to resolve. #[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum UnresolvedTypeAction { - /// Produce an error and return `ty_err` whenever a type cannot - /// be resolved (i.e. it is `ty_infer`). + /// Produce an error and return `TyError` whenever a type cannot + /// be resolved (i.e. it is `TyInfer`). Error, /// Go on without emitting any errors, and return the unresolved /// type. Useful for probing, e.g. in coercions. @@ -2096,7 +2096,7 @@ fn lookup_indexing<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // After we have fully autoderef'd, if the resulting type is [T; n], then // do a final unsized coercion to yield [T]. - if let ty::ty_vec(element_ty, Some(_)) = ty.sty { + if let ty::TyArray(element_ty, Some(_)) = ty.sty { let adjusted_ty = ty::mk_vec(fcx.tcx(), element_ty, None); try_index_step(fcx, MethodCall::expr(expr.id), expr, base_expr, adjusted_ty, autoderefs, true, lvalue_pref, idx_ty) @@ -2134,7 +2134,7 @@ fn try_index_step<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // First, try built-in indexing. match (ty::index(adjusted_ty), &index_ty.sty) { - (Some(ty), &ty::ty_uint(ast::TyUs)) | (Some(ty), &ty::ty_infer(ty::IntVar(_))) => { + (Some(ty), &ty::TyUint(ast::TyUs)) | (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); @@ -2212,7 +2212,7 @@ fn check_method_argument_types<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, ty::FnConverging(fcx.tcx().types.err) } else { match method_fn_ty.sty { - ty::ty_bare_fn(_, ref fty) => { + ty::TyBareFn(_, ref fty) => { // HACK(eddyb) ignore self in the definition (see above). let expected_arg_tys = expected_types_for_fn_args(fcx, sp, @@ -2260,7 +2260,7 @@ fn check_argument_types<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, let formal_tys = if tuple_arguments == TupleArguments { let tuple_type = structurally_resolved_type(fcx, sp, fn_inputs[0]); match tuple_type.sty { - ty::ty_tup(ref arg_types) => { + ty::TyTuple(ref arg_types) => { if arg_types.len() != args.len() { span_err!(tcx.sess, sp, E0057, "this function takes {} parameter{} but {} parameter{} supplied", @@ -2273,7 +2273,7 @@ fn check_argument_types<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, } else { expected_arg_tys = match expected_arg_tys.get(0) { Some(&ty) => match ty.sty { - ty::ty_tup(ref tys) => &**tys, + ty::TyTuple(ref tys) => &**tys, _ => &[] }, None => &[] @@ -2391,21 +2391,21 @@ fn check_argument_types<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, let arg_ty = structurally_resolved_type(fcx, arg.span, fcx.expr_ty(&**arg)); match arg_ty.sty { - ty::ty_float(ast::TyF32) => { + ty::TyFloat(ast::TyF32) => { fcx.type_error_message(arg.span, |t| { format!("can't pass an {} to variadic \ function, cast to c_double", t) }, arg_ty, None); } - ty::ty_int(ast::TyI8) | ty::ty_int(ast::TyI16) | ty::ty_bool => { + ty::TyInt(ast::TyI8) | ty::TyInt(ast::TyI16) | 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::ty_uint(ast::TyU8) | ty::ty_uint(ast::TyU16) => { + ty::TyUint(ast::TyU8) | ty::TyUint(ast::TyU16) => { fcx.type_error_message(arg.span, |t| { format!("can't pass {} to variadic \ function, cast to c_uint", @@ -2455,10 +2455,10 @@ fn check_lit<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, ast::LitInt(_, ast::UnsuffixedIntLit(_)) => { let opt_ty = expected.to_option(fcx).and_then(|ty| { match ty.sty { - ty::ty_int(_) | ty::ty_uint(_) => Some(ty), - ty::ty_char => Some(tcx.types.u8), - ty::ty_ptr(..) => Some(tcx.types.usize), - ty::ty_bare_fn(..) => Some(tcx.types.usize), + ty::TyInt(_) | ty::TyUint(_) => Some(ty), + ty::TyChar => Some(tcx.types.u8), + ty::TyRawPtr(..) => Some(tcx.types.usize), + ty::TyBareFn(..) => Some(tcx.types.usize), _ => None } }); @@ -2469,7 +2469,7 @@ fn check_lit<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, ast::LitFloatUnsuffixed(_) => { let opt_ty = expected.to_option(fcx).and_then(|ty| { match ty.sty { - ty::ty_float(_) => Some(ty), + ty::TyFloat(_) => Some(ty), _ => None } }); @@ -2621,7 +2621,7 @@ fn expected_types_for_fn_args<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, /// strict, _|_ can appear in the type of an expression that does not, /// itself, diverge: for example, fn() -> _|_.) /// Note that inspecting a type's structure *directly* may expose the fact -/// that there are actually multiple representations for `ty_err`, so avoid +/// that there are actually multiple representations for `TyError`, so avoid /// that when err needs to be handled differently. fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, expr: &'tcx ast::Expr, @@ -2746,7 +2746,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, lvalue_pref, |base_t, _| { match base_t.sty { - ty::ty_struct(base_id, substs) => { + ty::TyStruct(base_id, substs) => { debug!("struct named {}", ppaux::ty_to_string(tcx, base_t)); let fields = ty::lookup_struct_fields(tcx, base_id); fcx.lookup_field_ty(expr.span, base_id, &fields[..], @@ -2787,7 +2787,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, actual) }, expr_t, None); - if let ty::ty_struct(did, _) = expr_t.sty { + if let ty::TyStruct(did, _) = expr_t.sty { suggest_field_names(did, field, tcx, vec![]); } } @@ -2848,7 +2848,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, lvalue_pref, |base_t, _| { match base_t.sty { - ty::ty_struct(base_id, substs) => { + ty::TyStruct(base_id, substs) => { tuple_like = ty::is_tuple_struct(tcx, base_id); if tuple_like { debug!("tuple struct named {}", ppaux::ty_to_string(tcx, base_t)); @@ -2859,7 +2859,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, None } } - ty::ty_tup(ref v) => { + ty::TyTuple(ref v) => { tuple_like = true; if idx.node < v.len() { Some(v[idx.node]) } else { None } } @@ -3138,7 +3138,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, let expected_inner = expected.to_option(fcx).map_or(NoExpectation, |ty| { match unop { ast::UnUniq => match ty.sty { - ty::ty_uniq(ty) => { + ty::TyBox(ty) => { Expectation::rvalue_hint(ty) } _ => { @@ -3188,7 +3188,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, oprnd_t = structurally_resolved_type(fcx, oprnd.span, oprnd_t); if !(ty::type_is_integral(oprnd_t) || - oprnd_t.sty == ty::ty_bool) { + oprnd_t.sty == ty::TyBool) { oprnd_t = op::check_user_unop(fcx, "!", "not", tcx.lang_items.not_trait(), expr, &**oprnd, oprnd_t, unop); @@ -3203,7 +3203,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, tcx.lang_items.neg_trait(), expr, &**oprnd, oprnd_t, unop); } - if let ty::ty_uint(_) = oprnd_t.sty { + if let ty::TyUint(_) = oprnd_t.sty { if !tcx.sess.features.borrow().negate_unsigned { feature_gate::emit_feature_err( &tcx.sess.parse_sess.span_diagnostic, @@ -3220,7 +3220,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, ast::ExprAddrOf(mutbl, ref oprnd) => { let hint = expected.only_has_type(fcx).map_or(NoExpectation, |ty| { match ty.sty { - ty::ty_rptr(_, ref mt) | ty::ty_ptr(ref mt) => { + ty::TyRef(_, ref mt) | ty::TyRawPtr(ref mt) => { if ty::expr_is_lval(fcx.tcx(), &**oprnd) { // Lvalues may legitimately have unsized types. // For example, dereferences of a fat pointer and @@ -3453,7 +3453,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, ast::ExprVec(ref args) => { let uty = expected.to_option(fcx).and_then(|uty| { match uty.sty { - ty::ty_vec(ty, _) => Some(ty), + ty::TyArray(ty, _) => Some(ty), _ => None } }); @@ -3483,7 +3483,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, let uty = match expected { ExpectHasType(uty) => { match uty.sty { - ty::ty_vec(ty, _) => Some(ty), + ty::TyArray(ty, _) => Some(ty), _ => None } } @@ -3522,7 +3522,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, ast::ExprTup(ref elts) => { let flds = expected.only_has_type(fcx).and_then(|ty| { match ty.sty { - ty::ty_tup(ref flds) => Some(&flds[..]), + ty::TyTuple(ref flds) => Some(&flds[..]), _ => None } }); @@ -3573,7 +3573,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, // Verify that this was actually a struct. let typ = ty::lookup_item_type(fcx.ccx.tcx, def.def_id()); match typ.ty.sty { - ty::ty_struct(struct_did, _) => { + ty::TyStruct(struct_did, _) => { check_struct_constructor(fcx, id, expr.span, @@ -3863,7 +3863,7 @@ impl<'tcx> Expectation<'tcx> { /// for examples of where this comes up,. fn rvalue_hint(ty: Ty<'tcx>) -> Expectation<'tcx> { match ty.sty { - ty::ty_vec(_, None) | ty::ty_trait(..) => { + ty::TyArray(_, None) | ty::TyTrait(..) => { ExpectRvalueLikeUnsized(ty) } _ => ExpectHasType(ty) @@ -4213,7 +4213,7 @@ pub fn check_simd(tcx: &ty::ctxt, sp: Span, id: ast::NodeId) { return; } match t.sty { - ty::ty_struct(did, substs) => { + ty::TyStruct(did, substs) => { let fields = ty::lookup_struct_fields(tcx, did); if fields.is_empty() { span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty"); @@ -4959,7 +4959,7 @@ pub fn check_bounds_are_used<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, ty::walk_ty(ty, |t| { match t.sty { - ty::ty_param(ParamTy {idx, ..}) => { + ty::TyParam(ParamTy {idx, ..}) => { debug!("Found use of ty param num {}", idx); tps_used[idx as usize] = true; } diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index 469b9bded55..2b2cb31836c 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -669,7 +669,7 @@ fn visit_expr(rcx: &mut Rcx, expr: &ast::Expr) { } None => rcx.resolve_node_type(base.id) }; - if let ty::ty_rptr(r_ptr, _) = base_ty.sty { + if let ty::TyRef(r_ptr, _) = base_ty.sty { mk_subregion_due_to_dereference( rcx, expr.span, ty::ReScope(CodeExtent::from_node_id(expr.id)), *r_ptr); } @@ -762,23 +762,23 @@ fn constrain_cast(rcx: &mut Rcx, from_ty.repr(rcx.tcx()), to_ty.repr(rcx.tcx())); match (&from_ty.sty, &to_ty.sty) { - /*From:*/ (&ty::ty_rptr(from_r, ref from_mt), - /*To: */ &ty::ty_rptr(to_r, ref to_mt)) => { + /*From:*/ (&ty::TyRef(from_r, ref from_mt), + /*To: */ &ty::TyRef(to_r, ref to_mt)) => { // Target cannot outlive source, naturally. rcx.fcx.mk_subr(infer::Reborrow(cast_expr.span), *to_r, *from_r); walk_cast(rcx, cast_expr, from_mt.ty, to_mt.ty); } /*From:*/ (_, - /*To: */ &ty::ty_trait(box ty::TyTrait { ref bounds, .. })) => { + /*To: */ &ty::TyTrait(box ty::TraitTy { ref bounds, .. })) => { // When T is existentially quantified as a trait // `Foo+'to`, it must outlive the region bound `'to`. type_must_outlive(rcx, infer::RelateObjectBound(cast_expr.span), from_ty, bounds.region_bound); } - /*From:*/ (&ty::ty_uniq(from_referent_ty), - /*To: */ &ty::ty_uniq(to_referent_ty)) => { + /*From:*/ (&ty::TyBox(from_referent_ty), + /*To: */ &ty::TyBox(to_referent_ty)) => { walk_cast(rcx, cast_expr, from_referent_ty, to_referent_ty); } @@ -801,7 +801,7 @@ fn constrain_callee(rcx: &mut Rcx, _callee_expr: &ast::Expr) { let callee_ty = rcx.resolve_node_type(callee_id); match callee_ty.sty { - ty::ty_bare_fn(..) => { } + ty::TyBareFn(..) => { } _ => { // this should not happen, but it does if the program is // erroneous @@ -899,7 +899,7 @@ fn constrain_autoderefs<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>, ty::no_late_bound_regions(rcx.tcx(), fn_sig).unwrap(); let self_ty = fn_sig.inputs[0]; let (m, r) = match self_ty.sty { - ty::ty_rptr(r, ref m) => (m.mutbl, r), + ty::TyRef(r, ref m) => (m.mutbl, r), _ => { rcx.tcx().sess.span_bug( deref_expr.span, @@ -935,7 +935,7 @@ fn constrain_autoderefs<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>, None => derefd_ty }; - if let ty::ty_rptr(r_ptr, _) = derefd_ty.sty { + if let ty::TyRef(r_ptr, _) = derefd_ty.sty { mk_subregion_due_to_dereference(rcx, deref_expr.span, r_deref_expr, *r_ptr); } @@ -995,9 +995,9 @@ fn constrain_index<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>, rcx.fcx.infcx().ty_to_string(indexed_ty)); let r_index_expr = ty::ReScope(CodeExtent::from_node_id(index_expr.id)); - if let ty::ty_rptr(r_ptr, mt) = indexed_ty.sty { + if let ty::TyRef(r_ptr, mt) = indexed_ty.sty { match mt.ty.sty { - ty::ty_vec(_, None) | ty::ty_str => { + ty::TyArray(_, None) | ty::TyStr => { rcx.fcx.mk_subr(infer::IndexSlice(index_expr.span), r_index_expr, *r_ptr); } diff --git a/src/librustc_typeck/check/wf.rs b/src/librustc_typeck/check/wf.rs index 62790a1d0a8..cf324ef97e7 100644 --- a/src/librustc_typeck/check/wf.rs +++ b/src/librustc_typeck/check/wf.rs @@ -403,7 +403,7 @@ fn reject_non_type_param_bounds<'tcx>(tcx: &ty::ctxt<'tcx>, fn is_ty_param(ty: ty::Ty) -> bool { match &ty.sty { - &ty::sty::ty_param(_) => true, + &ty::TyParam(_) => true, _ => false } } @@ -568,8 +568,8 @@ impl<'cx,'tcx> TypeFolder<'tcx> for BoundsChecker<'cx,'tcx> { } match t.sty{ - ty::ty_struct(type_id, substs) | - ty::ty_enum(type_id, substs) => { + ty::TyStruct(type_id, substs) | + ty::TyEnum(type_id, substs) => { let type_predicates = ty::lookup_predicates(self.fcx.tcx(), type_id); let bounds = self.fcx.instantiate_bounds(self.span, substs, &type_predicates); diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index f48e9f73db3..5a6cf7cccfd 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -22,12 +22,12 @@ use middle::traits; use middle::ty::RegionEscape; use middle::ty::{ImplContainer, ImplOrTraitItemId, ConstTraitItemId}; use middle::ty::{MethodTraitItemId, TypeTraitItemId, ParameterEnvironment}; -use middle::ty::{Ty, ty_bool, ty_char, ty_enum, ty_err}; -use middle::ty::{ty_param, TypeScheme, ty_ptr}; -use middle::ty::{ty_rptr, ty_struct, ty_trait, ty_tup}; -use middle::ty::{ty_str, ty_vec, ty_float, ty_infer, ty_int}; -use middle::ty::{ty_uint, ty_closure, ty_uniq, ty_bare_fn}; -use middle::ty::ty_projection; +use middle::ty::{Ty, TyBool, TyChar, TyEnum, TyError}; +use middle::ty::{TyParam, TypeScheme, TyRawPtr}; +use middle::ty::{TyRef, TyStruct, TyTrait, TyTuple}; +use middle::ty::{TyStr, TyArray, TyFloat, TyInfer, TyInt}; +use middle::ty::{TyUint, TyClosure, TyBox, TyBareFn}; +use middle::ty::TyProjection; use middle::ty; use middle::free_region::FreeRegionMap; use CrateCtxt; @@ -56,27 +56,27 @@ fn get_base_type_def_id<'a, 'tcx>(inference_context: &InferCtxt<'a, 'tcx>, ty: Ty<'tcx>) -> Option<DefId> { match ty.sty { - ty_enum(def_id, _) | - ty_struct(def_id, _) => { + TyEnum(def_id, _) | + TyStruct(def_id, _) => { Some(def_id) } - ty_trait(ref t) => { + TyTrait(ref t) => { Some(t.principal_def_id()) } - ty_uniq(_) => { + TyBox(_) => { inference_context.tcx.lang_items.owned_box() } - ty_bool | ty_char | ty_int(..) | ty_uint(..) | ty_float(..) | - ty_str(..) | ty_vec(..) | ty_bare_fn(..) | ty_tup(..) | - ty_param(..) | ty_err | - ty_ptr(_) | ty_rptr(_, _) | ty_projection(..) => { + TyBool | TyChar | TyInt(..) | TyUint(..) | TyFloat(..) | + TyStr(..) | TyArray(..) | TyBareFn(..) | TyTuple(..) | + TyParam(..) | TyError | + TyRawPtr(_) | TyRef(_, _) | TyProjection(..) => { None } - ty_infer(..) | ty_closure(..) => { + TyInfer(..) | TyClosure(..) => { // `ty` comes from a user declaration so we should only expect types // that the user can type inference_context.tcx.sess.span_bug( @@ -315,9 +315,9 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { let self_type = ty::lookup_item_type(tcx, impl_did); match self_type.ty.sty { - ty::ty_enum(type_def_id, _) | - ty::ty_struct(type_def_id, _) | - ty::ty_closure(type_def_id, _) => { + ty::TyEnum(type_def_id, _) | + ty::TyStruct(type_def_id, _) | + ty::TyClosure(type_def_id, _) => { tcx.destructor_for_type .borrow_mut() .insert(type_def_id, method_def_id.def_id()); @@ -465,19 +465,19 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { (mt_a.ty, mt_b.ty, unsize_trait, None) }; let (source, target, trait_def_id, kind) = match (&source.sty, &target.sty) { - (&ty::ty_uniq(a), &ty::ty_uniq(b)) => (a, b, unsize_trait, None), + (&ty::TyBox(a), &ty::TyBox(b)) => (a, b, unsize_trait, None), - (&ty::ty_rptr(r_a, mt_a), &ty::ty_rptr(r_b, mt_b)) => { + (&ty::TyRef(r_a, mt_a), &ty::TyRef(r_b, mt_b)) => { infer::mk_subr(&infcx, infer::RelateObjectBound(span), *r_b, *r_a); check_mutbl(mt_a, mt_b, &|ty| ty::mk_imm_rptr(tcx, r_b, ty)) } - (&ty::ty_rptr(_, mt_a), &ty::ty_ptr(mt_b)) | - (&ty::ty_ptr(mt_a), &ty::ty_ptr(mt_b)) => { + (&ty::TyRef(_, mt_a), &ty::TyRawPtr(mt_b)) | + (&ty::TyRawPtr(mt_a), &ty::TyRawPtr(mt_b)) => { check_mutbl(mt_a, mt_b, &|ty| ty::mk_imm_ptr(tcx, ty)) } - (&ty::ty_struct(def_id_a, substs_a), &ty::ty_struct(def_id_b, substs_b)) => { + (&ty::TyStruct(def_id_a, substs_a), &ty::TyStruct(def_id_b, substs_b)) => { if def_id_a != def_id_b { let source_path = ty::item_path_str(tcx, def_id_a); let target_path = ty::item_path_str(tcx, def_id_b); diff --git a/src/librustc_typeck/coherence/orphan.rs b/src/librustc_typeck/coherence/orphan.rs index cc03dffe3a0..da01d4669f8 100644 --- a/src/librustc_typeck/coherence/orphan.rs +++ b/src/librustc_typeck/coherence/orphan.rs @@ -69,129 +69,129 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> { debug!("coherence2::orphan check: inherent impl {}", item.repr(self.tcx)); let self_ty = ty::lookup_item_type(self.tcx, def_id).ty; match self_ty.sty { - ty::ty_enum(def_id, _) | - ty::ty_struct(def_id, _) => { + ty::TyEnum(def_id, _) | + ty::TyStruct(def_id, _) => { self.check_def_id(item, def_id); } - ty::ty_trait(ref data) => { + ty::TyTrait(ref data) => { self.check_def_id(item, data.principal_def_id()); } - ty::ty_uniq(..) => { + ty::TyBox(..) => { self.check_def_id(item, self.tcx.lang_items.owned_box().unwrap()); } - ty::ty_char => { + ty::TyChar => { self.check_primitive_impl(def_id, self.tcx.lang_items.char_impl(), "char", "char", item.span); } - ty::ty_str => { + ty::TyStr => { self.check_primitive_impl(def_id, self.tcx.lang_items.str_impl(), "str", "str", item.span); } - ty::ty_vec(_, None) => { + ty::TyArray(_, None) => { self.check_primitive_impl(def_id, self.tcx.lang_items.slice_impl(), "slice", "[T]", item.span); } - ty::ty_ptr(ty::mt { ty: _, mutbl: ast::MutImmutable }) => { + ty::TyRawPtr(ty::mt { ty: _, mutbl: ast::MutImmutable }) => { self.check_primitive_impl(def_id, self.tcx.lang_items.const_ptr_impl(), "const_ptr", "*const T", item.span); } - ty::ty_ptr(ty::mt { ty: _, mutbl: ast::MutMutable }) => { + ty::TyRawPtr(ty::mt { ty: _, mutbl: ast::MutMutable }) => { self.check_primitive_impl(def_id, self.tcx.lang_items.mut_ptr_impl(), "mut_ptr", "*mut T", item.span); } - ty::ty_int(ast::TyI8) => { + ty::TyInt(ast::TyI8) => { self.check_primitive_impl(def_id, self.tcx.lang_items.i8_impl(), "i8", "i8", item.span); } - ty::ty_int(ast::TyI16) => { + ty::TyInt(ast::TyI16) => { self.check_primitive_impl(def_id, self.tcx.lang_items.i16_impl(), "i16", "i16", item.span); } - ty::ty_int(ast::TyI32) => { + ty::TyInt(ast::TyI32) => { self.check_primitive_impl(def_id, self.tcx.lang_items.i32_impl(), "i32", "i32", item.span); } - ty::ty_int(ast::TyI64) => { + ty::TyInt(ast::TyI64) => { self.check_primitive_impl(def_id, self.tcx.lang_items.i64_impl(), "i64", "i64", item.span); } - ty::ty_int(ast::TyIs) => { + ty::TyInt(ast::TyIs) => { self.check_primitive_impl(def_id, self.tcx.lang_items.isize_impl(), "isize", "isize", item.span); } - ty::ty_uint(ast::TyU8) => { + ty::TyUint(ast::TyU8) => { self.check_primitive_impl(def_id, self.tcx.lang_items.u8_impl(), "u8", "u8", item.span); } - ty::ty_uint(ast::TyU16) => { + ty::TyUint(ast::TyU16) => { self.check_primitive_impl(def_id, self.tcx.lang_items.u16_impl(), "u16", "u16", item.span); } - ty::ty_uint(ast::TyU32) => { + ty::TyUint(ast::TyU32) => { self.check_primitive_impl(def_id, self.tcx.lang_items.u32_impl(), "u32", "u32", item.span); } - ty::ty_uint(ast::TyU64) => { + ty::TyUint(ast::TyU64) => { self.check_primitive_impl(def_id, self.tcx.lang_items.u64_impl(), "u64", "u64", item.span); } - ty::ty_uint(ast::TyUs) => { + ty::TyUint(ast::TyUs) => { self.check_primitive_impl(def_id, self.tcx.lang_items.usize_impl(), "usize", "usize", item.span); } - ty::ty_float(ast::TyF32) => { + ty::TyFloat(ast::TyF32) => { self.check_primitive_impl(def_id, self.tcx.lang_items.f32_impl(), "f32", "f32", item.span); } - ty::ty_float(ast::TyF64) => { + ty::TyFloat(ast::TyF64) => { self.check_primitive_impl(def_id, self.tcx.lang_items.f64_impl(), "f64", @@ -275,9 +275,9 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> { { let self_ty = trait_ref.self_ty(); let opt_self_def_id = match self_ty.sty { - ty::ty_struct(self_def_id, _) | ty::ty_enum(self_def_id, _) => + ty::TyStruct(self_def_id, _) | ty::TyEnum(self_def_id, _) => Some(self_def_id), - ty::ty_uniq(..) => + ty::TyBox(..) => self.tcx.lang_items.owned_box(), _ => None diff --git a/src/librustc_typeck/coherence/overlap.rs b/src/librustc_typeck/coherence/overlap.rs index e9c69c84630..7564f7862fc 100644 --- a/src/librustc_typeck/coherence/overlap.rs +++ b/src/librustc_typeck/coherence/overlap.rs @@ -198,7 +198,7 @@ impl<'cx, 'tcx,'v> visit::Visitor<'v> for OverlapChecker<'cx, 'tcx> { let trait_ref = ty::impl_trait_ref(self.tcx, impl_def_id).unwrap(); let trait_def_id = trait_ref.def_id; match trait_ref.self_ty().sty { - ty::ty_trait(ref data) => { + ty::TyTrait(ref data) => { // This is something like impl Trait1 for Trait2. Illegal // if Trait1 is a supertrait of Trait2 or Trait2 is not object safe. diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index e09ed201a35..aabd33d9c1d 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -1882,7 +1882,7 @@ fn get_or_create_type_parameter_def<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, ty::walk_ty(ty, |t| { match t.sty { - ty::ty_param(p) => if p.idx > cur_idx { + ty::TyParam(p) => if p.idx > cur_idx { span_err!(tcx.sess, path.span, E0128, "type parameters with a default cannot use \ forward declared identifiers"); @@ -2174,8 +2174,8 @@ fn check_method_self_type<'a, 'tcx, RS:RegionScope>( if let ast::SelfExplicit(ref ast_type, _) = explicit_self.node { let typ = ccx.icx(&method_type.predicates).to_ty(rs, &**ast_type); let base_type = match typ.sty { - ty::ty_rptr(_, tm) => tm.ty, - ty::ty_uniq(typ) => typ, + ty::TyRef(_, tm) => tm.ty, + ty::TyBox(typ) => typ, _ => typ, }; diff --git a/src/librustc_typeck/constrained_type_params.rs b/src/librustc_typeck/constrained_type_params.rs index a46c04fee11..09539931c34 100644 --- a/src/librustc_typeck/constrained_type_params.rs +++ b/src/librustc_typeck/constrained_type_params.rs @@ -40,14 +40,14 @@ pub fn parameters_for_trait_ref<'tcx>(trait_ref: &ty::TraitRef<'tcx>) -> Vec<Par fn parameters_for_type_shallow<'tcx>(ty: Ty<'tcx>) -> Vec<Parameter> { match ty.sty { - ty::ty_param(ref d) => + ty::TyParam(ref d) => vec![Parameter::Type(d.clone())], - ty::ty_rptr(region, _) => + ty::TyRef(region, _) => parameters_for_region(region).into_iter().collect(), - ty::ty_struct(_, substs) | - ty::ty_enum(_, substs) => + ty::TyStruct(_, substs) | + ty::TyEnum(_, substs) => parameters_for_regions_in_substs(substs), - ty::ty_trait(ref data) => + ty::TyTrait(ref data) => parameters_for_regions_in_substs(&data.principal.skip_binder().substs), _ => vec![], diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index 8d7ecca5ddd..67101a69b57 100644 --- a/src/librustc_typeck/lib.rs +++ b/src/librustc_typeck/lib.rs @@ -212,7 +212,7 @@ fn check_main_fn_ty(ccx: &CrateCtxt, let tcx = ccx.tcx; let main_t = ty::node_id_to_type(tcx, main_id); match main_t.sty { - ty::ty_bare_fn(..) => { + ty::TyBareFn(..) => { match tcx.map.find(main_id) { Some(ast_map::NodeItem(it)) => { match it.node { @@ -259,7 +259,7 @@ fn check_start_fn_ty(ccx: &CrateCtxt, let tcx = ccx.tcx; let start_t = ty::node_id_to_type(tcx, start_id); match start_t.sty { - ty::ty_bare_fn(..) => { + ty::TyBareFn(..) => { match tcx.map.find(start_id) { Some(ast_map::NodeItem(it)) => { match it.node { diff --git a/src/librustc_typeck/variance.rs b/src/librustc_typeck/variance.rs index 75f8f7aa81e..c17e3038a8b 100644 --- a/src/librustc_typeck/variance.rs +++ b/src/librustc_typeck/variance.rs @@ -873,39 +873,39 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { variance); match ty.sty { - ty::ty_bool | - ty::ty_char | ty::ty_int(_) | ty::ty_uint(_) | - ty::ty_float(_) | ty::ty_str => { + ty::TyBool | + ty::TyChar | ty::TyInt(_) | ty::TyUint(_) | + ty::TyFloat(_) | ty::TyStr => { /* leaf type -- noop */ } - ty::ty_closure(..) => { + ty::TyClosure(..) => { self.tcx().sess.bug("Unexpected closure type in variance computation"); } - ty::ty_rptr(region, ref mt) => { + ty::TyRef(region, ref mt) => { let contra = self.contravariant(variance); self.add_constraints_from_region(generics, *region, contra); self.add_constraints_from_mt(generics, mt, variance); } - ty::ty_uniq(typ) | ty::ty_vec(typ, _) => { + ty::TyBox(typ) | ty::TyArray(typ, _) => { self.add_constraints_from_ty(generics, typ, variance); } - ty::ty_ptr(ref mt) => { + ty::TyRawPtr(ref mt) => { self.add_constraints_from_mt(generics, mt, variance); } - ty::ty_tup(ref subtys) => { + ty::TyTuple(ref subtys) => { for &subty in subtys { self.add_constraints_from_ty(generics, subty, variance); } } - ty::ty_enum(def_id, substs) | - ty::ty_struct(def_id, substs) => { + ty::TyEnum(def_id, substs) | + ty::TyStruct(def_id, substs) => { let item_type = ty::lookup_item_type(self.tcx(), def_id); // All type parameters on enums and structs should be @@ -924,7 +924,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { variance); } - ty::ty_projection(ref data) => { + ty::TyProjection(ref data) => { let trait_ref = &data.trait_ref; let trait_def = ty::lookup_trait_def(self.tcx(), trait_ref.def_id); self.add_constraints_from_substs( @@ -936,7 +936,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { variance); } - ty::ty_trait(ref data) => { + ty::TyTrait(ref data) => { let poly_trait_ref = data.principal_trait_ref_with_self_ty(self.tcx(), self.tcx().types.err); @@ -955,7 +955,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { } } - ty::ty_param(ref data) => { + ty::TyParam(ref data) => { let def_id = generics.types.get(data.space, data.idx as usize).def_id; assert_eq!(def_id.krate, ast::LOCAL_CRATE); match self.terms_cx.inferred_map.get(&def_id.node) { @@ -970,16 +970,16 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { } } - ty::ty_bare_fn(_, &ty::BareFnTy { ref sig, .. }) => { + ty::TyBareFn(_, &ty::BareFnTy { ref sig, .. }) => { self.add_constraints_from_sig(generics, sig, variance); } - ty::ty_err => { + ty::TyError => { // we encounter this when walking the trait references for object - // types, where we use ty_err as the Self type + // types, where we use TyError as the Self type } - ty::ty_infer(..) => { + ty::TyInfer(..) => { self.tcx().sess.bug( &format!("unexpected type encountered in \ variance inference: {}", diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs index fcf45f21a1e..53063c6247e 100644 --- a/src/librustdoc/clean/inline.rs +++ b/src/librustdoc/clean/inline.rs @@ -167,7 +167,7 @@ pub fn build_external_trait(cx: &DocContext, tcx: &ty::ctxt, fn build_external_function(cx: &DocContext, tcx: &ty::ctxt, did: ast::DefId) -> clean::Function { let t = ty::lookup_item_type(tcx, did); let (decl, style, abi) = match t.ty.sty { - ty::ty_bare_fn(_, ref f) => ((did, &f.sig).clean(cx), f.unsafety, f.abi), + ty::TyBareFn(_, ref f) => ((did, &f.sig).clean(cx), f.unsafety, f.abi), _ => panic!("bad function"), }; let predicates = ty::lookup_predicates(tcx, did); @@ -204,7 +204,7 @@ fn build_type(cx: &DocContext, tcx: &ty::ctxt, did: ast::DefId) -> clean::ItemEn let t = ty::lookup_item_type(tcx, did); let predicates = ty::lookup_predicates(tcx, did); match t.ty.sty { - ty::ty_enum(edid, _) if !csearch::is_typedef(&tcx.sess.cstore, did) => { + ty::TyEnum(edid, _) if !csearch::is_typedef(&tcx.sess.cstore, did) => { return clean::EnumItem(clean::Enum { generics: (&t.generics, &predicates, subst::TypeSpace).clean(cx), variants_stripped: false, diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index bbd999b1d73..920902e19c8 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -579,7 +579,6 @@ impl<'tcx> Clean<(Vec<TyParamBound>, Vec<TypeBinding>)> for ty::ExistentialBound fn external_path_params(cx: &DocContext, trait_did: Option<ast::DefId>, bindings: Vec<TypeBinding>, substs: &subst::Substs) -> PathParameters { - use rustc::middle::ty::sty; let lifetimes = substs.regions().get_slice(subst::TypeSpace) .iter() .filter_map(|v| v.clean(cx)) @@ -591,7 +590,7 @@ fn external_path_params(cx: &DocContext, trait_did: Option<ast::DefId>, (Some(did), Some(ref tcx)) if tcx.lang_items.fn_trait_kind(did).is_some() => { assert_eq!(types.len(), 1); let inputs = match types[0].sty { - sty::ty_tup(ref tys) => tys.iter().map(|t| t.clean(cx)).collect(), + ty::TyTuple(ref tys) => tys.iter().map(|t| t.clean(cx)).collect(), _ => { return PathParameters::AngleBracketed { lifetimes: lifetimes, @@ -603,7 +602,7 @@ fn external_path_params(cx: &DocContext, trait_did: Option<ast::DefId>, let output = None; // FIXME(#20299) return type comes from a projection now // match types[1].sty { - // sty::ty_tup(ref v) if v.is_empty() => None, // -> () + // ty::TyTuple(ref v) if v.is_empty() => None, // -> () // _ => Some(types[1].clean(cx)) // }; PathParameters::Parenthesized { @@ -691,11 +690,10 @@ impl<'tcx> Clean<TyParamBound> for ty::TraitRef<'tcx> { // collect any late bound regions let mut late_bounds = vec![]; for &ty_s in self.substs.types.get_slice(ParamSpace::TypeSpace) { - use rustc::middle::ty::{Region, sty}; - if let sty::ty_tup(ref ts) = ty_s.sty { + if let ty::TyTuple(ref ts) = ty_s.sty { for &ty_s in ts { - if let sty::ty_rptr(ref reg, _) = ty_s.sty { - if let &Region::ReLateBound(_, _) = *reg { + if let ty::TyRef(ref reg, _) = ty_s.sty { + if let &ty::Region::ReLateBound(_, _) = *reg { debug!(" hit an ReLateBound {:?}", reg); if let Some(lt) = reg.clean(cx) { late_bounds.push(lt) @@ -1326,7 +1324,7 @@ impl<'tcx> Clean<Item> for ty::Method<'tcx> { ty::ByValueExplicitSelfCategory => SelfValue, ty::ByReferenceExplicitSelfCategory(..) => { match self.fty.sig.0.inputs[0].sty { - ty::ty_rptr(r, mt) => { + ty::TyRef(r, mt) => { SelfBorrowed(r.clean(cx), mt.mutbl.clean(cx)) } _ => unreachable!(), @@ -1633,37 +1631,37 @@ impl Clean<Type> for ast::Ty { impl<'tcx> Clean<Type> for ty::Ty<'tcx> { fn clean(&self, cx: &DocContext) -> Type { match self.sty { - ty::ty_bool => Primitive(Bool), - ty::ty_char => Primitive(Char), - ty::ty_int(ast::TyIs) => Primitive(Isize), - ty::ty_int(ast::TyI8) => Primitive(I8), - ty::ty_int(ast::TyI16) => Primitive(I16), - ty::ty_int(ast::TyI32) => Primitive(I32), - ty::ty_int(ast::TyI64) => Primitive(I64), - ty::ty_uint(ast::TyUs) => Primitive(Usize), - ty::ty_uint(ast::TyU8) => Primitive(U8), - ty::ty_uint(ast::TyU16) => Primitive(U16), - ty::ty_uint(ast::TyU32) => Primitive(U32), - ty::ty_uint(ast::TyU64) => Primitive(U64), - ty::ty_float(ast::TyF32) => Primitive(F32), - ty::ty_float(ast::TyF64) => Primitive(F64), - ty::ty_str => Primitive(Str), - ty::ty_uniq(t) => { + 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::TyStr => Primitive(Str), + ty::TyBox(t) => { let box_did = cx.tcx_opt().and_then(|tcx| { tcx.lang_items.owned_box() }); lang_struct(cx, box_did, t, "Box", Unique) } - ty::ty_vec(ty, None) => Vector(box ty.clean(cx)), - ty::ty_vec(ty, Some(i)) => FixedVector(box ty.clean(cx), + ty::TyArray(ty, None) => Vector(box ty.clean(cx)), + ty::TyArray(ty, Some(i)) => FixedVector(box ty.clean(cx), format!("{}", i)), - ty::ty_ptr(mt) => RawPointer(mt.mutbl.clean(cx), box mt.ty.clean(cx)), - ty::ty_rptr(r, mt) => BorrowedRef { + ty::TyRawPtr(mt) => RawPointer(mt.mutbl.clean(cx), box mt.ty.clean(cx)), + ty::TyRef(r, mt) => BorrowedRef { lifetime: r.clean(cx), mutability: mt.mutbl.clean(cx), type_: box mt.ty.clean(cx), }, - ty::ty_bare_fn(_, ref fty) => BareFunction(box BareFunctionDecl { + ty::TyBareFn(_, ref fty) => BareFunction(box BareFunctionDecl { unsafety: fty.unsafety, generics: Generics { lifetimes: Vec::new(), @@ -1673,12 +1671,12 @@ impl<'tcx> Clean<Type> for ty::Ty<'tcx> { decl: (ast_util::local_def(0), &fty.sig).clean(cx), abi: fty.abi.to_string(), }), - ty::ty_struct(did, substs) | - ty::ty_enum(did, substs) => { + ty::TyStruct(did, substs) | + ty::TyEnum(did, substs) => { let fqn = csearch::get_item_path(cx.tcx(), did); let fqn: Vec<_> = fqn.into_iter().map(|i| i.to_string()).collect(); let kind = match self.sty { - ty::ty_struct(..) => TypeStruct, + ty::TyStruct(..) => TypeStruct, _ => TypeEnum, }; let path = external_path(cx, &fqn.last().unwrap().to_string(), @@ -1691,7 +1689,7 @@ impl<'tcx> Clean<Type> for ty::Ty<'tcx> { is_generic: false, } } - ty::ty_trait(box ty::TyTrait { ref principal, ref bounds }) => { + ty::TyTrait(box ty::TraitTy { ref principal, ref bounds }) => { let did = principal.def_id(); let fqn = csearch::get_item_path(cx.tcx(), did); let fqn: Vec<_> = fqn.into_iter().map(|i| i.to_string()).collect(); @@ -1706,16 +1704,16 @@ impl<'tcx> Clean<Type> for ty::Ty<'tcx> { is_generic: false, } } - ty::ty_tup(ref t) => Tuple(t.clean(cx)), + ty::TyTuple(ref t) => Tuple(t.clean(cx)), - ty::ty_projection(ref data) => data.clean(cx), + ty::TyProjection(ref data) => data.clean(cx), - ty::ty_param(ref p) => Generic(token::get_name(p.name).to_string()), + ty::TyParam(ref p) => Generic(token::get_name(p.name).to_string()), - ty::ty_closure(..) => Tuple(vec![]), // FIXME(pcwalton) + ty::TyClosure(..) => Tuple(vec![]), // FIXME(pcwalton) - ty::ty_infer(..) => panic!("ty_infer"), - ty::ty_err => panic!("ty_err"), + ty::TyInfer(..) => panic!("TyInfer"), + ty::TyError => panic!("TyError"), } } } diff --git a/src/test/auxiliary/issue13507.rs b/src/test/auxiliary/issue13507.rs index 22ccb3dfacd..7d82e79f949 100644 --- a/src/test/auxiliary/issue13507.rs +++ b/src/test/auxiliary/issue13507.rs @@ -34,54 +34,54 @@ pub mod testtypes { // Skipping ty_bot - // Tests ty_bool + // Tests TyBool pub type FooBool = bool; - // Tests ty_char + // Tests TyChar pub type FooChar = char; - // Tests ty_int (does not test all variants of IntTy) + // Tests TyInt (does not test all variants of IntTy) pub type FooInt = isize; - // Tests ty_uint (does not test all variants of UintTy) + // Tests TyUint (does not test all variants of UintTy) pub type FooUint = usize; - // Tests ty_float (does not test all variants of FloatTy) + // Tests TyFloat (does not test all variants of FloatTy) pub type FooFloat = f64; - // For ty_str, what kind of string should I use? &'static str? String? Raw str? + // For TyStr, what kind of string should I use? &'static str? String? Raw str? - // Tests ty_enum + // Tests TyEnum pub enum FooEnum { VarA(usize), VarB(usize, usize) } - // Tests ty_uniq (of u8) + // Tests TyBox (of u8) pub type FooUniq = Box<u8>; - // As with ty_str, what type should be used for ty_vec? + // As with TyStr, what type should be used for TyArray? - // Tests ty_ptr + // Tests TyRawPtr pub type FooPtr = *const u8; - // Skipping ty_rptr + // Skipping TyRef - // Skipping ty_bare_fn (how do you get a bare function type, rather than proc or closure?) + // Skipping TyBareFn (how do you get a bare function type, rather than proc or closure?) - // Tests ty_trait + // Tests TyTrait pub trait FooTrait { fn foo_method(&self) -> usize; fn foo_static_method() -> usize; } - // Tests ty_struct + // Tests TyStruct pub struct FooStruct { pub pub_foo_field: usize, foo_field: usize } - // Tests ty_tup + // Tests TyTuple pub type FooTuple = (u8, i8, bool); // Skipping ty_param @@ -90,7 +90,7 @@ pub mod testtypes { // Skipping ty_self - // Skipping ty_infer + // Skipping TyInfer - // Skipping ty_err + // Skipping TyError } diff --git a/src/test/run-pass/unboxed-closures-unique-type-id.rs b/src/test/run-pass/unboxed-closures-unique-type-id.rs index de7eeb57de1..30c45fc766a 100644 --- a/src/test/run-pass/unboxed-closures-unique-type-id.rs +++ b/src/test/run-pass/unboxed-closures-unique-type-id.rs @@ -12,7 +12,7 @@ // // error: internal compiler error: get_unique_type_id_of_type() - // unexpected type: closure, -// ty_closure(syntax::ast::DefId{krate: 0, node: 66}, +// TyClosure(syntax::ast::DefId{krate: 0, node: 66}, // ReScope(63)) // // This is a regression test for issue #17021. |