}
fn mk_test_descs(cx: &TestCtxt) -> @ast::Expr {
- let mut descs = Vec::new();
debug!("building test vector from {} tests", cx.testfns.borrow().len());
- for test in cx.testfns.borrow().iter() {
- descs.push(mk_test_desc_and_fn_rec(cx, test));
- }
-
- let inner_expr = @ast::Expr {
- id: ast::DUMMY_NODE_ID,
- node: ast::ExprVec(descs, ast::MutImmutable),
- span: DUMMY_SP,
- };
@ast::Expr {
id: ast::DUMMY_NODE_ID,
- node: ast::ExprVstore(inner_expr, ast::ExprVstoreSlice),
+ node: ast::ExprVstore(@ast::Expr {
+ id: ast::DUMMY_NODE_ID,
+ node: ast::ExprVec(cx.testfns.borrow().iter().map(|test| {
+ mk_test_desc_and_fn_rec(cx, test)
+ }).collect()),
+ span: DUMMY_SP,
+ }, ast::ExprVstoreSlice),
span: DUMMY_SP,
}
}
self.add_node(expr.id, [])
}
- ast::ExprVec(ref elems, _) => {
+ ast::ExprVec(ref elems) => {
self.straightline(expr, pred, elems.as_slice())
}
self.straightline(expr, base_exit, field_exprs.as_slice())
}
- ast::ExprRepeat(elem, count, _) => {
+ ast::ExprRepeat(elem, count) => {
self.straightline(expr, pred, [elem, count])
}
}
ExprVstore(_, ExprVstoreMutSlice) |
ExprVstore(_, ExprVstoreSlice) |
- ExprVec(_, MutImmutable) |
+ ExprVec(_) |
ExprAddrOf(MutImmutable, _) |
ExprParen(..) |
ExprField(..) |
join(self.classify(a), self.classify(b)),
ast::ExprTup(ref es) |
- ast::ExprVec(ref es, ast::MutImmutable) =>
+ ast::ExprVec(ref es) =>
join_all(es.iter().map(|e| self.classify(*e))),
ast::ExprVstore(e, vstore) => {
self.walk_expr(l, in_out, loop_scopes);
}
- ast::ExprVec(ref exprs, _) => {
+ ast::ExprVec(ref exprs) => {
self.walk_exprs(exprs.as_slice(), in_out, loop_scopes)
}
- ast::ExprRepeat(l, r, _) => {
+ ast::ExprRepeat(l, r) => {
self.walk_expr(l, in_out, loop_scopes);
self.walk_expr(r, in_out, loop_scopes);
}
let target_ty = ty::expr_ty(cx.tcx, e);
check_trait_cast(cx, source_ty, target_ty, source.span);
}
- ExprRepeat(element, count_expr, _) => {
+ ExprRepeat(element, count_expr) => {
let count = ty::eval_repeat_count(cx.tcx, count_expr);
if count > 1 {
let element_ty = ty::expr_ty(cx.tcx, element);
self.propagate_through_expr(expr, succ)
}
- ExprVec(ref exprs, _) => {
+ ExprVec(ref exprs) => {
self.propagate_through_exprs(exprs.as_slice(), succ)
}
- ExprRepeat(element, count, _) => {
+ ExprRepeat(element, count) => {
let succ = self.propagate_through_expr(count, succ);
self.propagate_through_expr(element, succ)
}
self.use_expr(base, expr_mode);
}
- ExprVec(ref exprs, _) => {
+ ExprVec(ref exprs) => {
self.consume_exprs(exprs.as_slice());
}
// }
}
- ExprRepeat(base, count, _) => {
+ ExprRepeat(base, count) => {
self.consume_expr(base);
self.consume_expr(count);
}
visitor.region_maps.record_rvalue_scope(subexpr.id, blk_id);
record_rvalue_scope_if_borrow_expr(visitor, subexpr, blk_id);
}
- ast::ExprVec(ref subexprs, _) |
+ ast::ExprVec(ref subexprs) |
ast::ExprTup(ref subexprs) => {
for &subexpr in subexprs.iter() {
record_rvalue_scope_if_borrow_expr(
inlineable.iter().fold(true, |a, &b| a && b))
})
}
- ast::ExprVec(ref es, ast::MutImmutable) => {
+ ast::ExprVec(ref es) => {
let (v, _, inlineable) = const_vec(cx,
e,
es.as_slice(),
_ => { cx.sess().span_bug(e.span, "bad const-slice lit") }
}
}
- ast::ExprVec(ref es, ast::MutImmutable) => {
+ ast::ExprVec(ref es) => {
let (cv, llunitty, _) = const_vec(cx,
e,
es.as_slice(),
_ => cx.sess().span_bug(e.span, "bad const-slice expr")
}
}
- ast::ExprRepeat(elem, count, _) => {
+ ast::ExprRepeat(elem, count) => {
let vec_ty = ty::expr_ty(cx.tcx(), e);
let unit_ty = ty::sequence_element_type(cx.tcx(), vec_ty);
let llunitty = type_of::type_of(cx, unit_ty);
walk_expr(cx, rhs, scope_stack, scope_map);
}
- ast::ExprVec(ref init_expressions, _) |
- ast::ExprTup(ref init_expressions) => {
+ ast::ExprVec(ref init_expressions) |
+ ast::ExprTup(ref init_expressions) => {
for ie in init_expressions.iter() {
walk_expr(cx, *ie, scope_stack, scope_map);
}
}
- ast::ExprAssign(sub_exp1, sub_exp2) |
- ast::ExprRepeat(sub_exp1, sub_exp2, _) => {
+ ast::ExprAssign(sub_exp1, sub_exp2) |
+ ast::ExprRepeat(sub_exp1, sub_exp2) => {
walk_expr(cx, sub_exp1, scope_stack, scope_map);
walk_expr(cx, sub_exp2, scope_stack, scope_map);
}
}
}
}
- ast::ExprVec(ref elements, _) => {
+ ast::ExprVec(ref elements) => {
match dest {
Ignore => {
for element in elements.iter() {
}
return bcx;
}
- ast::ExprRepeat(element, count_expr, _) => {
+ ast::ExprRepeat(element, count_expr) => {
match dest {
Ignore => {
return expr::trans_into(bcx, element, Ignore);
}
}
},
- ast::ExprVec(ref es, _) => es.len(),
- ast::ExprRepeat(_, count_expr, _) => {
+ ast::ExprVec(ref es) => es.len(),
+ ast::ExprRepeat(_, count_expr) => {
ty::eval_repeat_count(bcx.tcx(), count_expr)
}
_ => bcx.tcx().sess.span_bug(content_expr.span,
let tt = ast_expr_vstore_to_vstore(fcx, ev, vst);
ty::mk_str(tcx, tt)
}
- ast::ExprVec(ref args, mutbl) => {
+ ast::ExprVec(ref args) => {
let tt = ast_expr_vstore_to_vstore(fcx, ev, vst);
let mut any_error = false;
let mut any_bot = false;
let mutability = match vst {
ast::ExprVstoreMutSlice => ast::MutMutable,
- _ => mutbl,
+ _ => ast::MutImmutable,
};
let t: ty::t = fcx.infcx().next_ty_var();
for e in args.iter() {
ty::mk_vec(tcx, ty::mt {ty: t, mutbl: mutability}, tt)
}
}
- ast::ExprRepeat(element, count_expr, mutbl) => {
+ ast::ExprRepeat(element, count_expr) => {
check_expr_with_hint(fcx, count_expr, ty::mk_uint());
let _ = ty::eval_repeat_count(fcx, count_expr);
let tt = ast_expr_vstore_to_vstore(fcx, ev, vst);
let mutability = match vst {
ast::ExprVstoreMutSlice => ast::MutMutable,
- _ => mutbl,
+ _ => ast::MutImmutable,
};
let t: ty::t = fcx.infcx().next_ty_var();
check_expr_has_type(fcx, element, t);
fcx.write_ty(id, t_1);
}
}
- ast::ExprVec(ref args, mutbl) => {
+ ast::ExprVec(ref args) => {
let t: ty::t = fcx.infcx().next_ty_var();
for e in args.iter() {
check_expr_has_type(fcx, *e, t);
}
- let typ = ty::mk_vec(tcx, ty::mt {ty: t, mutbl: mutbl},
+ let typ = ty::mk_vec(tcx, ty::mt {ty: t, mutbl: ast::MutImmutable},
ty::vstore_fixed(args.len()));
fcx.write_ty(id, typ);
}
- ast::ExprRepeat(element, count_expr, mutbl) => {
+ ast::ExprRepeat(element, count_expr) => {
check_expr_with_hint(fcx, count_expr, ty::mk_uint());
let count = ty::eval_repeat_count(fcx, count_expr);
let t: ty::t = fcx.infcx().next_ty_var();
fcx.write_bot(id);
}
else {
- let t = ty::mk_vec(tcx, ty::mt {ty: t, mutbl: mutbl},
+ let t = ty::mk_vec(tcx, ty::mt {ty: t, mutbl: ast::MutImmutable},
ty::vstore_fixed(count));
fcx.write_ty(id, t);
}
// string literals and *empty slices* live in static memory
ty::vstore_slice(ty::ReStatic)
}
- ast::ExprVec(ref elements, _) if elements.len() == 0 => {
+ ast::ExprVec(ref elements) if elements.len() == 0 => {
// string literals and *empty slices* live in static memory
ty::vstore_slice(ty::ReStatic)
}
ExprVstore(@Expr, ExprVstore),
// First expr is the place; second expr is the value.
ExprBox(@Expr, @Expr),
- ExprVec(Vec<@Expr>, Mutability),
+ ExprVec(Vec<@Expr>),
ExprCall(@Expr, Vec<@Expr>),
ExprMethodCall(Ident, Vec<P<Ty>>, Vec<@Expr>),
ExprTup(Vec<@Expr>),
ExprStruct(Path, Vec<Field> , Option<@Expr> /* base */),
// A vector literal constructed from one repeated element.
- ExprRepeat(@Expr /* element */, @Expr /* count */, Mutability),
+ ExprRepeat(@Expr /* element */, @Expr /* count */),
// No-op: used solely so we can pretty-print faithfully
ExprParen(@Expr)
self.expr(sp, ast::ExprVstore(expr, vst))
}
fn expr_vec(&self, sp: Span, exprs: Vec<@ast::Expr> ) -> @ast::Expr {
- self.expr(sp, ast::ExprVec(exprs, ast::MutImmutable))
+ self.expr(sp, ast::ExprVec(exprs))
}
fn expr_vec_ng(&self, sp: Span) -> @ast::Expr {
self.expr_call_global(sp,
ExprBox(p, e) => {
ExprBox(folder.fold_expr(p), folder.fold_expr(e))
}
- ExprVec(ref exprs, mutt) => {
- ExprVec(exprs.iter().map(|&x| folder.fold_expr(x)).collect(), mutt)
+ ExprVec(ref exprs) => {
+ ExprVec(exprs.iter().map(|&x| folder.fold_expr(x)).collect())
}
- ExprRepeat(expr, count, mutt) => {
- ExprRepeat(folder.fold_expr(expr), folder.fold_expr(count), mutt)
+ ExprRepeat(expr, count) => {
+ ExprRepeat(folder.fold_expr(expr), folder.fold_expr(count))
}
ExprTup(ref elts) => ExprTup(elts.iter().map(|x| folder.fold_expr(*x)).collect()),
ExprCall(f, ref args) => {
return self.parse_block_expr(lo, UnsafeBlock(ast::UserProvided));
} else if self.token == token::LBRACKET {
self.bump();
- let mutbl = MutImmutable;
if self.token == token::RBRACKET {
// Empty vector.
self.bump();
- ex = ExprVec(Vec::new(), mutbl);
+ ex = ExprVec(Vec::new());
} else {
// Nonempty vector.
let first_expr = self.parse_expr();
self.bump();
let count = self.parse_expr();
self.expect(&token::RBRACKET);
- ex = ExprRepeat(first_expr, count, mutbl);
+ ex = ExprRepeat(first_expr, count);
} else if self.token == token::COMMA {
// Vector with two or more elements.
self.bump();
);
let mut exprs = vec!(first_expr);
exprs.push_all_move(remaining_exprs);
- ex = ExprVec(exprs, mutbl);
+ ex = ExprVec(exprs);
} else {
// Vector with one element.
self.expect(&token::RBRACKET);
- ex = ExprVec(vec!(first_expr), mutbl);
+ ex = ExprVec(vec!(first_expr));
}
}
hi = self.last_span.hi;
try!(self.word_space(")"));
try!(self.print_expr(e));
}
- ast::ExprVec(ref exprs, mutbl) => {
+ ast::ExprVec(ref exprs) => {
try!(self.ibox(indent_unit));
try!(word(&mut self.s, "["));
- if mutbl == ast::MutMutable {
- try!(word(&mut self.s, "mut"));
- if exprs.len() > 0u { try!(self.nbsp()); }
- }
try!(self.commasep_exprs(Inconsistent, exprs.as_slice()));
try!(word(&mut self.s, "]"));
try!(self.end());
}
- ast::ExprRepeat(element, count, mutbl) => {
+ ast::ExprRepeat(element, count) => {
try!(self.ibox(indent_unit));
try!(word(&mut self.s, "["));
- if mutbl == ast::MutMutable {
- try!(word(&mut self.s, "mut"));
- try!(self.nbsp());
- }
try!(self.print_expr(element));
try!(word(&mut self.s, ","));
try!(word(&mut self.s, ".."));
visitor.visit_expr(place, env.clone());
visitor.visit_expr(subexpression, env.clone())
}
- ExprVec(ref subexpressions, _) => {
+ ExprVec(ref subexpressions) => {
walk_exprs(visitor, subexpressions.as_slice(), env.clone())
}
- ExprRepeat(element, count, _) => {
+ ExprRepeat(element, count) => {
visitor.visit_expr(element, env.clone());
visitor.visit_expr(count, env.clone())
}