syntax: remove obsolete mutability from ExprVec and ExprRepeat.

eddyb · alexcrichton · commit 7c48e53c1e8c · 2014-04-04T13:23:03.000-07:00
diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs
@@ -404,21 +404,17 @@ fn is_test_crate(krate: &ast::Crate) -> bool {
 }
 
 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,
     }
 }
diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs
@@ -347,7 +347,7 @@ impl<'a> CFGBuilder<'a> {
                 self.add_node(expr.id, [])
             }
 
-            ast::ExprVec(ref elems, _) => {
+            ast::ExprVec(ref elems) => {
                 self.straightline(expr, pred, elems.as_slice())
             }
 
@@ -379,7 +379,7 @@ impl<'a> CFGBuilder<'a> {
                 self.straightline(expr, base_exit, field_exprs.as_slice())
             }
 
-            ast::ExprRepeat(elem, count, _) => {
+            ast::ExprRepeat(elem, count) => {
                 self.straightline(expr, pred, [elem, count])
             }
 
diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs
@@ -157,7 +157,7 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &Expr, is_const: bool) {
           }
           ExprVstore(_, ExprVstoreMutSlice) |
           ExprVstore(_, ExprVstoreSlice) |
-          ExprVec(_, MutImmutable) |
+          ExprVec(_) |
           ExprAddrOf(MutImmutable, _) |
           ExprParen(..) |
           ExprField(..) |
diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs
@@ -213,7 +213,7 @@ impl<'a> ConstEvalVisitor<'a> {
                 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) => {
diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs
@@ -538,11 +538,11 @@ impl<'a, 'b, O:DataFlowOperator> PropagationContext<'a, 'b, O> {
                 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);
             }
diff --git a/src/librustc/middle/kind.rs b/src/librustc/middle/kind.rs
@@ -309,7 +309,7 @@ pub fn check_expr(cx: &mut Context, e: &Expr) {
             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);
diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs
@@ -1109,11 +1109,11 @@ impl<'a> Liveness<'a> {
             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)
           }
diff --git a/src/librustc/middle/moves.rs b/src/librustc/middle/moves.rs
@@ -473,7 +473,7 @@ impl<'a> VisitContext<'a> {
                 self.use_expr(base, expr_mode);
             }
 
-            ExprVec(ref exprs, _) => {
+            ExprVec(ref exprs) => {
                 self.consume_exprs(exprs.as_slice());
             }
 
@@ -539,7 +539,7 @@ impl<'a> VisitContext<'a> {
                 // }
             }
 
-            ExprRepeat(base, count, _) => {
+            ExprRepeat(base, count) => {
                 self.consume_expr(base);
                 self.consume_expr(count);
             }
diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs
@@ -724,7 +724,7 @@ fn resolve_local(visitor: &mut RegionResolutionVisitor,
                 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(
diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs
@@ -557,7 +557,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::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(),
@@ -573,7 +573,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr,
                     _ => { 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(),
@@ -592,7 +592,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr,
               _ => 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);
diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs
@@ -2619,15 +2619,15 @@ fn populate_scope_map(cx: &CrateContext,
                 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);
             }
diff --git a/src/librustc/middle/trans/tvec.rs b/src/librustc/middle/trans/tvec.rs
@@ -392,7 +392,7 @@ pub fn write_content<'a>(
                 }
             }
         }
-        ast::ExprVec(ref elements, _) => {
+        ast::ExprVec(ref elements) => {
             match dest {
                 Ignore => {
                     for element in elements.iter() {
@@ -418,7 +418,7 @@ pub fn write_content<'a>(
             }
             return bcx;
         }
-        ast::ExprRepeat(element, count_expr, _) => {
+        ast::ExprRepeat(element, count_expr) => {
             match dest {
                 Ignore => {
                     return expr::trans_into(bcx, element, Ignore);
@@ -486,8 +486,8 @@ pub fn elements_required(bcx: &Block, content_expr: &ast::Expr) -> uint {
                 }
             }
         },
-        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,
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
@@ -2482,13 +2482,13 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
             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() {
@@ -2509,13 +2509,13 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
                 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);
@@ -3017,16 +3017,16 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
             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();
@@ -3039,7 +3039,7 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
             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);
         }
@@ -3864,7 +3864,7 @@ pub fn ast_expr_vstore_to_vstore(fcx: &FnCtxt,
                     // 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)
                 }
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
@@ -493,7 +493,7 @@ pub enum Expr_ {
     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>),
@@ -536,7 +536,7 @@ pub enum 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)
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
@@ -579,7 +579,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
         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,
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
@@ -740,11 +740,11 @@ pub fn noop_fold_expr<T: Folder>(e: @Expr, folder: &mut T) -> @Expr {
         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) => {
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
@@ -1819,12 +1819,11 @@ impl<'a> Parser<'a> {
             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();
@@ -1835,7 +1834,7 @@ impl<'a> Parser<'a> {
                     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();
@@ -1846,11 +1845,11 @@ impl<'a> Parser<'a> {
                     );
                     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;
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
@@ -1110,25 +1110,17 @@ impl<'a> State<'a> {
                 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, ".."));
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
@@ -635,10 +635,10 @@ pub fn walk_expr<E: Clone, V: Visitor<E>>(visitor: &mut V, expression: &Expr, en
             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())
         }

Original file line number	Diff line number	Diff line change
`@@ -347,7 +347,7 @@ impl<'a> CFGBuilder<'a> {`
`347`	`347`	`self.add_node(expr.id, [])`
`348`	`348`	`}`
`349`	`349`
`350`		`- ast::ExprVec(ref elems, _) => {`
	`350`	`+ ast::ExprVec(ref elems) => {`
`351`	`351`	`self.straightline(expr, pred, elems.as_slice())`
`352`	`352`	`}`
`353`	`353`
`@@ -379,7 +379,7 @@ impl<'a> CFGBuilder<'a> {`
`379`	`379`	`self.straightline(expr, base_exit, field_exprs.as_slice())`
`380`	`380`	`}`
`381`	`381`
`382`		`- ast::ExprRepeat(elem, count, _) => {`
	`382`	`+ ast::ExprRepeat(elem, count) => {`
`383`	`383`	`self.straightline(expr, pred, [elem, count])`
`384`	`384`	`}`
`385`	`385`
Original file line number	Diff line number	Diff line change
`@@ -157,7 +157,7 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &Expr, is_const: bool) {`
`157`	`157`	`}`
`158`	`158`	`ExprVstore(_, ExprVstoreMutSlice) \|`
`159`	`159`	`ExprVstore(_, ExprVstoreSlice) \|`
`160`		`- ExprVec(_, MutImmutable) \|`
	`160`	`+ ExprVec(_) \|`
`161`	`161`	`ExprAddrOf(MutImmutable, _) \|`
`162`	`162`	`ExprParen(..) \|`
`163`	`163`	`ExprField(..) \|`
Original file line number	Diff line number	Diff line change
`@@ -538,11 +538,11 @@ impl<'a, 'b, O:DataFlowOperator> PropagationContext<'a, 'b, O> {`
`538`	`538`	`self.walk_expr(l, in_out, loop_scopes);`
`539`	`539`	`}`
`540`	`540`
`541`		`- ast::ExprVec(ref exprs, _) => {`
	`541`	`+ ast::ExprVec(ref exprs) => {`
`542`	`542`	`self.walk_exprs(exprs.as_slice(), in_out, loop_scopes)`
`543`	`543`	`}`
`544`	`544`
`545`		`- ast::ExprRepeat(l, r, _) => {`
	`545`	`+ ast::ExprRepeat(l, r) => {`
`546`	`546`	`self.walk_expr(l, in_out, loop_scopes);`
`547`	`547`	`self.walk_expr(r, in_out, loop_scopes);`
`548`	`548`	`}`
Original file line number	Diff line number	Diff line change
`@@ -309,7 +309,7 @@ pub fn check_expr(cx: &mut Context, e: &Expr) {`
`309`	`309`	`let target_ty = ty::expr_ty(cx.tcx, e);`
`310`	`310`	`check_trait_cast(cx, source_ty, target_ty, source.span);`
`311`	`311`	`}`
`312`		`- ExprRepeat(element, count_expr, _) => {`
	`312`	`+ ExprRepeat(element, count_expr) => {`
`313`	`313`	`let count = ty::eval_repeat_count(cx.tcx, count_expr);`
`314`	`314`	`if count > 1 {`
`315`	`315`	`let element_ty = ty::expr_ty(cx.tcx, element);`
Original file line number	Diff line number	Diff line change
`@@ -1109,11 +1109,11 @@ impl<'a> Liveness<'a> {`
`1109`	`1109`	`self.propagate_through_expr(expr, succ)`
`1110`	`1110`	`}`
`1111`	`1111`
`1112`		`- ExprVec(ref exprs, _) => {`
	`1112`	`+ ExprVec(ref exprs) => {`
`1113`	`1113`	`self.propagate_through_exprs(exprs.as_slice(), succ)`
`1114`	`1114`	`}`
`1115`	`1115`
`1116`		`- ExprRepeat(element, count, _) => {`
	`1116`	`+ ExprRepeat(element, count) => {`
`1117`	`1117`	`let succ = self.propagate_through_expr(count, succ);`
`1118`	`1118`	`self.propagate_through_expr(element, succ)`
`1119`	`1119`	`}`
Original file line number	Diff line number	Diff line change
`@@ -473,7 +473,7 @@ impl<'a> VisitContext<'a> {`
`473`	`473`	`self.use_expr(base, expr_mode);`
`474`	`474`	`}`
`475`	`475`
`476`		`- ExprVec(ref exprs, _) => {`
	`476`	`+ ExprVec(ref exprs) => {`
`477`	`477`	`self.consume_exprs(exprs.as_slice());`
`478`	`478`	`}`
`479`	`479`
`@@ -539,7 +539,7 @@ impl<'a> VisitContext<'a> {`
`539`	`539`	`// }`
`540`	`540`	`}`
`541`	`541`
`542`		`- ExprRepeat(base, count, _) => {`
	`542`	`+ ExprRepeat(base, count) => {`
`543`	`543`	`self.consume_expr(base);`
`544`	`544`	`self.consume_expr(count);`
`545`	`545`	`}`
Original file line number	Diff line number	Diff line change
`@@ -724,7 +724,7 @@ fn resolve_local(visitor: &mut RegionResolutionVisitor,`
`724`	`724`	`visitor.region_maps.record_rvalue_scope(subexpr.id, blk_id);`
`725`	`725`	`record_rvalue_scope_if_borrow_expr(visitor, subexpr, blk_id);`
`726`	`726`	`}`
`727`		`- ast::ExprVec(ref subexprs, _) \|`
	`727`	`+ ast::ExprVec(ref subexprs) \|`
`728`	`728`	`ast::ExprTup(ref subexprs) => {`
`729`	`729`	`for &subexpr in subexprs.iter() {`
`730`	`730`	`record_rvalue_scope_if_borrow_expr(`
Original file line number	Diff line number	Diff line change
`@@ -557,7 +557,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr,`
`557`	`557`	`inlineable.iter().fold(true, \|a, &b\| a && b))`
`558`	`558`	`})`
`559`	`559`	`}`
`560`		`- ast::ExprVec(ref es, ast::MutImmutable) => {`
	`560`	`+ ast::ExprVec(ref es) => {`
`561`	`561`	`let (v, _, inlineable) = const_vec(cx,`
`562`	`562`	`e,`
`563`	`563`	`es.as_slice(),`
`@@ -573,7 +573,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr,`
`573`	`573`	`_ => { cx.sess().span_bug(e.span, "bad const-slice lit") }`
`574`	`574`	`}`
`575`	`575`	`}`
`576`		`- ast::ExprVec(ref es, ast::MutImmutable) => {`
	`576`	`+ ast::ExprVec(ref es) => {`
`577`	`577`	`let (cv, llunitty, _) = const_vec(cx,`
`578`	`578`	`e,`
`579`	`579`	`es.as_slice(),`
`@@ -592,7 +592,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr,`
`592`	`592`	`_ => cx.sess().span_bug(e.span, "bad const-slice expr")`
`593`	`593`	`}`
`594`	`594`	`}`
`595`		`- ast::ExprRepeat(elem, count, _) => {`
	`595`	`+ ast::ExprRepeat(elem, count) => {`
`596`	`596`	`let vec_ty = ty::expr_ty(cx.tcx(), e);`
`597`	`597`	`let unit_ty = ty::sequence_element_type(cx.tcx(), vec_ty);`
`598`	`598`	`let llunitty = type_of::type_of(cx, unit_ty);`