Call arrays "arrays" instead of "vecs" internally
This commit is contained in:
parent
69c3d0add4
commit
cf0b7bdd0c
@ -126,7 +126,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
|
||||
self.add_ast_node(pat.id, &[pats_exit])
|
||||
}
|
||||
|
||||
PatKind::Vec(ref pre, ref vec, ref post) => {
|
||||
PatKind::Slice(ref pre, ref vec, ref post) => {
|
||||
let pre_exit = self.pats_all(pre.iter(), pred);
|
||||
let vec_exit = self.pats_all(vec.iter(), pre_exit);
|
||||
let post_exit = self.pats_all(post.iter(), vec_exit);
|
||||
@ -298,7 +298,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
|
||||
self.add_unreachable_node()
|
||||
}
|
||||
|
||||
hir::ExprVec(ref elems) => {
|
||||
hir::ExprArray(ref elems) => {
|
||||
self.straightline(expr, pred, elems.iter().map(|e| &**e))
|
||||
}
|
||||
|
||||
|
@ -394,7 +394,7 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty) {
|
||||
visitor.visit_id(typ.id);
|
||||
|
||||
match typ.node {
|
||||
TyVec(ref ty) => {
|
||||
TySlice(ref ty) => {
|
||||
visitor.visit_ty(ty)
|
||||
}
|
||||
TyPtr(ref mutable_type) => {
|
||||
@ -422,7 +422,7 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty) {
|
||||
visitor.visit_ty(ty);
|
||||
walk_list!(visitor, visit_ty_param_bound, bounds);
|
||||
}
|
||||
TyFixedLengthVec(ref ty, ref expression) => {
|
||||
TyArray(ref ty, ref expression) => {
|
||||
visitor.visit_ty(ty);
|
||||
visitor.visit_expr(expression)
|
||||
}
|
||||
@ -520,7 +520,7 @@ pub fn walk_pat<'v, V: Visitor<'v>>(visitor: &mut V, pattern: &'v Pat) {
|
||||
visitor.visit_expr(upper_bound)
|
||||
}
|
||||
PatKind::Wild => (),
|
||||
PatKind::Vec(ref prepatterns, ref slice_pattern, ref postpatterns) => {
|
||||
PatKind::Slice(ref prepatterns, ref slice_pattern, ref postpatterns) => {
|
||||
walk_list!(visitor, visit_pat, prepatterns);
|
||||
walk_list!(visitor, visit_pat, slice_pattern);
|
||||
walk_list!(visitor, visit_pat, postpatterns);
|
||||
@ -749,7 +749,7 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) {
|
||||
ExprBox(ref subexpression) => {
|
||||
visitor.visit_expr(subexpression)
|
||||
}
|
||||
ExprVec(ref subexpressions) => {
|
||||
ExprArray(ref subexpressions) => {
|
||||
walk_list!(visitor, visit_expr, subexpressions);
|
||||
}
|
||||
ExprRepeat(ref element, ref count) => {
|
||||
|
@ -227,7 +227,7 @@ impl<'a> LoweringContext<'a> {
|
||||
id: t.id,
|
||||
node: match t.node {
|
||||
Infer | ImplicitSelf => hir::TyInfer,
|
||||
Vec(ref ty) => hir::TyVec(self.lower_ty(ty)),
|
||||
Vec(ref ty) => hir::TySlice(self.lower_ty(ty)),
|
||||
Ptr(ref mt) => hir::TyPtr(self.lower_mt(mt)),
|
||||
Rptr(ref region, ref mt) => {
|
||||
hir::TyRptr(self.lower_opt_lifetime(region), self.lower_mt(mt))
|
||||
@ -258,7 +258,7 @@ impl<'a> LoweringContext<'a> {
|
||||
hir::TyObjectSum(self.lower_ty(ty), self.lower_bounds(bounds))
|
||||
}
|
||||
FixedLengthVec(ref ty, ref e) => {
|
||||
hir::TyFixedLengthVec(self.lower_ty(ty), self.lower_expr(e))
|
||||
hir::TyArray(self.lower_ty(ty), self.lower_expr(e))
|
||||
}
|
||||
Typeof(ref expr) => {
|
||||
hir::TyTypeof(self.lower_expr(expr))
|
||||
@ -892,7 +892,7 @@ impl<'a> LoweringContext<'a> {
|
||||
hir::PatKind::Range(self.lower_expr(e1), self.lower_expr(e2))
|
||||
}
|
||||
PatKind::Vec(ref before, ref slice, ref after) => {
|
||||
hir::PatKind::Vec(before.iter().map(|x| self.lower_pat(x)).collect(),
|
||||
hir::PatKind::Slice(before.iter().map(|x| self.lower_pat(x)).collect(),
|
||||
slice.as_ref().map(|x| self.lower_pat(x)),
|
||||
after.iter().map(|x| self.lower_pat(x)).collect())
|
||||
}
|
||||
@ -1031,7 +1031,7 @@ impl<'a> LoweringContext<'a> {
|
||||
}
|
||||
|
||||
ExprKind::Vec(ref exprs) => {
|
||||
hir::ExprVec(exprs.iter().map(|x| self.lower_expr(x)).collect())
|
||||
hir::ExprArray(exprs.iter().map(|x| self.lower_expr(x)).collect())
|
||||
}
|
||||
ExprKind::Repeat(ref expr, ref count) => {
|
||||
let expr = self.lower_expr(expr);
|
||||
|
@ -448,7 +448,7 @@ impl<'ast> intravisit::Visitor<'ast> for DefCollector<'ast> {
|
||||
}
|
||||
|
||||
fn visit_ty(&mut self, ty: &'ast hir::Ty) {
|
||||
if let hir::TyFixedLengthVec(_, ref length) = ty.node {
|
||||
if let hir::TyArray(_, ref length) = ty.node {
|
||||
self.visit_hir_const_integer(length);
|
||||
}
|
||||
if let hir::TyImplTrait(..) = ty.node {
|
||||
|
@ -478,7 +478,7 @@ impl Pat {
|
||||
PatKind::Box(ref s) | PatKind::Ref(ref s, _) => {
|
||||
s.walk_(it)
|
||||
}
|
||||
PatKind::Vec(ref before, ref slice, ref after) => {
|
||||
PatKind::Slice(ref before, ref slice, ref after) => {
|
||||
before.iter().all(|p| p.walk_(it)) &&
|
||||
slice.iter().all(|p| p.walk_(it)) &&
|
||||
after.iter().all(|p| p.walk_(it))
|
||||
@ -554,8 +554,8 @@ pub enum PatKind {
|
||||
/// A range pattern, e.g. `1...2`
|
||||
Range(P<Expr>, P<Expr>),
|
||||
/// `[a, b, ..i, y, z]` is represented as:
|
||||
/// `PatKind::Vec(box [a, b], Some(i), box [y, z])`
|
||||
Vec(HirVec<P<Pat>>, Option<P<Pat>>, HirVec<P<Pat>>),
|
||||
/// `PatKind::Slice(box [a, b], Some(i), box [y, z])`
|
||||
Slice(HirVec<P<Pat>>, Option<P<Pat>>, HirVec<P<Pat>>),
|
||||
}
|
||||
|
||||
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
|
||||
@ -826,7 +826,7 @@ pub enum Expr_ {
|
||||
/// A `box x` expression.
|
||||
ExprBox(P<Expr>),
|
||||
/// An array (`[a, b, c, d]`)
|
||||
ExprVec(HirVec<P<Expr>>),
|
||||
ExprArray(HirVec<P<Expr>>),
|
||||
/// A function call
|
||||
///
|
||||
/// The first field resolves to the function itself (usually an `ExprPath`),
|
||||
@ -1080,10 +1080,10 @@ pub struct BareFnTy {
|
||||
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
|
||||
/// The different kinds of types recognized by the compiler
|
||||
pub enum Ty_ {
|
||||
/// A variable length array (`[T]`)
|
||||
TyVec(P<Ty>),
|
||||
/// A variable length slice (`[T]`)
|
||||
TySlice(P<Ty>),
|
||||
/// A fixed length array (`[T; n]`)
|
||||
TyFixedLengthVec(P<Ty>, P<Expr>),
|
||||
TyArray(P<Ty>, P<Expr>),
|
||||
/// A raw pointer (`*const T` or `*mut T`)
|
||||
TyPtr(MutTy),
|
||||
/// A reference (`&'a T` or `&'a mut T`)
|
||||
|
@ -62,7 +62,7 @@ pub fn pat_is_refutable(dm: &DefMap, pat: &hir::Pat) -> bool {
|
||||
_ => false
|
||||
}
|
||||
}
|
||||
PatKind::Vec(..) => true,
|
||||
PatKind::Slice(..) => true,
|
||||
_ => false
|
||||
}
|
||||
}
|
||||
|
@ -486,7 +486,7 @@ impl<'a> State<'a> {
|
||||
self.maybe_print_comment(ty.span.lo)?;
|
||||
self.ibox(0)?;
|
||||
match ty.node {
|
||||
hir::TyVec(ref ty) => {
|
||||
hir::TySlice(ref ty) => {
|
||||
word(&mut self.s, "[")?;
|
||||
self.print_type(&ty)?;
|
||||
word(&mut self.s, "]")?;
|
||||
@ -543,7 +543,7 @@ impl<'a> State<'a> {
|
||||
hir::TyImplTrait(ref bounds) => {
|
||||
self.print_bounds("impl ", &bounds[..])?;
|
||||
}
|
||||
hir::TyFixedLengthVec(ref ty, ref v) => {
|
||||
hir::TyArray(ref ty, ref v) => {
|
||||
word(&mut self.s, "[")?;
|
||||
self.print_type(&ty)?;
|
||||
word(&mut self.s, "; ")?;
|
||||
@ -1319,7 +1319,7 @@ impl<'a> State<'a> {
|
||||
self.word_space("box")?;
|
||||
self.print_expr(expr)?;
|
||||
}
|
||||
hir::ExprVec(ref exprs) => {
|
||||
hir::ExprArray(ref exprs) => {
|
||||
self.print_expr_vec(&exprs[..])?;
|
||||
}
|
||||
hir::ExprRepeat(ref element, ref count) => {
|
||||
@ -1829,7 +1829,7 @@ impl<'a> State<'a> {
|
||||
word(&mut self.s, "...")?;
|
||||
self.print_expr(&end)?;
|
||||
}
|
||||
PatKind::Vec(ref before, ref slice, ref after) => {
|
||||
PatKind::Slice(ref before, ref slice, ref after) => {
|
||||
word(&mut self.s, "[")?;
|
||||
self.commasep(Inconsistent, &before[..], |s, p| s.print_pat(&p))?;
|
||||
if let Some(ref p) = *slice {
|
||||
|
@ -1433,8 +1433,8 @@ impl<'a, 'gcx, 'tcx> Rebuilder<'a, 'gcx, 'tcx> {
|
||||
hir::TyPtr(ref mut_ty) => {
|
||||
ty_queue.push(&mut_ty.ty);
|
||||
}
|
||||
hir::TyVec(ref ty) |
|
||||
hir::TyFixedLengthVec(ref ty, _) => {
|
||||
hir::TySlice(ref ty) |
|
||||
hir::TyArray(ref ty, _) => {
|
||||
ty_queue.push(&ty);
|
||||
}
|
||||
hir::TyTup(ref tys) => ty_queue.extend(tys.iter().map(|ty| &**ty)),
|
||||
@ -1469,9 +1469,9 @@ impl<'a, 'gcx, 'tcx> Rebuilder<'a, 'gcx, 'tcx> {
|
||||
ty: build_to(mut_ty.ty, to),
|
||||
})
|
||||
}
|
||||
hir::TyVec(ty) => hir::TyVec(build_to(ty, to)),
|
||||
hir::TyFixedLengthVec(ty, e) => {
|
||||
hir::TyFixedLengthVec(build_to(ty, to), e)
|
||||
hir::TySlice(ty) => hir::TySlice(build_to(ty, to)),
|
||||
hir::TyArray(ty, e) => {
|
||||
hir::TyArray(build_to(ty, to), e)
|
||||
}
|
||||
hir::TyTup(tys) => {
|
||||
hir::TyTup(tys.into_iter().map(|ty| build_to(ty, to)).collect())
|
||||
|
@ -442,7 +442,7 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
|
||||
}
|
||||
}
|
||||
|
||||
hir::ExprVec(ref exprs) => {
|
||||
hir::ExprArray(ref exprs) => {
|
||||
self.consume_exprs(exprs);
|
||||
}
|
||||
|
||||
|
@ -490,7 +490,7 @@ fn visit_expr(ir: &mut IrMaps, expr: &Expr) {
|
||||
|
||||
// otherwise, live nodes are not required:
|
||||
hir::ExprIndex(..) | hir::ExprField(..) | hir::ExprTupField(..) |
|
||||
hir::ExprVec(..) | hir::ExprCall(..) | hir::ExprMethodCall(..) |
|
||||
hir::ExprArray(..) | hir::ExprCall(..) | hir::ExprMethodCall(..) |
|
||||
hir::ExprTup(..) | hir::ExprBinary(..) | hir::ExprAddrOf(..) |
|
||||
hir::ExprCast(..) | hir::ExprUnary(..) | hir::ExprBreak(_) |
|
||||
hir::ExprAgain(_) | hir::ExprLit(_) | hir::ExprRet(..) |
|
||||
@ -1095,7 +1095,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
|
||||
|
||||
// Uninteresting cases: just propagate in rev exec order
|
||||
|
||||
hir::ExprVec(ref exprs) => {
|
||||
hir::ExprArray(ref exprs) => {
|
||||
self.propagate_through_exprs(&exprs[..], succ)
|
||||
}
|
||||
|
||||
@ -1436,7 +1436,7 @@ fn check_expr(this: &mut Liveness, expr: &Expr) {
|
||||
hir::ExprCall(..) | hir::ExprMethodCall(..) | hir::ExprIf(..) |
|
||||
hir::ExprMatch(..) | hir::ExprWhile(..) | hir::ExprLoop(..) |
|
||||
hir::ExprIndex(..) | hir::ExprField(..) | hir::ExprTupField(..) |
|
||||
hir::ExprVec(..) | hir::ExprTup(..) | hir::ExprBinary(..) |
|
||||
hir::ExprArray(..) | hir::ExprTup(..) | hir::ExprBinary(..) |
|
||||
hir::ExprCast(..) | hir::ExprUnary(..) | hir::ExprRet(..) |
|
||||
hir::ExprBreak(..) | hir::ExprAgain(..) | hir::ExprLit(_) |
|
||||
hir::ExprBlock(..) | hir::ExprAddrOf(..) |
|
||||
|
@ -503,7 +503,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
|
||||
hir::ExprClosure(..) | hir::ExprRet(..) |
|
||||
hir::ExprUnary(..) |
|
||||
hir::ExprMethodCall(..) | hir::ExprCast(..) |
|
||||
hir::ExprVec(..) | hir::ExprTup(..) | hir::ExprIf(..) |
|
||||
hir::ExprArray(..) | hir::ExprTup(..) | hir::ExprIf(..) |
|
||||
hir::ExprBinary(..) | hir::ExprWhile(..) |
|
||||
hir::ExprBlock(..) | hir::ExprLoop(..) | hir::ExprMatch(..) |
|
||||
hir::ExprLit(..) | hir::ExprBreak(..) |
|
||||
@ -1155,7 +1155,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
|
||||
self.cat_pattern_(subcmt, &subpat, op)?;
|
||||
}
|
||||
|
||||
PatKind::Vec(ref before, ref slice, ref after) => {
|
||||
PatKind::Slice(ref before, ref slice, ref after) => {
|
||||
let context = InteriorOffsetKind::Pattern;
|
||||
let elt_cmt = self.cat_index(pat, cmt, context)?;
|
||||
for before_pat in before {
|
||||
|
@ -961,7 +961,7 @@ fn resolve_local(visitor: &mut RegionResolutionVisitor, local: &hir::Local) {
|
||||
field_pats.iter().any(|fp| is_binding_pat(&fp.node.pat))
|
||||
}
|
||||
|
||||
PatKind::Vec(ref pats1, ref pats2, ref pats3) => {
|
||||
PatKind::Slice(ref pats1, ref pats2, ref pats3) => {
|
||||
pats1.iter().any(|p| is_binding_pat(&p)) ||
|
||||
pats2.iter().any(|p| is_binding_pat(&p)) ||
|
||||
pats3.iter().any(|p| is_binding_pat(&p))
|
||||
@ -1012,7 +1012,7 @@ fn resolve_local(visitor: &mut RegionResolutionVisitor, local: &hir::Local) {
|
||||
visitor, &field.expr, blk_id);
|
||||
}
|
||||
}
|
||||
hir::ExprVec(ref subexprs) |
|
||||
hir::ExprArray(ref subexprs) |
|
||||
hir::ExprTup(ref subexprs) => {
|
||||
for subexpr in subexprs {
|
||||
record_rvalue_scope_if_borrow_expr(
|
||||
|
@ -1016,7 +1016,7 @@ pub enum CastKind {
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable)]
|
||||
pub enum AggregateKind<'tcx> {
|
||||
Vec,
|
||||
Array,
|
||||
Tuple,
|
||||
/// The second field is variant number (discriminant), it's equal to 0
|
||||
/// for struct and union expressions. The fourth field is active field
|
||||
@ -1107,8 +1107,6 @@ impl<'tcx> Debug for Rvalue<'tcx> {
|
||||
}
|
||||
|
||||
Aggregate(ref kind, ref lvs) => {
|
||||
use self::AggregateKind::*;
|
||||
|
||||
fn fmt_tuple(fmt: &mut Formatter, lvs: &[Operand]) -> fmt::Result {
|
||||
let mut tuple_fmt = fmt.debug_tuple("");
|
||||
for lv in lvs {
|
||||
@ -1118,9 +1116,9 @@ impl<'tcx> Debug for Rvalue<'tcx> {
|
||||
}
|
||||
|
||||
match *kind {
|
||||
Vec => write!(fmt, "{:?}", lvs),
|
||||
AggregateKind::Array => write!(fmt, "{:?}", lvs),
|
||||
|
||||
Tuple => {
|
||||
AggregateKind::Tuple => {
|
||||
match lvs.len() {
|
||||
0 => write!(fmt, "()"),
|
||||
1 => write!(fmt, "({:?},)", lvs[0]),
|
||||
@ -1128,7 +1126,7 @@ impl<'tcx> Debug for Rvalue<'tcx> {
|
||||
}
|
||||
}
|
||||
|
||||
Adt(adt_def, variant, substs, _) => {
|
||||
AggregateKind::Adt(adt_def, variant, substs, _) => {
|
||||
let variant_def = &adt_def.variants[variant];
|
||||
|
||||
ppaux::parameterized(fmt, substs, variant_def.did,
|
||||
@ -1147,7 +1145,7 @@ impl<'tcx> Debug for Rvalue<'tcx> {
|
||||
}
|
||||
}
|
||||
|
||||
Closure(def_id, _) => ty::tls::with(|tcx| {
|
||||
AggregateKind::Closure(def_id, _) => ty::tls::with(|tcx| {
|
||||
if let Some(node_id) = tcx.map.as_local_node_id(def_id) {
|
||||
let name = format!("[closure@{:?}]", tcx.map.span(node_id));
|
||||
let mut struct_fmt = fmt.debug_struct(&name);
|
||||
|
@ -175,7 +175,7 @@ impl<'tcx> Rvalue<'tcx> {
|
||||
}
|
||||
&Rvalue::Aggregate(ref ak, ref ops) => {
|
||||
match *ak {
|
||||
AggregateKind::Vec => {
|
||||
AggregateKind::Array => {
|
||||
if let Some(operand) = ops.get(0) {
|
||||
let ty = operand.ty(mir, tcx);
|
||||
Some(tcx.mk_array(ty, ops.len()))
|
||||
|
@ -531,7 +531,7 @@ macro_rules! make_mir_visitor {
|
||||
Rvalue::Aggregate(ref $($mutability)* kind,
|
||||
ref $($mutability)* operands) => {
|
||||
match *kind {
|
||||
AggregateKind::Vec => {
|
||||
AggregateKind::Array => {
|
||||
}
|
||||
AggregateKind::Tuple => {
|
||||
}
|
||||
|
@ -24,7 +24,7 @@ pub enum SimplifiedType {
|
||||
FloatSimplifiedType(ast::FloatTy),
|
||||
AdtSimplifiedType(DefId),
|
||||
StrSimplifiedType,
|
||||
VecSimplifiedType,
|
||||
ArraySimplifiedType,
|
||||
PtrSimplifiedType,
|
||||
NeverSimplifiedType,
|
||||
TupleSimplifiedType(usize),
|
||||
@ -57,7 +57,7 @@ pub fn simplify_type<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
|
||||
ty::TyFloat(float_type) => Some(FloatSimplifiedType(float_type)),
|
||||
ty::TyAdt(def, _) => Some(AdtSimplifiedType(def.did)),
|
||||
ty::TyStr => Some(StrSimplifiedType),
|
||||
ty::TyArray(..) | ty::TySlice(_) => Some(VecSimplifiedType),
|
||||
ty::TyArray(..) | ty::TySlice(_) => Some(ArraySimplifiedType),
|
||||
ty::TyRawPtr(_) => Some(PtrSimplifiedType),
|
||||
ty::TyTrait(ref trait_info) => {
|
||||
Some(TraitSimplifiedType(trait_info.principal.def_id()))
|
||||
|
@ -2228,7 +2228,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
|
||||
hir::ExprClosure(..) |
|
||||
hir::ExprBlock(..) |
|
||||
hir::ExprRepeat(..) |
|
||||
hir::ExprVec(..) |
|
||||
hir::ExprArray(..) |
|
||||
hir::ExprBreak(..) |
|
||||
hir::ExprAgain(..) |
|
||||
hir::ExprRet(..) |
|
||||
|
@ -610,14 +610,14 @@ fn construct_witness<'a,'tcx>(cx: &MatchCheckCtxt<'a,'tcx>, ctor: &Constructor,
|
||||
ty::TySlice(_) => match ctor {
|
||||
&Slice(n) => {
|
||||
assert_eq!(pats_len, n);
|
||||
PatKind::Vec(pats.collect(), None, hir::HirVec::new())
|
||||
PatKind::Slice(pats.collect(), None, hir::HirVec::new())
|
||||
},
|
||||
_ => unreachable!()
|
||||
},
|
||||
|
||||
ty::TyArray(_, len) => {
|
||||
assert_eq!(pats_len, len);
|
||||
PatKind::Vec(pats.collect(), None, hir::HirVec::new())
|
||||
PatKind::Slice(pats.collect(), None, hir::HirVec::new())
|
||||
}
|
||||
|
||||
_ => {
|
||||
@ -713,7 +713,7 @@ fn is_useful<'a, 'tcx>(cx: &MatchCheckCtxt<'a, 'tcx>,
|
||||
};
|
||||
|
||||
let max_slice_length = rows.iter().filter_map(|row| match row[0].0.node {
|
||||
PatKind::Vec(ref before, _, ref after) => Some(before.len() + after.len()),
|
||||
PatKind::Slice(ref before, _, ref after) => Some(before.len() + after.len()),
|
||||
_ => None
|
||||
}).max().map_or(0, |v| v + 1);
|
||||
|
||||
@ -812,7 +812,7 @@ fn pat_constructors(cx: &MatchCheckCtxt, p: &Pat,
|
||||
vec![ConstantValue(eval_const_expr(cx.tcx, &expr))],
|
||||
PatKind::Range(ref lo, ref hi) =>
|
||||
vec![ConstantRange(eval_const_expr(cx.tcx, &lo), eval_const_expr(cx.tcx, &hi))],
|
||||
PatKind::Vec(ref before, ref slice, ref after) =>
|
||||
PatKind::Slice(ref before, ref slice, ref after) =>
|
||||
match left_ty.sty {
|
||||
ty::TyArray(..) => vec![Single],
|
||||
ty::TySlice(_) if slice.is_some() => {
|
||||
@ -1001,7 +1001,7 @@ pub fn specialize<'a, 'b, 'tcx>(
|
||||
}
|
||||
}
|
||||
|
||||
PatKind::Vec(ref before, ref slice, ref after) => {
|
||||
PatKind::Slice(ref before, ref slice, ref after) => {
|
||||
let pat_len = before.len() + after.len();
|
||||
match *constructor {
|
||||
Single => {
|
||||
|
@ -317,11 +317,11 @@ pub fn const_expr_to_pat<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
||||
PatKind::Struct(path.clone(), field_pats, false)
|
||||
}
|
||||
|
||||
hir::ExprVec(ref exprs) => {
|
||||
hir::ExprArray(ref exprs) => {
|
||||
let pats = exprs.iter()
|
||||
.map(|expr| const_expr_to_pat(tcx, &expr, pat_id, span))
|
||||
.collect::<Result<_, _>>()?;
|
||||
PatKind::Vec(pats, None, hir::HirVec::new())
|
||||
PatKind::Slice(pats, None, hir::HirVec::new())
|
||||
}
|
||||
|
||||
hir::ExprPath(_, ref path) => {
|
||||
@ -898,7 +898,7 @@ pub fn eval_const_expr_partial<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
||||
Array(_, n) if idx >= n => {
|
||||
signal!(e, IndexOutOfBounds { len: n, index: idx })
|
||||
}
|
||||
Array(v, n) => if let hir::ExprVec(ref v) = tcx.map.expect_expr(v).node {
|
||||
Array(v, n) => if let hir::ExprArray(ref v) = tcx.map.expect_expr(v).node {
|
||||
assert_eq!(n as usize as u64, n);
|
||||
eval_const_expr_partial(tcx, &v[idx as usize], ty_hint, fn_args)?
|
||||
} else {
|
||||
@ -925,7 +925,7 @@ pub fn eval_const_expr_partial<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
||||
_ => signal!(e, IndexedNonVec),
|
||||
}
|
||||
}
|
||||
hir::ExprVec(ref v) => Array(e.id, v.len() as u64),
|
||||
hir::ExprArray(ref v) => Array(e.id, v.len() as u64),
|
||||
hir::ExprRepeat(_, ref n) => {
|
||||
let len_hint = ty_hint.checked_or(tcx.types.usize);
|
||||
Repeat(
|
||||
|
@ -207,7 +207,7 @@ enum SawExprComponent<'a> {
|
||||
SawExprAgain(Option<token::InternedString>),
|
||||
|
||||
SawExprBox,
|
||||
SawExprVec,
|
||||
SawExprArray,
|
||||
SawExprCall,
|
||||
SawExprMethodCall,
|
||||
SawExprTup,
|
||||
@ -235,7 +235,7 @@ enum SawExprComponent<'a> {
|
||||
fn saw_expr<'a>(node: &'a Expr_) -> SawExprComponent<'a> {
|
||||
match *node {
|
||||
ExprBox(..) => SawExprBox,
|
||||
ExprVec(..) => SawExprVec,
|
||||
ExprArray(..) => SawExprArray,
|
||||
ExprCall(..) => SawExprCall,
|
||||
ExprMethodCall(..) => SawExprMethodCall,
|
||||
ExprTup(..) => SawExprTup,
|
||||
|
@ -160,7 +160,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
|
||||
.map(|f| unpack!(block = this.as_operand(block, f)))
|
||||
.collect();
|
||||
|
||||
block.and(Rvalue::Aggregate(AggregateKind::Vec, fields))
|
||||
block.and(Rvalue::Aggregate(AggregateKind::Array, fields))
|
||||
}
|
||||
ExprKind::Tuple { fields } => { // see (*) above
|
||||
// first process the set of fields
|
||||
|
@ -613,7 +613,7 @@ fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
|
||||
value: value.to_ref(),
|
||||
value_extents: cx.tcx.region_maps.node_extent(value.id)
|
||||
},
|
||||
hir::ExprVec(ref fields) =>
|
||||
hir::ExprArray(ref fields) =>
|
||||
ExprKind::Vec { fields: fields.to_ref() },
|
||||
hir::ExprTup(ref fields) =>
|
||||
ExprKind::Tuple { fields: fields.to_ref() },
|
||||
|
@ -113,7 +113,7 @@ impl<'patcx, 'cx, 'gcx, 'tcx> PatCx<'patcx, 'cx, 'gcx, 'tcx> {
|
||||
PatternKind::Deref { subpattern: self.to_pattern(subpattern) }
|
||||
}
|
||||
|
||||
PatKind::Vec(ref prefix, ref slice, ref suffix) => {
|
||||
PatKind::Slice(ref prefix, ref slice, ref suffix) => {
|
||||
let ty = self.cx.tcx.node_id_to_type(pat.id);
|
||||
match ty.sty {
|
||||
ty::TyRef(_, mt) =>
|
||||
|
@ -202,7 +202,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BuildMir<'a, 'tcx> {
|
||||
|
||||
// Array lengths, i.e. [T; constant].
|
||||
fn visit_ty(&mut self, ty: &'tcx hir::Ty) {
|
||||
if let hir::TyFixedLengthVec(_, ref length) = ty.node {
|
||||
if let hir::TyArray(_, ref length) = ty.node {
|
||||
self.build_const_integer(length);
|
||||
}
|
||||
intravisit::walk_ty(self, ty);
|
||||
|
@ -602,7 +602,7 @@ fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, e: &hir::Expr, node
|
||||
hir::ExprIndex(..) |
|
||||
hir::ExprField(..) |
|
||||
hir::ExprTupField(..) |
|
||||
hir::ExprVec(_) |
|
||||
hir::ExprArray(_) |
|
||||
hir::ExprType(..) |
|
||||
hir::ExprTup(..) => {}
|
||||
|
||||
|
@ -572,7 +572,7 @@ impl<'a, 'tcx> MirConstContext<'a, 'tcx> {
|
||||
}
|
||||
|
||||
match *kind {
|
||||
mir::AggregateKind::Vec => {
|
||||
mir::AggregateKind::Array => {
|
||||
self.const_array(dest_ty, &fields)
|
||||
}
|
||||
mir::AggregateKind::Adt(..) |
|
||||
|
@ -1623,7 +1623,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o {
|
||||
}
|
||||
|
||||
let result_ty = match ast_ty.node {
|
||||
hir::TyVec(ref ty) => {
|
||||
hir::TySlice(ref ty) => {
|
||||
tcx.mk_slice(self.ast_ty_to_ty(rscope, &ty))
|
||||
}
|
||||
hir::TyObjectSum(ref ty, ref bounds) => {
|
||||
@ -1758,7 +1758,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> AstConv<'gcx, 'tcx>+'o {
|
||||
|
||||
ty
|
||||
}
|
||||
hir::TyFixedLengthVec(ref ty, ref e) => {
|
||||
hir::TyArray(ref ty, ref e) => {
|
||||
if let Ok(length) = eval_length(tcx.global_tcx(), &e, "array length") {
|
||||
tcx.mk_array(self.ast_ty_to_ty(rscope, &ty), length)
|
||||
} else {
|
||||
|
@ -227,7 +227,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
|
||||
tcx.types.err
|
||||
}
|
||||
}
|
||||
PatKind::Vec(ref before, ref slice, ref after) => {
|
||||
PatKind::Slice(ref before, ref slice, ref after) => {
|
||||
let expected_ty = self.structurally_resolved_type(pat.span, expected);
|
||||
let (inner_ty, slice_ty) = match expected_ty.sty {
|
||||
ty::TyArray(inner_ty, size) => {
|
||||
|
@ -450,7 +450,7 @@ impl<'a, 'tcx> Visitor<'tcx> for CheckItemTypesVisitor<'a, 'tcx> {
|
||||
|
||||
fn visit_ty(&mut self, t: &'tcx hir::Ty) {
|
||||
match t.node {
|
||||
hir::TyFixedLengthVec(_, ref expr) => {
|
||||
hir::TyArray(_, ref expr) => {
|
||||
check_const_with_type(self.ccx, &expr, self.ccx.tcx.types.usize, expr.id);
|
||||
}
|
||||
_ => {}
|
||||
@ -626,7 +626,7 @@ impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
|
||||
// need to record the type for that node
|
||||
fn visit_ty(&mut self, t: &'gcx hir::Ty) {
|
||||
match t.node {
|
||||
hir::TyFixedLengthVec(ref ty, ref count_expr) => {
|
||||
hir::TyArray(ref ty, ref count_expr) => {
|
||||
self.visit_ty(&ty);
|
||||
self.fcx.check_expr_with_hint(&count_expr, self.fcx.tcx.types.usize);
|
||||
}
|
||||
@ -3590,7 +3590,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
|
||||
self.check_method_call(expr, name, &args[..], &tps[..], expected, lvalue_pref)
|
||||
}
|
||||
hir::ExprCast(ref e, ref t) => {
|
||||
if let hir::TyFixedLengthVec(_, ref count_expr) = t.node {
|
||||
if let hir::TyArray(_, ref count_expr) = t.node {
|
||||
self.check_expr_with_hint(&count_expr, tcx.types.usize);
|
||||
}
|
||||
|
||||
@ -3623,7 +3623,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
|
||||
self.check_expr_eq_type(&e, typ);
|
||||
typ
|
||||
}
|
||||
hir::ExprVec(ref args) => {
|
||||
hir::ExprArray(ref args) => {
|
||||
let uty = expected.to_option(self).and_then(|uty| {
|
||||
match uty.sty {
|
||||
ty::TyArray(ty, _) | ty::TySlice(ty) => Some(ty),
|
||||
|
@ -247,7 +247,7 @@ impl<'cx, 'gcx, 'tcx, 'v> Visitor<'v> for WritebackCx<'cx, 'gcx, 'tcx> {
|
||||
|
||||
fn visit_ty(&mut self, t: &hir::Ty) {
|
||||
match t.node {
|
||||
hir::TyFixedLengthVec(ref ty, ref count_expr) => {
|
||||
hir::TyArray(ref ty, ref count_expr) => {
|
||||
self.visit_ty(&ty);
|
||||
write_ty_to_tcx(self.fcx.ccx, count_expr.id, self.tcx().types.usize);
|
||||
}
|
||||
|
@ -1646,8 +1646,8 @@ impl Clean<Type> for hir::Ty {
|
||||
TyRptr(ref l, ref m) =>
|
||||
BorrowedRef {lifetime: l.clean(cx), mutability: m.mutbl.clean(cx),
|
||||
type_: box m.ty.clean(cx)},
|
||||
TyVec(ref ty) => Vector(box ty.clean(cx)),
|
||||
TyFixedLengthVec(ref ty, ref e) => {
|
||||
TySlice(ref ty) => Vector(box ty.clean(cx)),
|
||||
TyArray(ref ty, ref e) => {
|
||||
let n = if let Some(tcx) = cx.tcx_opt() {
|
||||
use rustc_const_math::{ConstInt, ConstUsize};
|
||||
use rustc_const_eval::eval_const_expr;
|
||||
@ -2699,7 +2699,7 @@ fn name_from_pat(p: &hir::Pat) -> String {
|
||||
},
|
||||
PatKind::Range(..) => panic!("tried to get argument name from PatKind::Range, \
|
||||
which is not allowed in function arguments"),
|
||||
PatKind::Vec(ref begin, ref mid, ref end) => {
|
||||
PatKind::Slice(ref begin, ref mid, ref end) => {
|
||||
let begin = begin.iter().map(|p| name_from_pat(&**p));
|
||||
let mid = mid.as_ref().map(|p| format!("..{}", name_from_pat(&**p))).into_iter();
|
||||
let end = end.iter().map(|p| name_from_pat(&**p));
|
||||
|
Loading…
x
Reference in New Issue
Block a user