From 33b7386d3949e0a372e386f7a4593b12d5fa542a Mon Sep 17 00:00:00 2001 From: Eli Friedman Date: Fri, 12 Jun 2015 16:50:13 -0700 Subject: [PATCH] Split TyArray into TyArray and TySlice. Arrays and slices are closely related, but not that closely; making the separation more explicit is generally more clear. --- src/librustc/metadata/tyencode.rs | 11 +-- src/librustc/middle/check_const.rs | 12 ++-- src/librustc/middle/check_match.rs | 14 ++-- src/librustc/middle/fast_reject.rs | 2 +- src/librustc/middle/implicator.rs | 1 + src/librustc/middle/infer/freshen.rs | 1 + src/librustc/middle/mem_categorization.rs | 10 +-- src/librustc/middle/traits/coherence.rs | 1 + src/librustc/middle/traits/select.rs | 33 +++------ src/librustc/middle/ty.rs | 70 +++++++++---------- src/librustc/middle/ty_fold.rs | 3 + src/librustc/middle/ty_relate/mod.rs | 4 +- src/librustc/middle/ty_walk.rs | 2 +- src/librustc/util/ppaux.rs | 11 ++- src/librustc_trans/trans/_match.rs | 4 +- src/librustc_trans/trans/adt.rs | 2 +- src/librustc_trans/trans/base.rs | 4 +- src/librustc_trans/trans/common.rs | 2 +- src/librustc_trans/trans/consts.rs | 6 +- .../trans/debuginfo/metadata.rs | 25 ++++--- .../trans/debuginfo/type_names.rs | 16 ++--- src/librustc_trans/trans/expr.rs | 2 +- src/librustc_trans/trans/glue.rs | 2 +- src/librustc_trans/trans/tvec.rs | 4 +- src/librustc_trans/trans/type_of.rs | 10 +-- src/librustc_typeck/check/_match.rs | 4 +- src/librustc_typeck/check/cast.rs | 4 +- src/librustc_typeck/check/method/probe.rs | 4 +- src/librustc_typeck/check/mod.rs | 8 +-- src/librustc_typeck/check/regionck.rs | 2 +- src/librustc_typeck/coherence/mod.rs | 4 +- src/librustc_typeck/coherence/orphan.rs | 2 +- src/librustc_typeck/variance.rs | 2 +- src/librustdoc/clean/mod.rs | 6 +- 34 files changed, 138 insertions(+), 150 deletions(-) diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs index 8f78e97c4bb..72e96121a3a 100644 --- a/src/librustc/metadata/tyencode.rs +++ b/src/librustc/metadata/tyencode.rs @@ -113,11 +113,12 @@ pub fn enc_ty<'a, 'tcx>(w: &mut Encoder, cx: &ctxt<'a, 'tcx>, t: Ty<'tcx>) { ty::TyArray(t, sz) => { mywrite!(w, "V"); enc_ty(w, cx, t); - mywrite!(w, "/"); - match sz { - Some(n) => mywrite!(w, "{}|", n), - None => mywrite!(w, "|"), - } + mywrite!(w, "/{}|", sz); + } + ty::TySlice(t) => { + mywrite!(w, "V"); + enc_ty(w, cx, t); + mywrite!(w, "/|"); } ty::TyStr => { mywrite!(w, "v"); diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs index 2d27e9d2ed6..125de300db1 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::TyArray(_, Some(n)) => n, + ty::TyArray(_, n) => n, _ => unreachable!() }; // [element; 0] is always zero-sized. @@ -851,10 +851,14 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for CheckCrateVisitor<'a, 'tcx> { } let mutbl = bk.to_mutbl_lossy(); if mutbl == ast::MutMutable && self.mode == Mode::StaticMut { - // Mutable slices are the only `&mut` allowed in globals, - // but only in `static mut`, nowhere else. + // Mutable slices are the only `&mut` allowed in + // globals, but only in `static mut`, nowhere else. + // FIXME: This exception is really weird... there isn't + // any fundamental reason to restrict this based on + // type of the expression. `&mut [1]` has exactly the + // same representation as &mut 1. match cmt.ty.sty { - ty::TyArray(_, _) => break, + ty::TyArray(_, _) | ty::TySlice(_) => break, _ => {} } } diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index f3ba9148ba6..ea95536b811 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -537,14 +537,14 @@ fn construct_witness(cx: &MatchCheckCtxt, ctor: &Constructor, ty::TyRef(_, ty::mt { ty, mutbl }) => { match ty.sty { - ty::TyArray(_, Some(n)) => match ctor { + ty::TyArray(_, n) => match ctor { &Single => { assert_eq!(pats_len, n); ast::PatVec(pats.collect(), None, vec!()) }, _ => unreachable!() }, - ty::TyArray(_, None) => match ctor { + ty::TySlice(_) => match ctor { &Slice(n) => { assert_eq!(pats_len, n); ast::PatVec(pats.collect(), None, vec!()) @@ -560,7 +560,7 @@ fn construct_witness(cx: &MatchCheckCtxt, ctor: &Constructor, } } - ty::TyArray(_, Some(len)) => { + ty::TyArray(_, len) => { assert_eq!(pats_len, len); ast::PatVec(pats.collect(), None, vec![]) } @@ -601,7 +601,7 @@ fn all_constructors(cx: &MatchCheckCtxt, left_ty: Ty, [true, false].iter().map(|b| ConstantValue(const_bool(*b))).collect(), ty::TyRef(_, ty::mt { ty, .. }) => match ty.sty { - ty::TyArray(_, None) => + ty::TySlice(_) => range_inclusive(0, max_slice_length).map(|length| Slice(length)).collect(), _ => vec!(Single) }, @@ -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::TyArray(_, Some(_)) => vec!(Single), + ty::TyArray(_, _) => vec!(Single), _ => if slice.is_some() { range_inclusive(before.len() + after.len(), max_slice_length) .map(|length| Slice(length)) @@ -807,7 +807,7 @@ pub fn constructor_arity(cx: &MatchCheckCtxt, ctor: &Constructor, ty: Ty) -> usi ty::TyTuple(ref fs) => fs.len(), ty::TyBox(_) => 1, ty::TyRef(_, ty::mt { ty, .. }) => match ty.sty { - ty::TyArray(_, None) => match *ctor { + ty::TySlice(_) => match *ctor { Slice(length) => length, ConstantValue(_) => 0, _ => unreachable!() @@ -822,7 +822,7 @@ pub fn constructor_arity(cx: &MatchCheckCtxt, ctor: &Constructor, ty: Ty) -> usi } } ty::TyStruct(cid, _) => ty::lookup_struct_fields(cx.tcx, cid).len(), - ty::TyArray(_, Some(n)) => n, + ty::TyArray(_, n) => n, _ => 0 } } diff --git a/src/librustc/middle/fast_reject.rs b/src/librustc/middle/fast_reject.rs index ee792989ccf..168494043e5 100644 --- a/src/librustc/middle/fast_reject.rs +++ b/src/librustc/middle/fast_reject.rs @@ -55,7 +55,7 @@ pub fn simplify_type(tcx: &ty::ctxt, 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::TyArray(..) | ty::TySlice(_) => Some(VecSimplifiedType), ty::TyRawPtr(_) => Some(PtrSimplifiedType), ty::TyTrait(ref trait_info) => { Some(TraitSimplifiedType(trait_info.principal_def_id())) diff --git a/src/librustc/middle/implicator.rs b/src/librustc/middle/implicator.rs index 367d5efb54b..fc9636ae366 100644 --- a/src/librustc/middle/implicator.rs +++ b/src/librustc/middle/implicator.rs @@ -117,6 +117,7 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> { } ty::TyArray(t, _) | + ty::TySlice(t) | ty::TyRawPtr(ty::mt { ty: t, .. }) | ty::TyBox(t) => { self.accumulate_from_ty(t) diff --git a/src/librustc/middle/infer/freshen.rs b/src/librustc/middle/infer/freshen.rs index 6eb4fcce887..1aa54863c20 100644 --- a/src/librustc/middle/infer/freshen.rs +++ b/src/librustc/middle/infer/freshen.rs @@ -159,6 +159,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, 'tcx> { ty::TyStr | ty::TyError | ty::TyArray(..) | + ty::TySlice(..) | ty::TyRawPtr(..) | ty::TyRef(..) | ty::TyBareFn(..) | diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index d099b71c3f2..6d8e412c8a5 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -230,7 +230,7 @@ fn deref_kind(t: Ty, context: DerefKindContext) -> McResult { Ok(deref_interior(InteriorField(PositionalField(0)))) } - ty::TyArray(_, _) | ty::TyStr => { + ty::TyArray(_, _) | ty::TySlice(_) | ty::TyStr => { // no deref of indexed content without supplying InteriorOffsetKind if let Some(context) = context { Ok(deref_interior(InteriorElement(context, element_kind(t)))) @@ -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::TyArray(_, Some(0)) => qualif, + ty::TyArray(_, 0) => qualif, _ => check_const::ConstQualif::NOT_CONST }; @@ -1130,7 +1130,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { -> (ast::Mutability, ty::Region) { match slice_ty.sty { ty::TyRef(r, ref mt) => match mt.ty.sty { - ty::TyArray(_, None) => (mt.mutbl, *r), + ty::TySlice(_) => (mt.mutbl, *r), _ => vec_slice_info(tcx, pat, mt.ty), }, @@ -1669,10 +1669,10 @@ fn element_kind(t: Ty) -> ElementKind { match t.sty { ty::TyRef(_, ty::mt{ty, ..}) | ty::TyBox(ty) => match ty.sty { - ty::TyArray(_, None) => VecElement, + ty::TySlice(_) => VecElement, _ => OtherElement }, - ty::TyArray(..) => VecElement, + ty::TyArray(..) | ty::TySlice(_) => VecElement, _ => OtherElement } } diff --git a/src/librustc/middle/traits/coherence.rs b/src/librustc/middle/traits/coherence.rs index ae2454013e8..dcf37e7d56a 100644 --- a/src/librustc/middle/traits/coherence.rs +++ b/src/librustc/middle/traits/coherence.rs @@ -306,6 +306,7 @@ fn ty_is_local_constructor<'tcx>(tcx: &ty::ctxt<'tcx>, ty::TyStr(..) | ty::TyBareFn(..) | ty::TyArray(..) | + ty::TySlice(..) | ty::TyRawPtr(..) | ty::TyRef(..) | ty::TyTuple(..) | diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs index ba5f0686f48..5d8cdd44eaa 100644 --- a/src/librustc/middle/traits/select.rs +++ b/src/librustc/middle/traits/select.rs @@ -1429,7 +1429,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } // [T; n] -> [T]. - (&ty::TyArray(_, Some(_)), &ty::TyArray(_, None)) => true, + (&ty::TyArray(_, _), &ty::TySlice(_)) => true, // Struct -> Struct. (&ty::TyStruct(def_id_a, _), &ty::TyStruct(def_id_b, _)) => { @@ -1662,35 +1662,18 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } } - ty::TyArray(element_ty, ref len) => { - // [T; n] and [T] + ty::TyArray(element_ty, _) => { + // [T; n] match bound { - ty::BoundCopy => { - match *len { - // [T; n] is copy iff T is copy - Some(_) => ok_if(vec![element_ty]), - - // [T] is unsized and hence affine - None => Err(Unimplemented), - } - } - - ty::BoundSized => { - if len.is_some() { - ok_if(Vec::new()) - } else { - Err(Unimplemented) - } - } - + ty::BoundCopy => ok_if(vec![element_ty]), + ty::BoundSized => ok_if(Vec::new()), ty::BoundSync | ty::BoundSend => { self.tcx().sess.bug("Send/Sync shouldn't occur in builtin_bounds()"); } } } - ty::TyStr => { - // Equivalent to [u8] + ty::TyStr | ty::TySlice(_) => { match bound { ty::BoundSync | ty::BoundSend => { self.tcx().sess.bug("Send/Sync shouldn't occur in builtin_bounds()"); @@ -1855,7 +1838,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { Some(vec![element_ty]) }, - ty::TyArray(element_ty, _) => { + ty::TyArray(element_ty, _) | ty::TySlice(element_ty) => { Some(vec![element_ty]) } @@ -2510,7 +2493,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } // [T; n] -> [T]. - (&ty::TyArray(a, Some(_)), &ty::TyArray(b, None)) => { + (&ty::TyArray(a, _), &ty::TySlice(b)) => { let origin = infer::Misc(obligation.cause.span); if self.infcx.sub_types(false, origin, a, b).is_err() { return Err(Unimplemented); diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 42bc399e822..c24f1d3e7be 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -906,7 +906,7 @@ impl<'tcx> ctxt<'tcx> { pub fn print_debug_stats(&self) { sty_debug_print!( self, - TyEnum, TyBox, TyArray, TyRawPtr, TyRef, TyBareFn, TyTrait, + TyEnum, TyBox, TyArray, TySlice, TyRawPtr, TyRef, TyBareFn, TyTrait, TyStruct, TyClosure, TyTuple, TyParam, TyInfer, TyProjection); println!("Substs interner: #{}", self.substs_interner.borrow().len()); @@ -1378,10 +1378,11 @@ pub enum TypeVariants<'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), + /// An array with the given length. Written as `[T; n]`. + TyArray(Ty<'tcx>, usize), + + /// The pointee of an array slice. Written as `[T]`. + TySlice(Ty<'tcx>), /// A raw pointer. Written as `*mut T` or `*const T` TyRawPtr(mt<'tcx>), @@ -3047,7 +3048,7 @@ impl FlagComputation { self.add_bounds(bounds); } - &TyBox(tt) | &TyArray(tt, _) => { + &TyBox(tt) | &TyArray(tt, _) | &TySlice(tt) => { self.add_ty(tt) } @@ -3201,7 +3202,10 @@ pub fn mk_nil_ptr<'tcx>(cx: &ctxt<'tcx>) -> Ty<'tcx> { } pub fn mk_vec<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>, sz: Option) -> Ty<'tcx> { - mk_t(cx, TyArray(ty, sz)) + match sz { + Some(n) => mk_t(cx, TyArray(ty, n)), + None => mk_t(cx, TySlice(ty)) + } } pub fn mk_slice<'tcx>(cx: &ctxt<'tcx>, r: &'tcx Region, tm: mt<'tcx>) -> Ty<'tcx> { @@ -3480,29 +3484,17 @@ pub fn type_is_self(ty: Ty) -> bool { fn type_is_slice(ty: Ty) -> bool { match ty.sty { TyRawPtr(mt) | TyRef(_, mt) => match mt.ty.sty { - TyArray(_, None) | TyStr => true, + TySlice(_) | TyStr => true, _ => false, }, _ => false } } -pub fn type_is_vec(ty: Ty) -> bool { - match ty.sty { - TyArray(..) => true, - TyRawPtr(mt{ty, ..}) | TyRef(_, mt{ty, ..}) | - TyBox(ty) => match ty.sty { - TyArray(_, None) => true, - _ => false - }, - _ => false - } -} - pub fn type_is_structural(ty: Ty) -> bool { match ty.sty { TyStruct(..) | TyTuple(_) | TyEnum(..) | - TyArray(_, Some(_)) | TyClosure(..) => true, + TyArray(..) | TyClosure(..) => true, _ => type_is_slice(ty) | type_is_trait(ty) } } @@ -3516,7 +3508,7 @@ pub fn type_is_simd(cx: &ctxt, ty: Ty) -> bool { pub fn sequence_element_type<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { match ty.sty { - TyArray(ty, _) => ty, + TyArray(ty, _) | TySlice(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))), @@ -3816,17 +3808,18 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents { TyRef(r, ref mt) => { TC::ReachesFfiUnsafe | match mt.ty.sty { TyStr => borrowed_contents(*r, ast::MutImmutable), - TyArray(..) => tc_ty(cx, mt.ty, cache).reference(borrowed_contents(*r, + TyArray(..) | + TySlice(_) => tc_ty(cx, mt.ty, cache).reference(borrowed_contents(*r, mt.mutbl)), _ => tc_ty(cx, mt.ty, cache).reference(borrowed_contents(*r, mt.mutbl)), } } - TyArray(ty, Some(_)) => { + TyArray(ty, _) => { tc_ty(cx, ty, cache) } - TyArray(ty, None) => { + TySlice(ty) => { tc_ty(cx, ty, cache) | TC::Nonsized } TyStr => TC::Nonsized, @@ -4021,7 +4014,7 @@ pub fn type_moves_by_default<'a,'tcx>(param_env: &ParameterEnvironment<'a,'tcx>, mutbl: ast::MutMutable, .. }) => Some(true), - TyArray(..) | TyTrait(..) | TyTuple(..) | + TyArray(..) | TySlice(_) | TyTrait(..) | TyTuple(..) | TyClosure(..) | TyEnum(..) | TyStruct(..) | TyProjection(..) | TyParam(..) | TyInfer(..) | TyError => None }.unwrap_or_else(|| !type_impls_bound(Some(param_env), @@ -4066,9 +4059,9 @@ fn type_is_sized_uncached<'a,'tcx>(param_env: Option<&ParameterEnvironment<'a,'t let result = match ty.sty { TyBool | TyChar | TyInt(..) | TyUint(..) | TyFloat(..) | TyBox(..) | TyRawPtr(..) | TyRef(..) | TyBareFn(..) | - TyArray(_, Some(..)) | TyTuple(..) | TyClosure(..) => Some(true), + TyArray(..) | TyTuple(..) | TyClosure(..) => Some(true), - TyStr | TyTrait(..) | TyArray(_, None) => Some(false), + TyStr | TyTrait(..) | TySlice(_) => Some(false), TyEnum(..) | TyStruct(..) | TyProjection(..) | TyParam(..) | TyInfer(..) | TyError => None @@ -4116,8 +4109,8 @@ 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. - TyArray(_, Some(0)) => false, // don't need no contents - TyArray(ty, Some(_)) => type_requires(cx, seen, r_ty, ty), + TyArray(_, 0) => false, // don't need no contents + TyArray(ty, _) => type_requires(cx, seen, r_ty, ty), TyBool | TyChar | @@ -4128,7 +4121,7 @@ pub fn is_instantiable<'tcx>(cx: &ctxt<'tcx>, r_ty: Ty<'tcx>) -> bool { TyBareFn(..) | TyParam(_) | TyProjection(_) | - TyArray(_, None) => { + TySlice(_) => { false } TyBox(typ) => { @@ -4238,7 +4231,7 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>) } // Fixed-length vectors. // FIXME(#11924) Behavior undecided for zero-length vectors. - TyArray(ty, Some(_)) => { + TyArray(ty, _) => { is_type_structurally_recursive(cx, sp, seen, ty) } TyStruct(did, substs) => { @@ -4494,7 +4487,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> { match ty.sty { - TyArray(ty, _) => Some(ty), + TyArray(ty, _) | TySlice(ty) => Some(ty), _ => None } } @@ -4504,7 +4497,7 @@ pub fn index<'tcx>(ty: Ty<'tcx>) -> Option> { // which can't actually be indexed. pub fn array_element_ty<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Option> { match ty.sty { - TyArray(ty, _) => Some(ty), + TyArray(ty, _) | TySlice(ty) => Some(ty), TyStr => Some(tcx.types.u8), _ => None } @@ -5063,8 +5056,8 @@ pub fn ty_sort_string<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> String { 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(), + TyArray(_, n) => format!("array of {} elements", n), + TySlice(_) => "slice".to_string(), TyRawPtr(_) => "*-ptr".to_string(), TyRef(_, _) => "&-ptr".to_string(), TyBareFn(Some(_), _) => format!("fn item"), @@ -6626,11 +6619,11 @@ pub fn hash_crate_independent<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh) - TyBox(_) => { byte!(9); } - TyArray(_, Some(n)) => { + TyArray(_, n) => { byte!(10); n.hash(state); } - TyArray(_, None) => { + TySlice(_) => { byte!(11); } TyRawPtr(m) => { @@ -6967,6 +6960,7 @@ pub fn accumulate_lifetimes_in_type(accumulator: &mut Vec, TyBox(_) | TyStr | TyArray(_, _) | + TySlice(_) | TyRawPtr(_) | TyBareFn(..) | TyTuple(_) | diff --git a/src/librustc/middle/ty_fold.rs b/src/librustc/middle/ty_fold.rs index 40d5dab15a4..38391438298 100644 --- a/src/librustc/middle/ty_fold.rs +++ b/src/librustc/middle/ty_fold.rs @@ -599,6 +599,9 @@ pub fn super_fold_ty<'tcx, T: TypeFolder<'tcx>>(this: &mut T, ty::TyArray(typ, sz) => { ty::TyArray(typ.fold_with(this), sz) } + ty::TySlice(typ) => { + ty::TySlice(typ.fold_with(this)) + } ty::TyEnum(tid, ref substs) => { let substs = substs.fold_with(this); ty::TyEnum(tid, this.tcx().mk_substs(substs)) diff --git a/src/librustc/middle/ty_relate/mod.rs b/src/librustc/middle/ty_relate/mod.rs index c79fe7f5ad1..91169af4adb 100644 --- a/src/librustc/middle/ty_relate/mod.rs +++ b/src/librustc/middle/ty_relate/mod.rs @@ -518,7 +518,7 @@ pub fn super_relate_tys<'a,'tcx:'a,R>(relation: &mut R, Ok(ty::mk_rptr(tcx, tcx.mk_region(r), mt)) } - (&ty::TyArray(a_t, Some(sz_a)), &ty::TyArray(b_t, Some(sz_b))) => + (&ty::TyArray(a_t, sz_a), &ty::TyArray(b_t, sz_b)) => { let t = try!(relation.relate(&a_t, &b_t)); if sz_a == sz_b { @@ -528,7 +528,7 @@ pub fn super_relate_tys<'a,'tcx:'a,R>(relation: &mut R, } } - (&ty::TyArray(a_t, None), &ty::TyArray(b_t, None)) => + (&ty::TySlice(a_t), &ty::TySlice(b_t)) => { let t = try!(relation.relate(&a_t, &b_t)); Ok(ty::mk_vec(tcx, t, None)) diff --git a/src/librustc/middle/ty_walk.rs b/src/librustc/middle/ty_walk.rs index 50118ed6e9f..b34eb2ddb1e 100644 --- a/src/librustc/middle/ty_walk.rs +++ b/src/librustc/middle/ty_walk.rs @@ -71,7 +71,7 @@ fn push_subtypes<'tcx>(stack: &mut Vec>, parent_ty: Ty<'tcx>) { ty::TyBool | ty::TyChar | ty::TyInt(_) | ty::TyUint(_) | ty::TyFloat(_) | ty::TyStr | ty::TyInfer(_) | ty::TyParam(_) | ty::TyError => { } - ty::TyBox(ty) | ty::TyArray(ty, _) => { + ty::TyBox(ty) | ty::TyArray(ty, _) | ty::TySlice(ty) => { stack.push(ty); } ty::TyRawPtr(ref mt) | ty::TyRef(_, ref mt) => { diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 5d68c9d9b28..7341420c553 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -20,7 +20,7 @@ use middle::ty::{ReFree, ReScope, ReInfer, ReStatic, Region, ReEmpty}; use middle::ty::{ReSkolemized, ReVar, BrEnv}; use middle::ty::{mt, Ty, ParamTy}; use middle::ty::{TyBool, TyChar, TyStruct, TyEnum}; -use middle::ty::{TyError, TyStr, TyArray, TyFloat, TyBareFn}; +use middle::ty::{TyError, TyStr, TyArray, TySlice, TyFloat, TyBareFn}; use middle::ty::{TyParam, TyRawPtr, TyRef, TyTuple}; use middle::ty::TyClosure; use middle::ty::{TyBox, TyTrait, TyInt, TyUint, TyInfer}; @@ -432,11 +432,10 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String { }) } TyArray(t, sz) => { - let inner_str = ty_to_string(cx, t); - match sz { - Some(n) => format!("[{}; {}]", inner_str, n), - None => format!("[{}]", inner_str), - } + format!("[{}; {}]", ty_to_string(cx, t), sz) + } + TySlice(t) => { + format!("[{}]", ty_to_string(cx, t)) } } } diff --git a/src/librustc_trans/trans/_match.rs b/src/librustc_trans/trans/_match.rs index bcf5922fb3d..d2a7b3198f8 100644 --- a/src/librustc_trans/trans/_match.rs +++ b/src/librustc_trans/trans/_match.rs @@ -852,7 +852,7 @@ fn compare_values<'blk, 'tcx>(cx: Block<'blk, 'tcx>, match rhs_t.sty { 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::TyArray(ty, _) | ty::TySlice(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(). @@ -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::TyArray(_, Some(n)) => { + ty::TyArray(_, 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 977b2b69c46..d9e1a75d3dc 100644 --- a/src/librustc_trans/trans/adt.rs +++ b/src/librustc_trans/trans/adt.rs @@ -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::TyArray(ety, Some(d)) if d > 0 => { + ty::TyArray(ety, 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/base.rs b/src/librustc_trans/trans/base.rs index cdb036bc6a9..0ec2d1abb09 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -444,12 +444,12 @@ pub fn iter_structural_ty<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>, cx = f(cx, llupvar, upvar.ty); } } - ty::TyArray(_, Some(n)) => { + ty::TyArray(_, 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::TyArray(_, None) | ty::TyStr => { + ty::TySlice(_) | 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); } diff --git a/src/librustc_trans/trans/common.rs b/src/librustc_trans/trans/common.rs index 7fe879dad0a..0f8fd45b05a 100644 --- a/src/librustc_trans/trans/common.rs +++ b/src/librustc_trans/trans/common.rs @@ -246,7 +246,7 @@ pub fn type_is_immediate<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) - return false; } match ty.sty { - ty::TyStruct(..) | ty::TyEnum(..) | ty::TyTuple(..) | ty::TyArray(_, Some(_)) | + ty::TyStruct(..) | ty::TyEnum(..) | ty::TyTuple(..) | ty::TyArray(_, _) | 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 50dbeafa7e1..f7d1fad19a1 100644 --- a/src/librustc_trans/trans/consts.rs +++ b/src/librustc_trans/trans/consts.rs @@ -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::TyArray(_, Some(u)) => (bv, C_uint(cx, u)), - ty::TyArray(_, None) | ty::TyStr => { + ty::TyArray(_, u) => (bv, C_uint(cx, u)), + ty::TySlice(_) | ty::TyStr => { let e1 = const_get_elt(cx, bv, &[0]); (const_deref_ptr(cx, e1), const_get_elt(cx, bv, &[1])) } ty::TyRef(_, mt) => match mt.ty.sty { - ty::TyArray(_, Some(u)) => { + ty::TyArray(_, u) => { (const_deref_ptr(cx, bv), C_uint(cx, u)) }, _ => cx.sess().span_bug(base.span, diff --git a/src/librustc_trans/trans/debuginfo/metadata.rs b/src/librustc_trans/trans/debuginfo/metadata.rs index 551ccfb6650..42aa96ed21e 100644 --- a/src/librustc_trans/trans/debuginfo/metadata.rs +++ b/src/librustc_trans/trans/debuginfo/metadata.rs @@ -226,15 +226,15 @@ 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::TyArray(inner_type, optional_length) => { - match optional_length { - Some(len) => { - unique_type_id.push_str(&format!("[{}]", len)); - } - None => { - unique_type_id.push_str("[]"); - } - }; + ty::TyArray(inner_type, len) => { + unique_type_id.push_str(&format!("[{}]", len)); + + 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::TySlice(inner_type) => { + unique_type_id.push_str("[]"); 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); @@ -756,7 +756,10 @@ pub fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, prepare_enum_metadata(cx, t, def_id, unique_type_id, usage_site_span).finalize(cx) } ty::TyArray(typ, len) => { - fixed_vec_metadata(cx, unique_type_id, typ, len.map(|x| x as u64), usage_site_span) + fixed_vec_metadata(cx, unique_type_id, typ, Some(len as u64), usage_site_span) + } + ty::TySlice(typ) => { + fixed_vec_metadata(cx, unique_type_id, typ, None, usage_site_span) } ty::TyStr => { fixed_vec_metadata(cx, unique_type_id, cx.tcx().types.i8, None, usage_site_span) @@ -768,7 +771,7 @@ pub fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, } ty::TyBox(ty) | ty::TyRawPtr(ty::mt{ty, ..}) | ty::TyRef(_, ty::mt{ty, ..}) => { match ty.sty { - ty::TyArray(typ, None) => { + ty::TySlice(typ) => { vec_slice_metadata(cx, t, typ, unique_type_id, usage_site_span) } ty::TyStr => { diff --git a/src/librustc_trans/trans/debuginfo/type_names.rs b/src/librustc_trans/trans/debuginfo/type_names.rs index 153170913ed..7d6c053cd1b 100644 --- a/src/librustc_trans/trans/debuginfo/type_names.rs +++ b/src/librustc_trans/trans/debuginfo/type_names.rs @@ -94,17 +94,15 @@ pub fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, push_debuginfo_type_name(cx, inner_type, true, output); }, - ty::TyArray(inner_type, optional_length) => { + ty::TyArray(inner_type, len) => { + output.push('['); + push_debuginfo_type_name(cx, inner_type, true, output); + output.push_str(&format!("; {}", len)); + output.push(']'); + }, + ty::TySlice(inner_type) => { output.push('['); push_debuginfo_type_name(cx, inner_type, true, output); - - match optional_length { - Some(len) => { - output.push_str(&format!("; {}", len)); - } - None => { /* nothing to do */ } - }; - output.push(']'); }, ty::TyTrait(ref trait_data) => { diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs index 9fda58db5d2..07a8cbc38d5 100644 --- a/src/librustc_trans/trans/expr.rs +++ b/src/librustc_trans/trans/expr.rs @@ -313,7 +313,7 @@ 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::TyArray(_, Some(len)), &ty::TyArray(_, None)) => C_uint(ccx, len), + (&ty::TyArray(_, len), &ty::TySlice(_)) => 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 diff --git a/src/librustc_trans/trans/glue.rs b/src/librustc_trans/trans/glue.rs index da1409a8f3d..c7f5b86412c 100644 --- a/src/librustc_trans/trans/glue.rs +++ b/src/librustc_trans/trans/glue.rs @@ -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::TyArray(_, None) | ty::TyStr => { + ty::TySlice(_) | 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. diff --git a/src/librustc_trans/trans/tvec.rs b/src/librustc_trans/trans/tvec.rs index 18c123cec28..3df6c904c7b 100644 --- a/src/librustc_trans/trans/tvec.rs +++ b/src/librustc_trans/trans/tvec.rs @@ -310,8 +310,8 @@ pub fn get_base_and_len<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let ccx = bcx.ccx(); match vec_ty.sty { - ty::TyArray(_, Some(n)) => get_fixed_base_and_len(bcx, llval, n), - ty::TyArray(_, None) | ty::TyStr => { + ty::TyArray(_, n) => get_fixed_base_and_len(bcx, llval, n), + ty::TySlice(_) | ty::TyStr => { let base = Load(bcx, expr::get_dataptr(bcx, llval)); let len = Load(bcx, expr::get_len(bcx, llval)); (base, len) diff --git a/src/librustc_trans/trans/type_of.rs b/src/librustc_trans/trans/type_of.rs index 0356bade22d..763d0581d6f 100644 --- a/src/librustc_trans/trans/type_of.rs +++ b/src/librustc_trans/trans/type_of.rs @@ -200,7 +200,7 @@ pub fn sizing_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Typ ty::TyBareFn(..) => Type::i8p(cx), - ty::TyArray(ty, Some(size)) => { + ty::TyArray(ty, size) => { let llty = sizing_type_of(cx, ty); let size = size as u64; ensure_array_fits_in_address_space(cx, llty, size, t); @@ -232,7 +232,7 @@ pub fn sizing_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Typ cx.sess().bug(&format!("fictitious type {} in sizing_type_of()", ppaux::ty_to_string(cx.tcx(), t))) } - ty::TyArray(_, None) | ty::TyTrait(..) | ty::TyStr => unreachable!() + ty::TySlice(_) | ty::TyTrait(..) | ty::TyStr => unreachable!() }; cx.llsizingtypes().borrow_mut().insert(t, llsizingty); @@ -359,7 +359,7 @@ 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::TyStr | ty::TyArray(..) => { + ty::TyStr | ty::TyArray(..) | ty::TySlice(_) => { Type::uint_from_ty(cx, ast::TyUs) } ty::TyTrait(_) => Type::vtable_ptr(cx), @@ -374,7 +374,7 @@ pub fn in_memory_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> } } - ty::TyArray(ty, Some(size)) => { + ty::TyArray(ty, 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,7 +385,7 @@ 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::TyArray(ty, None) => in_memory_type_of(cx, ty), + ty::TySlice(ty) => in_memory_type_of(cx, ty), ty::TyStr | ty::TyTrait(..) => Type::i8(cx), ty::TyBareFn(..) => { diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs index 3df93ee7dbf..2f1447e0714 100644 --- a/src/librustc_typeck/check/_match.rs +++ b/src/librustc_typeck/check/_match.rs @@ -59,7 +59,7 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, if let ast::LitBinary(_) = lt.node { let expected_ty = structurally_resolved_type(fcx, pat.span, expected); if let ty::TyRef(_, mt) = expected_ty.sty { - if let ty::TyArray(_, None) = mt.ty.sty { + if let ty::TySlice(_) = 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::TyArray(_, Some(size)) => ty::mk_vec(tcx, inner_ty, Some({ + ty::TyArray(_, size) => ty::mk_vec(tcx, inner_ty, Some({ let min_len = before.len() + after.len(); match *slice { Some(_) => cmp::max(min_len, size), diff --git a/src/librustc_typeck/check/cast.rs b/src/librustc_typeck/check/cast.rs index 04a357b6c11..6e306047f75 100644 --- a/src/librustc_typeck/check/cast.rs +++ b/src/librustc_typeck/check/cast.rs @@ -74,7 +74,7 @@ fn unsize_kind<'a,'tcx>(fcx: &FnCtxt<'a, 'tcx>, t: Ty<'tcx>) -> Option> { match t.sty { - ty::TyArray(_, None) | ty::TyStr => Some(UnsizeKind::Length), + ty::TySlice(_) | ty::TyStr => Some(UnsizeKind::Length), ty::TyTrait(_) => Some(UnsizeKind::Vtable), ty::TyStruct(did, substs) => { match ty::struct_fields(fcx.tcx(), did, substs).pop() { @@ -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::TyArray(ety, Some(_)) = m_expr.ty.sty { + if let ty::TyArray(ety, _) = 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/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index e7fd6f7834a..79449b2f10d 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::TyArray(elem_ty, Some(_)) => { + ty::TyArray(elem_ty, _) => { let slice_ty = ty::mk_vec(fcx.tcx(), elem_ty, None); steps.push(CandidateStep { self_ty: slice_ty, @@ -295,7 +295,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { let lang_def_id = self.tcx().lang_items.str_impl(); self.assemble_inherent_impl_for_primitive(lang_def_id); } - ty::TyArray(_, None) => { + ty::TySlice(_) => { let lang_def_id = self.tcx().lang_items.slice_impl(); self.assemble_inherent_impl_for_primitive(lang_def_id); } diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 9cab4a47732..69f1b5091df 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -2095,7 +2095,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::TyArray(element_ty, Some(_)) = ty.sty { + if let ty::TyArray(element_ty, _) = 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) @@ -3452,7 +3452,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::TyArray(ty, _) => Some(ty), + ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty), _ => None } }); @@ -3482,7 +3482,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, let uty = match expected { ExpectHasType(uty) => { match uty.sty { - ty::TyArray(ty, _) => Some(ty), + ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty), _ => None } } @@ -3862,7 +3862,7 @@ impl<'tcx> Expectation<'tcx> { /// for examples of where this comes up,. fn rvalue_hint(ty: Ty<'tcx>) -> Expectation<'tcx> { match ty.sty { - ty::TyArray(_, None) | ty::TyTrait(..) => { + ty::TySlice(_) | ty::TyTrait(..) => { ExpectRvalueLikeUnsized(ty) } _ => ExpectHasType(ty) diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index 2b2cb31836c..cb4d048ab37 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -997,7 +997,7 @@ fn constrain_index<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>, let r_index_expr = ty::ReScope(CodeExtent::from_node_id(index_expr.id)); if let ty::TyRef(r_ptr, mt) = indexed_ty.sty { match mt.ty.sty { - ty::TyArray(_, None) | ty::TyStr => { + ty::TySlice(_) | ty::TyStr => { rcx.fcx.mk_subr(infer::IndexSlice(index_expr.span), r_index_expr, *r_ptr); } diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index 5a6cf7cccfd..f6a40eec582 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -25,7 +25,7 @@ use middle::ty::{MethodTraitItemId, TypeTraitItemId, ParameterEnvironment}; 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::{TyStr, TyArray, TySlice, TyFloat, TyInfer, TyInt}; use middle::ty::{TyUint, TyClosure, TyBox, TyBareFn}; use middle::ty::TyProjection; use middle::ty; @@ -70,7 +70,7 @@ fn get_base_type_def_id<'a, 'tcx>(inference_context: &InferCtxt<'a, 'tcx>, } TyBool | TyChar | TyInt(..) | TyUint(..) | TyFloat(..) | - TyStr(..) | TyArray(..) | TyBareFn(..) | TyTuple(..) | + TyStr(..) | TyArray(..) | TySlice(..) | TyBareFn(..) | TyTuple(..) | TyParam(..) | TyError | TyRawPtr(_) | TyRef(_, _) | TyProjection(..) => { None diff --git a/src/librustc_typeck/coherence/orphan.rs b/src/librustc_typeck/coherence/orphan.rs index da01d4669f8..d815893524f 100644 --- a/src/librustc_typeck/coherence/orphan.rs +++ b/src/librustc_typeck/coherence/orphan.rs @@ -93,7 +93,7 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> { "str", item.span); } - ty::TyArray(_, None) => { + ty::TySlice(_) => { self.check_primitive_impl(def_id, self.tcx.lang_items.slice_impl(), "slice", diff --git a/src/librustc_typeck/variance.rs b/src/librustc_typeck/variance.rs index c17e3038a8b..37088701adc 100644 --- a/src/librustc_typeck/variance.rs +++ b/src/librustc_typeck/variance.rs @@ -889,7 +889,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { self.add_constraints_from_mt(generics, mt, variance); } - ty::TyBox(typ) | ty::TyArray(typ, _) => { + ty::TyBox(typ) | ty::TyArray(typ, _) | ty::TySlice(typ) => { self.add_constraints_from_ty(generics, typ, variance); } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 920902e19c8..77409f2746a 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1652,9 +1652,9 @@ impl<'tcx> Clean for ty::Ty<'tcx> { }); lang_struct(cx, box_did, t, "Box", Unique) } - ty::TyArray(ty, None) => Vector(box ty.clean(cx)), - ty::TyArray(ty, Some(i)) => FixedVector(box ty.clean(cx), - format!("{}", i)), + ty::TySlice(ty) => Vector(box ty.clean(cx)), + ty::TyArray(ty, i) => FixedVector(box ty.clean(cx), + format!("{}", i)), ty::TyRawPtr(mt) => RawPointer(mt.mutbl.clean(cx), box mt.ty.clean(cx)), ty::TyRef(r, mt) => BorrowedRef { lifetime: r.clean(cx),