diff options
Diffstat (limited to 'src/librustc')
28 files changed, 219 insertions, 219 deletions
diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs index 43cc33f422f..6bdfbd40e8d 100644 --- a/src/librustc/hir/mod.rs +++ b/src/librustc/hir/mod.rs @@ -1672,12 +1672,12 @@ impl fmt::Debug for Ty { /// Not represented directly in the AST, referred to by name through a ty_path. #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] pub enum PrimTy { - TyInt(IntTy), - TyUint(UintTy), - TyFloat(FloatTy), - TyStr, - TyBool, - TyChar, + Int(IntTy), + Uint(UintTy), + Float(FloatTy), + Str, + Bool, + Char, } #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] diff --git a/src/librustc/ich/impls_hir.rs b/src/librustc/ich/impls_hir.rs index cb822d01534..4e75905595e 100644 --- a/src/librustc/ich/impls_hir.rs +++ b/src/librustc/ich/impls_hir.rs @@ -308,12 +308,12 @@ impl<'a> HashStable<StableHashingContext<'a>> for hir::Ty { } impl_stable_hash_for!(enum hir::PrimTy { - TyInt(int_ty), - TyUint(uint_ty), - TyFloat(float_ty), - TyStr, - TyBool, - TyChar + Int(int_ty), + Uint(uint_ty), + Float(float_ty), + Str, + Bool, + Char }); impl_stable_hash_for!(struct hir::BareFnTy { diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs index a3d7aca3297..709b53f248d 100644 --- a/src/librustc/ich/impls_ty.rs +++ b/src/librustc/ich/impls_ty.rs @@ -806,20 +806,20 @@ for ty::TyKind<'gcx> mem::discriminant(self).hash_stable(hcx, hasher); match *self { - TyBool | - TyChar | - TyStr | + Bool | + Char | + Str | Error | Never => { // Nothing more to hash. } - TyInt(int_ty) => { + Int(int_ty) => { int_ty.hash_stable(hcx, hasher); } - TyUint(uint_ty) => { + Uint(uint_ty) => { uint_ty.hash_stable(hcx, hasher); } - TyFloat(float_ty) => { + Float(float_ty) => { float_ty.hash_stable(hcx, hasher); } Adt(adt_def, substs) => { diff --git a/src/librustc/infer/canonical/canonicalizer.rs b/src/librustc/infer/canonical/canonicalizer.rs index 02f8b4648f1..16c33e9adf8 100644 --- a/src/librustc/infer/canonical/canonicalizer.rs +++ b/src/librustc/infer/canonical/canonicalizer.rs @@ -265,13 +265,13 @@ impl<'cx, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for Canonicalizer<'cx, 'gcx, 'tcx> ty::Closure(..) | ty::Generator(..) | ty::GeneratorWitness(..) - | ty::TyBool - | ty::TyChar - | ty::TyInt(..) - | ty::TyUint(..) - | ty::TyFloat(..) + | ty::Bool + | ty::Char + | ty::Int(..) + | ty::Uint(..) + | ty::Float(..) | ty::Adt(..) - | ty::TyStr + | ty::Str | ty::Error | ty::Array(..) | ty::Slice(..) diff --git a/src/librustc/infer/combine.rs b/src/librustc/infer/combine.rs index 6d4293216a4..4738a03cbd3 100644 --- a/src/librustc/infer/combine.rs +++ b/src/librustc/infer/combine.rs @@ -83,16 +83,16 @@ impl<'infcx, 'gcx, 'tcx> InferCtxt<'infcx, 'gcx, 'tcx> { .map_err(|e| int_unification_error(a_is_expected, e))?; Ok(a) } - (&ty::Infer(ty::IntVar(v_id)), &ty::TyInt(v)) => { + (&ty::Infer(ty::IntVar(v_id)), &ty::Int(v)) => { self.unify_integral_variable(a_is_expected, v_id, IntType(v)) } - (&ty::TyInt(v), &ty::Infer(ty::IntVar(v_id))) => { + (&ty::Int(v), &ty::Infer(ty::IntVar(v_id))) => { self.unify_integral_variable(!a_is_expected, v_id, IntType(v)) } - (&ty::Infer(ty::IntVar(v_id)), &ty::TyUint(v)) => { + (&ty::Infer(ty::IntVar(v_id)), &ty::Uint(v)) => { self.unify_integral_variable(a_is_expected, v_id, UintType(v)) } - (&ty::TyUint(v), &ty::Infer(ty::IntVar(v_id))) => { + (&ty::Uint(v), &ty::Infer(ty::IntVar(v_id))) => { self.unify_integral_variable(!a_is_expected, v_id, UintType(v)) } @@ -104,10 +104,10 @@ impl<'infcx, 'gcx, 'tcx> InferCtxt<'infcx, 'gcx, 'tcx> { .map_err(|e| float_unification_error(relation.a_is_expected(), e))?; Ok(a) } - (&ty::Infer(ty::FloatVar(v_id)), &ty::TyFloat(v)) => { + (&ty::Infer(ty::FloatVar(v_id)), &ty::Float(v)) => { self.unify_float_variable(a_is_expected, v_id, v) } - (&ty::TyFloat(v), &ty::Infer(ty::FloatVar(v_id))) => { + (&ty::Float(v), &ty::Infer(ty::FloatVar(v_id))) => { self.unify_float_variable(!a_is_expected, v_id, v) } diff --git a/src/librustc/infer/error_reporting/mod.rs b/src/librustc/infer/error_reporting/mod.rs index 4f83c7c4d0c..02da3701db2 100644 --- a/src/librustc/infer/error_reporting/mod.rs +++ b/src/librustc/infer/error_reporting/mod.rs @@ -704,11 +704,11 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { fn equals<'tcx>(a: &Ty<'tcx>, b: &Ty<'tcx>) -> bool { match (&a.sty, &b.sty) { (a, b) if *a == *b => true, - (&ty::TyInt(_), &ty::Infer(ty::InferTy::IntVar(_))) - | (&ty::Infer(ty::InferTy::IntVar(_)), &ty::TyInt(_)) + (&ty::Int(_), &ty::Infer(ty::InferTy::IntVar(_))) + | (&ty::Infer(ty::InferTy::IntVar(_)), &ty::Int(_)) | (&ty::Infer(ty::InferTy::IntVar(_)), &ty::Infer(ty::InferTy::IntVar(_))) - | (&ty::TyFloat(_), &ty::Infer(ty::InferTy::FloatVar(_))) - | (&ty::Infer(ty::InferTy::FloatVar(_)), &ty::TyFloat(_)) + | (&ty::Float(_), &ty::Infer(ty::InferTy::FloatVar(_))) + | (&ty::Infer(ty::InferTy::FloatVar(_)), &ty::Float(_)) | ( &ty::Infer(ty::InferTy::FloatVar(_)), &ty::Infer(ty::InferTy::FloatVar(_)), diff --git a/src/librustc/infer/freshen.rs b/src/librustc/infer/freshen.rs index c1c16677ccc..4673aac1872 100644 --- a/src/librustc/infer/freshen.rs +++ b/src/librustc/infer/freshen.rs @@ -175,13 +175,13 @@ impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for TypeFreshener<'a, 'gcx, 'tcx> { bug!("encountered canonical ty during freshening"), ty::Generator(..) | - ty::TyBool | - ty::TyChar | - ty::TyInt(..) | - ty::TyUint(..) | - ty::TyFloat(..) | + ty::Bool | + ty::Char | + ty::Int(..) | + ty::Uint(..) | + ty::Float(..) | ty::Adt(..) | - ty::TyStr | + ty::Str | ty::Error | ty::Array(..) | ty::Slice(..) | diff --git a/src/librustc/mir/mod.rs b/src/librustc/mir/mod.rs index 9d556902e43..66a42cfb11a 100644 --- a/src/librustc/mir/mod.rs +++ b/src/librustc/mir/mod.rs @@ -2227,12 +2227,12 @@ pub fn fmt_const_val(f: &mut impl Write, const_val: &ty::Const) -> fmt::Result { // print some primitives if let ConstValue::Scalar(Scalar::Bits { bits, .. }) = value { match ty.sty { - TyBool if bits == 0 => return write!(f, "false"), - TyBool if bits == 1 => return write!(f, "true"), - TyFloat(ast::FloatTy::F32) => return write!(f, "{}f32", Single::from_bits(bits)), - TyFloat(ast::FloatTy::F64) => return write!(f, "{}f64", Double::from_bits(bits)), - TyUint(ui) => return write!(f, "{:?}{}", bits, ui), - TyInt(i) => { + Bool if bits == 0 => return write!(f, "false"), + Bool if bits == 1 => return write!(f, "true"), + Float(ast::FloatTy::F32) => return write!(f, "{}f32", Single::from_bits(bits)), + Float(ast::FloatTy::F64) => return write!(f, "{}f64", Double::from_bits(bits)), + Uint(ui) => return write!(f, "{:?}{}", bits, ui), + Int(i) => { let bit_width = ty::tls::with(|tcx| { let ty = tcx.lift_to_global(&ty).unwrap(); tcx.layout_of(ty::ParamEnv::empty().and(ty)) @@ -2243,7 +2243,7 @@ pub fn fmt_const_val(f: &mut impl Write, const_val: &ty::Const) -> fmt::Result { let shift = 128 - bit_width; return write!(f, "{:?}{}", ((bits as i128) << shift) >> shift, i); } - TyChar => return write!(f, "{:?}", ::std::char::from_u32(bits as u32).unwrap()), + Char => return write!(f, "{:?}", ::std::char::from_u32(bits as u32).unwrap()), _ => {}, } } @@ -2255,7 +2255,7 @@ pub fn fmt_const_val(f: &mut impl Write, const_val: &ty::Const) -> fmt::Result { if let ConstValue::ScalarPair(ptr, len) = value { if let Scalar::Ptr(ptr) = ptr { if let ScalarMaybeUndef::Scalar(Scalar::Bits { bits: len, .. }) = len { - if let Ref(_, &ty::TyS { sty: TyStr, .. }, _) = ty.sty { + if let Ref(_, &ty::TyS { sty: Str, .. }, _) = ty.sty { return ty::tls::with(|tcx| { let alloc = tcx.alloc_map.lock().get(ptr.alloc_id); if let Some(interpret::AllocType::Memory(alloc)) = alloc { diff --git a/src/librustc/traits/coherence.rs b/src/librustc/traits/coherence.rs index dd0fc7ebfce..c283c4d3cab 100644 --- a/src/librustc/traits/coherence.rs +++ b/src/librustc/traits/coherence.rs @@ -441,12 +441,12 @@ fn ty_is_local_constructor(ty: Ty, in_crate: InCrate) -> bool { debug!("ty_is_local_constructor({:?})", ty); match ty.sty { - ty::TyBool | - ty::TyChar | - ty::TyInt(..) | - ty::TyUint(..) | - ty::TyFloat(..) | - ty::TyStr | + ty::Bool | + ty::Char | + ty::Int(..) | + ty::Uint(..) | + ty::Float(..) | + ty::Str | ty::FnDef(..) | ty::FnPtr(_) | ty::Array(..) | diff --git a/src/librustc/traits/error_reporting.rs b/src/librustc/traits/error_reporting.rs index e095984d07f..f92deb89e8b 100644 --- a/src/librustc/traits/error_reporting.rs +++ b/src/librustc/traits/error_reporting.rs @@ -244,11 +244,11 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { /// if the type can be equated to any type. fn type_category<'tcx>(t: Ty<'tcx>) -> Option<u32> { match t.sty { - ty::TyBool => Some(0), - ty::TyChar => Some(1), - ty::TyStr => Some(2), - ty::TyInt(..) | ty::TyUint(..) | ty::Infer(ty::IntVar(..)) => Some(3), - ty::TyFloat(..) | ty::Infer(ty::FloatVar(..)) => Some(4), + ty::Bool => Some(0), + ty::Char => Some(1), + ty::Str => Some(2), + ty::Int(..) | ty::Uint(..) | ty::Infer(ty::IntVar(..)) => Some(3), + ty::Float(..) | ty::Infer(ty::FloatVar(..)) => Some(4), ty::Ref(..) | ty::RawPtr(..) => Some(5), ty::Array(..) | ty::Slice(..) => Some(6), ty::FnDef(..) | ty::FnPtr(..) => Some(7), diff --git a/src/librustc/traits/query/dropck_outlives.rs b/src/librustc/traits/query/dropck_outlives.rs index 63552ba4a30..b479cafd1ce 100644 --- a/src/librustc/traits/query/dropck_outlives.rs +++ b/src/librustc/traits/query/dropck_outlives.rs @@ -216,18 +216,18 @@ pub fn trivial_dropck_outlives<'tcx>(tcx: TyCtxt<'_, '_, 'tcx>, ty: Ty<'tcx>) -> // execution. ty::Infer(ty::FreshIntTy(_)) | ty::Infer(ty::FreshFloatTy(_)) - | ty::TyBool - | ty::TyInt(_) - | ty::TyUint(_) - | ty::TyFloat(_) + | ty::Bool + | ty::Int(_) + | ty::Uint(_) + | ty::Float(_) | ty::Never | ty::FnDef(..) | ty::FnPtr(_) - | ty::TyChar + | ty::Char | ty::GeneratorWitness(..) | ty::RawPtr(_) | ty::Ref(..) - | ty::TyStr + | ty::Str | ty::Foreign(..) | ty::Error => true, diff --git a/src/librustc/traits/select.rs b/src/librustc/traits/select.rs index d2d7b8c37cc..dd383732bf8 100644 --- a/src/librustc/traits/select.rs +++ b/src/librustc/traits/select.rs @@ -2180,16 +2180,16 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> { match self_ty.sty { ty::Infer(ty::IntVar(_)) | ty::Infer(ty::FloatVar(_)) | - ty::TyUint(_) | ty::TyInt(_) | ty::TyBool | ty::TyFloat(_) | + ty::Uint(_) | ty::Int(_) | ty::Bool | ty::Float(_) | ty::FnDef(..) | ty::FnPtr(_) | ty::RawPtr(..) | - ty::TyChar | ty::Ref(..) | ty::Generator(..) | + ty::Char | ty::Ref(..) | ty::Generator(..) | ty::GeneratorWitness(..) | ty::Array(..) | ty::Closure(..) | ty::Never | ty::Error => { // safe for everything Where(ty::Binder::dummy(Vec::new())) } - ty::TyStr | ty::Slice(_) | ty::Dynamic(..) | ty::Foreign(..) => None, + ty::Str | ty::Slice(_) | ty::Dynamic(..) | ty::Foreign(..) => None, ty::Tuple(tys) => { Where(ty::Binder::bind(tys.last().into_iter().cloned().collect())) @@ -2231,14 +2231,14 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> { Where(ty::Binder::dummy(Vec::new())) } - ty::TyUint(_) | ty::TyInt(_) | ty::TyBool | ty::TyFloat(_) | - ty::TyChar | ty::RawPtr(..) | ty::Never | + ty::Uint(_) | ty::Int(_) | ty::Bool | ty::Float(_) | + ty::Char | ty::RawPtr(..) | ty::Never | ty::Ref(_, _, hir::MutImmutable) => { // Implementations provided in libcore None } - ty::Dynamic(..) | ty::TyStr | ty::Slice(..) | + ty::Dynamic(..) | ty::Str | ty::Slice(..) | ty::Generator(..) | ty::GeneratorWitness(..) | ty::Foreign(..) | ty::Ref(_, _, hir::MutMutable) => { None @@ -2300,18 +2300,18 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> { /// ``` fn constituent_types_for_ty(&self, t: Ty<'tcx>) -> Vec<Ty<'tcx>> { match t.sty { - ty::TyUint(_) | - ty::TyInt(_) | - ty::TyBool | - ty::TyFloat(_) | + ty::Uint(_) | + ty::Int(_) | + ty::Bool | + ty::Float(_) | ty::FnDef(..) | ty::FnPtr(_) | - ty::TyStr | + ty::Str | ty::Error | ty::Infer(ty::IntVar(_)) | ty::Infer(ty::FloatVar(_)) | ty::Never | - ty::TyChar => { + ty::Char => { Vec::new() } diff --git a/src/librustc/ty/cast.rs b/src/librustc/ty/cast.rs index 56ca13404aa..c0861abb774 100644 --- a/src/librustc/ty/cast.rs +++ b/src/librustc/ty/cast.rs @@ -60,13 +60,13 @@ pub enum CastKind { impl<'tcx> CastTy<'tcx> { pub fn from_ty(t: Ty<'tcx>) -> Option<CastTy<'tcx>> { match t.sty { - ty::TyBool => Some(CastTy::Int(IntTy::Bool)), - ty::TyChar => Some(CastTy::Int(IntTy::Char)), - ty::TyInt(_) => Some(CastTy::Int(IntTy::I)), + ty::Bool => Some(CastTy::Int(IntTy::Bool)), + ty::Char => Some(CastTy::Int(IntTy::Char)), + ty::Int(_) => Some(CastTy::Int(IntTy::I)), ty::Infer(ty::InferTy::IntVar(_)) => Some(CastTy::Int(IntTy::I)), ty::Infer(ty::InferTy::FloatVar(_)) => Some(CastTy::Float), - ty::TyUint(u) => Some(CastTy::Int(IntTy::U(u))), - ty::TyFloat(_) => Some(CastTy::Float), + ty::Uint(u) => Some(CastTy::Int(IntTy::U(u))), + ty::Float(_) => Some(CastTy::Float), ty::Adt(d,_) if d.is_enum() && d.is_payloadfree() => Some(CastTy::Int(IntTy::CEnum)), ty::RawPtr(mt) => Some(CastTy::Ptr(mt)), diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs index b725823b406..0545a88f36b 100644 --- a/src/librustc/ty/context.rs +++ b/src/librustc/ty/context.rs @@ -817,24 +817,24 @@ impl<'tcx> CommonTypes<'tcx> { &*r }; CommonTypes { - bool: mk(TyBool), - char: mk(TyChar), + bool: mk(Bool), + char: mk(Char), never: mk(Never), err: mk(Error), - isize: mk(TyInt(ast::IntTy::Isize)), - i8: mk(TyInt(ast::IntTy::I8)), - i16: mk(TyInt(ast::IntTy::I16)), - i32: mk(TyInt(ast::IntTy::I32)), - i64: mk(TyInt(ast::IntTy::I64)), - i128: mk(TyInt(ast::IntTy::I128)), - usize: mk(TyUint(ast::UintTy::Usize)), - u8: mk(TyUint(ast::UintTy::U8)), - u16: mk(TyUint(ast::UintTy::U16)), - u32: mk(TyUint(ast::UintTy::U32)), - u64: mk(TyUint(ast::UintTy::U64)), - u128: mk(TyUint(ast::UintTy::U128)), - f32: mk(TyFloat(ast::FloatTy::F32)), - f64: mk(TyFloat(ast::FloatTy::F64)), + isize: mk(Int(ast::IntTy::Isize)), + i8: mk(Int(ast::IntTy::I8)), + i16: mk(Int(ast::IntTy::I16)), + i32: mk(Int(ast::IntTy::I32)), + i64: mk(Int(ast::IntTy::I64)), + i128: mk(Int(ast::IntTy::I128)), + usize: mk(Uint(ast::UintTy::Usize)), + u8: mk(Uint(ast::UintTy::U8)), + u16: mk(Uint(ast::UintTy::U16)), + u32: mk(Uint(ast::UintTy::U32)), + u64: mk(Uint(ast::UintTy::U64)), + u128: mk(Uint(ast::UintTy::U128)), + f32: mk(Float(ast::FloatTy::F32)), + f64: mk(Float(ast::FloatTy::F64)), re_empty: mk_region(RegionKind::ReEmpty), re_static: mk_region(RegionKind::ReStatic), @@ -2035,8 +2035,8 @@ macro_rules! sty_debug_print { for &Interned(t) in tcx.interners.type_.borrow().iter() { let variant = match t.sty { - ty::TyBool | ty::TyChar | ty::TyInt(..) | ty::TyUint(..) | - ty::TyFloat(..) | ty::TyStr | ty::Never => continue, + ty::Bool | ty::Char | ty::Int(..) | ty::Uint(..) | + ty::Float(..) | ty::Str | ty::Never => continue, ty::Error => /* unimportant */ continue, $(ty::$variant(..) => &mut $variant,)* }; @@ -2374,7 +2374,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } pub fn mk_str(self) -> Ty<'tcx> { - self.mk_ty(TyStr) + self.mk_ty(Str) } pub fn mk_static_str(self) -> Ty<'tcx> { @@ -2466,7 +2466,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } pub fn mk_bool(self) -> Ty<'tcx> { - self.mk_ty(TyBool) + self.mk_ty(Bool) } pub fn mk_fn_def(self, def_id: DefId, diff --git a/src/librustc/ty/error.rs b/src/librustc/ty/error.rs index d367a5e4bcf..aa6ee420a21 100644 --- a/src/librustc/ty/error.rs +++ b/src/librustc/ty/error.rs @@ -175,8 +175,8 @@ impl<'tcx> fmt::Display for TypeError<'tcx> { impl<'a, 'gcx, 'lcx, 'tcx> ty::TyS<'tcx> { pub fn sort_string(&self, tcx: TyCtxt<'a, 'gcx, 'lcx>) -> String { match self.sty { - ty::TyBool | ty::TyChar | ty::TyInt(_) | - ty::TyUint(_) | ty::TyFloat(_) | ty::TyStr | ty::Never => self.to_string(), + ty::Bool | ty::Char | ty::Int(_) | + ty::Uint(_) | ty::Float(_) | ty::Str | ty::Never => self.to_string(), ty::Tuple(ref tys) if tys.is_empty() => self.to_string(), ty::Adt(def, _) => format!("{} `{}`", def.descr(), tcx.item_path_str(def.did)), @@ -251,7 +251,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { db.help("consider boxing your closure and/or using it as a trait object"); } match (&values.found.sty, &values.expected.sty) { // Issue #53280 - (ty::Infer(ty::IntVar(_)), ty::TyFloat(_)) => { + (ty::Infer(ty::IntVar(_)), ty::Float(_)) => { if let Ok(snippet) = self.sess.source_map().span_to_snippet(sp) { if snippet.chars().all(|c| c.is_digit(10) || c == '-' || c == '_') { db.span_suggestion_with_applicability( diff --git a/src/librustc/ty/fast_reject.rs b/src/librustc/ty/fast_reject.rs index d4eda9e96f2..567d1c668f7 100644 --- a/src/librustc/ty/fast_reject.rs +++ b/src/librustc/ty/fast_reject.rs @@ -68,13 +68,13 @@ pub fn simplify_type<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>, -> Option<SimplifiedType> { match ty.sty { - 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::Bool => Some(BoolSimplifiedType), + ty::Char => Some(CharSimplifiedType), + ty::Int(int_type) => Some(IntSimplifiedType(int_type)), + ty::Uint(uint_type) => Some(UintSimplifiedType(uint_type)), + ty::Float(float_type) => Some(FloatSimplifiedType(float_type)), ty::Adt(def, _) => Some(AdtSimplifiedType(def.did)), - ty::TyStr => Some(StrSimplifiedType), + ty::Str => Some(StrSimplifiedType), ty::Array(..) | ty::Slice(_) => Some(ArraySimplifiedType), ty::RawPtr(_) => Some(PtrSimplifiedType), ty::Dynamic(ref trait_info, ..) => { diff --git a/src/librustc/ty/flags.rs b/src/librustc/ty/flags.rs index bdff532933c..b9371ec39cc 100644 --- a/src/librustc/ty/flags.rs +++ b/src/librustc/ty/flags.rs @@ -69,13 +69,13 @@ impl FlagComputation { fn add_sty(&mut self, st: &ty::TyKind) { match st { - &ty::TyBool | - &ty::TyChar | - &ty::TyInt(_) | - &ty::TyFloat(_) | - &ty::TyUint(_) | + &ty::Bool | + &ty::Char | + &ty::Int(_) | + &ty::Float(_) | + &ty::Uint(_) | &ty::Never | - &ty::TyStr | + &ty::Str | &ty::Foreign(..) => { } diff --git a/src/librustc/ty/item_path.rs b/src/librustc/ty/item_path.rs index b8d68111284..e38bb411a14 100644 --- a/src/librustc/ty/item_path.rs +++ b/src/librustc/ty/item_path.rs @@ -309,12 +309,12 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { ty::Foreign(did) => self.push_item_path(buffer, did), - ty::TyBool | - ty::TyChar | - ty::TyInt(_) | - ty::TyUint(_) | - ty::TyFloat(_) | - ty::TyStr => { + ty::Bool | + ty::Char | + ty::Int(_) | + ty::Uint(_) | + ty::Float(_) | + ty::Str => { buffer.push(&self_ty.to_string()); } @@ -377,11 +377,11 @@ pub fn characteristic_def_id_of_type(ty: Ty) -> Option<DefId> { ty::Generator(def_id, _, _) | ty::Foreign(def_id) => Some(def_id), - ty::TyBool | - ty::TyChar | - ty::TyInt(_) | - ty::TyUint(_) | - ty::TyStr | + ty::Bool | + ty::Char | + ty::Int(_) | + ty::Uint(_) | + ty::Str | ty::FnPtr(_) | ty::Projection(_) | ty::Param(_) | @@ -390,7 +390,7 @@ pub fn characteristic_def_id_of_type(ty: Ty) -> Option<DefId> { ty::Error | ty::GeneratorWitness(..) | ty::Never | - ty::TyFloat(_) => None, + ty::Float(_) => None, } } diff --git a/src/librustc/ty/layout.rs b/src/librustc/ty/layout.rs index 9bff0784283..d485b9b32d4 100644 --- a/src/librustc/ty/layout.rs +++ b/src/librustc/ty/layout.rs @@ -470,25 +470,25 @@ impl<'a, 'tcx> LayoutCx<'tcx, TyCtxt<'a, 'tcx, 'tcx>> { Ok(match ty.sty { // Basic scalars. - ty::TyBool => { + ty::Bool => { tcx.intern_layout(LayoutDetails::scalar(self, Scalar { value: Int(I8, false), valid_range: 0..=1 })) } - ty::TyChar => { + ty::Char => { tcx.intern_layout(LayoutDetails::scalar(self, Scalar { value: Int(I32, false), valid_range: 0..=0x10FFFF })) } - ty::TyInt(ity) => { + ty::Int(ity) => { scalar(Int(Integer::from_attr(dl, attr::SignedInt(ity)), true)) } - ty::TyUint(ity) => { + ty::Uint(ity) => { scalar(Int(Integer::from_attr(dl, attr::UnsignedInt(ity)), false)) } - ty::TyFloat(fty) => scalar(Float(fty)), + ty::Float(fty) => scalar(Float(fty)), ty::FnPtr(_) => { let mut ptr = scalar_unit(Pointer); ptr.valid_range = 1..=*ptr.valid_range.end(); @@ -524,7 +524,7 @@ impl<'a, 'tcx> LayoutCx<'tcx, TyCtxt<'a, 'tcx, 'tcx>> { ty::Foreign(..) => { return Ok(tcx.intern_layout(LayoutDetails::scalar(self, data_ptr))); } - ty::Slice(_) | ty::TyStr => { + ty::Slice(_) | ty::Str => { scalar_unit(Int(dl.ptr_sized_integer(), false)) } ty::Dynamic(..) => { @@ -577,7 +577,7 @@ impl<'a, 'tcx> LayoutCx<'tcx, TyCtxt<'a, 'tcx, 'tcx>> { size: Size::ZERO }) } - ty::TyStr => { + ty::Str => { tcx.intern_layout(LayoutDetails { variants: Variants::Single { index: 0 }, fields: FieldPlacement::Array { @@ -1582,11 +1582,11 @@ impl<'a, 'tcx, C> TyLayoutMethods<'tcx, C> for Ty<'tcx> fn field(this: TyLayout<'tcx>, cx: C, i: usize) -> C::TyLayout { let tcx = cx.tcx(); cx.layout_of(match this.ty.sty { - ty::TyBool | - ty::TyChar | - ty::TyInt(_) | - ty::TyUint(_) | - ty::TyFloat(_) | + ty::Bool | + ty::Char | + ty::Int(_) | + ty::Uint(_) | + ty::Float(_) | ty::FnPtr(_) | ty::Never | ty::FnDef(..) | @@ -1620,7 +1620,7 @@ impl<'a, 'tcx, C> TyLayoutMethods<'tcx, C> for Ty<'tcx> match tcx.struct_tail(pointee).sty { ty::Slice(_) | - ty::TyStr => tcx.types.usize, + ty::Str => tcx.types.usize, ty::Dynamic(data, _) => { let trait_def_id = data.principal().unwrap().def_id(); let num_fns: u64 = crate::traits::supertrait_def_ids(tcx, trait_def_id) @@ -1648,7 +1648,7 @@ impl<'a, 'tcx, C> TyLayoutMethods<'tcx, C> for Ty<'tcx> // Arrays and slices. ty::Array(element, _) | ty::Slice(element) => element, - ty::TyStr => tcx.types.u8, + ty::Str => tcx.types.u8, // Tuples, generators and closures. ty::Closure(def_id, ref substs) => { diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index 3b1f91c5d74..8d5006d17b3 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -542,11 +542,11 @@ impl<'tcx> Hash for TyS<'tcx> { impl<'tcx> TyS<'tcx> { pub fn is_primitive_ty(&self) -> bool { match self.sty { - TyKind::TyBool | - TyKind::TyChar | - TyKind::TyInt(_) | - TyKind::TyUint(_) | - TyKind::TyFloat(_) | + TyKind::Bool | + TyKind::Char | + TyKind::Int(_) | + TyKind::Uint(_) | + TyKind::Float(_) | TyKind::Infer(InferTy::IntVar(_)) | TyKind::Infer(InferTy::FloatVar(_)) | TyKind::Infer(InferTy::FreshIntTy(_)) | @@ -2230,13 +2230,13 @@ impl<'a, 'gcx, 'tcx> AdtDef { ty: Ty<'tcx>) -> Vec<Ty<'tcx>> { let result = match ty.sty { - TyBool | TyChar | TyInt(..) | TyUint(..) | TyFloat(..) | + Bool | Char | Int(..) | Uint(..) | Float(..) | RawPtr(..) | Ref(..) | FnDef(..) | FnPtr(_) | Array(..) | Closure(..) | Generator(..) | Never => { vec![] } - TyStr | + Str | Dynamic(..) | Slice(_) | Foreign(..) | diff --git a/src/librustc/ty/outlives.rs b/src/librustc/ty/outlives.rs index 884f366de4f..5171bfb7e06 100644 --- a/src/librustc/ty/outlives.rs +++ b/src/librustc/ty/outlives.rs @@ -137,16 +137,16 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { // the type and then visits the types that are lexically // contained within. (The comments refer to relevant rules // from RFC1214.) - ty::TyBool | // OutlivesScalar - ty::TyChar | // OutlivesScalar - ty::TyInt(..) | // OutlivesScalar - ty::TyUint(..) | // OutlivesScalar - ty::TyFloat(..) | // OutlivesScalar + ty::Bool | // OutlivesScalar + ty::Char | // OutlivesScalar + ty::Int(..) | // OutlivesScalar + ty::Uint(..) | // OutlivesScalar + ty::Float(..) | // OutlivesScalar ty::Never | // ... ty::Adt(..) | // OutlivesNominalType ty::Anon(..) | // OutlivesNominalType (ish) ty::Foreign(..) | // OutlivesNominalType - ty::TyStr | // OutlivesScalar (ish) + ty::Str | // OutlivesScalar (ish) ty::Array(..) | // ... ty::Slice(..) | // ... ty::RawPtr(..) | // ... diff --git a/src/librustc/ty/relate.rs b/src/librustc/ty/relate.rs index c65efdd946c..d72e48c04fe 100644 --- a/src/librustc/ty/relate.rs +++ b/src/librustc/ty/relate.rs @@ -376,12 +376,12 @@ pub fn super_relate_tys<'a, 'gcx, 'tcx, R>(relation: &mut R, } (&ty::Never, _) | - (&ty::TyChar, _) | - (&ty::TyBool, _) | - (&ty::TyInt(_), _) | - (&ty::TyUint(_), _) | - (&ty::TyFloat(_), _) | - (&ty::TyStr, _) + (&ty::Char, _) | + (&ty::Bool, _) | + (&ty::Int(_), _) | + (&ty::Uint(_), _) | + (&ty::Float(_), _) | + (&ty::Str, _) if a == b => { Ok(a) diff --git a/src/librustc/ty/structural_impls.rs b/src/librustc/ty/structural_impls.rs index 4dbbf50caa8..09ec6c79139 100644 --- a/src/librustc/ty/structural_impls.rs +++ b/src/librustc/ty/structural_impls.rs @@ -860,8 +860,8 @@ impl<'tcx> TypeFoldable<'tcx> for Ty<'tcx> { ty::Closure(did, substs) => ty::Closure(did, substs.fold_with(folder)), ty::Projection(ref data) => ty::Projection(data.fold_with(folder)), ty::Anon(did, substs) => ty::Anon(did, substs.fold_with(folder)), - ty::TyBool | ty::TyChar | ty::TyStr | ty::TyInt(_) | - ty::TyUint(_) | ty::TyFloat(_) | ty::Error | ty::Infer(_) | + ty::Bool | ty::Char | ty::Str | ty::Int(_) | + ty::Uint(_) | ty::Float(_) | ty::Error | ty::Infer(_) | ty::Param(..) | ty::Never | ty::Foreign(..) => return self }; @@ -895,8 +895,8 @@ impl<'tcx> TypeFoldable<'tcx> for Ty<'tcx> { ty::Closure(_did, ref substs) => substs.visit_with(visitor), ty::Projection(ref data) => data.visit_with(visitor), ty::Anon(_, ref substs) => substs.visit_with(visitor), - ty::TyBool | ty::TyChar | ty::TyStr | ty::TyInt(_) | - ty::TyUint(_) | ty::TyFloat(_) | ty::Error | ty::Infer(_) | + ty::Bool | ty::Char | ty::Str | ty::Int(_) | + ty::Uint(_) | ty::Float(_) | ty::Error | ty::Infer(_) | ty::Param(..) | ty::Never | ty::Foreign(..) => false, } } diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs index 9c3da83814f..7c7ee9b330e 100644 --- a/src/librustc/ty/sty.rs +++ b/src/librustc/ty/sty.rs @@ -84,20 +84,20 @@ impl BoundRegion { #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable)] pub enum TyKind<'tcx> { /// The primitive boolean type. Written as `bool`. - TyBool, + Bool, /// The primitive character type; holds a Unicode scalar value /// (a non-surrogate code point). Written as `char`. - TyChar, + Char, /// A primitive signed integer type. For example, `i32`. - TyInt(ast::IntTy), + Int(ast::IntTy), /// A primitive unsigned integer type. For example, `u32`. - TyUint(ast::UintTy), + Uint(ast::UintTy), /// A primitive floating-point type. For example, `f64`. - TyFloat(ast::FloatTy), + Float(ast::FloatTy), /// Structures, enumerations and unions. /// @@ -110,7 +110,7 @@ pub enum TyKind<'tcx> { Foreign(DefId), /// The pointee of a string slice. Written as `str`. - TyStr, + Str, /// An array with the given length. Written as `[T; n]`. Array(Ty<'tcx>, &'tcx ty::Const<'tcx>), @@ -1483,7 +1483,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> { pub fn is_primitive(&self) -> bool { match self.sty { - TyBool | TyChar | TyInt(_) | TyUint(_) | TyFloat(_) => true, + Bool | Char | Int(_) | Uint(_) | Float(_) => true, _ => false, } } @@ -1510,7 +1510,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> { } } - pub fn is_bool(&self) -> bool { self.sty == TyBool } + pub fn is_bool(&self) -> bool { self.sty == Bool } pub fn is_param(&self, index: u32) -> bool { match self.sty { @@ -1529,7 +1529,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> { pub fn is_slice(&self) -> bool { match self.sty { RawPtr(TypeAndMut { ty, .. }) | Ref(_, ty, _) => match ty.sty { - Slice(_) | TyStr => true, + Slice(_) | Str => true, _ => false, }, _ => false @@ -1547,7 +1547,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> { pub fn sequence_element_type(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Ty<'tcx> { match self.sty { Array(ty, _) | Slice(ty) => ty, - TyStr => tcx.mk_mach_uint(ast::UintTy::U8), + Str => tcx.mk_mach_uint(ast::UintTy::U8), _ => bug!("sequence_element_type called on non-sequence value: {}", self), } } @@ -1610,7 +1610,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> { /// contents are abstract to rustc.) pub fn is_scalar(&self) -> bool { match self.sty { - TyBool | TyChar | TyInt(_) | TyFloat(_) | TyUint(_) | + Bool | Char | Int(_) | Float(_) | Uint(_) | Infer(IntVar(_)) | Infer(FloatVar(_)) | FnDef(..) | FnPtr(_) | RawPtr(_) => true, _ => false @@ -1620,7 +1620,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> { /// Returns true if this type is a floating point type and false otherwise. pub fn is_floating_point(&self) -> bool { match self.sty { - TyFloat(_) | + Float(_) | Infer(FloatVar(_)) => true, _ => false, } @@ -1658,7 +1658,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> { pub fn is_integral(&self) -> bool { match self.sty { - Infer(IntVar(_)) | TyInt(_) | TyUint(_) => true, + Infer(IntVar(_)) | Int(_) | Uint(_) => true, _ => false } } @@ -1681,14 +1681,14 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> { pub fn is_char(&self) -> bool { match self.sty { - TyChar => true, + Char => true, _ => false, } } pub fn is_fp(&self) -> bool { match self.sty { - Infer(FloatVar(_)) | TyFloat(_) => true, + Infer(FloatVar(_)) | Float(_) => true, _ => false } } @@ -1699,15 +1699,15 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> { pub fn is_signed(&self) -> bool { match self.sty { - TyInt(_) => true, + Int(_) => true, _ => false, } } pub fn is_machine(&self) -> bool { match self.sty { - TyInt(ast::IntTy::Isize) | TyUint(ast::UintTy::Usize) => false, - TyInt(..) | TyUint(..) | TyFloat(..) => true, + Int(ast::IntTy::Isize) | Uint(ast::UintTy::Usize) => false, + Int(..) | Uint(..) | Float(..) => true, _ => false, } } @@ -1804,12 +1804,12 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> { FnDef(..) | FnPtr(_) | GeneratorWitness(..) | - TyBool | - TyChar | - TyInt(_) | - TyUint(_) | - TyFloat(_) | - TyStr | + Bool | + Char | + Int(_) | + Uint(_) | + Float(_) | + Str | Array(..) | Slice(_) | RawPtr(_) | @@ -1838,7 +1838,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> { /// is complete, that type variable will be unified. pub fn to_opt_closure_kind(&self) -> Option<ty::ClosureKind> { match self.sty { - TyInt(int_ty) => match int_ty { + Int(int_ty) => match int_ty { ast::IntTy::I8 => Some(ty::ClosureKind::Fn), ast::IntTy::I16 => Some(ty::ClosureKind::FnMut), ast::IntTy::I32 => Some(ty::ClosureKind::FnOnce), @@ -1860,14 +1860,14 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> { pub fn is_trivially_sized(&self, tcx: TyCtxt<'_, '_, 'tcx>) -> bool { match self.sty { ty::Infer(ty::IntVar(_)) | ty::Infer(ty::FloatVar(_)) | - ty::TyUint(_) | ty::TyInt(_) | ty::TyBool | ty::TyFloat(_) | + ty::Uint(_) | ty::Int(_) | ty::Bool | ty::Float(_) | ty::FnDef(..) | ty::FnPtr(_) | ty::RawPtr(..) | - ty::TyChar | ty::Ref(..) | ty::Generator(..) | + ty::Char | ty::Ref(..) | ty::Generator(..) | ty::GeneratorWitness(..) | ty::Array(..) | ty::Closure(..) | ty::Never | ty::Error => true, - ty::TyStr | ty::Slice(_) | ty::Dynamic(..) | ty::Foreign(..) => + ty::Str | ty::Slice(_) | ty::Dynamic(..) | ty::Foreign(..) => false, ty::Tuple(tys) => diff --git a/src/librustc/ty/util.rs b/src/librustc/ty/util.rs index 6b0734cc992..44f5ab141fa 100644 --- a/src/librustc/ty/util.rs +++ b/src/librustc/ty/util.rs @@ -41,7 +41,7 @@ pub struct Discr<'tcx> { impl<'tcx> fmt::Display for Discr<'tcx> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { match self.ty.sty { - ty::TyInt(ity) => { + ty::Int(ity) => { let bits = ty::tls::with(|tcx| { Integer::from_attr(tcx, SignedInt(ity)).size().bits() }); @@ -62,8 +62,8 @@ impl<'tcx> Discr<'tcx> { } pub fn checked_add<'a, 'gcx>(self, tcx: TyCtxt<'a, 'gcx, 'tcx>, n: u128) -> (Self, bool) { let (int, signed) = match self.ty.sty { - TyInt(ity) => (Integer::from_attr(tcx, SignedInt(ity)), true), - TyUint(uty) => (Integer::from_attr(tcx, UnsignedInt(uty)), false), + Int(ity) => (Integer::from_attr(tcx, SignedInt(ity)), true), + Uint(uty) => (Integer::from_attr(tcx, UnsignedInt(uty)), false), _ => bug!("non integer discriminant"), }; @@ -193,8 +193,8 @@ impl<'tcx> ty::ParamEnv<'tcx> { let (adt, substs) = match self_type.sty { // These types used to have a builtin impl. // Now libcore provides that impl. - ty::TyUint(_) | ty::TyInt(_) | ty::TyBool | ty::TyFloat(_) | - ty::TyChar | ty::RawPtr(..) | ty::Never | + ty::Uint(_) | ty::Int(_) | ty::Bool | ty::Float(_) | + ty::Char | ty::RawPtr(..) | ty::Never | ty::Ref(_, _, hir::MutImmutable) => return Ok(()), ty::Adt(adt, substs) => (adt, substs), @@ -925,9 +925,9 @@ fn needs_drop_raw<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, match ty.sty { // Fast-path for primitive types ty::Infer(ty::FreshIntTy(_)) | ty::Infer(ty::FreshFloatTy(_)) | - ty::TyBool | ty::TyInt(_) | ty::TyUint(_) | ty::TyFloat(_) | ty::Never | - ty::FnDef(..) | ty::FnPtr(_) | ty::TyChar | ty::GeneratorWitness(..) | - ty::RawPtr(_) | ty::Ref(..) | ty::TyStr => false, + ty::Bool | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Never | + ty::FnDef(..) | ty::FnPtr(_) | ty::Char | ty::GeneratorWitness(..) | + ty::RawPtr(_) | ty::Ref(..) | ty::Str => false, // Foreign types can never have destructors ty::Foreign(..) => false, diff --git a/src/librustc/ty/walk.rs b/src/librustc/ty/walk.rs index b40e0968fd8..e2df7c32f58 100644 --- a/src/librustc/ty/walk.rs +++ b/src/librustc/ty/walk.rs @@ -81,8 +81,8 @@ pub fn walk_shallow<'tcx>(ty: Ty<'tcx>) -> AccIntoIter<TypeWalkerArray<'tcx>> { // types as they are written). fn push_subtypes<'tcx>(stack: &mut TypeWalkerStack<'tcx>, parent_ty: Ty<'tcx>) { match parent_ty.sty { - ty::TyBool | ty::TyChar | ty::TyInt(_) | ty::TyUint(_) | ty::TyFloat(_) | - ty::TyStr | ty::Infer(_) | ty::Param(_) | ty::Never | ty::Error | + ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | + ty::Str | ty::Infer(_) | ty::Param(_) | ty::Never | ty::Error | ty::Foreign(..) => { } ty::Array(ty, len) => { diff --git a/src/librustc/ty/wf.rs b/src/librustc/ty/wf.rs index 56eaaa942f5..fc55d8f34a2 100644 --- a/src/librustc/ty/wf.rs +++ b/src/librustc/ty/wf.rs @@ -248,13 +248,13 @@ impl<'a, 'gcx, 'tcx> WfPredicates<'a, 'gcx, 'tcx> { let param_env = self.param_env; while let Some(ty) = subtys.next() { match ty.sty { - ty::TyBool | - ty::TyChar | - ty::TyInt(..) | - ty::TyUint(..) | - ty::TyFloat(..) | + ty::Bool | + ty::Char | + ty::Int(..) | + ty::Uint(..) | + ty::Float(..) | ty::Error | - ty::TyStr | + ty::Str | ty::GeneratorWitness(..) | ty::Never | ty::Param(_) | diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 18901fcb4f2..0f15c75c2fb 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -14,11 +14,11 @@ use mir::interpret::ConstValue; use middle::region::{self, BlockRemainder}; use ty::subst::{self, Subst}; use ty::{BrAnon, BrEnv, BrFresh, BrNamed}; -use ty::{TyBool, TyChar, Adt}; -use ty::{Error, TyStr, Array, Slice, TyFloat, FnDef, FnPtr}; +use ty::{Bool, Char, Adt}; +use ty::{Error, Str, Array, Slice, Float, FnDef, FnPtr}; use ty::{Param, RawPtr, Ref, Never, Tuple}; use ty::{Closure, Generator, GeneratorWitness, Foreign, Projection, Anon}; -use ty::{Dynamic, TyInt, TyUint, Infer}; +use ty::{Dynamic, Int, Uint, Infer}; use ty::{self, RegionVid, Ty, TyCtxt, TypeFoldable, GenericParamCount, GenericParamDefKind}; use util::nodemap::FxHashSet; @@ -1032,11 +1032,11 @@ define_print! { ('tcx) ty::TyKind<'tcx>, (self, f, cx) { display { match *self { - TyBool => write!(f, "bool"), - TyChar => write!(f, "char"), - TyInt(t) => write!(f, "{}", t.ty_to_string()), - TyUint(t) => write!(f, "{}", t.ty_to_string()), - TyFloat(t) => write!(f, "{}", t.ty_to_string()), + Bool => write!(f, "bool"), + Char => write!(f, "char"), + Int(t) => write!(f, "{}", t.ty_to_string()), + Uint(t) => write!(f, "{}", t.ty_to_string()), + Float(t) => write!(f, "{}", t.ty_to_string()), RawPtr(ref tm) => { write!(f, "*{} ", match tm.mutbl { hir::MutMutable => "mut", @@ -1154,7 +1154,7 @@ define_print! { Ok(()) }) } - TyStr => write!(f, "str"), + Str => write!(f, "str"), Generator(did, substs, movability) => ty::tls::with(|tcx| { let upvar_tys = substs.upvar_tys(did, tcx); let witness = substs.witness(did, tcx); |