diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs
index 146891825d684..43227627b678d 100644
--- a/src/librustc/middle/cfg/construct.rs
+++ b/src/librustc/middle/cfg/construct.rs
@@ -73,19 +73,19 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
 
         let expr_exit = self.opt_expr(&blk.expr, stmts_exit);
 
-        self.add_node(blk.id, [expr_exit])
+        self.add_node(blk.id, &[expr_exit])
     }
 
     fn stmt(&mut self, stmt: &ast::Stmt, pred: CFGIndex) -> CFGIndex {
         match stmt.node {
             ast::StmtDecl(ref decl, id) => {
                 let exit = self.decl(&**decl, pred);
-                self.add_node(id, [exit])
+                self.add_node(id, &[exit])
             }
 
             ast::StmtExpr(ref expr, id) | ast::StmtSemi(ref expr, id) => {
                 let exit = self.expr(&**expr, pred);
-                self.add_node(id, [exit])
+                self.add_node(id, &[exit])
             }
 
             ast::StmtMac(..) => {
@@ -114,33 +114,33 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
             ast::PatLit(..) |
             ast::PatRange(..) |
             ast::PatWild(_) => {
-                self.add_node(pat.id, [pred])
+                self.add_node(pat.id, &[pred])
             }
 
             ast::PatBox(ref subpat) |
             ast::PatRegion(ref subpat) |
             ast::PatIdent(_, _, Some(ref subpat)) => {
                 let subpat_exit = self.pat(&**subpat, pred);
-                self.add_node(pat.id, [subpat_exit])
+                self.add_node(pat.id, &[subpat_exit])
             }
 
             ast::PatEnum(_, Some(ref subpats)) |
             ast::PatTup(ref subpats) => {
                 let pats_exit = self.pats_all(subpats.iter(), pred);
-                self.add_node(pat.id, [pats_exit])
+                self.add_node(pat.id, &[pats_exit])
             }
 
             ast::PatStruct(_, ref subpats, _) => {
                 let pats_exit =
                     self.pats_all(subpats.iter().map(|f| &f.node.pat), pred);
-                self.add_node(pat.id, [pats_exit])
+                self.add_node(pat.id, &[pats_exit])
             }
 
             ast::PatVec(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);
-                self.add_node(pat.id, [post_exit])
+                self.add_node(pat.id, &[post_exit])
             }
 
             ast::PatMac(_) => {
@@ -165,7 +165,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
         if pats.len() == 1 {
             self.pat(&*pats[0], pred)
         } else {
-            let collect = self.add_dummy_node([]);
+            let collect = self.add_dummy_node(&[]);
             for pat in pats.iter() {
                 let pat_exit = self.pat(&**pat, pred);
                 self.add_contained_edge(pat_exit, collect);
@@ -178,7 +178,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
         match expr.node {
             ast::ExprBlock(ref blk) => {
                 let blk_exit = self.block(&**blk, pred);
-                self.add_node(expr.id, [blk_exit])
+                self.add_node(expr.id, &[blk_exit])
             }
 
             ast::ExprIf(ref cond, ref then, None) => {
@@ -198,7 +198,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
                 //
                 let cond_exit = self.expr(&**cond, pred);                // 1
                 let then_exit = self.block(&**then, cond_exit);          // 2
-                self.add_node(expr.id, [cond_exit, then_exit])           // 3,4
+                self.add_node(expr.id, &[cond_exit, then_exit])          // 3,4
             }
 
             ast::ExprIf(ref cond, ref then, Some(ref otherwise)) => {
@@ -219,7 +219,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
                 let cond_exit = self.expr(&**cond, pred);                // 1
                 let then_exit = self.block(&**then, cond_exit);          // 2
                 let else_exit = self.expr(&**otherwise, cond_exit);      // 3
-                self.add_node(expr.id, [then_exit, else_exit])           // 4, 5
+                self.add_node(expr.id, &[then_exit, else_exit])          // 4, 5
             }
 
             ast::ExprIfLet(..) => {
@@ -245,9 +245,9 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
                 // may cause additional edges.
 
                 // Is the condition considered part of the loop?
-                let loopback = self.add_dummy_node([pred]);              // 1
-                let cond_exit = self.expr(&**cond, loopback);            // 2
-                let expr_exit = self.add_node(expr.id, [cond_exit]);     // 3
+                let loopback = self.add_dummy_node(&[pred]);              // 1
+                let cond_exit = self.expr(&**cond, loopback);             // 2
+                let expr_exit = self.add_node(expr.id, &[cond_exit]);     // 3
                 self.loop_scopes.push(LoopScope {
                     loop_id: expr.id,
                     continue_index: loopback,
@@ -286,10 +286,10 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
                 // Note that `break` and `continue` statements
                 // may cause additional edges.
 
-                let head = self.expr(&**head, pred);            // 1
-                let loopback = self.add_dummy_node([head]);     // 2
-                let cond = self.add_dummy_node([loopback]);     // 3
-                let expr_exit = self.add_node(expr.id, [cond]); // 4
+                let head = self.expr(&**head, pred);             // 1
+                let loopback = self.add_dummy_node(&[head]);     // 2
+                let cond = self.add_dummy_node(&[loopback]);     // 3
+                let expr_exit = self.add_node(expr.id, &[cond]); // 4
                 self.loop_scopes.push(LoopScope {
                     loop_id: expr.id,
                     continue_index: loopback,
@@ -317,8 +317,8 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
                 // Note that `break` and `loop` statements
                 // may cause additional edges.
 
-                let loopback = self.add_dummy_node([pred]);              // 1
-                let expr_exit = self.add_node(expr.id, []);              // 2
+                let loopback = self.add_dummy_node(&[pred]);              // 1
+                let expr_exit = self.add_node(expr.id, &[]);              // 2
                 self.loop_scopes.push(LoopScope {
                     loop_id: expr.id,
                     continue_index: loopback,
@@ -358,10 +358,10 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
                 //
                 let discr_exit = self.expr(&**discr, pred);              // 1
 
-                let expr_exit = self.add_node(expr.id, []);
+                let expr_exit = self.add_node(expr.id, &[]);
                 let mut cond_exit = discr_exit;
                 for arm in arms.iter() {
-                    cond_exit = self.add_dummy_node([cond_exit]);        // 2
+                    cond_exit = self.add_dummy_node(&[cond_exit]);        // 2
                     let pats_exit = self.pats_any(arm.pats.as_slice(),
                                                   cond_exit);            // 3
                     let guard_exit = self.opt_expr(&arm.guard,
@@ -389,30 +389,30 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
                 //
                 let l_exit = self.expr(&**l, pred);                      // 1
                 let r_exit = self.expr(&**r, l_exit);                    // 2
-                self.add_node(expr.id, [l_exit, r_exit])                 // 3,4
+                self.add_node(expr.id, &[l_exit, r_exit])                 // 3,4
             }
 
             ast::ExprRet(ref v) => {
                 let v_exit = self.opt_expr(v, pred);
-                let b = self.add_node(expr.id, [v_exit]);
+                let b = self.add_node(expr.id, &[v_exit]);
                 self.add_returning_edge(expr, b);
-                self.add_node(ast::DUMMY_NODE_ID, [])
+                self.add_node(ast::DUMMY_NODE_ID, &[])
             }
 
             ast::ExprBreak(label) => {
                 let loop_scope = self.find_scope(expr, label);
-                let b = self.add_node(expr.id, [pred]);
+                let b = self.add_node(expr.id, &[pred]);
                 self.add_exiting_edge(expr, b,
                                       loop_scope, loop_scope.break_index);
-                self.add_node(ast::DUMMY_NODE_ID, [])
+                self.add_node(ast::DUMMY_NODE_ID, &[])
             }
 
             ast::ExprAgain(label) => {
                 let loop_scope = self.find_scope(expr, label);
-                let a = self.add_node(expr.id, [pred]);
+                let a = self.add_node(expr.id, &[pred]);
                 self.add_exiting_edge(expr, a,
                                       loop_scope, loop_scope.continue_index);
-                self.add_node(ast::DUMMY_NODE_ID, [])
+                self.add_node(ast::DUMMY_NODE_ID, &[])
             }
 
             ast::ExprVec(ref elems) => {
@@ -492,7 +492,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
                     let &(_, ref expr, _) = a;
                     &**expr
                 }), post_inputs);
-                self.add_node(expr.id, [post_outputs])
+                self.add_node(expr.id, &[post_outputs])
             }
 
             ast::ExprMac(..) |
@@ -520,7 +520,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
         let func_or_rcvr_exit = self.expr(func_or_rcvr, pred);
         let ret = self.straightline(call_expr, func_or_rcvr_exit, args);
         if return_ty == ty::FnDiverging {
-            self.add_node(ast::DUMMY_NODE_ID, [])
+            self.add_node(ast::DUMMY_NODE_ID, &[])
         } else {
             ret
         }
@@ -547,7 +547,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
         //! Handles case of an expression that evaluates `subexprs` in order
 
         let subexprs_exit = self.exprs(subexprs, pred);
-        self.add_node(expr.id, [subexprs_exit])
+        self.add_node(expr.id, &[subexprs_exit])
     }
 
     fn add_dummy_node(&mut self, preds: &[CFGIndex]) -> CFGIndex {
diff --git a/src/librustc/middle/cfg/graphviz.rs b/src/librustc/middle/cfg/graphviz.rs
index fcd9a166c6ab1..1feca05e4499d 100644
--- a/src/librustc/middle/cfg/graphviz.rs
+++ b/src/librustc/middle/cfg/graphviz.rs
@@ -40,7 +40,7 @@ fn replace_newline_with_backslash_l(s: String) -> String {
         let mut last_two: Vec<_> =
             s.as_slice().chars().rev().take(2).collect();
         last_two.reverse();
-        if last_two.as_slice() != ['\\', 'l'] {
+        if last_two.as_slice() != &['\\', 'l'] {
             s.push_str("\\l");
         }
         s
diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs
index fe38669ea6c29..2006920a2a051 100644
--- a/src/librustc/middle/check_match.rs
+++ b/src/librustc/middle/check_match.rs
@@ -935,7 +935,7 @@ fn check_fn(cx: &mut MatchCheckCtxt,
 
 fn is_refutable<A>(cx: &MatchCheckCtxt, pat: &Pat, refutable: |&Pat| -> A) -> Option<A> {
     let pats = Matrix(vec!(vec!(pat)));
-    match is_useful(cx, &pats, [DUMMY_WILD_PAT], ConstructWitness) {
+    match is_useful(cx, &pats, &[DUMMY_WILD_PAT], ConstructWitness) {
         UsefulWithWitness(pats) => {
             assert_eq!(pats.len(), 1);
             Some(refutable(&*pats[0]))
diff --git a/src/librustc/middle/graph.rs b/src/librustc/middle/graph.rs
index 18ecc9dd05331..d2a7ec1e186e1 100644
--- a/src/librustc/middle/graph.rs
+++ b/src/librustc/middle/graph.rs
@@ -419,31 +419,31 @@ mod test {
     fn each_adjacent_from_a() {
         let graph = create_graph();
         test_adjacent_edges(&graph, NodeIndex(0), "A",
-                            [],
-                            [("AB", "B")]);
+                            &[],
+                            &[("AB", "B")]);
     }
 
     #[test]
     fn each_adjacent_from_b() {
         let graph = create_graph();
         test_adjacent_edges(&graph, NodeIndex(1), "B",
-                            [("FB", "F"), ("AB", "A"),],
-                            [("BD", "D"), ("BC", "C"),]);
+                            &[("FB", "F"), ("AB", "A"),],
+                            &[("BD", "D"), ("BC", "C"),]);
     }
 
     #[test]
     fn each_adjacent_from_c() {
         let graph = create_graph();
         test_adjacent_edges(&graph, NodeIndex(2), "C",
-                            [("EC", "E"), ("BC", "B")],
-                            []);
+                            &[("EC", "E"), ("BC", "B")],
+                            &[]);
     }
 
     #[test]
     fn each_adjacent_from_d() {
         let graph = create_graph();
         test_adjacent_edges(&graph, NodeIndex(3), "D",
-                            [("BD", "B")],
-                            [("DE", "E")]);
+                            &[("BD", "B")],
+                            &[("DE", "E")]);
     }
 }
diff --git a/src/librustc/middle/traits/util.rs b/src/librustc/middle/traits/util.rs
index 9ee2c3aa14907..b18c75f514ea3 100644
--- a/src/librustc/middle/traits/util.rs
+++ b/src/librustc/middle/traits/util.rs
@@ -57,7 +57,7 @@ pub fn supertraits<'cx, 'tcx>(tcx: &'cx ty::ctxt<'tcx>,
      * `supertraits(Baz)` yields `[Baz, Bar, Foo, Foo]` in some order.
      */
 
-    transitive_bounds(tcx, [trait_ref])
+    transitive_bounds(tcx, &[trait_ref])
 }
 
 pub fn transitive_bounds<'cx, 'tcx>(tcx: &'cx ty::ctxt<'tcx>,
diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs
index 70aef4504f031..63faa0eaf3ff5 100644
--- a/src/librustc/middle/trans/_match.rs
+++ b/src/librustc/middle/trans/_match.rs
@@ -643,8 +643,8 @@ fn bind_subslice_pat(bcx: Block,
                                 ty::mt {ty: vt.unit_ty, mutbl: ast::MutImmutable});
     let scratch = rvalue_scratch_datum(bcx, slice_ty, "");
     Store(bcx, slice_begin,
-          GEPi(bcx, scratch.val, [0u, abi::slice_elt_base]));
-    Store(bcx, slice_len, GEPi(bcx, scratch.val, [0u, abi::slice_elt_len]));
+          GEPi(bcx, scratch.val, &[0u, abi::slice_elt_base]));
+    Store(bcx, slice_len, GEPi(bcx, scratch.val, &[0u, abi::slice_elt_len]));
     scratch.val
 }
 
@@ -658,9 +658,9 @@ fn extract_vec_elems<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     let vec_datum = match_datum(val, left_ty);
     let (base, len) = vec_datum.get_vec_base_and_len(bcx);
     let mut elems = vec![];
-    elems.extend(range(0, before).map(|i| GEPi(bcx, base, [i])));
+    elems.extend(range(0, before).map(|i| GEPi(bcx, base, &[i])));
     elems.extend(range(0, after).rev().map(|i| {
-        InBoundsGEP(bcx, base, [
+        InBoundsGEP(bcx, base, &[
             Sub(bcx, len, C_uint(bcx.ccx(), i + 1))
         ])
     }));
@@ -796,7 +796,7 @@ fn compare_values<'blk, 'tcx>(cx: Block<'blk, 'tcx>,
                            format!("comparison of `{}`",
                                    cx.ty_to_string(rhs_t)).as_slice(),
                            StrEqFnLangItem);
-        callee::trans_lang_call(cx, did, [lhs, rhs], None)
+        callee::trans_lang_call(cx, did, &[lhs, rhs], None)
     }
 
     let _icx = push_ctxt("compare_values");
@@ -1390,7 +1390,7 @@ fn trans_match_inner<'blk, 'tcx>(scope_cx: Block<'blk, 'tcx>,
         && arm.pats.last().unwrap().node == ast::PatWild(ast::PatWildSingle)
     });
 
-    compile_submatch(bcx, matches.as_slice(), [discr_datum.val], &chk, has_default);
+    compile_submatch(bcx, matches.as_slice(), &[discr_datum.val], &chk, has_default);
 
     let mut arm_cxs = Vec::new();
     for arm_data in arm_datas.iter() {
diff --git a/src/librustc/middle/trans/adt.rs b/src/librustc/middle/trans/adt.rs
index d3658e89a2a53..d941d732febf4 100644
--- a/src/librustc/middle/trans/adt.rs
+++ b/src/librustc/middle/trans/adt.rs
@@ -642,7 +642,7 @@ pub fn trans_get_discr(bcx: Block, r: &Repr, scrutinee: ValueRef, cast_to: Optio
             signed = ity.is_signed();
         }
         General(ity, ref cases, _) => {
-            let ptr = GEPi(bcx, scrutinee, [0, 0]);
+            let ptr = GEPi(bcx, scrutinee, &[0, 0]);
             val = load_discr(bcx, ity, ptr, 0, (cases.len() - 1) as Disr);
             signed = ity.is_signed();
         }
@@ -670,8 +670,8 @@ pub fn trans_get_discr(bcx: Block, r: &Repr, scrutinee: ValueRef, cast_to: Optio
 fn struct_wrapped_nullable_bitdiscr(bcx: Block, nndiscr: Disr, ptrfield: PointerField,
                                     scrutinee: ValueRef) -> ValueRef {
     let llptrptr = match ptrfield {
-        ThinPointer(field) => GEPi(bcx, scrutinee, [0, field]),
-        FatPointer(field, pair) => GEPi(bcx, scrutinee, [0, field, pair])
+        ThinPointer(field) => GEPi(bcx, scrutinee, &[0, field]),
+        FatPointer(field, pair) => GEPi(bcx, scrutinee, &[0, field, pair])
     };
     let llptr = Load(bcx, llptrptr);
     let cmp = if nndiscr == 0 { IntEQ } else { IntNE };
@@ -746,13 +746,13 @@ pub fn trans_set_discr(bcx: Block, r: &Repr, val: ValueRef, discr: Disr) {
                 Store(bcx, C_u8(bcx.ccx(), 1), ptr);
             }
             Store(bcx, C_integral(ll_inttype(bcx.ccx(), ity), discr as u64, true),
-                  GEPi(bcx, val, [0, 0]))
+                  GEPi(bcx, val, &[0, 0]))
         }
         Univariant(ref st, dtor) => {
             assert_eq!(discr, 0);
             if dtor {
                 Store(bcx, C_u8(bcx.ccx(), 1),
-                    GEPi(bcx, val, [0, st.fields.len() - 1]));
+                    GEPi(bcx, val, &[0, st.fields.len() - 1]));
             }
         }
         RawNullablePointer { nndiscr, nnty, ..} => {
@@ -765,10 +765,10 @@ pub fn trans_set_discr(bcx: Block, r: &Repr, val: ValueRef, discr: Disr) {
             if discr != nndiscr {
                 let (llptrptr, llptrty) = match ptrfield {
                     ThinPointer(field) =>
-                        (GEPi(bcx, val, [0, field]),
+                        (GEPi(bcx, val, &[0, field]),
                          type_of::type_of(bcx.ccx(), nonnull.fields[field])),
                     FatPointer(field, pair) => {
-                        let v = GEPi(bcx, val, [0, field, pair]);
+                        let v = GEPi(bcx, val, &[0, field, pair]);
                         (v, val_ty(v).element_type())
                     }
                 };
@@ -860,7 +860,7 @@ pub fn struct_field_ptr(bcx: Block, st: &Struct, val: ValueRef,
         val
     };
 
-    GEPi(bcx, val, [0, ix])
+    GEPi(bcx, val, &[0, ix])
 }
 
 pub fn fold_variants<'blk, 'tcx>(
@@ -909,7 +909,7 @@ pub fn trans_drop_flag_ptr<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, r: &Repr, val
     let ptr_ty = ty::mk_imm_ptr(bcx.tcx(), ty::mk_bool());
     match *r {
         Univariant(ref st, true) => {
-            let flag_ptr = GEPi(bcx, val, [0, st.fields.len() - 1]);
+            let flag_ptr = GEPi(bcx, val, &[0, st.fields.len() - 1]);
             datum::immediate_rvalue_bcx(bcx, flag_ptr, ptr_ty).to_expr_datumblock()
         }
         General(_, _, true) => {
@@ -968,7 +968,7 @@ pub fn trans_const(ccx: &CrateContext, r: &Repr, discr: Disr,
             let mut f = vec![lldiscr];
             f.push_all(vals);
             let mut contents = build_const_struct(ccx, case, f.as_slice());
-            contents.push_all([padding(ccx, max_sz - case.size)]);
+            contents.push_all(&[padding(ccx, max_sz - case.size)]);
             C_struct(ccx, contents.as_slice(), false)
         }
         Univariant(ref st, _dro) => {
@@ -1086,8 +1086,8 @@ pub fn const_get_discrim(ccx: &CrateContext, r: &Repr, val: ValueRef)
         }
         General(ity, _, _) => {
             match ity {
-                attr::SignedInt(..) => const_to_int(const_get_elt(ccx, val, [0])) as Disr,
-                attr::UnsignedInt(..) => const_to_uint(const_get_elt(ccx, val, [0])) as Disr
+                attr::SignedInt(..) => const_to_int(const_get_elt(ccx, val, &[0])) as Disr,
+                attr::UnsignedInt(..) => const_to_uint(const_get_elt(ccx, val, &[0])) as Disr
             }
         }
         Univariant(..) => 0,
@@ -1145,8 +1145,8 @@ fn const_struct_field(ccx: &CrateContext, val: ValueRef, ix: uint, sub_idx: Opti
     loop {
         loop {
             field = match sub_idx {
-                Some(si) => const_get_elt(ccx, val, [real_ix, si as u32]),
-                None => const_get_elt(ccx, val, [real_ix])
+                Some(si) => const_get_elt(ccx, val, &[real_ix, si as u32]),
+                None => const_get_elt(ccx, val, &[real_ix])
             };
             if !is_undef(field) {
                 break;
diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs
index b80425e7ac855..ae72349a71361 100644
--- a/src/librustc/middle/trans/base.rs
+++ b/src/librustc/middle/trans/base.rs
@@ -349,7 +349,7 @@ pub fn at_box_body(bcx: Block, body_t: ty::t, boxptr: ValueRef) -> ValueRef {
     let ccx = bcx.ccx();
     let ty = Type::at_box(ccx, type_of(ccx, body_t));
     let boxptr = PointerCast(bcx, boxptr, ty.ptr_to());
-    GEPi(bcx, boxptr, [0u, abi::box_field_body])
+    GEPi(bcx, boxptr, &[0u, abi::box_field_body])
 }
 
 fn require_alloc_fn(bcx: Block, info_ty: ty::t, it: LangItem) -> ast::DefId {
@@ -377,7 +377,7 @@ pub fn malloc_raw_dyn<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     // Allocate space:
     let r = callee::trans_lang_call(bcx,
         require_alloc_fn(bcx, info_ty, ExchangeMallocFnLangItem),
-        [size, align],
+        &[size, align],
         None);
 
     Result::new(r.bcx, PointerCast(r.bcx, r.val, llty_ptr))
@@ -397,7 +397,7 @@ pub fn malloc_raw_dyn_proc<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, t: ty::t) -> Resu
 
     // Allocate space and store the destructor pointer:
     let Result {bcx, val: llbox} = malloc_raw_dyn(bcx, ptr_llty, t, size, llalign);
-    let dtor_ptr = GEPi(bcx, llbox, [0u, abi::box_field_drop_glue]);
+    let dtor_ptr = GEPi(bcx, llbox, &[0u, abi::box_field_drop_glue]);
     let drop_glue_field_ty = type_of(ccx, ty::mk_nil_ptr(bcx.tcx()));
     let drop_glue = PointerCast(bcx, glue::get_drop_glue(ccx, ty::mk_uniq(bcx.tcx(), t)),
                                 drop_glue_field_ty);
@@ -529,7 +529,7 @@ pub fn get_res_dtor(ccx: &CrateContext,
         let class_ty = ty::lookup_item_type(tcx, parent_id).ty.subst(tcx, substs);
         let llty = type_of_dtor(ccx, class_ty);
         let dtor_ty = ty::mk_ctor_fn(ccx.tcx(), ast::DUMMY_NODE_ID,
-                                     [glue::get_drop_glue_type(ccx, t)], ty::mk_nil());
+                                     &[glue::get_drop_glue_type(ccx, t)], ty::mk_nil());
         get_extern_fn(ccx,
                       &mut *ccx.externs().borrow_mut(),
                       name.as_slice(),
@@ -706,8 +706,8 @@ pub fn iter_structural_ty<'a, 'blk, 'tcx>(cx: Block<'blk, 'tcx>,
     let (data_ptr, info) = if ty::type_is_sized(cx.tcx(), t) {
         (av, None)
     } else {
-        let data = GEPi(cx, av, [0, abi::slice_elt_base]);
-        let info = GEPi(cx, av, [0, abi::slice_elt_len]);
+        let data = GEPi(cx, av, &[0, abi::slice_elt_base]);
+        let info = GEPi(cx, av, &[0, abi::slice_elt_len]);
         (Load(cx, data), Some(Load(cx, info)))
     };
 
@@ -725,8 +725,8 @@ pub fn iter_structural_ty<'a, 'blk, 'tcx>(cx: Block<'blk, 'tcx>,
                   } else {
                       let boxed_ty = ty::mk_open(cx.tcx(), field_ty);
                       let scratch = datum::rvalue_scratch_datum(cx, boxed_ty, "__fat_ptr_iter");
-                      Store(cx, llfld_a, GEPi(cx, scratch.val, [0, abi::slice_elt_base]));
-                      Store(cx, info.unwrap(), GEPi(cx, scratch.val, [0, abi::slice_elt_len]));
+                      Store(cx, llfld_a, GEPi(cx, scratch.val, &[0, abi::slice_elt_base]));
+                      Store(cx, info.unwrap(), GEPi(cx, scratch.val, &[0, abi::slice_elt_len]));
                       scratch.val
                   };
                   cx = f(cx, val, field_ty);
@@ -1122,7 +1122,7 @@ pub fn call_lifetime_start(cx: Block, ptr: ValueRef) {
     let llsize = C_u64(ccx, machine::llsize_of_alloc(ccx, val_ty(ptr).element_type()));
     let ptr = PointerCast(cx, ptr, Type::i8p(ccx));
     let lifetime_start = ccx.get_intrinsic(&"llvm.lifetime.start");
-    Call(cx, lifetime_start, [llsize, ptr], None);
+    Call(cx, lifetime_start, &[llsize, ptr], None);
 }
 
 pub fn call_lifetime_end(cx: Block, ptr: ValueRef) {
@@ -1136,7 +1136,7 @@ pub fn call_lifetime_end(cx: Block, ptr: ValueRef) {
     let llsize = C_u64(ccx, machine::llsize_of_alloc(ccx, val_ty(ptr).element_type()));
     let ptr = PointerCast(cx, ptr, Type::i8p(ccx));
     let lifetime_end = ccx.get_intrinsic(&"llvm.lifetime.end");
-    Call(cx, lifetime_end, [llsize, ptr], None);
+    Call(cx, lifetime_end, &[llsize, ptr], None);
 }
 
 pub fn call_memcpy(cx: Block, dst: ValueRef, src: ValueRef, n_bytes: ValueRef, align: u32) {
@@ -1153,7 +1153,7 @@ pub fn call_memcpy(cx: Block, dst: ValueRef, src: ValueRef, n_bytes: ValueRef, a
     let size = IntCast(cx, n_bytes, ccx.int_type());
     let align = C_i32(ccx, align as i32);
     let volatile = C_bool(ccx, false);
-    Call(cx, memcpy, [dst_ptr, src_ptr, size, align, volatile], None);
+    Call(cx, memcpy, &[dst_ptr, src_ptr, size, align, volatile], None);
 }
 
 pub fn memcpy_ty(bcx: Block, dst: ValueRef, src: ValueRef, t: ty::t) {
@@ -1199,7 +1199,7 @@ fn memzero(b: &Builder, llptr: ValueRef, ty: ty::t) {
     let size = machine::llsize_of(ccx, llty);
     let align = C_i32(ccx, type_of::align_of(ccx, ty) as i32);
     let volatile = C_bool(ccx, false);
-    b.call(llintrinsicfn, [llptr, llzeroval, size, align, volatile], None);
+    b.call(llintrinsicfn, &[llptr, llzeroval, size, align, volatile], None);
 }
 
 pub fn alloc_ty(bcx: Block, t: ty::t, name: &str) -> ValueRef {
@@ -1575,7 +1575,7 @@ fn create_datums_for_fn_args_under_call_abi(
                             let llarg =
                                 get_param(bcx.fcx.llfn,
                                           bcx.fcx.arg_pos(i + j) as c_uint);
-                            let lldest = GEPi(bcx, llval, [0, j]);
+                            let lldest = GEPi(bcx, llval, &[0, j]);
                             let datum = datum::Datum::new(
                                 llarg,
                                 tupled_arg_ty,
@@ -1674,7 +1674,7 @@ fn copy_unboxed_closure_args_to_allocas<'blk, 'tcx>(
         let tuple_element_datum =
             tuple_datum.get_element(bcx,
                                     tuple_element_type,
-                                    |llval| GEPi(bcx, llval, [0, j]));
+                                    |llval| GEPi(bcx, llval, &[0, j]));
         let tuple_element_datum = tuple_element_datum.to_expr_datum();
         let tuple_element_datum =
             unpack_datum!(bcx,
@@ -2577,7 +2577,7 @@ pub fn create_entry_wrapper(ccx: &CrateContext,
     fn create_entry_fn(ccx: &CrateContext,
                        rust_main: ValueRef,
                        use_start_lang_item: bool) {
-        let llfty = Type::func([ccx.int_type(), Type::i8p(ccx).ptr_to()],
+        let llfty = Type::func(&[ccx.int_type(), Type::i8p(ccx).ptr_to()],
                                &ccx.int_type());
 
         let llfn = decl_cdecl_fn(ccx, "main", llfty, ty::mk_nil());
@@ -2934,7 +2934,7 @@ pub fn write_metadata(cx: &SharedCrateContext, krate: &ast::Crate) -> Vec<u8> {
         None => cx.sess().fatal("failed to compress metadata"),
     }.as_slice());
     let llmeta = C_bytes_in_context(cx.metadata_llcx(), compressed.as_slice());
-    let llconst = C_struct_in_context(cx.metadata_llcx(), [llmeta], false);
+    let llconst = C_struct_in_context(cx.metadata_llcx(), &[llmeta], false);
     let name = format!("rust_metadata_{}_{}",
                        cx.link_meta().crate_name,
                        cx.link_meta().crate_hash);
diff --git a/src/librustc/middle/trans/builder.rs b/src/librustc/middle/trans/builder.rs
index 81428937e4b1f..ae6dc388feda0 100644
--- a/src/librustc/middle/trans/builder.rs
+++ b/src/librustc/middle/trans/builder.rs
@@ -776,11 +776,11 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             self.count_insn("inlineasm");
             let asm = comment_text.as_slice().with_c_str(|c| {
                 unsafe {
-                    llvm::LLVMConstInlineAsm(Type::func([], &Type::void(self.ccx)).to_ref(),
+                    llvm::LLVMConstInlineAsm(Type::func(&[], &Type::void(self.ccx)).to_ref(),
                                              c, noname(), False, False)
                 }
             });
-            self.call(asm, [], None);
+            self.call(asm, &[], None);
         }
     }
 
@@ -930,7 +930,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 llvm::LLVMGetNamedFunction(m, buf)
             });
             assert!((t as int != 0));
-            let args: &[ValueRef] = [];
+            let args: &[ValueRef] = &[];
             self.count_insn("trap");
             llvm::LLVMBuildCall(
                 self.llbuilder, t, args.as_ptr(), args.len() as c_uint, noname());
diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs
index 6addd9144409c..000a1dd1eeab0 100644
--- a/src/librustc/middle/trans/callee.rs
+++ b/src/librustc/middle/trans/callee.rs
@@ -718,9 +718,9 @@ pub fn trans_call_inner<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             // Closures are represented as (llfn, llclosure) pair:
             // load the requisite values out.
             let pair = d.to_llref();
-            let llfn = GEPi(bcx, pair, [0u, abi::fn_field_code]);
+            let llfn = GEPi(bcx, pair, &[0u, abi::fn_field_code]);
             let llfn = Load(bcx, llfn);
-            let llenv = GEPi(bcx, pair, [0u, abi::fn_field_box]);
+            let llenv = GEPi(bcx, pair, &[0u, abi::fn_field_box]);
             let llenv = Load(bcx, llenv);
             (llfn, Some(llenv), None)
         }
diff --git a/src/librustc/middle/trans/cleanup.rs b/src/librustc/middle/trans/cleanup.rs
index 5a4979d9dcd5e..fbdefe6ab948a 100644
--- a/src/librustc/middle/trans/cleanup.rs
+++ b/src/librustc/middle/trans/cleanup.rs
@@ -785,7 +785,7 @@ impl<'blk, 'tcx> CleanupHelperMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx
         // this represents but it's determined by the personality function and
         // this is what the EH proposal example uses.
         let llretty = Type::struct_(self.ccx,
-                                    [Type::i8p(self.ccx), Type::i32(self.ccx)],
+                                    &[Type::i8p(self.ccx), Type::i32(self.ccx)],
                                     false);
 
         // The exception handling personality function.
diff --git a/src/librustc/middle/trans/closure.rs b/src/librustc/middle/trans/closure.rs
index decd238627c20..d6ac573623c4e 100644
--- a/src/librustc/middle/trans/closure.rs
+++ b/src/librustc/middle/trans/closure.rs
@@ -206,7 +206,7 @@ pub fn store_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                                      bv.to_string(ccx)).as_slice());
         }
 
-        let bound_data = GEPi(bcx, llbox, [0u, abi::box_field_body, i]);
+        let bound_data = GEPi(bcx, llbox, &[0u, abi::box_field_body, i]);
 
         match bv.action {
             ast::CaptureByValue => {
@@ -274,7 +274,7 @@ fn load_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     // Populate the upvars from the environment
     let mut i = 0u;
     for freevar in freevars.iter() {
-        let mut upvarptr = GEPi(bcx, llcdata, [0u, i]);
+        let mut upvarptr = GEPi(bcx, llcdata, &[0u, i]);
         match store {
             ty::RegionTraitStore(..) => { upvarptr = Load(bcx, upvarptr); }
             ty::UniqTraitStore => {}
@@ -329,7 +329,7 @@ fn load_unboxed_closure_environment<'blk, 'tcx>(
     };
 
     for (i, freevar) in freevars.iter().enumerate() {
-        let mut upvar_ptr = GEPi(bcx, llenv, [0, i]);
+        let mut upvar_ptr = GEPi(bcx, llenv, &[0, i]);
         if freevar_mode == ast::CaptureByRef {
             upvar_ptr = Load(bcx, upvar_ptr);
         }
@@ -347,9 +347,9 @@ fn load_unboxed_closure_environment<'blk, 'tcx>(
 }
 
 fn fill_fn_pair(bcx: Block, pair: ValueRef, llfn: ValueRef, llenvptr: ValueRef) {
-    Store(bcx, llfn, GEPi(bcx, pair, [0u, abi::fn_field_code]));
+    Store(bcx, llfn, GEPi(bcx, pair, &[0u, abi::fn_field_code]));
     let llenvptr = PointerCast(bcx, llenvptr, Type::i8p(bcx.ccx()));
-    Store(bcx, llenvptr, GEPi(bcx, pair, [0u, abi::fn_field_box]));
+    Store(bcx, llenvptr, GEPi(bcx, pair, &[0u, abi::fn_field_box]));
 }
 
 pub fn trans_expr_fn<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
@@ -407,7 +407,7 @@ pub fn trans_expr_fn<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                   llfn,
                   bcx.fcx.param_substs,
                   id,
-                  [],
+                  &[],
                   ty::ty_fn_ret(fty),
                   ty::ty_fn_abi(fty),
                   true,
@@ -499,7 +499,7 @@ pub fn trans_unboxed_closure<'blk, 'tcx>(
                   llfn,
                   bcx.fcx.param_substs,
                   id,
-                  [],
+                  &[],
                   ty::ty_fn_ret(function_type),
                   ty::ty_fn_abi(function_type),
                   true,
diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs
index 8b5e82ecf9012..07a097bc0b577 100644
--- a/src/librustc/middle/trans/common.rs
+++ b/src/librustc/middle/trans/common.rs
@@ -582,7 +582,7 @@ pub fn C_floating(s: &str, t: Type) -> ValueRef {
 }
 
 pub fn C_nil(ccx: &CrateContext) -> ValueRef {
-    C_struct(ccx, [], false)
+    C_struct(ccx, &[], false)
 }
 
 pub fn C_bool(ccx: &CrateContext, val: bool) -> ValueRef {
@@ -677,7 +677,7 @@ pub fn C_str_slice(cx: &CrateContext, s: InternedString) -> ValueRef {
         let len = s.get().len();
         let cs = llvm::LLVMConstPointerCast(C_cstr(cx, s, false),
                                             Type::i8p(cx).to_ref());
-        C_named_struct(cx.tn().find_type("str_slice").unwrap(), [cs, C_uint(cx, len)])
+        C_named_struct(cx.tn().find_type("str_slice").unwrap(), &[cs, C_uint(cx, len)])
     }
 }
 
@@ -695,7 +695,7 @@ pub fn C_binary_slice(cx: &CrateContext, data: &[u8]) -> ValueRef {
         llvm::SetLinkage(g, llvm::InternalLinkage);
 
         let cs = llvm::LLVMConstPointerCast(g, Type::i8p(cx).to_ref());
-        C_struct(cx, [cs, C_uint(cx, len)], false)
+        C_struct(cx, &[cs, C_uint(cx, len)], false)
     }
 }
 
diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs
index 6ba6ff6fb2113..6bb477ec5f85c 100644
--- a/src/librustc/middle/trans/consts.rs
+++ b/src/librustc/middle/trans/consts.rs
@@ -205,7 +205,7 @@ pub fn const_expr(cx: &CrateContext, e: &ast::Expr) -> (ValueRef, ty::t) {
                                                                    def,
                                                                    llconst,
                                                                    true);
-                    llconst = C_struct(cx, [wrapper, C_null(Type::i8p(cx))], false)
+                    llconst = C_struct(cx, &[wrapper, C_null(Type::i8p(cx))], false)
                 }
                 ty::AdjustAddEnv(store) => {
                     cx.sess()
@@ -265,7 +265,7 @@ pub fn const_expr(cx: &CrateContext, e: &ast::Expr) -> (ValueRef, ty::t) {
                                             let llptr = const_ptrcast(cx, llconst, llunitty);
                                             assert_eq!(abi::slice_elt_base, 0);
                                             assert_eq!(abi::slice_elt_len, 1);
-                                            llconst = C_struct(cx, [
+                                            llconst = C_struct(cx, &[
                                                 llptr,
                                                 C_uint(cx, len)
                                             ], false);
@@ -445,8 +445,8 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef {
                   ty::ty_vec(_, Some(u)) => (bv, C_uint(cx, u)),
                   ty::ty_open(ty) => match ty::get(ty).sty {
                       ty::ty_vec(_, None) | ty::ty_str => {
-                          let e1 = const_get_elt(cx, bv, [0]);
-                          (const_deref_ptr(cx, e1), const_get_elt(cx, bv, [1]))
+                          let e1 = const_get_elt(cx, bv, &[0]);
+                          (const_deref_ptr(cx, e1), const_get_elt(cx, bv, &[1]))
                       },
                       _ => cx.sess().span_bug(base.span,
                                               format!("index-expr base must be a vector \
@@ -485,7 +485,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef {
                   cx.sess().span_err(e.span,
                                      "const index-expr is out of bounds");
               }
-              const_get_elt(cx, arr, [iv as c_uint])
+              const_get_elt(cx, arr, &[iv as c_uint])
           }
           ast::ExprCast(ref base, _) => {
             let ety = ty::expr_ty(cx.tcx(), e);
@@ -647,7 +647,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef {
                     let vinfo = ty::enum_variant_with_id(cx.tcx(),
                                                          enum_did,
                                                          variant_did);
-                    adt::trans_const(cx, &*repr, vinfo.disr_val, [])
+                    adt::trans_const(cx, &*repr, vinfo.disr_val, &[])
                 }
                 Some(def::DefStruct(_)) => {
                     let ety = ty::expr_ty(cx.tcx(), e);
diff --git a/src/librustc/middle/trans/context.rs b/src/librustc/middle/trans/context.rs
index 7d2460093feee..df822a0508412 100644
--- a/src/librustc/middle/trans/context.rs
+++ b/src/librustc/middle/trans/context.rs
@@ -435,7 +435,7 @@ impl LocalCrateContext {
                 let ccx = local_ccx.dummy_ccx(shared);
 
                 let mut str_slice_ty = Type::named_struct(&ccx, "str_slice");
-                str_slice_ty.set_struct_body([Type::i8p(&ccx), ccx.int_type()], false);
+                str_slice_ty.set_struct_body(&[Type::i8p(&ccx), ccx.int_type()], false);
                 ccx.tn().associate_type("str_slice", &str_slice_ty);
 
                 ccx.tn().associate_type("tydesc", &Type::tydesc(&ccx, str_slice_ty));
@@ -719,7 +719,7 @@ fn declare_intrinsic(ccx: &CrateContext, key: & &'static str) -> Option<ValueRef
     macro_rules! ifn (
         ($name:expr fn() -> $ret:expr) => (
             if *key == $name {
-                let f = base::decl_cdecl_fn(ccx, $name, Type::func([], &$ret), ty::mk_nil());
+                let f = base::decl_cdecl_fn(ccx, $name, Type::func(&[], &$ret), ty::mk_nil());
                 ccx.intrinsics().borrow_mut().insert($name, f.clone());
                 return Some(f);
             }
@@ -727,14 +727,14 @@ fn declare_intrinsic(ccx: &CrateContext, key: & &'static str) -> Option<ValueRef
         ($name:expr fn($($arg:expr),*) -> $ret:expr) => (
             if *key == $name {
                 let f = base::decl_cdecl_fn(ccx, $name,
-                                  Type::func([$($arg),*], &$ret), ty::mk_nil());
+                                  Type::func(&[$($arg),*], &$ret), ty::mk_nil());
                 ccx.intrinsics().borrow_mut().insert($name, f.clone());
                 return Some(f);
             }
         )
     )
     macro_rules! mk_struct (
-        ($($field_ty:expr),*) => (Type::struct_(ccx, [$($field_ty),*], false))
+        ($($field_ty:expr),*) => (Type::struct_(ccx, &[$($field_ty),*], false))
     )
 
     let i8p = Type::i8p(ccx);
@@ -863,7 +863,7 @@ fn declare_intrinsic(ccx: &CrateContext, key: & &'static str) -> Option<ValueRef
                 ifn!($name fn($($arg),*) -> $ret);
             } else if *key == $name {
                 let f = base::decl_cdecl_fn(ccx, stringify!($cname),
-                                      Type::func([$($arg),*], &$ret),
+                                      Type::func(&[$($arg),*], &$ret),
                                       ty::mk_nil());
                 ccx.intrinsics().borrow_mut().insert($name, f.clone());
                 return Some(f);
diff --git a/src/librustc/middle/trans/controlflow.rs b/src/librustc/middle/trans/controlflow.rs
index 911ae42e142d8..b6c8e40fdc88b 100644
--- a/src/librustc/middle/trans/controlflow.rs
+++ b/src/librustc/middle/trans/controlflow.rs
@@ -189,7 +189,7 @@ pub fn trans_if<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             let else_bcx_in = bcx.fcx.new_id_block("else-block", elexpr.id);
             let else_bcx_out = expr::trans_into(else_bcx_in, &*elexpr, dest);
             next_bcx = bcx.fcx.join_blocks(if_id,
-                                           [then_bcx_out, else_bcx_out]);
+                                           &[then_bcx_out, else_bcx_out]);
             CondBr(bcx, cond_val, then_bcx_in.llbb, else_bcx_in.llbb);
         }
 
@@ -324,7 +324,7 @@ pub fn trans_for<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                                              None,
                                              arg_cleanup_scope)
                                      },
-                                     callee::ArgVals([lliterator]),
+                                     callee::ArgVals(&[lliterator]),
                                      Some(expr::SaveIn(lloption)));
         bcx
     }));
diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs
index ea7f28796f03c..6b25469f7ccfd 100644
--- a/src/librustc/middle/trans/debuginfo.rs
+++ b/src/librustc/middle/trans/debuginfo.rs
@@ -984,7 +984,7 @@ pub fn create_match_binding_metadata(bcx: Block,
         },
         TrByMove => IndirectVariable {
             alloca: binding.llmatch,
-            address_operations: aops
+            address_operations: &aops
         },
         TrByRef => DirectVariable {
             alloca: binding.llmatch
@@ -1367,7 +1367,7 @@ pub fn create_function_debug_context(cx: &CrateContext,
                               param_substs: &param_substs,
                               error_reporting_span: Span) -> DIArray {
         if cx.sess().opts.debuginfo == LimitedDebugInfo {
-            return create_DIArray(DIB(cx), []);
+            return create_DIArray(DIB(cx), &[]);
         }
 
         let mut signature = Vec::with_capacity(fn_decl.inputs.len() + 1);
@@ -1409,7 +1409,7 @@ pub fn create_function_debug_context(cx: &CrateContext,
         let has_self_type = self_type.is_some();
 
         if !generics.is_type_parameterized() && !has_self_type {
-            return create_DIArray(DIB(cx), []);
+            return create_DIArray(DIB(cx), &[]);
         }
 
         name_to_append_suffix_to.push('<');
@@ -2644,7 +2644,7 @@ fn create_struct_stub(cx: &CrateContext,
                 // LLVMDIBuilderCreateStructType() wants an empty array. A null
                 // pointer will lead to hard to trace and debug LLVM assertions
                 // later on in llvm/lib/IR/Value.cpp.
-                let empty_array = create_DIArray(DIB(cx), []);
+                let empty_array = create_DIArray(DIB(cx), &[]);
 
                 llvm::LLVMDIBuilderCreateStructType(
                     DIB(cx),
@@ -2687,7 +2687,7 @@ fn fixed_vec_metadata(cx: &CrateContext,
             len as i64)
     };
 
-    let subscripts = create_DIArray(DIB(cx), [subrange]);
+    let subscripts = create_DIArray(DIB(cx), &[subrange]);
     let metadata = unsafe {
         llvm::LLVMDIBuilderCreateArrayType(
             DIB(cx),
@@ -2748,7 +2748,7 @@ fn vec_slice_metadata(cx: &CrateContext,
                                            slice_llvm_type,
                                            slice_type_name.as_slice(),
                                            unique_type_id,
-                                           member_descriptions,
+                                           &member_descriptions,
                                            UNKNOWN_SCOPE_METADATA,
                                            file_metadata,
                                            span);
@@ -2834,7 +2834,7 @@ fn trait_pointer_metadata(cx: &CrateContext,
                             trait_llvm_type,
                             trait_type_name.as_slice(),
                             unique_type_id,
-                            [],
+                            &[],
                             containing_scope,
                             UNKNOWN_FILE_METADATA,
                             codemap::DUMMY_SP)
diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs
index a0ba2996334b9..6d623b58b973d 100644
--- a/src/librustc/middle/trans/expr.rs
+++ b/src/librustc/middle/trans/expr.rs
@@ -166,11 +166,11 @@ pub fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
 }
 
 pub fn get_len(bcx: Block, fat_ptr: ValueRef) -> ValueRef {
-    GEPi(bcx, fat_ptr, [0u, abi::slice_elt_len])
+    GEPi(bcx, fat_ptr, &[0u, abi::slice_elt_len])
 }
 
 pub fn get_dataptr(bcx: Block, fat_ptr: ValueRef) -> ValueRef {
-    GEPi(bcx, fat_ptr, [0u, abi::slice_elt_base])
+    GEPi(bcx, fat_ptr, &[0u, abi::slice_elt_base])
 }
 
 fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
@@ -356,7 +356,7 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                                        val,
                                        type_of::type_of(bcx.ccx(), unsized_ty).ptr_to()),
             &ty::UnsizeLength(..) =>
-                |bcx, val| GEPi(bcx, val, [0u, 0u]),
+                |bcx, val| GEPi(bcx, val, &[0u, 0u]),
             &ty::UnsizeVtable(..) =>
                 |_bcx, val| PointerCast(bcx, val, Type::i8p(bcx.ccx()))
         };
@@ -814,7 +814,7 @@ fn trans_index<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             let expect = ccx.get_intrinsic(&("llvm.expect.i1"));
             let expected = Call(bcx,
                                 expect,
-                                [bounds_check, C_bool(ccx, false)],
+                                &[bounds_check, C_bool(ccx, false)],
                                 None);
             bcx = with_cond(bcx, expected, |bcx| {
                 controlflow::trans_fail_bounds_check(bcx,
@@ -822,7 +822,7 @@ fn trans_index<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                                                      ix_val,
                                                      len)
             });
-            let elt = InBoundsGEP(bcx, base, [ix_val]);
+            let elt = InBoundsGEP(bcx, base, &[ix_val]);
             let elt = PointerCast(bcx, elt, vt.llunit_ty.ptr_to());
             Datum::new(elt, vt.unit_ty, LvalueExpr)
         }
@@ -1737,8 +1737,8 @@ fn trans_lazy_binop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     }
 
     Br(past_rhs, join.llbb);
-    let phi = Phi(join, Type::i1(bcx.ccx()), [lhs, rhs],
-                  [past_lhs.llbb, past_rhs.llbb]);
+    let phi = Phi(join, Type::i1(bcx.ccx()), &[lhs, rhs],
+                  &[past_lhs.llbb, past_rhs.llbb]);
 
     return immediate_rvalue_bcx(join, phi, binop_ty).to_expr_datumblock();
 }
diff --git a/src/librustc/middle/trans/foreign.rs b/src/librustc/middle/trans/foreign.rs
index bed45a2869118..f4d597f9df3ba 100644
--- a/src/librustc/middle/trans/foreign.rs
+++ b/src/librustc/middle/trans/foreign.rs
@@ -610,7 +610,7 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: &CrateContext,
 
         let llfn = base::decl_internal_rust_fn(ccx, t, ps.as_slice());
         base::set_llvm_fn_attrs(ccx, attrs, llfn);
-        base::trans_fn(ccx, decl, body, llfn, param_substs, id, []);
+        base::trans_fn(ccx, decl, body, llfn, param_substs, id, &[]);
         llfn
     }
 
diff --git a/src/librustc/middle/trans/glue.rs b/src/librustc/middle/trans/glue.rs
index fb85e61986667..2bbe09205ab18 100644
--- a/src/librustc/middle/trans/glue.rs
+++ b/src/librustc/middle/trans/glue.rs
@@ -51,7 +51,7 @@ pub fn trans_exchange_free_dyn<'blk, 'tcx>(cx: Block<'blk, 'tcx>, v: ValueRef,
     let ccx = cx.ccx();
     callee::trans_lang_call(cx,
         langcall(cx, None, "", ExchangeFreeFnLangItem),
-        [PointerCast(cx, v, Type::i8p(ccx)), size, align],
+        &[PointerCast(cx, v, Type::i8p(ccx)), size, align],
         Some(expr::Ignore)).bcx
 }
 
@@ -124,7 +124,7 @@ pub fn drop_ty<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             None => debuginfo::clear_source_location(bcx.fcx)
         };
 
-        Call(bcx, glue, [ptr], None);
+        Call(bcx, glue, &[ptr], None);
     }
     bcx
 }
@@ -195,7 +195,7 @@ fn trans_struct_drop_flag<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
     let struct_data = if ty::type_is_sized(bcx.tcx(), t) {
         v0
     } else {
-        let llval = GEPi(bcx, v0, [0, abi::slice_elt_base]);
+        let llval = GEPi(bcx, v0, &[0, abi::slice_elt_base]);
         Load(bcx, llval)
     };
     let drop_flag = unpack_datum!(bcx, adt::trans_drop_flag_ptr(bcx, &*repr, struct_data));
@@ -236,8 +236,8 @@ fn trans_struct_drop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     let (struct_data, info) = if ty::type_is_sized(bcx.tcx(), t) {
         (v0, None)
     } else {
-        let data = GEPi(bcx, v0, [0, abi::slice_elt_base]);
-        let info = GEPi(bcx, v0, [0, abi::slice_elt_len]);
+        let data = GEPi(bcx, v0, &[0, abi::slice_elt_base]);
+        let info = GEPi(bcx, v0, &[0, abi::slice_elt_len]);
         (Load(bcx, data), Some(Load(bcx, info)))
     };
 
@@ -254,14 +254,14 @@ fn trans_struct_drop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             // The dtor expects a fat pointer, so make one, even if we have to fake it.
             let boxed_ty = ty::mk_open(bcx.tcx(), t);
             let scratch = datum::rvalue_scratch_datum(bcx, boxed_ty, "__fat_ptr_drop_self");
-            Store(bcx, value, GEPi(bcx, scratch.val, [0, abi::slice_elt_base]));
+            Store(bcx, value, GEPi(bcx, scratch.val, &[0, abi::slice_elt_base]));
             Store(bcx,
                   // If we just had a thin pointer, make a fat pointer by sticking
                   // null where we put the unsizing info. This works because t
                   // is a sized type, so we will only unpack the fat pointer, never
                   // use the fake info.
                   info.unwrap_or(C_null(Type::i8p(bcx.ccx()))),
-                  GEPi(bcx, scratch.val, [0, abi::slice_elt_len]));
+                  GEPi(bcx, scratch.val, &[0, abi::slice_elt_len]));
             PointerCast(variant_cx, scratch.val, params[0])
         } else {
             PointerCast(variant_cx, value, params[0])
@@ -279,8 +279,8 @@ fn trans_struct_drop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             } else {
                 let boxed_ty = ty::mk_open(bcx.tcx(), *ty);
                 let scratch = datum::rvalue_scratch_datum(bcx, boxed_ty, "__fat_ptr_drop_field");
-                Store(bcx, llfld_a, GEPi(bcx, scratch.val, [0, abi::slice_elt_base]));
-                Store(bcx, info.unwrap(), GEPi(bcx, scratch.val, [0, abi::slice_elt_len]));
+                Store(bcx, llfld_a, GEPi(bcx, scratch.val, &[0, abi::slice_elt_base]));
+                Store(bcx, info.unwrap(), GEPi(bcx, scratch.val, &[0, abi::slice_elt_len]));
                 scratch.val
             };
             variant_cx.fcx.schedule_drop_mem(cleanup::CustomScope(field_scope),
@@ -288,7 +288,7 @@ fn trans_struct_drop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         }
 
         let dtor_ty = ty::mk_ctor_fn(variant_cx.tcx(), ast::DUMMY_NODE_ID,
-                                     [get_drop_glue_type(bcx.ccx(), t)], ty::mk_nil());
+                                     &[get_drop_glue_type(bcx.ccx(), t)], ty::mk_nil());
         let (_, variant_cx) = invoke(variant_cx, dtor_addr, args, dtor_ty, None, false);
 
         variant_cx.fcx.pop_and_trans_custom_cleanup_scope(variant_cx, field_scope);
@@ -335,8 +335,8 @@ fn size_and_align_of_dst(bcx: Block, t :ty::t, info: ValueRef) -> (ValueRef, Val
             // info points to the vtable and the second entry in the vtable is the
             // dynamic size of the object.
             let info = PointerCast(bcx, info, Type::int(bcx.ccx()).ptr_to());
-            let size_ptr = GEPi(bcx, info, [1u]);
-            let align_ptr = GEPi(bcx, info, [2u]);
+            let size_ptr = GEPi(bcx, info, &[1u]);
+            let align_ptr = GEPi(bcx, info, &[2u]);
             (Load(bcx, size_ptr), Load(bcx, align_ptr))
         }
         ty::ty_vec(unit_ty, None) => {
@@ -366,26 +366,26 @@ fn make_drop_glue<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, v0: ValueRef, t: ty::t)
                     tvec::make_drop_glue_unboxed(bcx, v0, unit_ty, true)
                 }
                 ty::ty_trait(..) => {
-                    let lluniquevalue = GEPi(bcx, v0, [0, abi::trt_field_box]);
+                    let lluniquevalue = GEPi(bcx, v0, &[0, abi::trt_field_box]);
                     // Only drop the value when it is non-null
                     let concrete_ptr = Load(bcx, lluniquevalue);
                     with_cond(bcx, IsNotNull(bcx, concrete_ptr), |bcx| {
-                        let dtor_ptr = Load(bcx, GEPi(bcx, v0, [0, abi::trt_field_vtable]));
+                        let dtor_ptr = Load(bcx, GEPi(bcx, v0, &[0, abi::trt_field_vtable]));
                         let dtor = Load(bcx, dtor_ptr);
                         Call(bcx,
                              dtor,
-                             [PointerCast(bcx, lluniquevalue, Type::i8p(bcx.ccx()))],
+                             &[PointerCast(bcx, lluniquevalue, Type::i8p(bcx.ccx()))],
                              None);
                         bcx
                     })
                 }
                 ty::ty_struct(..) if !ty::type_is_sized(bcx.tcx(), content_ty) => {
-                    let llval = GEPi(bcx, v0, [0, abi::slice_elt_base]);
+                    let llval = GEPi(bcx, v0, &[0, abi::slice_elt_base]);
                     let llbox = Load(bcx, llval);
                     let not_null = IsNotNull(bcx, llbox);
                     with_cond(bcx, not_null, |bcx| {
                         let bcx = drop_ty(bcx, v0, content_ty, None);
-                        let info = GEPi(bcx, v0, [0, abi::slice_elt_len]);
+                        let info = GEPi(bcx, v0, &[0, abi::slice_elt_len]);
                         let info = Load(bcx, info);
                         let (llsize, llalign) = size_and_align_of_dst(bcx, content_ty, info);
                         trans_exchange_free_dyn(bcx, llbox, llsize, llalign)
@@ -437,14 +437,14 @@ fn make_drop_glue<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, v0: ValueRef, t: ty::t)
                                                          t,
                                                          |bb, vv, tt| drop_ty(bb, vv, tt, None)),
         ty::ty_closure(ref f) if f.store == ty::UniqTraitStore => {
-            let box_cell_v = GEPi(bcx, v0, [0u, abi::fn_field_box]);
+            let box_cell_v = GEPi(bcx, v0, &[0u, abi::fn_field_box]);
             let env = Load(bcx, box_cell_v);
             let env_ptr_ty = Type::at_box(bcx.ccx(), Type::i8(bcx.ccx())).ptr_to();
             let env = PointerCast(bcx, env, env_ptr_ty);
             with_cond(bcx, IsNotNull(bcx, env), |bcx| {
-                let dtor_ptr = GEPi(bcx, env, [0u, abi::box_field_drop_glue]);
+                let dtor_ptr = GEPi(bcx, env, &[0u, abi::box_field_drop_glue]);
                 let dtor = Load(bcx, dtor_ptr);
-                Call(bcx, dtor, [PointerCast(bcx, box_cell_v, Type::i8p(bcx.ccx()))], None);
+                Call(bcx, dtor, &[PointerCast(bcx, box_cell_v, Type::i8p(bcx.ccx()))], None);
                 bcx
             })
         }
@@ -453,12 +453,12 @@ fn make_drop_glue<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, v0: ValueRef, t: ty::t)
             // above), because this happens for a trait field in an unsized
             // struct. If anything is null, it is the whole struct and we won't
             // get here.
-            let lluniquevalue = GEPi(bcx, v0, [0, abi::trt_field_box]);
-            let dtor_ptr = Load(bcx, GEPi(bcx, v0, [0, abi::trt_field_vtable]));
+            let lluniquevalue = GEPi(bcx, v0, &[0, abi::trt_field_box]);
+            let dtor_ptr = Load(bcx, GEPi(bcx, v0, &[0, abi::trt_field_vtable]));
             let dtor = Load(bcx, dtor_ptr);
             Call(bcx,
                  dtor,
-                 [PointerCast(bcx, Load(bcx, lluniquevalue), Type::i8p(bcx.ccx()))],
+                 &[PointerCast(bcx, Load(bcx, lluniquevalue), Type::i8p(bcx.ccx()))],
                  None);
             bcx
         }
@@ -577,10 +577,10 @@ pub fn emit_tydescs(ccx: &CrateContext) {
         ccx.stats().n_real_glues.set(ccx.stats().n_real_glues.get() + 1);
 
         let tydesc = C_named_struct(ccx.tydesc_type(),
-                                    [ti.size, // size
-                                     ti.align, // align
-                                     drop_glue, // drop_glue
-                                     ti.name]); // name
+                                    &[ti.size, // size
+                                      ti.align, // align
+                                      drop_glue, // drop_glue
+                                      ti.name]); // name
 
         unsafe {
             let gvar = ti.tydesc;
diff --git a/src/librustc/middle/trans/inline.rs b/src/librustc/middle/trans/inline.rs
index 048402782a6d9..0ac1b94b1858f 100644
--- a/src/librustc/middle/trans/inline.rs
+++ b/src/librustc/middle/trans/inline.rs
@@ -166,7 +166,7 @@ fn instantiate_inline(ccx: &CrateContext, fn_id: ast::DefId)
                                  llfn,
                                  &param_substs::empty(),
                                  mth.id,
-                                 []);
+                                 &[]);
                         // Use InternalLinkage so LLVM can optimize more
                         // aggressively.
                         SetLinkage(llfn, InternalLinkage);
diff --git a/src/librustc/middle/trans/intrinsic.rs b/src/librustc/middle/trans/intrinsic.rs
index 906e9e8bfa014..13a10258f806f 100644
--- a/src/librustc/middle/trans/intrinsic.rs
+++ b/src/librustc/middle/trans/intrinsic.rs
@@ -207,7 +207,7 @@ pub fn trans_intrinsic_call<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, node: ast::N
     // These are the only intrinsic functions that diverge.
     if name.get() == "abort" {
         let llfn = ccx.get_intrinsic(&("llvm.trap"));
-        Call(bcx, llfn, [], None);
+        Call(bcx, llfn, &[], None);
         Unreachable(bcx);
         return Result::new(bcx, C_undef(Type::nil(ccx).ptr_to()));
     } else if name.get() == "unreachable" {
@@ -242,7 +242,7 @@ pub fn trans_intrinsic_call<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, node: ast::N
         }
         (_, "breakpoint") => {
             let llfn = ccx.get_intrinsic(&("llvm.debugtrap"));
-            Call(bcx, llfn, [], None)
+            Call(bcx, llfn, &[], None)
         }
         (_, "size_of") => {
             let tp_ty = *substs.types.get(FnSpace, 0);
@@ -291,7 +291,7 @@ pub fn trans_intrinsic_call<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, node: ast::N
                 &ccx.link_meta().crate_hash);
             // NB: This needs to be kept in lockstep with the TypeId struct in
             //     the intrinsic module
-            C_named_struct(llret_ty, [C_u64(ccx, hash)])
+            C_named_struct(llret_ty, &[C_u64(ccx, hash)])
         }
         (_, "init") => {
             let tp_ty = *substs.types.get(FnSpace, 0);
@@ -317,7 +317,7 @@ pub fn trans_intrinsic_call<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, node: ast::N
         (_, "offset") => {
             let ptr = llargs[0];
             let offset = llargs[1];
-            InBoundsGEP(bcx, ptr, [offset])
+            InBoundsGEP(bcx, ptr, &[offset])
         }
 
         (_, "copy_nonoverlapping_memory") => {
@@ -578,8 +578,8 @@ fn copy_intrinsic(bcx: Block, allow_overlap: bool, volatile: bool,
     let src_ptr = PointerCast(bcx, src, Type::i8p(ccx));
     let llfn = ccx.get_intrinsic(&name);
 
-    Call(bcx, llfn, [dst_ptr, src_ptr, Mul(bcx, size, count), align,
-                     C_bool(ccx, volatile)], None)
+    Call(bcx, llfn, &[dst_ptr, src_ptr, Mul(bcx, size, count), align,
+                      C_bool(ccx, volatile)], None)
 }
 
 fn memset_intrinsic(bcx: Block, volatile: bool, tp_ty: ty::t,
@@ -597,14 +597,14 @@ fn memset_intrinsic(bcx: Block, volatile: bool, tp_ty: ty::t,
     let dst_ptr = PointerCast(bcx, dst, Type::i8p(ccx));
     let llfn = ccx.get_intrinsic(&name);
 
-    Call(bcx, llfn, [dst_ptr, val, Mul(bcx, size, count), align,
-                     C_bool(ccx, volatile)], None)
+    Call(bcx, llfn, &[dst_ptr, val, Mul(bcx, size, count), align,
+                      C_bool(ccx, volatile)], None)
 }
 
 fn count_zeros_intrinsic(bcx: Block, name: &'static str, val: ValueRef) -> ValueRef {
     let y = C_bool(bcx.ccx(), false);
     let llfn = bcx.ccx().get_intrinsic(&name);
-    Call(bcx, llfn, [val, y], None)
+    Call(bcx, llfn, &[val, y], None)
 }
 
 fn with_overflow_intrinsic(bcx: Block, name: &'static str, t: ty::t,
@@ -612,7 +612,7 @@ fn with_overflow_intrinsic(bcx: Block, name: &'static str, t: ty::t,
     let llfn = bcx.ccx().get_intrinsic(&name);
 
     // Convert `i1` to a `bool`, and write it to the out parameter
-    let val = Call(bcx, llfn, [a, b], None);
+    let val = Call(bcx, llfn, &[a, b], None);
     let result = ExtractValue(bcx, val, 0);
     let overflow = ZExt(bcx, ExtractValue(bcx, val, 1), Type::bool(bcx.ccx()));
     let ret = C_undef(type_of::type_of(bcx.ccx(), t));
diff --git a/src/librustc/middle/trans/meth.rs b/src/librustc/middle/trans/meth.rs
index fbd4db959ce0c..afd37d1338335 100644
--- a/src/librustc/middle/trans/meth.rs
+++ b/src/librustc/middle/trans/meth.rs
@@ -89,7 +89,7 @@ pub fn trans_impl(ccx: &CrateContext,
                                  llfn,
                                  &param_substs::empty(),
                                  method.id,
-                                 []);
+                                 &[]);
                         update_linkage(ccx,
                                        llfn,
                                        Some(method.id),
@@ -482,7 +482,7 @@ pub fn trans_trait_callee_from_llval<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
 
     // Load the data pointer from the object.
     debug!("(translating trait callee) loading second index from pair");
-    let llboxptr = GEPi(bcx, llpair, [0u, abi::trt_field_box]);
+    let llboxptr = GEPi(bcx, llpair, &[0u, abi::trt_field_box]);
     let llbox = Load(bcx, llboxptr);
     let llself = PointerCast(bcx, llbox, Type::i8p(ccx));
 
@@ -504,9 +504,9 @@ pub fn trans_trait_callee_from_llval<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     let llvtable = Load(bcx,
                         PointerCast(bcx,
                                     GEPi(bcx, llpair,
-                                         [0u, abi::trt_field_vtable]),
+                                         &[0u, abi::trt_field_vtable]),
                                     Type::vtable(ccx).ptr_to().ptr_to()));
-    let mptr = Load(bcx, GEPi(bcx, llvtable, [0u, n_method + VTABLE_OFFSET]));
+    let mptr = Load(bcx, GEPi(bcx, llvtable, &[0u, n_method + VTABLE_OFFSET]));
     let mptr = PointerCast(bcx, mptr, llcallee_ty.ptr_to());
 
     return Callee {
@@ -786,13 +786,13 @@ pub fn trans_trait_cast<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     let llbox_ty = type_of(bcx.ccx(), datum_ty);
 
     // Store the pointer into the first half of pair.
-    let llboxdest = GEPi(bcx, lldest, [0u, abi::trt_field_box]);
+    let llboxdest = GEPi(bcx, lldest, &[0u, abi::trt_field_box]);
     let llboxdest = PointerCast(bcx, llboxdest, llbox_ty.ptr_to());
     bcx = datum.store_to(bcx, llboxdest);
 
     // Store the vtable into the second half of pair.
     let vtable = get_vtable(bcx, datum_ty, trait_ref);
-    let llvtabledest = GEPi(bcx, lldest, [0u, abi::trt_field_vtable]);
+    let llvtabledest = GEPi(bcx, lldest, &[0u, abi::trt_field_vtable]);
     let llvtabledest = PointerCast(bcx, llvtabledest, val_ty(vtable).ptr_to());
     Store(bcx, vtable, llvtabledest);
 
diff --git a/src/librustc/middle/trans/monomorphize.rs b/src/librustc/middle/trans/monomorphize.rs
index 258d12e631f2f..4a148d83926e8 100644
--- a/src/librustc/middle/trans/monomorphize.rs
+++ b/src/librustc/middle/trans/monomorphize.rs
@@ -179,10 +179,10 @@ pub fn monomorphic_fn(ccx: &CrateContext,
                   if needs_body {
                       if abi != abi::Rust {
                           foreign::trans_rust_fn_with_foreign_abi(
-                              ccx, &**decl, &**body, [], d, &psubsts, fn_id.node,
+                              ccx, &**decl, &**body, &[], d, &psubsts, fn_id.node,
                               Some(hash.as_slice()));
                       } else {
-                          trans_fn(ccx, &**decl, &**body, d, &psubsts, fn_id.node, []);
+                          trans_fn(ccx, &**decl, &**body, d, &psubsts, fn_id.node, &[]);
                       }
                   }
 
@@ -226,7 +226,7 @@ pub fn monomorphic_fn(ccx: &CrateContext,
                                  d,
                                  &psubsts,
                                  mth.id,
-                                 []);
+                                 &[]);
                     }
                     d
                 }
@@ -242,7 +242,7 @@ pub fn monomorphic_fn(ccx: &CrateContext,
                     let needs_body = setup_lldecl(d, mth.attrs.as_slice());
                     if needs_body {
                         trans_fn(ccx, mth.pe_fn_decl(), mth.pe_body(), d,
-                                 &psubsts, mth.id, []);
+                                 &psubsts, mth.id, &[]);
                     }
                     d
                 }
diff --git a/src/librustc/middle/trans/tvec.rs b/src/librustc/middle/trans/tvec.rs
index 60c38af3e72ab..cf1aeca79168e 100644
--- a/src/librustc/middle/trans/tvec.rs
+++ b/src/librustc/middle/trans/tvec.rs
@@ -47,7 +47,7 @@ pub fn pointer_add_byte(bcx: Block, ptr: ValueRef, bytes: ValueRef) -> ValueRef
     let _icx = push_ctxt("tvec::pointer_add_byte");
     let old_ty = val_ty(ptr);
     let bptr = PointerCast(bcx, ptr, Type::i8p(bcx.ccx()));
-    return PointerCast(bcx, InBoundsGEP(bcx, bptr, [bytes]), old_ty);
+    return PointerCast(bcx, InBoundsGEP(bcx, bptr, &[bytes]), old_ty);
 }
 
 pub fn make_drop_glue_unboxed<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
@@ -128,7 +128,7 @@ pub fn trans_fixed_vstore<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         SaveIn(lldest) => {
             // lldest will have type *[T x N], but we want the type *T,
             // so use GEP to convert:
-            let lldest = GEPi(bcx, lldest, [0, 0]);
+            let lldest = GEPi(bcx, lldest, &[0, 0]);
             write_content(bcx, &vt, expr, expr, SaveIn(lldest))
         }
     };
@@ -231,8 +231,8 @@ pub fn trans_lit_str<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                 let llbytes = C_uint(bcx.ccx(), bytes);
                 let llcstr = C_cstr(bcx.ccx(), str_lit, false);
                 let llcstr = llvm::LLVMConstPointerCast(llcstr, Type::i8p(bcx.ccx()).to_ref());
-                Store(bcx, llcstr, GEPi(bcx, lldest, [0u, abi::slice_elt_base]));
-                Store(bcx, llbytes, GEPi(bcx, lldest, [0u, abi::slice_elt_len]));
+                Store(bcx, llcstr, GEPi(bcx, lldest, &[0u, abi::slice_elt_base]));
+                Store(bcx, llbytes, GEPi(bcx, lldest, &[0u, abi::slice_elt_len]));
                 bcx
             }
         }
@@ -290,7 +290,7 @@ pub fn write_content<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                 SaveIn(lldest) => {
                     let temp_scope = fcx.push_custom_cleanup_scope();
                     for (i, element) in elements.iter().enumerate() {
-                        let lleltptr = GEPi(bcx, lldest, [i]);
+                        let lleltptr = GEPi(bcx, lldest, &[i]);
                         debug!("writing index {} with lleltptr={}",
                                i, bcx.val_to_string(lleltptr));
                         bcx = expr::trans_into(bcx, &**element,
@@ -397,8 +397,8 @@ pub fn get_fixed_base_and_len(bcx: Block,
 fn get_slice_base_and_len(bcx: Block,
                           llval: ValueRef)
                           -> (ValueRef, ValueRef) {
-    let base = Load(bcx, GEPi(bcx, llval, [0u, abi::slice_elt_base]));
-    let len = Load(bcx, GEPi(bcx, llval, [0u, abi::slice_elt_len]));
+    let base = Load(bcx, GEPi(bcx, llval, &[0u, abi::slice_elt_base]));
+    let len = Load(bcx, GEPi(bcx, llval, &[0u, abi::slice_elt_len]));
     (base, len)
 }
 
@@ -427,7 +427,7 @@ pub fn get_base_and_len(bcx: Block,
         ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) => match ty::get(ty).sty {
             ty::ty_vec(_, None) | ty::ty_str => get_slice_base_and_len(bcx, llval),
             ty::ty_vec(_, Some(n)) => {
-                let base = GEPi(bcx, Load(bcx, llval), [0u, 0u]);
+                let base = GEPi(bcx, Load(bcx, llval), &[0u, 0u]);
                 (base, C_uint(ccx, n))
             }
             _ => ccx.sess().bug("unexpected type in get_base_and_len"),
@@ -477,7 +477,7 @@ pub fn iter_vec_loop<'a, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         let lleltptr = if vt.llunit_alloc_size == 0 {
             data_ptr
         } else {
-            InBoundsGEP(body_bcx, data_ptr, [i])
+            InBoundsGEP(body_bcx, data_ptr, &[i])
         };
         let body_bcx = f(body_bcx, lleltptr, vt.unit_ty);
 
@@ -521,7 +521,7 @@ pub fn iter_vec_raw<'a, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         let header_bcx = fcx.new_temp_block("iter_vec_loop_header");
         Br(bcx, header_bcx.llbb);
         let data_ptr =
-            Phi(header_bcx, val_ty(data_ptr), [data_ptr], [bcx.llbb]);
+            Phi(header_bcx, val_ty(data_ptr), &[data_ptr], &[bcx.llbb]);
         let not_yet_at_end =
             ICmp(header_bcx, llvm::IntULT, data_ptr, data_end_ptr);
         let body_bcx = fcx.new_temp_block("iter_vec_loop_body");
@@ -529,7 +529,7 @@ pub fn iter_vec_raw<'a, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         CondBr(header_bcx, not_yet_at_end, body_bcx.llbb, next_bcx.llbb);
         let body_bcx = f(body_bcx, data_ptr, vt.unit_ty);
         AddIncomingToPhi(data_ptr, InBoundsGEP(body_bcx, data_ptr,
-                                               [C_int(bcx.ccx(), 1i)]),
+                                               &[C_int(bcx.ccx(), 1i)]),
                          body_bcx.llbb);
         Br(body_bcx, header_bcx.llbb);
         next_bcx
diff --git a/src/librustc/middle/trans/type_.rs b/src/librustc/middle/trans/type_.rs
index 7b8eb4e02b2bc..f334774332d14 100644
--- a/src/librustc/middle/trans/type_.rs
+++ b/src/librustc/middle/trans/type_.rs
@@ -162,7 +162,7 @@ impl Type {
     }
 
     pub fn empty_struct(ccx: &CrateContext) -> Type {
-        Type::struct_(ccx, [], false)
+        Type::struct_(ccx, &[], false)
     }
 
     pub fn vtable(ccx: &CrateContext) -> Type {
@@ -182,7 +182,7 @@ impl Type {
     }
 
     pub fn glue_fn(ccx: &CrateContext, t: Type) -> Type {
-        Type::func([t], &Type::void(ccx))
+        Type::func(&[t], &Type::void(ccx))
     }
 
     pub fn tydesc(ccx: &CrateContext, str_slice_ty: Type) -> Type {
@@ -199,7 +199,7 @@ impl Type {
                      int_ty,     // align
                      glue_fn_ty, // drop
                      str_slice_ty]; // name
-        tydesc.set_struct_body(elems, false);
+        tydesc.set_struct_body(&elems, false);
 
         tydesc
     }
@@ -214,7 +214,7 @@ impl Type {
 
     pub fn vec(ccx: &CrateContext, ty: &Type) -> Type {
         Type::struct_(ccx,
-            [Type::array(ty, 0), Type::int(ccx)],
+            &[Type::array(ty, 0), Type::int(ccx)],
         false)
     }
 
@@ -224,7 +224,7 @@ impl Type {
 
     // The box pointed to by @T.
     pub fn at_box(ccx: &CrateContext, ty: Type) -> Type {
-        Type::struct_(ccx, [
+        Type::struct_(ccx, &[
             ccx.int_type(), Type::glue_fn(ccx, Type::i8p(ccx)).ptr_to(),
             Type::i8p(ccx), Type::i8p(ccx), ty
         ], false)
@@ -235,7 +235,7 @@ impl Type {
     }
 
     pub fn opaque_trait(ccx: &CrateContext) -> Type {
-        Type::struct_(ccx, [Type::opaque_trait_data(ccx).ptr_to(), Type::vtable_ptr(ccx)], false)
+        Type::struct_(ccx, &[Type::opaque_trait_data(ccx).ptr_to(), Type::vtable_ptr(ccx)], false)
     }
 
     pub fn opaque_trait_data(ccx: &CrateContext) -> Type {
diff --git a/src/librustc/middle/trans/type_of.rs b/src/librustc/middle/trans/type_of.rs
index 649dbbacc6984..3b85d3ef89d18 100644
--- a/src/librustc/middle/trans/type_of.rs
+++ b/src/librustc/middle/trans/type_of.rs
@@ -198,12 +198,12 @@ pub fn sizing_type_of(cx: &CrateContext, t: ty::t) -> Type {
             if ty::type_is_sized(cx.tcx(), ty) {
                 Type::i8p(cx)
             } else {
-                Type::struct_(cx, [Type::i8p(cx), Type::i8p(cx)], false)
+                Type::struct_(cx, &[Type::i8p(cx), Type::i8p(cx)], false)
             }
         }
 
         ty::ty_bare_fn(..) => Type::i8p(cx),
-        ty::ty_closure(..) => Type::struct_(cx, [Type::i8p(cx), Type::i8p(cx)], false),
+        ty::ty_closure(..) => Type::struct_(cx, &[Type::i8p(cx), Type::i8p(cx)], false),
 
         ty::ty_vec(ty, Some(size)) => {
             let llty = sizing_type_of(cx, ty);
@@ -230,7 +230,7 @@ pub fn sizing_type_of(cx: &CrateContext, t: ty::t) -> Type {
         }
 
         ty::ty_open(_) => {
-            Type::struct_(cx, [Type::i8p(cx), Type::i8p(cx)], false)
+            Type::struct_(cx, &[Type::i8p(cx), Type::i8p(cx)], false)
         }
 
         ty::ty_infer(..) | ty::ty_param(..) | ty::ty_err(..) => {
@@ -337,7 +337,7 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type {
               ty::ty_trait(..) => Type::opaque_trait(cx),
               _ if !ty::type_is_sized(cx.tcx(), ty) => {
                   let p_ty = type_of(cx, ty).ptr_to();
-                  Type::struct_(cx, [p_ty, type_of_unsize_info(cx, ty)], false)
+                  Type::struct_(cx, &[p_ty, type_of_unsize_info(cx, ty)], false)
               }
               _ => type_of(cx, ty).ptr_to(),
           }
@@ -364,7 +364,7 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type {
       }
       ty::ty_closure(_) => {
           let fn_ty = type_of_fn_from_ty(cx, t).ptr_to();
-          Type::struct_(cx, [fn_ty, Type::i8p(cx)], false)
+          Type::struct_(cx, &[fn_ty, Type::i8p(cx)], false)
       }
       ty::ty_tup(..) => {
           let repr = adt::represent_type(cx, t);
@@ -390,15 +390,15 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type {
       ty::ty_open(t) => match ty::get(t).sty {
           ty::ty_struct(..) => {
               let p_ty = type_of(cx, t).ptr_to();
-              Type::struct_(cx, [p_ty, type_of_unsize_info(cx, t)], false)
+              Type::struct_(cx, &[p_ty, type_of_unsize_info(cx, t)], false)
           }
           ty::ty_vec(ty, None) => {
               let p_ty = type_of(cx, ty).ptr_to();
-              Type::struct_(cx, [p_ty, type_of_unsize_info(cx, t)], false)
+              Type::struct_(cx, &[p_ty, type_of_unsize_info(cx, t)], false)
           }
           ty::ty_str => {
               let p_ty = Type::i8p(cx);
-              Type::struct_(cx, [p_ty, type_of_unsize_info(cx, t)], false)
+              Type::struct_(cx, &[p_ty, type_of_unsize_info(cx, t)], false)
           }
           ty::ty_trait(..) => Type::opaque_trait(cx),
           _ => cx.sess().bug(format!("ty_open with sized type: {}",
@@ -466,5 +466,5 @@ pub fn llvm_type_name(cx: &CrateContext,
 
 pub fn type_of_dtor(ccx: &CrateContext, self_ty: ty::t) -> Type {
     let self_ty = type_of(ccx, self_ty).ptr_to();
-    Type::func([self_ty], &Type::void(ccx))
+    Type::func(&[self_ty], &Type::void(ccx))
 }
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index 76caa42b85023..b65f986c192f5 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -2667,7 +2667,7 @@ pub fn type_contents(cx: &ctxt, ty: t) -> TypeContents {
                        bounds: ExistentialBounds)
                        -> TypeContents {
         // These are the type contents of the (opaque) interior
-        kind_bounds_to_contents(cx, bounds.builtin_bounds, [])
+        kind_bounds_to_contents(cx, bounds.builtin_bounds, &[])
     }
 
     fn kind_bounds_to_contents(cx: &ctxt,
@@ -4870,7 +4870,7 @@ pub fn required_region_bounds(tcx: &ctxt,
 
     all_bounds.push_all(region_bounds);
 
-    push_region_bounds([],
+    push_region_bounds(&[],
                        builtin_bounds,
                        &mut all_bounds);
 
diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs
index 7c8d9309df3b8..2125d5eeacbf6 100644
--- a/src/librustc/middle/typeck/astconv.rs
+++ b/src/librustc/middle/typeck/astconv.rs
@@ -1459,7 +1459,7 @@ pub fn compute_opt_region_bound(tcx: &ty::ctxt,
     let derived_region_bounds =
         ty::required_region_bounds(
             tcx,
-            [],
+            &[],
             builtin_bounds,
             trait_bounds);
 
diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs
index f854bc52acd7b..ccf507ed04bb2 100644
--- a/src/librustc/middle/typeck/check/method.rs
+++ b/src/librustc/middle/typeck/check/method.rs
@@ -1065,7 +1065,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
 
         // First try to borrow to a slice
         let entry = self.search_for_some_kind_of_autorefd_method(
-            |r, m| AutoPtr(r, m, None), autoderefs, [MutImmutable, MutMutable],
+            |r, m| AutoPtr(r, m, None), autoderefs, &[MutImmutable, MutMutable],
             |m,r| ty::mk_slice(tcx, r,
                                ty::mt {ty:ty, mutbl:m}));
 
@@ -1076,7 +1076,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
         // Then try to borrow to a slice *and* borrow a pointer.
         self.search_for_some_kind_of_autorefd_method(
             |r, m| AutoPtr(r, ast::MutImmutable, Some( box AutoPtr(r, m, None))),
-            autoderefs, [MutImmutable, MutMutable],
+            autoderefs, &[MutImmutable, MutMutable],
             |m, r| {
                 let slice_ty = ty::mk_slice(tcx, r,
                                             ty::mt {ty:ty, mutbl:m});
@@ -1097,7 +1097,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
         // First try to borrow to an unsized vec.
         let entry = self.search_for_some_kind_of_autorefd_method(
             |_r, _m| AutoUnsize(ty::UnsizeLength(len)),
-            autoderefs, [MutImmutable, MutMutable],
+            autoderefs, &[MutImmutable, MutMutable],
             |_m, _r| ty::mk_vec(tcx, ty, None));
 
         if entry.is_some() {
@@ -1107,7 +1107,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
         // Then try to borrow to a slice.
         let entry = self.search_for_some_kind_of_autorefd_method(
             |r, m| AutoPtr(r, m, Some(box AutoUnsize(ty::UnsizeLength(len)))),
-            autoderefs, [MutImmutable, MutMutable],
+            autoderefs, &[MutImmutable, MutMutable],
             |m, r|  ty::mk_slice(tcx, r, ty::mt {ty:ty, mutbl:m}));
 
         if entry.is_some() {
@@ -1119,7 +1119,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
             |r, m| AutoPtr(r, m,
                            Some(box AutoPtr(r, m,
                                             Some(box AutoUnsize(ty::UnsizeLength(len)))))),
-            autoderefs, [MutImmutable, MutMutable],
+            autoderefs, &[MutImmutable, MutMutable],
             |m, r| {
                 let slice_ty = ty::mk_slice(tcx, r, ty::mt {ty:ty, mutbl:m});
                 ty::mk_rptr(tcx, r, ty::mt {ty:slice_ty, mutbl:MutImmutable})
@@ -1131,7 +1131,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
         debug!("auto_slice_str");
 
         let entry = self.search_for_some_kind_of_autorefd_method(
-            |r, m| AutoPtr(r, m, None), autoderefs, [MutImmutable],
+            |r, m| AutoPtr(r, m, None), autoderefs, &[MutImmutable],
             |_m, r| ty::mk_str_slice(tcx, r, MutImmutable));
 
         if entry.is_some() {
@@ -1140,7 +1140,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
 
         self.search_for_some_kind_of_autorefd_method(
             |r, m| AutoPtr(r, ast::MutImmutable, Some( box AutoPtr(r, m, None))),
-            autoderefs, [MutImmutable],
+            autoderefs, &[MutImmutable],
             |m, r| {
                 let slice_ty = ty::mk_str_slice(tcx, r, m);
                 ty::mk_rptr(tcx, r, ty::mt {ty:slice_ty, mutbl:m})
@@ -1159,7 +1159,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
                 let tcx = self.tcx();
                 self.search_for_some_kind_of_autorefd_method(
                     |r, m| AutoPtr(r, m, None),
-                    autoderefs, [MutImmutable, MutMutable],
+                    autoderefs, &[MutImmutable, MutMutable],
                     |m, r| {
                         let tr = ty::mk_trait(tcx, trt_did, trt_substs.clone(), b);
                         ty::mk_rptr(tcx, r, ty::mt{ ty: tr, mutbl: m })
@@ -1219,7 +1219,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
             ty_unboxed_closure(..) | ty_tup(..) | ty_open(..) |
             ty_str | ty_vec(..) | ty_trait(..) | ty_closure(..) => {
                 self.search_for_some_kind_of_autorefd_method(
-                    |r, m| AutoPtr(r, m, None), autoderefs, [MutImmutable, MutMutable],
+                    |r, m| AutoPtr(r, m, None), autoderefs, &[MutImmutable, MutMutable],
                     |m,r| ty::mk_rptr(tcx, r, ty::mt {ty:self_ty, mutbl:m}))
             }
 
diff --git a/src/librustc/middle/typeck/check/regionmanip.rs b/src/librustc/middle/typeck/check/regionmanip.rs
index 91e9c18853c80..56f6d19147adb 100644
--- a/src/librustc/middle/typeck/check/regionmanip.rs
+++ b/src/librustc/middle/typeck/check/regionmanip.rs
@@ -413,9 +413,9 @@ impl<'a, 'tcx> Wf<'a, 'tcx> {
         // region bounds required from all of the trait types:
         let required_region_bounds =
             ty::required_region_bounds(self.tcx,
-                                       [],
+                                       &[],
                                        bounds.builtin_bounds,
-                                       []);
+                                       &[]);
         for &r_d in required_region_bounds.iter() {
             // Each of these is an instance of the `'c <= 'b`
             // constraint above
diff --git a/src/librustc/middle/typeck/coherence/mod.rs b/src/librustc/middle/typeck/coherence/mod.rs
index ac18f53de0465..e425f457b0d9e 100644
--- a/src/librustc/middle/typeck/coherence/mod.rs
+++ b/src/librustc/middle/typeck/coherence/mod.rs
@@ -152,9 +152,9 @@ impl<'a, 'tcx, 'v> visit::Visitor<'v> for CoherenceCheckVisitor<'a, 'tcx> {
             ItemImpl(_, ref opt_trait, _, _) => {
                 match opt_trait.clone() {
                     Some(opt_trait) => {
-                        self.cc.check_implementation(item, [opt_trait]);
+                        self.cc.check_implementation(item, &[opt_trait]);
                     }
-                    None => self.cc.check_implementation(item, [])
+                    None => self.cc.check_implementation(item, &[])
                 }
             }
             _ => {
diff --git a/src/librustc/middle/typeck/infer/test.rs b/src/librustc/middle/typeck/infer/test.rs
index 5b1ee7c64b4a3..769fdef06253f 100644
--- a/src/librustc/middle/typeck/infer/test.rs
+++ b/src/librustc/middle/typeck/infer/test.rs
@@ -376,7 +376,7 @@ impl<'a, 'tcx> Env<'a, 'tcx> {
 
 #[test]
 fn contravariant_region_ptr_ok() {
-    test_env("contravariant_region_ptr", EMPTY_SOURCE_STR, errors([]), |env| {
+    test_env("contravariant_region_ptr", EMPTY_SOURCE_STR, errors(&[]), |env| {
         env.create_simple_region_hierarchy();
         let t_rptr1 = env.t_rptr_scope(1);
         let t_rptr10 = env.t_rptr_scope(10);
@@ -390,7 +390,7 @@ fn contravariant_region_ptr_ok() {
 fn contravariant_region_ptr_err() {
     test_env("contravariant_region_ptr",
              EMPTY_SOURCE_STR,
-             errors(["lifetime mismatch"]),
+             errors(&["lifetime mismatch"]),
              |env| {
                  env.create_simple_region_hierarchy();
                  let t_rptr1 = env.t_rptr_scope(1);
@@ -405,114 +405,114 @@ fn contravariant_region_ptr_err() {
 
 #[test]
 fn lub_bound_bound() {
-    test_env("contravariant_region_ptr", EMPTY_SOURCE_STR, errors([]), |env| {
+    test_env("contravariant_region_ptr", EMPTY_SOURCE_STR, errors(&[]), |env| {
         let t_rptr_bound1 = env.t_rptr_late_bound(22, 1);
         let t_rptr_bound2 = env.t_rptr_late_bound(22, 2);
-        env.check_lub(env.t_fn(22, [t_rptr_bound1], env.t_int()),
-                      env.t_fn(22, [t_rptr_bound2], env.t_int()),
-                      env.t_fn(22, [t_rptr_bound1], env.t_int()));
+        env.check_lub(env.t_fn(22, &[t_rptr_bound1], env.t_int()),
+                      env.t_fn(22, &[t_rptr_bound2], env.t_int()),
+                      env.t_fn(22, &[t_rptr_bound1], env.t_int()));
     })
 }
 
 #[test]
 fn lub_bound_free() {
-    test_env("contravariant_region_ptr", EMPTY_SOURCE_STR, errors([]), |env| {
+    test_env("contravariant_region_ptr", EMPTY_SOURCE_STR, errors(&[]), |env| {
         let t_rptr_bound1 = env.t_rptr_late_bound(22, 1);
         let t_rptr_free1 = env.t_rptr_free(0, 1);
-        env.check_lub(env.t_fn(22, [t_rptr_bound1], env.t_int()),
-                      env.t_fn(22, [t_rptr_free1], env.t_int()),
-                      env.t_fn(22, [t_rptr_free1], env.t_int()));
+        env.check_lub(env.t_fn(22, &[t_rptr_bound1], env.t_int()),
+                      env.t_fn(22, &[t_rptr_free1], env.t_int()),
+                      env.t_fn(22, &[t_rptr_free1], env.t_int()));
     })
 }
 
 #[test]
 fn lub_bound_static() {
-    test_env("contravariant_region_ptr", EMPTY_SOURCE_STR, errors([]), |env| {
+    test_env("contravariant_region_ptr", EMPTY_SOURCE_STR, errors(&[]), |env| {
         let t_rptr_bound1 = env.t_rptr_late_bound(22, 1);
         let t_rptr_static = env.t_rptr_static();
-        env.check_lub(env.t_fn(22, [t_rptr_bound1], env.t_int()),
-                      env.t_fn(22, [t_rptr_static], env.t_int()),
-                      env.t_fn(22, [t_rptr_static], env.t_int()));
+        env.check_lub(env.t_fn(22, &[t_rptr_bound1], env.t_int()),
+                      env.t_fn(22, &[t_rptr_static], env.t_int()),
+                      env.t_fn(22, &[t_rptr_static], env.t_int()));
     })
 }
 
 #[test]
 fn lub_bound_bound_inverse_order() {
-    test_env("contravariant_region_ptr", EMPTY_SOURCE_STR, errors([]), |env| {
+    test_env("contravariant_region_ptr", EMPTY_SOURCE_STR, errors(&[]), |env| {
         let t_rptr_bound1 = env.t_rptr_late_bound(22, 1);
         let t_rptr_bound2 = env.t_rptr_late_bound(22, 2);
-        env.check_lub(env.t_fn(22, [t_rptr_bound1, t_rptr_bound2], t_rptr_bound1),
-                      env.t_fn(22, [t_rptr_bound2, t_rptr_bound1], t_rptr_bound1),
-                      env.t_fn(22, [t_rptr_bound1, t_rptr_bound1], t_rptr_bound1));
+        env.check_lub(env.t_fn(22, &[t_rptr_bound1, t_rptr_bound2], t_rptr_bound1),
+                      env.t_fn(22, &[t_rptr_bound2, t_rptr_bound1], t_rptr_bound1),
+                      env.t_fn(22, &[t_rptr_bound1, t_rptr_bound1], t_rptr_bound1));
     })
 }
 
 #[test]
 fn lub_free_free() {
-    test_env("contravariant_region_ptr", EMPTY_SOURCE_STR, errors([]), |env| {
+    test_env("contravariant_region_ptr", EMPTY_SOURCE_STR, errors(&[]), |env| {
         let t_rptr_free1 = env.t_rptr_free(0, 1);
         let t_rptr_free2 = env.t_rptr_free(0, 2);
         let t_rptr_static = env.t_rptr_static();
-        env.check_lub(env.t_fn(22, [t_rptr_free1], env.t_int()),
-                      env.t_fn(22, [t_rptr_free2], env.t_int()),
-                      env.t_fn(22, [t_rptr_static], env.t_int()));
+        env.check_lub(env.t_fn(22, &[t_rptr_free1], env.t_int()),
+                      env.t_fn(22, &[t_rptr_free2], env.t_int()),
+                      env.t_fn(22, &[t_rptr_static], env.t_int()));
     })
 }
 
 #[test]
 fn lub_returning_scope() {
     test_env("contravariant_region_ptr", EMPTY_SOURCE_STR,
-             errors(["cannot infer an appropriate lifetime"]), |env| {
+             errors(&["cannot infer an appropriate lifetime"]), |env| {
                  let t_rptr_scope10 = env.t_rptr_scope(10);
                  let t_rptr_scope11 = env.t_rptr_scope(11);
 
                  // this should generate an error when regions are resolved
-                 env.make_lub_ty(env.t_fn(22, [], t_rptr_scope10),
-                                 env.t_fn(22, [], t_rptr_scope11));
+                 env.make_lub_ty(env.t_fn(22, &[], t_rptr_scope10),
+                                 env.t_fn(22, &[], t_rptr_scope11));
              })
 }
 
 #[test]
 fn glb_free_free_with_common_scope() {
-    test_env("contravariant_region_ptr", EMPTY_SOURCE_STR, errors([]), |env| {
+    test_env("contravariant_region_ptr", EMPTY_SOURCE_STR, errors(&[]), |env| {
         let t_rptr_free1 = env.t_rptr_free(0, 1);
         let t_rptr_free2 = env.t_rptr_free(0, 2);
         let t_rptr_scope = env.t_rptr_scope(0);
-        env.check_glb(env.t_fn(22, [t_rptr_free1], env.t_int()),
-                      env.t_fn(22, [t_rptr_free2], env.t_int()),
-                      env.t_fn(22, [t_rptr_scope], env.t_int()));
+        env.check_glb(env.t_fn(22, &[t_rptr_free1], env.t_int()),
+                      env.t_fn(22, &[t_rptr_free2], env.t_int()),
+                      env.t_fn(22, &[t_rptr_scope], env.t_int()));
     })
 }
 
 #[test]
 fn glb_bound_bound() {
-    test_env("contravariant_region_ptr", EMPTY_SOURCE_STR, errors([]), |env| {
+    test_env("contravariant_region_ptr", EMPTY_SOURCE_STR, errors(&[]), |env| {
         let t_rptr_bound1 = env.t_rptr_late_bound(22, 1);
         let t_rptr_bound2 = env.t_rptr_late_bound(22, 2);
-        env.check_glb(env.t_fn(22, [t_rptr_bound1], env.t_int()),
-                      env.t_fn(22, [t_rptr_bound2], env.t_int()),
-                      env.t_fn(22, [t_rptr_bound1], env.t_int()));
+        env.check_glb(env.t_fn(22, &[t_rptr_bound1], env.t_int()),
+                      env.t_fn(22, &[t_rptr_bound2], env.t_int()),
+                      env.t_fn(22, &[t_rptr_bound1], env.t_int()));
     })
 }
 
 #[test]
 fn glb_bound_free() {
-    test_env("contravariant_region_ptr", EMPTY_SOURCE_STR, errors([]), |env| {
+    test_env("contravariant_region_ptr", EMPTY_SOURCE_STR, errors(&[]), |env| {
         let t_rptr_bound1 = env.t_rptr_late_bound(22, 1);
         let t_rptr_free1 = env.t_rptr_free(0, 1);
-        env.check_glb(env.t_fn(22, [t_rptr_bound1], env.t_int()),
-                      env.t_fn(22, [t_rptr_free1], env.t_int()),
-                      env.t_fn(22, [t_rptr_bound1], env.t_int()));
+        env.check_glb(env.t_fn(22, &[t_rptr_bound1], env.t_int()),
+                      env.t_fn(22, &[t_rptr_free1], env.t_int()),
+                      env.t_fn(22, &[t_rptr_bound1], env.t_int()));
     })
 }
 
 #[test]
 fn glb_bound_static() {
-    test_env("contravariant_region_ptr", EMPTY_SOURCE_STR, errors([]), |env| {
+    test_env("contravariant_region_ptr", EMPTY_SOURCE_STR, errors(&[]), |env| {
         let t_rptr_bound1 = env.t_rptr_late_bound(22, 1);
         let t_rptr_static = env.t_rptr_static();
-        env.check_glb(env.t_fn(22, [t_rptr_bound1], env.t_int()),
-                      env.t_fn(22, [t_rptr_static], env.t_int()),
-                      env.t_fn(22, [t_rptr_bound1], env.t_int()));
+        env.check_glb(env.t_fn(22, &[t_rptr_bound1], env.t_int()),
+                      env.t_fn(22, &[t_rptr_static], env.t_int()),
+                      env.t_fn(22, &[t_rptr_bound1], env.t_int()));
     })
 }
diff --git a/src/librustc_back/archive.rs b/src/librustc_back/archive.rs
index db2f291e5e7de..8a15a4eae28ad 100644
--- a/src/librustc_back/archive.rs
+++ b/src/librustc_back/archive.rs
@@ -141,12 +141,12 @@ impl<'a> Archive<'a> {
 
     /// Removes a file from this archive
     pub fn remove_file(&mut self, file: &str) {
-        run_ar(self.handler, &self.maybe_ar_prog, "d", None, [&self.dst, &Path::new(file)]);
+        run_ar(self.handler, &self.maybe_ar_prog, "d", None, &[&self.dst, &Path::new(file)]);
     }
 
     /// Lists all files in an archive
     pub fn files(&self) -> Vec<String> {
-        let output = run_ar(self.handler, &self.maybe_ar_prog, "t", None, [&self.dst]);
+        let output = run_ar(self.handler, &self.maybe_ar_prog, "t", None, &[&self.dst]);
         let output = str::from_utf8(output.output.as_slice()).unwrap();
         // use lines_any because windows delimits output with `\r\n` instead of
         // just `\n`
@@ -183,7 +183,7 @@ impl<'a> ArchiveBuilder<'a> {
                                     self.archive.slib_suffix.as_slice(),
                                     self.archive.lib_search_paths.as_slice(),
                                     self.archive.handler);
-        self.add_archive(&location, name, [])
+        self.add_archive(&location, name, &[])
     }
 
     /// Adds all of the contents of the rlib at the specified path to this
@@ -281,7 +281,7 @@ impl<'a> ArchiveBuilder<'a> {
         // of filename collisions.
         let archive = os::make_absolute(archive);
         run_ar(self.archive.handler, &self.archive.maybe_ar_prog,
-               "x", Some(loc.path()), [&archive]);
+               "x", Some(loc.path()), &[&archive]);
 
         // Next, we must rename all of the inputs to "guaranteed unique names".
         // We move each file into `self.work_dir` under its new unique name.
diff --git a/src/librustc_back/rpath.rs b/src/librustc_back/rpath.rs
index e7ac1bbcf8474..974d8f889c95e 100644
--- a/src/librustc_back/rpath.rs
+++ b/src/librustc_back/rpath.rs
@@ -140,7 +140,7 @@ mod test {
 
     #[test]
     fn test_rpaths_to_flags() {
-        let flags = rpaths_to_flags([
+        let flags = rpaths_to_flags(&[
             "path1".to_string(),
             "path2".to_string()
         ]);
@@ -151,12 +151,12 @@ mod test {
 
     #[test]
     fn test_minimize1() {
-        let res = minimize_rpaths([
+        let res = minimize_rpaths(&[
             "rpath1".to_string(),
             "rpath2".to_string(),
             "rpath1".to_string()
         ]);
-        assert!(res.as_slice() == [
+        assert!(res.as_slice() == &[
             "rpath1".to_string(),
             "rpath2".to_string()
         ]);
@@ -164,7 +164,7 @@ mod test {
 
     #[test]
     fn test_minimize2() {
-        let res = minimize_rpaths([
+        let res = minimize_rpaths(&[
             "1a".to_string(),
             "2".to_string(),
             "2".to_string(),
@@ -176,7 +176,7 @@ mod test {
             "4a".to_string(),
             "3".to_string()
         ]);
-        assert!(res.as_slice() == [
+        assert!(res.as_slice() == &[
             "1a".to_string(),
             "2".to_string(),
             "4a".to_string(),
diff --git a/src/librustc_back/sha2.rs b/src/librustc_back/sha2.rs
index 96a15213c5ed6..a4e476c948cd5 100644
--- a/src/librustc_back/sha2.rs
+++ b/src/librustc_back/sha2.rs
@@ -139,7 +139,7 @@ impl FixedBuffer for FixedBuffer64 {
                         self.buffer[mut self.buffer_idx..size],
                         input[..buffer_remaining]);
                 self.buffer_idx = 0;
-                func(self.buffer);
+                func(&self.buffer);
                 i += buffer_remaining;
             } else {
                 copy_memory(
@@ -657,7 +657,7 @@ mod bench {
         let mut sh = Sha256::new();
         let bytes = [1u8, ..10];
         b.iter(|| {
-            sh.input(bytes);
+            sh.input(&bytes);
         });
         b.bytes = bytes.len() as u64;
     }
@@ -667,7 +667,7 @@ mod bench {
         let mut sh = Sha256::new();
         let bytes = [1u8, ..1024];
         b.iter(|| {
-            sh.input(bytes);
+            sh.input(&bytes);
         });
         b.bytes = bytes.len() as u64;
     }
@@ -677,7 +677,7 @@ mod bench {
         let mut sh = Sha256::new();
         let bytes = [1u8, ..65536];
         b.iter(|| {
-            sh.input(bytes);
+            sh.input(&bytes);
         });
         b.bytes = bytes.len() as u64;
     }
diff --git a/src/librustrt/c_str.rs b/src/librustrt/c_str.rs
index b15cdb88b6783..079d3bd473847 100644
--- a/src/librustrt/c_str.rs
+++ b/src/librustrt/c_str.rs
@@ -432,7 +432,7 @@ unsafe fn with_c_str<T>(v: &[u8], checked: bool,
                         f: |*const libc::c_char| -> T) -> T {
     let c_str = if v.len() < BUF_LEN {
         let mut buf: [u8, .. BUF_LEN] = mem::uninitialized();
-        slice::bytes::copy_memory(buf, v);
+        slice::bytes::copy_memory(&mut buf, v);
         buf[v.len()] = 0;
 
         let buf = buf.as_mut_ptr();
@@ -554,7 +554,7 @@ mod tests {
 
     #[test]
     fn test_vec_to_c_str() {
-        let b: &[u8] = [];
+        let b: &[u8] = &[];
         let c_str = b.to_c_str();
         unsafe {
             assert_eq!(*c_str.as_ptr().offset(0), 0);
@@ -646,7 +646,7 @@ mod tests {
         let c_str = "hello".to_c_str();
         assert_eq!(c_str.as_bytes_no_nul(), b"hello");
         let c_str = "".to_c_str();
-        let exp: &[u8] = [];
+        let exp: &[u8] = &[];
         assert_eq!(c_str.as_bytes_no_nul(), exp);
         let c_str = b"foo\xFF".to_c_str();
         assert_eq!(c_str.as_bytes_no_nul(), b"foo\xFF");
diff --git a/src/librustrt/util.rs b/src/librustrt/util.rs
index 06d1efdcd704a..c77fbd4aee067 100644
--- a/src/librustrt/util.rs
+++ b/src/librustrt/util.rs
@@ -74,7 +74,7 @@ pub fn abort(args: &fmt::Arguments) -> ! {
 
     // Convert the arguments into a stack-allocated string
     let mut msg = [0u8, ..512];
-    let mut w = BufWriter { buf: msg, pos: 0 };
+    let mut w = BufWriter { buf: &mut msg, pos: 0 };
     let _ = write!(&mut w, "{}", args);
     let msg = str::from_utf8(w.buf[mut ..w.pos]).unwrap_or("aborted");
     let msg = if msg.is_empty() {"aborted"} else {msg};
diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs
index e0d436f5e0eb6..4cc5f7eaf22fe 100644
--- a/src/libserialize/json.rs
+++ b/src/libserialize/json.rs
@@ -361,8 +361,8 @@ fn escape_str(writer: &mut io::Writer, v: &str) -> Result<(), io::IoError> {
 
 fn escape_char(writer: &mut io::Writer, v: char) -> Result<(), io::IoError> {
     let mut buf = [0, .. 4];
-    v.encode_utf8(buf);
-    escape_bytes(writer, buf)
+    v.encode_utf8(&mut buf);
+    escape_bytes(writer, &mut buf)
 }
 
 fn spaces(wr: &mut io::Writer, mut n: uint) -> Result<(), io::IoError> {
@@ -370,7 +370,7 @@ fn spaces(wr: &mut io::Writer, mut n: uint) -> Result<(), io::IoError> {
     static BUF: [u8, ..LEN] = [b' ', ..LEN];
 
     while n >= LEN {
-        try!(wr.write(BUF));
+        try!(wr.write(&BUF));
         n -= LEN;
     }
 
@@ -2579,27 +2579,27 @@ mod tests {
 
     #[test]
     fn test_write_object() {
-        assert_eq!(mk_object([]).to_string().into_string(), "{}".to_string());
-        assert_eq!(mk_object([]).to_pretty_str().into_string(), "{}".to_string());
+        assert_eq!(mk_object(&[]).to_string().into_string(), "{}".to_string());
+        assert_eq!(mk_object(&[]).to_pretty_str().into_string(), "{}".to_string());
 
         assert_eq!(
-            mk_object([
+            mk_object(&[
                 ("a".to_string(), Boolean(true))
             ]).to_string().into_string(),
             "{\"a\":true}".to_string()
         );
         assert_eq!(
-            mk_object([("a".to_string(), Boolean(true))]).to_pretty_str(),
+            mk_object(&[("a".to_string(), Boolean(true))]).to_pretty_str(),
             "\
             {\n  \
                 \"a\": true\n\
             }".to_string()
         );
 
-        let complex_obj = mk_object([
+        let complex_obj = mk_object(&[
                 ("b".to_string(), List(vec![
-                    mk_object([("c".to_string(), String("\x0c\r".to_string()))]),
-                    mk_object([("d".to_string(), String("".to_string()))])
+                    mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
+                    mk_object(&[("d".to_string(), String("".to_string()))])
                 ]))
             ]);
 
@@ -2627,11 +2627,11 @@ mod tests {
             }".to_string()
         );
 
-        let a = mk_object([
+        let a = mk_object(&[
             ("a".to_string(), Boolean(true)),
             ("b".to_string(), List(vec![
-                mk_object([("c".to_string(), String("\x0c\r".to_string()))]),
-                mk_object([("d".to_string(), String("".to_string()))])
+                mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
+                mk_object(&[("d".to_string(), String("".to_string()))])
             ]))
         ]);
 
@@ -2936,22 +2936,22 @@ mod tests {
         assert_eq!(from_str("{\"a\":1 1"), Err(SyntaxError(InvalidSyntax,         1, 8)));
         assert_eq!(from_str("{\"a\":1,"),  Err(SyntaxError(EOFWhileParsingObject, 1, 8)));
 
-        assert_eq!(from_str("{}").unwrap(), mk_object([]));
+        assert_eq!(from_str("{}").unwrap(), mk_object(&[]));
         assert_eq!(from_str("{\"a\": 3}").unwrap(),
-                  mk_object([("a".to_string(), U64(3))]));
+                  mk_object(&[("a".to_string(), U64(3))]));
 
         assert_eq!(from_str(
                       "{ \"a\": null, \"b\" : true }").unwrap(),
-                  mk_object([
+                  mk_object(&[
                       ("a".to_string(), Null),
                       ("b".to_string(), Boolean(true))]));
         assert_eq!(from_str("\n{ \"a\": null, \"b\" : true }\n").unwrap(),
-                  mk_object([
+                  mk_object(&[
                       ("a".to_string(), Null),
                       ("b".to_string(), Boolean(true))]));
         assert_eq!(from_str(
                       "{\"a\" : 1.0 ,\"b\": [ true ]}").unwrap(),
-                  mk_object([
+                  mk_object(&[
                       ("a".to_string(), F64(1.0)),
                       ("b".to_string(), List(vec![Boolean(true)]))
                   ]));
@@ -2964,13 +2964,13 @@ mod tests {
                               { \"c\": {\"d\": null} } \
                           ]\
                       }").unwrap(),
-                  mk_object([
+                  mk_object(&[
                       ("a".to_string(), F64(1.0)),
                       ("b".to_string(), List(vec![
                           Boolean(true),
                           String("foo\nbar".to_string()),
-                          mk_object([
-                              ("c".to_string(), mk_object([("d".to_string(), Null)]))
+                          mk_object(&[
+                              ("c".to_string(), mk_object(&[("d".to_string(), Null)]))
                           ])
                       ]))
                   ]));
@@ -3634,20 +3634,20 @@ mod tests {
         stack.bump_index();
 
         assert!(stack.len() == 1);
-        assert!(stack.is_equal_to([Index(1)]));
-        assert!(stack.starts_with([Index(1)]));
-        assert!(stack.ends_with([Index(1)]));
+        assert!(stack.is_equal_to(&[Index(1)]));
+        assert!(stack.starts_with(&[Index(1)]));
+        assert!(stack.ends_with(&[Index(1)]));
         assert!(stack.last_is_index());
         assert!(stack.get(0) == Index(1));
 
         stack.push_key("foo".to_string());
 
         assert!(stack.len() == 2);
-        assert!(stack.is_equal_to([Index(1), Key("foo")]));
-        assert!(stack.starts_with([Index(1), Key("foo")]));
-        assert!(stack.starts_with([Index(1)]));
-        assert!(stack.ends_with([Index(1), Key("foo")]));
-        assert!(stack.ends_with([Key("foo")]));
+        assert!(stack.is_equal_to(&[Index(1), Key("foo")]));
+        assert!(stack.starts_with(&[Index(1), Key("foo")]));
+        assert!(stack.starts_with(&[Index(1)]));
+        assert!(stack.ends_with(&[Index(1), Key("foo")]));
+        assert!(stack.ends_with(&[Key("foo")]));
         assert!(!stack.last_is_index());
         assert!(stack.get(0) == Index(1));
         assert!(stack.get(1) == Key("foo"));
@@ -3655,13 +3655,13 @@ mod tests {
         stack.push_key("bar".to_string());
 
         assert!(stack.len() == 3);
-        assert!(stack.is_equal_to([Index(1), Key("foo"), Key("bar")]));
-        assert!(stack.starts_with([Index(1)]));
-        assert!(stack.starts_with([Index(1), Key("foo")]));
-        assert!(stack.starts_with([Index(1), Key("foo"), Key("bar")]));
-        assert!(stack.ends_with([Key("bar")]));
-        assert!(stack.ends_with([Key("foo"), Key("bar")]));
-        assert!(stack.ends_with([Index(1), Key("foo"), Key("bar")]));
+        assert!(stack.is_equal_to(&[Index(1), Key("foo"), Key("bar")]));
+        assert!(stack.starts_with(&[Index(1)]));
+        assert!(stack.starts_with(&[Index(1), Key("foo")]));
+        assert!(stack.starts_with(&[Index(1), Key("foo"), Key("bar")]));
+        assert!(stack.ends_with(&[Key("bar")]));
+        assert!(stack.ends_with(&[Key("foo"), Key("bar")]));
+        assert!(stack.ends_with(&[Index(1), Key("foo"), Key("bar")]));
         assert!(!stack.last_is_index());
         assert!(stack.get(0) == Index(1));
         assert!(stack.get(1) == Key("foo"));
@@ -3670,11 +3670,11 @@ mod tests {
         stack.pop();
 
         assert!(stack.len() == 2);
-        assert!(stack.is_equal_to([Index(1), Key("foo")]));
-        assert!(stack.starts_with([Index(1), Key("foo")]));
-        assert!(stack.starts_with([Index(1)]));
-        assert!(stack.ends_with([Index(1), Key("foo")]));
-        assert!(stack.ends_with([Key("foo")]));
+        assert!(stack.is_equal_to(&[Index(1), Key("foo")]));
+        assert!(stack.starts_with(&[Index(1), Key("foo")]));
+        assert!(stack.starts_with(&[Index(1)]));
+        assert!(stack.ends_with(&[Index(1), Key("foo")]));
+        assert!(stack.ends_with(&[Key("foo")]));
         assert!(!stack.last_is_index());
         assert!(stack.get(0) == Index(1));
         assert!(stack.get(1) == Key("foo"));
diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index 49c688da31cbf..24dd64a4da9c4 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -38,7 +38,7 @@ use vec::Vec;
 /// let mut reader = BufferedReader::new(file);
 ///
 /// let mut buf = [0, ..100];
-/// match reader.read(buf) {
+/// match reader.read(&mut buf) {
 ///     Ok(nread) => println!("Read {} bytes", nread),
 ///     Err(e) => println!("error reading: {}", e)
 /// }
@@ -300,7 +300,7 @@ impl<W: Reader> Reader for InternalBufferedWriter<W> {
 /// stream.flush();
 ///
 /// let mut buf = [0, ..100];
-/// match stream.read(buf) {
+/// match stream.read(&mut buf) {
 ///     Ok(nread) => println!("Read {} bytes", nread),
 ///     Err(e) => println!("error reading: {}", e)
 /// }
@@ -414,35 +414,35 @@ mod test {
         let mut reader = BufferedReader::with_capacity(2, inner);
 
         let mut buf = [0, 0, 0];
-        let nread = reader.read(buf);
+        let nread = reader.read(&mut buf);
         assert_eq!(Ok(3), nread);
         let b: &[_] = &[5, 6, 7];
         assert_eq!(buf.as_slice(), b);
 
         let mut buf = [0, 0];
-        let nread = reader.read(buf);
+        let nread = reader.read(&mut buf);
         assert_eq!(Ok(2), nread);
         let b: &[_] = &[0, 1];
         assert_eq!(buf.as_slice(), b);
 
         let mut buf = [0];
-        let nread = reader.read(buf);
+        let nread = reader.read(&mut buf);
         assert_eq!(Ok(1), nread);
         let b: &[_] = &[2];
         assert_eq!(buf.as_slice(), b);
 
         let mut buf = [0, 0, 0];
-        let nread = reader.read(buf);
+        let nread = reader.read(&mut buf);
         assert_eq!(Ok(1), nread);
         let b: &[_] = &[3, 0, 0];
         assert_eq!(buf.as_slice(), b);
 
-        let nread = reader.read(buf);
+        let nread = reader.read(&mut buf);
         assert_eq!(Ok(1), nread);
         let b: &[_] = &[4, 0, 0];
         assert_eq!(buf.as_slice(), b);
 
-        assert!(reader.read(buf).is_err());
+        assert!(reader.read(&mut buf).is_err());
     }
 
     #[test]
@@ -450,36 +450,36 @@ mod test {
         let inner = MemWriter::new();
         let mut writer = BufferedWriter::with_capacity(2, inner);
 
-        writer.write([0, 1]).unwrap();
+        writer.write(&[0, 1]).unwrap();
         let b: &[_] = &[];
         assert_eq!(writer.get_ref().get_ref(), b);
 
-        writer.write([2]).unwrap();
+        writer.write(&[2]).unwrap();
         let b: &[_] = &[0, 1];
         assert_eq!(writer.get_ref().get_ref(), b);
 
-        writer.write([3]).unwrap();
+        writer.write(&[3]).unwrap();
         assert_eq!(writer.get_ref().get_ref(), b);
 
         writer.flush().unwrap();
         let a: &[_] = &[0, 1, 2, 3];
         assert_eq!(a, writer.get_ref().get_ref());
 
-        writer.write([4]).unwrap();
-        writer.write([5]).unwrap();
+        writer.write(&[4]).unwrap();
+        writer.write(&[5]).unwrap();
         assert_eq!(a, writer.get_ref().get_ref());
 
-        writer.write([6]).unwrap();
+        writer.write(&[6]).unwrap();
         let a: &[_] = &[0, 1, 2, 3, 4, 5];
         assert_eq!(a,
                    writer.get_ref().get_ref());
 
-        writer.write([7, 8]).unwrap();
+        writer.write(&[7, 8]).unwrap();
         let a: &[_] = &[0, 1, 2, 3, 4, 5, 6];
         assert_eq!(a,
                    writer.get_ref().get_ref());
 
-        writer.write([9, 10, 11]).unwrap();
+        writer.write(&[9, 10, 11]).unwrap();
         let a: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
         assert_eq!(a,
                    writer.get_ref().get_ref());
@@ -492,7 +492,7 @@ mod test {
     #[test]
     fn test_buffered_writer_inner_flushes() {
         let mut w = BufferedWriter::with_capacity(3, MemWriter::new());
-        w.write([0, 1]).unwrap();
+        w.write(&[0, 1]).unwrap();
         let a: &[_] = &[];
         assert_eq!(a, w.get_ref().get_ref());
         let w = w.unwrap();
@@ -518,8 +518,8 @@ mod test {
 
         let mut stream = BufferedStream::new(S);
         let mut buf = [];
-        assert!(stream.read(buf).is_err());
-        stream.write(buf).unwrap();
+        assert!(stream.read(&mut buf).is_err());
+        stream.write(&buf).unwrap();
         stream.flush().unwrap();
     }
 
@@ -537,21 +537,21 @@ mod test {
     #[test]
     fn test_line_buffer() {
         let mut writer = LineBufferedWriter::new(MemWriter::new());
-        writer.write([0]).unwrap();
+        writer.write(&[0]).unwrap();
         let b: &[_] = &[];
         assert_eq!(writer.get_ref().get_ref(), b);
-        writer.write([1]).unwrap();
+        writer.write(&[1]).unwrap();
         assert_eq!(writer.get_ref().get_ref(), b);
         writer.flush().unwrap();
         let b: &[_] = &[0, 1];
         assert_eq!(writer.get_ref().get_ref(), b);
-        writer.write([0, b'\n', 1, b'\n', 2]).unwrap();
+        writer.write(&[0, b'\n', 1, b'\n', 2]).unwrap();
         let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n'];
         assert_eq!(writer.get_ref().get_ref(), b);
         writer.flush().unwrap();
         let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n', 2];
         assert_eq!(writer.get_ref().get_ref(), b);
-        writer.write([3, b'\n']).unwrap();
+        writer.write(&[3, b'\n']).unwrap();
         let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n', 2, 3, b'\n'];
         assert_eq!(writer.get_ref().get_ref(), b);
     }
@@ -582,26 +582,26 @@ mod test {
         let inner = ShortReader{lengths: vec![0, 1, 2, 0, 1, 0]};
         let mut reader = BufferedReader::new(inner);
         let mut buf = [0, 0];
-        assert_eq!(reader.read(buf), Ok(0));
-        assert_eq!(reader.read(buf), Ok(1));
-        assert_eq!(reader.read(buf), Ok(2));
-        assert_eq!(reader.read(buf), Ok(0));
-        assert_eq!(reader.read(buf), Ok(1));
-        assert_eq!(reader.read(buf), Ok(0));
-        assert!(reader.read(buf).is_err());
+        assert_eq!(reader.read(&mut buf), Ok(0));
+        assert_eq!(reader.read(&mut buf), Ok(1));
+        assert_eq!(reader.read(&mut buf), Ok(2));
+        assert_eq!(reader.read(&mut buf), Ok(0));
+        assert_eq!(reader.read(&mut buf), Ok(1));
+        assert_eq!(reader.read(&mut buf), Ok(0));
+        assert!(reader.read(&mut buf).is_err());
     }
 
     #[test]
     fn read_char_buffered() {
         let buf = [195u8, 159u8];
-        let mut reader = BufferedReader::with_capacity(1, BufReader::new(buf));
+        let mut reader = BufferedReader::with_capacity(1, BufReader::new(&buf));
         assert_eq!(reader.read_char(), Ok('ß'));
     }
 
     #[test]
     fn test_chars() {
         let buf = [195u8, 159u8, b'a'];
-        let mut reader = BufferedReader::with_capacity(1, BufReader::new(buf));
+        let mut reader = BufferedReader::with_capacity(1, BufReader::new(&buf));
         let mut it = reader.chars();
         assert_eq!(it.next(), Some(Ok('ß')));
         assert_eq!(it.next(), Some(Ok('a')));
diff --git a/src/libstd/io/comm_adapters.rs b/src/libstd/io/comm_adapters.rs
index c925208c3eee7..919c52f44442d 100644
--- a/src/libstd/io/comm_adapters.rs
+++ b/src/libstd/io/comm_adapters.rs
@@ -30,7 +30,7 @@ use vec::Vec;
 /// let mut reader = ChanReader::new(rx);
 ///
 /// let mut buf = [0u8, ..100];
-/// match reader.read(buf) {
+/// match reader.read(&mut buf) {
 ///     Ok(nread) => println!("Read {} bytes", nread),
 ///     Err(e) => println!("read error: {}", e),
 /// }
@@ -172,17 +172,17 @@ mod test {
         let mut reader = ChanReader::new(rx);
         let mut buf = [0u8, ..3];
 
-        assert_eq!(Ok(0), reader.read([]));
+        assert_eq!(Ok(0), reader.read(&mut []));
 
-        assert_eq!(Ok(3), reader.read(buf));
+        assert_eq!(Ok(3), reader.read(&mut buf));
         let a: &[u8] = &[1,2,3];
         assert_eq!(a, buf.as_slice());
 
-        assert_eq!(Ok(3), reader.read(buf));
+        assert_eq!(Ok(3), reader.read(&mut buf));
         let a: &[u8] = &[4,5,6];
         assert_eq!(a, buf.as_slice());
 
-        assert_eq!(Ok(2), reader.read(buf));
+        assert_eq!(Ok(2), reader.read(&mut buf));
         let a: &[u8] = &[7,8,6];
         assert_eq!(a, buf.as_slice());
 
diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs
index 6d0b8ebc3d9c4..0d180b4e9d6db 100644
--- a/src/libstd/io/extensions.rs
+++ b/src/libstd/io/extensions.rs
@@ -82,9 +82,9 @@ pub fn u64_to_le_bytes<T>(n: u64, size: uint, f: |v: &[u8]| -> T) -> T {
     assert!(size <= 8u);
     match size {
       1u => f(&[n as u8]),
-      2u => f(unsafe { transmute::<_, [u8, ..2]>((n as u16).to_le()) }),
-      4u => f(unsafe { transmute::<_, [u8, ..4]>((n as u32).to_le()) }),
-      8u => f(unsafe { transmute::<_, [u8, ..8]>(n.to_le()) }),
+      2u => f(unsafe { & transmute::<_, [u8, ..2]>((n as u16).to_le()) }),
+      4u => f(unsafe { & transmute::<_, [u8, ..4]>((n as u32).to_le()) }),
+      8u => f(unsafe { & transmute::<_, [u8, ..8]>(n.to_le()) }),
       _ => {
 
         let mut bytes = vec!();
@@ -121,9 +121,9 @@ pub fn u64_to_be_bytes<T>(n: u64, size: uint, f: |v: &[u8]| -> T) -> T {
     assert!(size <= 8u);
     match size {
       1u => f(&[n as u8]),
-      2u => f(unsafe { transmute::<_, [u8, ..2]>((n as u16).to_be()) }),
-      4u => f(unsafe { transmute::<_, [u8, ..4]>((n as u32).to_be()) }),
-      8u => f(unsafe { transmute::<_, [u8, ..8]>(n.to_be()) }),
+      2u => f(unsafe { & transmute::<_, [u8, ..2]>((n as u16).to_be()) }),
+      4u => f(unsafe { & transmute::<_, [u8, ..4]>((n as u32).to_be()) }),
+      8u => f(unsafe { & transmute::<_, [u8, ..8]>(n.to_be()) }),
       _ => {
         let mut bytes = vec!();
         let mut i = size;
@@ -474,26 +474,26 @@ mod test {
         let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09];
 
         // Aligned access
-        assert_eq!(u64_from_be_bytes(buf, 0, 0), 0);
-        assert_eq!(u64_from_be_bytes(buf, 0, 1), 0x01);
-        assert_eq!(u64_from_be_bytes(buf, 0, 2), 0x0102);
-        assert_eq!(u64_from_be_bytes(buf, 0, 3), 0x010203);
-        assert_eq!(u64_from_be_bytes(buf, 0, 4), 0x01020304);
-        assert_eq!(u64_from_be_bytes(buf, 0, 5), 0x0102030405);
-        assert_eq!(u64_from_be_bytes(buf, 0, 6), 0x010203040506);
-        assert_eq!(u64_from_be_bytes(buf, 0, 7), 0x01020304050607);
-        assert_eq!(u64_from_be_bytes(buf, 0, 8), 0x0102030405060708);
+        assert_eq!(u64_from_be_bytes(&buf, 0, 0), 0);
+        assert_eq!(u64_from_be_bytes(&buf, 0, 1), 0x01);
+        assert_eq!(u64_from_be_bytes(&buf, 0, 2), 0x0102);
+        assert_eq!(u64_from_be_bytes(&buf, 0, 3), 0x010203);
+        assert_eq!(u64_from_be_bytes(&buf, 0, 4), 0x01020304);
+        assert_eq!(u64_from_be_bytes(&buf, 0, 5), 0x0102030405);
+        assert_eq!(u64_from_be_bytes(&buf, 0, 6), 0x010203040506);
+        assert_eq!(u64_from_be_bytes(&buf, 0, 7), 0x01020304050607);
+        assert_eq!(u64_from_be_bytes(&buf, 0, 8), 0x0102030405060708);
 
         // Unaligned access
-        assert_eq!(u64_from_be_bytes(buf, 1, 0), 0);
-        assert_eq!(u64_from_be_bytes(buf, 1, 1), 0x02);
-        assert_eq!(u64_from_be_bytes(buf, 1, 2), 0x0203);
-        assert_eq!(u64_from_be_bytes(buf, 1, 3), 0x020304);
-        assert_eq!(u64_from_be_bytes(buf, 1, 4), 0x02030405);
-        assert_eq!(u64_from_be_bytes(buf, 1, 5), 0x0203040506);
-        assert_eq!(u64_from_be_bytes(buf, 1, 6), 0x020304050607);
-        assert_eq!(u64_from_be_bytes(buf, 1, 7), 0x02030405060708);
-        assert_eq!(u64_from_be_bytes(buf, 1, 8), 0x0203040506070809);
+        assert_eq!(u64_from_be_bytes(&buf, 1, 0), 0);
+        assert_eq!(u64_from_be_bytes(&buf, 1, 1), 0x02);
+        assert_eq!(u64_from_be_bytes(&buf, 1, 2), 0x0203);
+        assert_eq!(u64_from_be_bytes(&buf, 1, 3), 0x020304);
+        assert_eq!(u64_from_be_bytes(&buf, 1, 4), 0x02030405);
+        assert_eq!(u64_from_be_bytes(&buf, 1, 5), 0x0203040506);
+        assert_eq!(u64_from_be_bytes(&buf, 1, 6), 0x020304050607);
+        assert_eq!(u64_from_be_bytes(&buf, 1, 7), 0x02030405060708);
+        assert_eq!(u64_from_be_bytes(&buf, 1, 8), 0x0203040506070809);
     }
 }
 
diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index c8524676a6dd4..c16bb8c124391 100644
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -479,7 +479,7 @@ pub fn copy(from: &Path, to: &Path) -> IoResult<()> {
     let mut buf = [0, ..io::DEFAULT_BUF_SIZE];
 
     loop {
-        let amt = match reader.read(buf) {
+        let amt = match reader.read(&mut buf) {
             Ok(n) => n,
             Err(ref e) if e.kind == io::EndOfFile => { break }
             Err(e) => return update_err(Err(e), from, to)
@@ -1011,7 +1011,7 @@ mod test {
         {
             let mut read_stream = File::open_mode(filename, Open, Read);
             let mut read_buf = [0, .. 1028];
-            let read_str = match check!(read_stream.read(read_buf)) {
+            let read_str = match check!(read_stream.read(&mut read_buf)) {
                 -1|0 => panic!("shouldn't happen"),
                 n => str::from_utf8(read_buf[..n]).unwrap().to_string()
             };
@@ -1069,7 +1069,7 @@ mod test {
             }
         }
         check!(unlink(filename));
-        let read_str = str::from_utf8(read_mem).unwrap();
+        let read_str = str::from_utf8(&read_mem).unwrap();
         assert_eq!(read_str, message);
     }
 
@@ -1090,11 +1090,11 @@ mod test {
             let mut read_stream = File::open_mode(filename, Open, Read);
             check!(read_stream.seek(set_cursor as i64, SeekSet));
             tell_pos_pre_read = check!(read_stream.tell());
-            check!(read_stream.read(read_mem));
+            check!(read_stream.read(&mut read_mem));
             tell_pos_post_read = check!(read_stream.tell());
         }
         check!(unlink(filename));
-        let read_str = str::from_utf8(read_mem).unwrap();
+        let read_str = str::from_utf8(&read_mem).unwrap();
         assert_eq!(read_str, message.slice(4, 8));
         assert_eq!(tell_pos_pre_read, set_cursor);
         assert_eq!(tell_pos_post_read, message.len() as u64);
@@ -1117,10 +1117,10 @@ mod test {
         }
         {
             let mut read_stream = File::open_mode(filename, Open, Read);
-            check!(read_stream.read(read_mem));
+            check!(read_stream.read(&mut read_mem));
         }
         check!(unlink(filename));
-        let read_str = str::from_utf8(read_mem).unwrap();
+        let read_str = str::from_utf8(&read_mem).unwrap();
         assert!(read_str.as_slice() == final_msg.as_slice());
     }
 
@@ -1142,16 +1142,16 @@ mod test {
             let mut read_stream = File::open_mode(filename, Open, Read);
 
             check!(read_stream.seek(-4, SeekEnd));
-            check!(read_stream.read(read_mem));
-            assert_eq!(str::from_utf8(read_mem).unwrap(), chunk_three);
+            check!(read_stream.read(&mut read_mem));
+            assert_eq!(str::from_utf8(&read_mem).unwrap(), chunk_three);
 
             check!(read_stream.seek(-9, SeekCur));
-            check!(read_stream.read(read_mem));
-            assert_eq!(str::from_utf8(read_mem).unwrap(), chunk_two);
+            check!(read_stream.read(&mut read_mem));
+            assert_eq!(str::from_utf8(&read_mem).unwrap(), chunk_two);
 
             check!(read_stream.seek(0, SeekSet));
-            check!(read_stream.read(read_mem));
-            assert_eq!(str::from_utf8(read_mem).unwrap(), chunk_one);
+            check!(read_stream.read(&mut read_mem));
+            assert_eq!(str::from_utf8(&read_mem).unwrap(), chunk_one);
         }
         check!(unlink(filename));
     }
@@ -1237,8 +1237,8 @@ mod test {
         for f in files.iter() {
             {
                 let n = f.filestem_str();
-                check!(File::open(f).read(mem));
-                let read_str = str::from_utf8(mem).unwrap();
+                check!(File::open(f).read(&mut mem));
+                let read_str = str::from_utf8(&mem).unwrap();
                 let expected = match n {
                     None|Some("") => panic!("really shouldn't happen.."),
                     Some(n) => format!("{}{}", prefix, n),
@@ -1662,13 +1662,13 @@ mod test {
         use rand::{StdRng, Rng};
 
         let mut bytes = [0, ..1024];
-        StdRng::new().ok().unwrap().fill_bytes(bytes);
+        StdRng::new().ok().unwrap().fill_bytes(&mut bytes);
 
         let tmpdir = tmpdir();
 
-        check!(File::create(&tmpdir.join("test")).write(bytes));
+        check!(File::create(&tmpdir.join("test")).write(&bytes));
         let actual = check!(File::open(&tmpdir.join("test")).read_to_end());
-        assert!(actual.as_slice() == bytes);
+        assert!(actual.as_slice() == &bytes);
     }
 
     #[test]
diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index 6010436581764..dff391f209684 100644
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -50,7 +50,7 @@ fn combine(seek: SeekStyle, cur: uint, end: uint, offset: i64) -> IoResult<u64>
 /// use std::io::MemWriter;
 ///
 /// let mut w = MemWriter::new();
-/// w.write([0, 1, 2]);
+/// w.write(&[0, 1, 2]);
 ///
 /// assert_eq!(w.unwrap(), vec!(0, 1, 2));
 /// ```
@@ -200,10 +200,10 @@ impl Buffer for MemReader {
 ///
 /// let mut buf = [0, ..4];
 /// {
-///     let mut w = BufWriter::new(buf);
-///     w.write([0, 1, 2]);
+///     let mut w = BufWriter::new(&mut buf);
+///     w.write(&[0, 1, 2]);
 /// }
-/// assert!(buf == [0, 1, 2, 0]);
+/// assert!(buf == &[0, 1, 2, 0]);
 /// ```
 pub struct BufWriter<'a> {
     buf: &'a mut [u8],
@@ -262,7 +262,7 @@ impl<'a> Seek for BufWriter<'a> {
 /// use std::io::BufReader;
 ///
 /// let mut buf = [0, 1, 2, 3];
-/// let mut r = BufReader::new(buf);
+/// let mut r = BufReader::new(&mut buf);
 ///
 /// assert_eq!(r.read_to_end().unwrap(), vec!(0, 1, 2, 3));
 /// ```
@@ -346,9 +346,9 @@ mod test {
     #[test]
     fn test_mem_writer() {
         let mut writer = MemWriter::new();
-        writer.write([0]).unwrap();
-        writer.write([1, 2, 3]).unwrap();
-        writer.write([4, 5, 6, 7]).unwrap();
+        writer.write(&[0]).unwrap();
+        writer.write(&[1, 2, 3]).unwrap();
+        writer.write(&[4, 5, 6, 7]).unwrap();
         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
         assert_eq!(writer.get_ref(), b);
     }
@@ -357,14 +357,14 @@ mod test {
     fn test_buf_writer() {
         let mut buf = [0 as u8, ..8];
         {
-            let mut writer = BufWriter::new(buf);
+            let mut writer = BufWriter::new(&mut buf);
             assert_eq!(writer.tell(), Ok(0));
-            writer.write([0]).unwrap();
+            writer.write(&[0]).unwrap();
             assert_eq!(writer.tell(), Ok(1));
-            writer.write([1, 2, 3]).unwrap();
-            writer.write([4, 5, 6, 7]).unwrap();
+            writer.write(&[1, 2, 3]).unwrap();
+            writer.write(&[4, 5, 6, 7]).unwrap();
             assert_eq!(writer.tell(), Ok(8));
-            writer.write([]).unwrap();
+            writer.write(&[]).unwrap();
             assert_eq!(writer.tell(), Ok(8));
         }
         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
@@ -375,24 +375,24 @@ mod test {
     fn test_buf_writer_seek() {
         let mut buf = [0 as u8, ..8];
         {
-            let mut writer = BufWriter::new(buf);
+            let mut writer = BufWriter::new(&mut buf);
             assert_eq!(writer.tell(), Ok(0));
-            writer.write([1]).unwrap();
+            writer.write(&[1]).unwrap();
             assert_eq!(writer.tell(), Ok(1));
 
             writer.seek(2, SeekSet).unwrap();
             assert_eq!(writer.tell(), Ok(2));
-            writer.write([2]).unwrap();
+            writer.write(&[2]).unwrap();
             assert_eq!(writer.tell(), Ok(3));
 
             writer.seek(-2, SeekCur).unwrap();
             assert_eq!(writer.tell(), Ok(1));
-            writer.write([3]).unwrap();
+            writer.write(&[3]).unwrap();
             assert_eq!(writer.tell(), Ok(2));
 
             writer.seek(-1, SeekEnd).unwrap();
             assert_eq!(writer.tell(), Ok(7));
-            writer.write([4]).unwrap();
+            writer.write(&[4]).unwrap();
             assert_eq!(writer.tell(), Ok(8));
 
         }
@@ -403,10 +403,10 @@ mod test {
     #[test]
     fn test_buf_writer_error() {
         let mut buf = [0 as u8, ..2];
-        let mut writer = BufWriter::new(buf);
-        writer.write([0]).unwrap();
+        let mut writer = BufWriter::new(&mut buf);
+        writer.write(&[0]).unwrap();
 
-        match writer.write([0, 0]) {
+        match writer.write(&[0, 0]) {
             Ok(..) => panic!(),
             Err(e) => assert_eq!(e.kind, io::OtherIoError),
         }
@@ -416,26 +416,26 @@ mod test {
     fn test_mem_reader() {
         let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
         let mut buf = [];
-        assert_eq!(reader.read(buf), Ok(0));
+        assert_eq!(reader.read(&mut buf), Ok(0));
         assert_eq!(reader.tell(), Ok(0));
         let mut buf = [0];
-        assert_eq!(reader.read(buf), Ok(1));
+        assert_eq!(reader.read(&mut buf), Ok(1));
         assert_eq!(reader.tell(), Ok(1));
         let b: &[_] = &[0];
         assert_eq!(buf.as_slice(), b);
         let mut buf = [0, ..4];
-        assert_eq!(reader.read(buf), Ok(4));
+        assert_eq!(reader.read(&mut buf), Ok(4));
         assert_eq!(reader.tell(), Ok(5));
         let b: &[_] = &[1, 2, 3, 4];
         assert_eq!(buf.as_slice(), b);
-        assert_eq!(reader.read(buf), Ok(3));
+        assert_eq!(reader.read(&mut buf), Ok(3));
         let b: &[_] = &[5, 6, 7];
         assert_eq!(buf[0..3], b);
-        assert!(reader.read(buf).is_err());
+        assert!(reader.read(&mut buf).is_err());
         let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
         assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
         assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7));
-        assert!(reader.read(buf).is_err());
+        assert!(reader.read(&mut buf).is_err());
     }
 
     #[test]
@@ -443,26 +443,26 @@ mod test {
         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
         let mut reader = BufReader::new(in_buf.as_slice());
         let mut buf = [];
-        assert_eq!(reader.read(buf), Ok(0));
+        assert_eq!(reader.read(&mut buf), Ok(0));
         assert_eq!(reader.tell(), Ok(0));
         let mut buf = [0];
-        assert_eq!(reader.read(buf), Ok(1));
+        assert_eq!(reader.read(&mut buf), Ok(1));
         assert_eq!(reader.tell(), Ok(1));
         let b: &[_] = &[0];
         assert_eq!(buf.as_slice(), b);
         let mut buf = [0, ..4];
-        assert_eq!(reader.read(buf), Ok(4));
+        assert_eq!(reader.read(&mut buf), Ok(4));
         assert_eq!(reader.tell(), Ok(5));
         let b: &[_] = &[1, 2, 3, 4];
         assert_eq!(buf.as_slice(), b);
-        assert_eq!(reader.read(buf), Ok(3));
+        assert_eq!(reader.read(&mut buf), Ok(3));
         let b: &[_] = &[5, 6, 7];
         assert_eq!(buf[0..3], b);
-        assert!(reader.read(buf).is_err());
+        assert!(reader.read(&mut buf).is_err());
         let mut reader = BufReader::new(in_buf.as_slice());
         assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
         assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7));
-        assert!(reader.read(buf).is_err());
+        assert!(reader.read(&mut buf).is_err());
     }
 
     #[test]
@@ -506,7 +506,7 @@ mod test {
     #[test]
     fn test_read_whole_string_bad() {
         let buf = [0xff];
-        let mut r = BufReader::new(buf);
+        let mut r = BufReader::new(&buf);
         match r.read_to_string() {
             Ok(..) => panic!(),
             Err(..) => {}
@@ -516,7 +516,7 @@ mod test {
     #[test]
     fn seek_past_end() {
         let buf = [0xff];
-        let mut r = BufReader::new(buf);
+        let mut r = BufReader::new(&buf);
         r.seek(10, SeekSet).unwrap();
         assert!(r.read(&mut []).is_err());
 
@@ -525,22 +525,22 @@ mod test {
         assert!(r.read(&mut []).is_err());
 
         let mut buf = [0];
-        let mut r = BufWriter::new(buf);
+        let mut r = BufWriter::new(&mut buf);
         r.seek(10, SeekSet).unwrap();
-        assert!(r.write([3]).is_err());
+        assert!(r.write(&[3]).is_err());
     }
 
     #[test]
     fn seek_before_0() {
         let buf = [0xff];
-        let mut r = BufReader::new(buf);
+        let mut r = BufReader::new(&buf);
         assert!(r.seek(-1, SeekSet).is_err());
 
         let mut r = MemReader::new(vec!(10));
         assert!(r.seek(-1, SeekSet).is_err());
 
         let mut buf = [0];
-        let mut r = BufWriter::new(buf);
+        let mut r = BufWriter::new(&mut buf);
         assert!(r.seek(-1, SeekSet).is_err());
     }
 
@@ -548,15 +548,15 @@ mod test {
     fn io_read_at_least() {
         let mut r = MemReader::new(vec![1, 2, 3, 4, 5, 6, 7, 8]);
         let mut buf = [0, ..3];
-        assert!(r.read_at_least(buf.len(), buf).is_ok());
+        assert!(r.read_at_least(buf.len(), &mut buf).is_ok());
         let b: &[_] = &[1, 2, 3];
         assert_eq!(buf.as_slice(), b);
         assert!(r.read_at_least(0, buf[mut ..0]).is_ok());
         assert_eq!(buf.as_slice(), b);
-        assert!(r.read_at_least(buf.len(), buf).is_ok());
+        assert!(r.read_at_least(buf.len(), &mut buf).is_ok());
         let b: &[_] = &[4, 5, 6];
         assert_eq!(buf.as_slice(), b);
-        assert!(r.read_at_least(buf.len(), buf).is_err());
+        assert!(r.read_at_least(buf.len(), &mut buf).is_err());
         let b: &[_] = &[7, 8, 6];
         assert_eq!(buf.as_slice(), b);
     }
@@ -625,7 +625,7 @@ mod test {
                 let mut rdr = MemReader::new(buf);
                 for _i in range(0u, 10) {
                     let mut buf = [0 as u8, .. 10];
-                    rdr.read(buf).unwrap();
+                    rdr.read(&mut buf).unwrap();
                     assert_eq!(buf.as_slice(), [5, .. 10].as_slice());
                 }
             }
@@ -637,9 +637,9 @@ mod test {
         b.iter(|| {
             let mut buf = [0 as u8, ..100];
             {
-                let mut wr = BufWriter::new(buf);
+                let mut wr = BufWriter::new(&mut buf);
                 for _i in range(0u, 10) {
-                    wr.write([5, .. 10]).unwrap();
+                    wr.write(&[5, .. 10]).unwrap();
                 }
             }
             assert_eq!(buf.as_slice(), [5, .. 100].as_slice());
@@ -651,10 +651,10 @@ mod test {
         b.iter(|| {
             let buf = [5 as u8, ..100];
             {
-                let mut rdr = BufReader::new(buf);
+                let mut rdr = BufReader::new(&buf);
                 for _i in range(0u, 10) {
                     let mut buf = [0 as u8, .. 10];
-                    rdr.read(buf).unwrap();
+                    rdr.read(&mut buf).unwrap();
                     assert_eq!(buf.as_slice(), [5, .. 10].as_slice());
                 }
             }
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index ebf541a63dafa..791b0d1498921 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -613,7 +613,7 @@ pub trait Reader {
     /// Reads a single byte. Returns `Err` on EOF.
     fn read_byte(&mut self) -> IoResult<u8> {
         let mut buf = [0];
-        try!(self.read_at_least(1, buf));
+        try!(self.read_at_least(1, &mut buf));
         Ok(buf[0])
     }
 
@@ -1136,7 +1136,7 @@ pub trait Writer {
     /// that the `write` method is used specifically instead.
     #[inline]
     fn write_line(&mut self, s: &str) -> IoResult<()> {
-        self.write_str(s).and_then(|()| self.write([b'\n']))
+        self.write_str(s).and_then(|()| self.write(&[b'\n']))
     }
 
     /// Write a single char, encoded as UTF-8.
@@ -1292,13 +1292,13 @@ pub trait Writer {
     /// Write a u8 (1 byte).
     #[inline]
     fn write_u8(&mut self, n: u8) -> IoResult<()> {
-        self.write([n])
+        self.write(&[n])
     }
 
     /// Write an i8 (1 byte).
     #[inline]
     fn write_i8(&mut self, n: i8) -> IoResult<()> {
-        self.write([n as u8])
+        self.write(&[n as u8])
     }
 }
 
@@ -1997,7 +1997,7 @@ mod tests {
     fn test_read_at_least() {
         let mut r = BadReader::new(MemReader::new(b"hello, world!".to_vec()),
                                    vec![GoodBehavior(uint::MAX)]);
-        let mut buf = [0u8, ..5];
+        let buf = &mut [0u8, ..5];
         assert!(r.read_at_least(1, buf).unwrap() >= 1);
         assert!(r.read_exact(5).unwrap().len() == 5); // read_exact uses read_at_least
         assert!(r.read_at_least(0, buf).is_ok());
diff --git a/src/libstd/io/net/pipe.rs b/src/libstd/io/net/pipe.rs
index 8c7deadebea10..729aaa5b9cb26 100644
--- a/src/libstd/io/net/pipe.rs
+++ b/src/libstd/io/net/pipe.rs
@@ -50,7 +50,7 @@ impl UnixStream {
     ///
     /// let server = Path::new("path/to/my/socket");
     /// let mut stream = UnixStream::connect(&server);
-    /// stream.write([1, 2, 3]);
+    /// stream.write(&[1, 2, 3]);
     /// ```
     pub fn connect<P: ToCStr>(path: &P) -> IoResult<UnixStream> {
         LocalIo::maybe_raise(|io| {
@@ -170,7 +170,7 @@ impl UnixListener {
     /// let server = Path::new("/path/to/my/socket");
     /// let stream = UnixListener::bind(&server);
     /// for mut client in stream.listen().incoming() {
-    ///     client.write([1, 2, 3, 4]);
+    ///     client.write(&[1, 2, 3, 4]);
     /// }
     /// # }
     /// ```
@@ -310,10 +310,10 @@ mod tests {
     fn smoke() {
         smalltest(proc(mut server) {
             let mut buf = [0];
-            server.read(buf).unwrap();
+            server.read(&mut buf).unwrap();
             assert!(buf[0] == 99);
         }, proc(mut client) {
-            client.write([99]).unwrap();
+            client.write(&[99]).unwrap();
         })
     }
 
@@ -322,8 +322,8 @@ mod tests {
     fn read_eof() {
         smalltest(proc(mut server) {
             let mut buf = [0];
-            assert!(server.read(buf).is_err());
-            assert!(server.read(buf).is_err());
+            assert!(server.read(&mut buf).is_err());
+            assert!(server.read(&mut buf).is_err());
         }, proc(_client) {
             // drop the client
         })
@@ -334,7 +334,7 @@ mod tests {
         smalltest(proc(mut server) {
             let buf = [0];
             loop {
-                match server.write(buf) {
+                match server.write(&buf) {
                     Ok(..) => {}
                     Err(e) => {
                         assert!(e.kind == BrokenPipe ||
@@ -364,7 +364,7 @@ mod tests {
         spawn(proc() {
             for _ in range(0u, times) {
                 let mut stream = UnixStream::connect(&path2);
-                match stream.write([100]) {
+                match stream.write(&[100]) {
                     Ok(..) => {}
                     Err(e) => panic!("failed write: {}", e)
                 }
@@ -374,7 +374,7 @@ mod tests {
         for _ in range(0, times) {
             let mut client = acceptor.accept();
             let mut buf = [0];
-            match client.read(buf) {
+            match client.read(&mut buf) {
                 Ok(..) => {}
                 Err(e) => panic!("failed read/accept: {}", e),
             }
@@ -399,10 +399,10 @@ mod tests {
             let mut s = UnixStream::connect(&addr);
             let mut buf = [0, 0];
             debug!("client reading");
-            assert_eq!(s.read(buf), Ok(1));
+            assert_eq!(s.read(&mut buf), Ok(1));
             assert_eq!(buf[0], 1);
             debug!("client writing");
-            s.write([2]).unwrap();
+            s.write(&[2]).unwrap();
             debug!("client dropping");
         });
 
@@ -415,14 +415,14 @@ mod tests {
             let mut s2 = s2;
             rx1.recv();
             debug!("writer writing");
-            s2.write([1]).unwrap();
+            s2.write(&[1]).unwrap();
             debug!("writer done");
             tx2.send(());
         });
         tx1.send(());
         let mut buf = [0, 0];
         debug!("reader reading");
-        assert_eq!(s1.read(buf), Ok(1));
+        assert_eq!(s1.read(&mut buf), Ok(1));
         debug!("reader done");
         rx2.recv();
     }
@@ -436,9 +436,9 @@ mod tests {
 
         spawn(proc() {
             let mut s = UnixStream::connect(&addr);
-            s.write([1]).unwrap();
+            s.write(&[1]).unwrap();
             rx.recv();
-            s.write([2]).unwrap();
+            s.write(&[2]).unwrap();
             rx.recv();
         });
 
@@ -449,12 +449,12 @@ mod tests {
         spawn(proc() {
             let mut s2 = s2;
             let mut buf = [0, 0];
-            s2.read(buf).unwrap();
+            s2.read(&mut buf).unwrap();
             tx2.send(());
             done.send(());
         });
         let mut buf = [0, 0];
-        s1.read(buf).unwrap();
+        s1.read(&mut buf).unwrap();
         tx1.send(());
 
         rx.recv();
@@ -467,7 +467,7 @@ mod tests {
 
         spawn(proc() {
             let mut s = UnixStream::connect(&addr);
-            let mut buf = [0, 1];
+            let buf = &mut [0, 1];
             s.read(buf).unwrap();
             s.read(buf).unwrap();
         });
@@ -478,10 +478,10 @@ mod tests {
         let (tx, rx) = channel();
         spawn(proc() {
             let mut s2 = s2;
-            s2.write([1]).unwrap();
+            s2.write(&[1]).unwrap();
             tx.send(());
         });
-        s1.write([2]).unwrap();
+        s1.write(&[2]).unwrap();
 
         rx.recv();
     }
@@ -591,18 +591,18 @@ mod tests {
 
         // closing should prevent reads/writes
         s.close_write().unwrap();
-        assert!(s.write([0]).is_err());
+        assert!(s.write(&[0]).is_err());
         s.close_read().unwrap();
-        assert!(s.read(b).is_err());
+        assert!(s.read(&mut b).is_err());
 
         // closing should affect previous handles
-        assert!(s2.write([0]).is_err());
-        assert!(s2.read(b).is_err());
+        assert!(s2.write(&[0]).is_err());
+        assert!(s2.read(&mut b).is_err());
 
         // closing should affect new handles
         let mut s3 = s.clone();
-        assert!(s3.write([0]).is_err());
-        assert!(s3.read(b).is_err());
+        assert!(s3.write(&[0]).is_err());
+        assert!(s3.read(&mut b).is_err());
 
         // make sure these don't die
         let _ = s2.close_read();
@@ -627,7 +627,7 @@ mod tests {
         let (tx, rx) = channel();
         spawn(proc() {
             let mut s2 = s2;
-            assert!(s2.read([0]).is_err());
+            assert!(s2.read(&mut [0]).is_err());
             tx.send(());
         });
         // this should wake up the child task
@@ -645,18 +645,18 @@ mod tests {
         spawn(proc() {
             let mut s = UnixStream::connect(&addr).unwrap();
             rx.recv();
-            assert!(s.write([0]).is_ok());
+            assert!(s.write(&[0]).is_ok());
             let _ = rx.recv_opt();
         });
 
         let mut s = a.accept().unwrap();
         s.set_timeout(Some(20));
-        assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
-        assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
 
         s.set_timeout(Some(20));
         for i in range(0u, 1001) {
-            match s.write([0, .. 128 * 1024]) {
+            match s.write(&[0, .. 128 * 1024]) {
                 Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
                 Err(IoError { kind: TimedOut, .. }) => break,
                 Err(e) => panic!("{}", e),
@@ -667,12 +667,12 @@ mod tests {
         // I'm not sure as to why, but apparently the write on windows always
         // succeeds after the previous timeout. Who knows?
         if !cfg!(windows) {
-            assert_eq!(s.write([0]).err().unwrap().kind, TimedOut);
+            assert_eq!(s.write(&[0]).err().unwrap().kind, TimedOut);
         }
 
         tx.send(());
         s.set_timeout(None);
-        assert_eq!(s.read([0, 0]), Ok(1));
+        assert_eq!(s.read(&mut [0, 0]), Ok(1));
     }
 
     #[test]
@@ -685,7 +685,7 @@ mod tests {
             rx.recv();
             let mut amt = 0;
             while amt < 100 * 128 * 1024 {
-                match s.read([0, ..128 * 1024]) {
+                match s.read(&mut [0, ..128 * 1024]) {
                     Ok(n) => { amt += n; }
                     Err(e) => panic!("{}", e),
                 }
@@ -695,12 +695,12 @@ mod tests {
 
         let mut s = a.accept().unwrap();
         s.set_read_timeout(Some(20));
-        assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
-        assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
 
         tx.send(());
         for _ in range(0u, 100) {
-            assert!(s.write([0, ..128 * 1024]).is_ok());
+            assert!(s.write(&[0, ..128 * 1024]).is_ok());
         }
     }
 
@@ -712,14 +712,14 @@ mod tests {
         spawn(proc() {
             let mut s = UnixStream::connect(&addr).unwrap();
             rx.recv();
-            assert!(s.write([0]).is_ok());
+            assert!(s.write(&[0]).is_ok());
             let _ = rx.recv_opt();
         });
 
         let mut s = a.accept().unwrap();
         s.set_write_timeout(Some(20));
         for i in range(0u, 1001) {
-            match s.write([0, .. 128 * 1024]) {
+            match s.write(&[0, .. 128 * 1024]) {
                 Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
                 Err(IoError { kind: TimedOut, .. }) => break,
                 Err(e) => panic!("{}", e),
@@ -728,7 +728,7 @@ mod tests {
         }
 
         tx.send(());
-        assert!(s.read([0]).is_ok());
+        assert!(s.read(&mut [0]).is_ok());
     }
 
     #[test]
@@ -739,7 +739,7 @@ mod tests {
         spawn(proc() {
             let mut s = UnixStream::connect(&addr).unwrap();
             rx.recv();
-            assert!(s.write([0]).is_ok());
+            assert!(s.write(&[0]).is_ok());
             let _ = rx.recv_opt();
         });
 
@@ -748,12 +748,12 @@ mod tests {
         let (tx2, rx2) = channel();
         spawn(proc() {
             let mut s2 = s2;
-            assert!(s2.read([0]).is_ok());
+            assert!(s2.read(&mut [0]).is_ok());
             tx2.send(());
         });
 
         s.set_read_timeout(Some(20));
-        assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
         tx.send(());
 
         rx2.recv();
diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs
index 928c858673963..943d04333c099 100644
--- a/src/libstd/io/net/tcp.rs
+++ b/src/libstd/io/net/tcp.rs
@@ -44,9 +44,9 @@ use time::Duration;
 ///
 /// let mut stream = TcpStream::connect("127.0.0.1:34254");
 ///
-/// stream.write([1]);
+/// stream.write(&[1]);
 /// let mut buf = [0];
-/// stream.read(buf);
+/// stream.read(&mut buf);
 /// drop(stream); // close the connection
 /// ```
 pub struct TcpStream {
@@ -159,7 +159,7 @@ impl TcpStream {
     ///
     /// // wait for some data, will get canceled after one second
     /// let mut buf = [0];
-    /// stream.read(buf);
+    /// stream.read(&mut buf);
     /// ```
     ///
     /// Note that this method affects all cloned handles associated with this
@@ -512,12 +512,12 @@ mod test {
 
         spawn(proc() {
             let mut stream = TcpStream::connect(("localhost", socket_addr.port));
-            stream.write([144]).unwrap();
+            stream.write(&[144]).unwrap();
         });
 
         let mut stream = acceptor.accept();
         let mut buf = [0];
-        stream.read(buf).unwrap();
+        stream.read(&mut buf).unwrap();
         assert!(buf[0] == 144);
     }
 
@@ -528,12 +528,12 @@ mod test {
 
         spawn(proc() {
             let mut stream = TcpStream::connect(("localhost", addr.port));
-            stream.write([64]).unwrap();
+            stream.write(&[64]).unwrap();
         });
 
         let mut stream = acceptor.accept();
         let mut buf = [0];
-        stream.read(buf).unwrap();
+        stream.read(&mut buf).unwrap();
         assert!(buf[0] == 64);
     }
 
@@ -544,12 +544,12 @@ mod test {
 
         spawn(proc() {
             let mut stream = TcpStream::connect(("127.0.0.1", addr.port));
-            stream.write([44]).unwrap();
+            stream.write(&[44]).unwrap();
         });
 
         let mut stream = acceptor.accept();
         let mut buf = [0];
-        stream.read(buf).unwrap();
+        stream.read(&mut buf).unwrap();
         assert!(buf[0] == 44);
     }
 
@@ -560,12 +560,12 @@ mod test {
 
         spawn(proc() {
             let mut stream = TcpStream::connect(("::1", addr.port));
-            stream.write([66]).unwrap();
+            stream.write(&[66]).unwrap();
         });
 
         let mut stream = acceptor.accept();
         let mut buf = [0];
-        stream.read(buf).unwrap();
+        stream.read(&mut buf).unwrap();
         assert!(buf[0] == 66);
     }
 
@@ -576,12 +576,12 @@ mod test {
 
         spawn(proc() {
             let mut stream = TcpStream::connect(addr);
-            stream.write([99]).unwrap();
+            stream.write(&[99]).unwrap();
         });
 
         let mut stream = acceptor.accept();
         let mut buf = [0];
-        stream.read(buf).unwrap();
+        stream.read(&mut buf).unwrap();
         assert!(buf[0] == 99);
     }
 
@@ -592,12 +592,12 @@ mod test {
 
         spawn(proc() {
             let mut stream = TcpStream::connect(addr);
-            stream.write([99]).unwrap();
+            stream.write(&[99]).unwrap();
         });
 
         let mut stream = acceptor.accept();
         let mut buf = [0];
-        stream.read(buf).unwrap();
+        stream.read(&mut buf).unwrap();
         assert!(buf[0] == 99);
     }
 
@@ -613,7 +613,7 @@ mod test {
 
         let mut stream = acceptor.accept();
         let mut buf = [0];
-        let nread = stream.read(buf);
+        let nread = stream.read(&mut buf);
         assert!(nread.is_err());
     }
 
@@ -629,7 +629,7 @@ mod test {
 
         let mut stream = acceptor.accept();
         let mut buf = [0];
-        let nread = stream.read(buf);
+        let nread = stream.read(&mut buf);
         assert!(nread.is_err());
     }
 
@@ -645,10 +645,10 @@ mod test {
 
         let mut stream = acceptor.accept();
         let mut buf = [0];
-        let nread = stream.read(buf);
+        let nread = stream.read(&mut buf);
         assert!(nread.is_err());
 
-        match stream.read(buf) {
+        match stream.read(&mut buf) {
             Ok(..) => panic!(),
             Err(ref e) => {
                 assert!(e.kind == NotConnected || e.kind == EndOfFile,
@@ -669,10 +669,10 @@ mod test {
 
         let mut stream = acceptor.accept();
         let mut buf = [0];
-        let nread = stream.read(buf);
+        let nread = stream.read(&mut buf);
         assert!(nread.is_err());
 
-        match stream.read(buf) {
+        match stream.read(&mut buf) {
             Ok(..) => panic!(),
             Err(ref e) => {
                 assert!(e.kind == NotConnected || e.kind == EndOfFile,
@@ -694,7 +694,7 @@ mod test {
         let mut stream = acceptor.accept();
         let buf = [0];
         loop {
-            match stream.write(buf) {
+            match stream.write(&buf) {
                 Ok(..) => {}
                 Err(e) => {
                     assert!(e.kind == ConnectionReset ||
@@ -720,7 +720,7 @@ mod test {
         let mut stream = acceptor.accept();
         let buf = [0];
         loop {
-            match stream.write(buf) {
+            match stream.write(&buf) {
                 Ok(..) => {}
                 Err(e) => {
                     assert!(e.kind == ConnectionReset ||
@@ -742,13 +742,13 @@ mod test {
         spawn(proc() {
             for _ in range(0, max) {
                 let mut stream = TcpStream::connect(addr);
-                stream.write([99]).unwrap();
+                stream.write(&[99]).unwrap();
             }
         });
 
         for ref mut stream in acceptor.incoming().take(max) {
             let mut buf = [0];
-            stream.read(buf).unwrap();
+            stream.read(&mut buf).unwrap();
             assert_eq!(buf[0], 99);
         }
     }
@@ -762,13 +762,13 @@ mod test {
         spawn(proc() {
             for _ in range(0, max) {
                 let mut stream = TcpStream::connect(addr);
-                stream.write([99]).unwrap();
+                stream.write(&[99]).unwrap();
             }
         });
 
         for ref mut stream in acceptor.incoming().take(max) {
             let mut buf = [0];
-            stream.read(buf).unwrap();
+            stream.read(&mut buf).unwrap();
             assert_eq!(buf[0], 99);
         }
     }
@@ -786,7 +786,7 @@ mod test {
                 spawn(proc() {
                     let mut stream = stream;
                     let mut buf = [0];
-                    stream.read(buf).unwrap();
+                    stream.read(&mut buf).unwrap();
                     assert!(buf[0] == i as u8);
                     debug!("read");
                 });
@@ -804,7 +804,7 @@ mod test {
                 // Connect again before writing
                 connect(i + 1, addr);
                 debug!("writing");
-                stream.write([i as u8]).unwrap();
+                stream.write(&[i as u8]).unwrap();
             });
         }
     }
@@ -822,7 +822,7 @@ mod test {
                 spawn(proc() {
                     let mut stream = stream;
                     let mut buf = [0];
-                    stream.read(buf).unwrap();
+                    stream.read(&mut buf).unwrap();
                     assert!(buf[0] == i as u8);
                     debug!("read");
                 });
@@ -840,7 +840,7 @@ mod test {
                 // Connect again before writing
                 connect(i + 1, addr);
                 debug!("writing");
-                stream.write([i as u8]).unwrap();
+                stream.write(&[i as u8]).unwrap();
             });
         }
     }
@@ -858,7 +858,7 @@ mod test {
                 spawn(proc() {
                     let mut stream = stream;
                     let mut buf = [0];
-                    stream.read(buf).unwrap();
+                    stream.read(&mut buf).unwrap();
                     assert!(buf[0] == 99);
                     debug!("read");
                 });
@@ -876,7 +876,7 @@ mod test {
                 // Connect again before writing
                 connect(i + 1, addr);
                 debug!("writing");
-                stream.write([99]).unwrap();
+                stream.write(&[99]).unwrap();
             });
         }
     }
@@ -894,7 +894,7 @@ mod test {
                 spawn(proc() {
                     let mut stream = stream;
                     let mut buf = [0];
-                    stream.read(buf).unwrap();
+                    stream.read(&mut buf).unwrap();
                     assert!(buf[0] == 99);
                     debug!("read");
                 });
@@ -912,7 +912,7 @@ mod test {
                 // Connect again before writing
                 connect(i + 1, addr);
                 debug!("writing");
-                stream.write([99]).unwrap();
+                stream.write(&[99]).unwrap();
             });
         }
     }
@@ -968,17 +968,17 @@ mod test {
             let mut srv = TcpListener::bind(addr).listen().unwrap();
             tx.send(());
             let mut cl = srv.accept().unwrap();
-            cl.write([10]).unwrap();
+            cl.write(&[10]).unwrap();
             let mut b = [0];
-            cl.read(b).unwrap();
+            cl.read(&mut b).unwrap();
             tx.send(());
         });
 
         rx.recv();
         let mut c = TcpStream::connect(addr).unwrap();
         let mut b = [0, ..10];
-        assert_eq!(c.read(b), Ok(1));
-        c.write([1]).unwrap();
+        assert_eq!(c.read(&mut b), Ok(1));
+        c.write(&[1]).unwrap();
         rx.recv();
     }
 
@@ -1029,9 +1029,9 @@ mod test {
         spawn(proc() {
             let mut s = TcpStream::connect(addr);
             let mut buf = [0, 0];
-            assert_eq!(s.read(buf), Ok(1));
+            assert_eq!(s.read(&mut buf), Ok(1));
             assert_eq!(buf[0], 1);
-            s.write([2]).unwrap();
+            s.write(&[2]).unwrap();
         });
 
         let mut s1 = acceptor.accept().unwrap();
@@ -1042,12 +1042,12 @@ mod test {
         spawn(proc() {
             let mut s2 = s2;
             rx1.recv();
-            s2.write([1]).unwrap();
+            s2.write(&[1]).unwrap();
             tx2.send(());
         });
         tx1.send(());
         let mut buf = [0, 0];
-        assert_eq!(s1.read(buf), Ok(1));
+        assert_eq!(s1.read(&mut buf), Ok(1));
         rx2.recv();
     }
 
@@ -1060,9 +1060,9 @@ mod test {
 
         spawn(proc() {
             let mut s = TcpStream::connect(addr);
-            s.write([1]).unwrap();
+            s.write(&[1]).unwrap();
             rx.recv();
-            s.write([2]).unwrap();
+            s.write(&[2]).unwrap();
             rx.recv();
         });
 
@@ -1073,12 +1073,12 @@ mod test {
         spawn(proc() {
             let mut s2 = s2;
             let mut buf = [0, 0];
-            s2.read(buf).unwrap();
+            s2.read(&mut buf).unwrap();
             tx2.send(());
             done.send(());
         });
         let mut buf = [0, 0];
-        s1.read(buf).unwrap();
+        s1.read(&mut buf).unwrap();
         tx1.send(());
 
         rx.recv();
@@ -1092,8 +1092,8 @@ mod test {
         spawn(proc() {
             let mut s = TcpStream::connect(addr);
             let mut buf = [0, 1];
-            s.read(buf).unwrap();
-            s.read(buf).unwrap();
+            s.read(&mut buf).unwrap();
+            s.read(&mut buf).unwrap();
         });
 
         let mut s1 = acceptor.accept().unwrap();
@@ -1102,10 +1102,10 @@ mod test {
         let (done, rx) = channel();
         spawn(proc() {
             let mut s2 = s2;
-            s2.write([1]).unwrap();
+            s2.write(&[1]).unwrap();
             done.send(());
         });
-        s1.write([2]).unwrap();
+        s1.write(&[2]).unwrap();
 
         rx.recv();
     }
@@ -1120,12 +1120,12 @@ mod test {
             let mut a = a;
             let mut c = a.accept().unwrap();
             assert_eq!(c.read_to_end(), Ok(vec!()));
-            c.write([1]).unwrap();
+            c.write(&[1]).unwrap();
         });
 
         let mut s = TcpStream::connect(addr).unwrap();
         assert!(s.obj.close_write().is_ok());
-        assert!(s.write([1]).is_err());
+        assert!(s.write(&[1]).is_err());
         assert_eq!(s.read_to_end(), Ok(vec!(1)));
     }
 
@@ -1190,18 +1190,18 @@ mod test {
 
         // closing should prevent reads/writes
         s.close_write().unwrap();
-        assert!(s.write([0]).is_err());
+        assert!(s.write(&[0]).is_err());
         s.close_read().unwrap();
-        assert!(s.read(b).is_err());
+        assert!(s.read(&mut b).is_err());
 
         // closing should affect previous handles
-        assert!(s2.write([0]).is_err());
-        assert!(s2.read(b).is_err());
+        assert!(s2.write(&[0]).is_err());
+        assert!(s2.read(&mut b).is_err());
 
         // closing should affect new handles
         let mut s3 = s.clone();
-        assert!(s3.write([0]).is_err());
-        assert!(s3.read(b).is_err());
+        assert!(s3.write(&[0]).is_err());
+        assert!(s3.read(&mut b).is_err());
 
         // make sure these don't die
         let _ = s2.close_read();
@@ -1226,7 +1226,7 @@ mod test {
         let (tx, rx) = channel();
         spawn(proc() {
             let mut s2 = s2;
-            assert!(s2.read([0]).is_err());
+            assert!(s2.read(&mut [0]).is_err());
             tx.send(());
         });
         // this should wake up the child task
@@ -1244,29 +1244,29 @@ mod test {
         spawn(proc() {
             let mut s = TcpStream::connect(addr).unwrap();
             rx.recv();
-            assert!(s.write([0]).is_ok());
+            assert!(s.write(&[0]).is_ok());
             let _ = rx.recv_opt();
         });
 
         let mut s = a.accept().unwrap();
         s.set_timeout(Some(20));
-        assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
-        assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
 
         s.set_timeout(Some(20));
         for i in range(0i, 1001) {
-            match s.write([0, .. 128 * 1024]) {
+            match s.write(&[0, .. 128 * 1024]) {
                 Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
                 Err(IoError { kind: TimedOut, .. }) => break,
                 Err(e) => panic!("{}", e),
            }
            if i == 1000 { panic!("should have filled up?!"); }
         }
-        assert_eq!(s.write([0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.write(&[0]).err().unwrap().kind, TimedOut);
 
         tx.send(());
         s.set_timeout(None);
-        assert_eq!(s.read([0, 0]), Ok(1));
+        assert_eq!(s.read(&mut [0, 0]), Ok(1));
     }
 
     #[test]
@@ -1279,7 +1279,7 @@ mod test {
             rx.recv();
             let mut amt = 0;
             while amt < 100 * 128 * 1024 {
-                match s.read([0, ..128 * 1024]) {
+                match s.read(&mut [0, ..128 * 1024]) {
                     Ok(n) => { amt += n; }
                     Err(e) => panic!("{}", e),
                 }
@@ -1289,12 +1289,12 @@ mod test {
 
         let mut s = a.accept().unwrap();
         s.set_read_timeout(Some(20));
-        assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
-        assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
 
         tx.send(());
         for _ in range(0i, 100) {
-            assert!(s.write([0, ..128 * 1024]).is_ok());
+            assert!(s.write(&[0, ..128 * 1024]).is_ok());
         }
     }
 
@@ -1306,24 +1306,24 @@ mod test {
         spawn(proc() {
             let mut s = TcpStream::connect(addr).unwrap();
             rx.recv();
-            assert!(s.write([0]).is_ok());
+            assert!(s.write(&[0]).is_ok());
             let _ = rx.recv_opt();
         });
 
         let mut s = a.accept().unwrap();
         s.set_write_timeout(Some(20));
         for i in range(0i, 1001) {
-            match s.write([0, .. 128 * 1024]) {
+            match s.write(&[0, .. 128 * 1024]) {
                 Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
                 Err(IoError { kind: TimedOut, .. }) => break,
                 Err(e) => panic!("{}", e),
            }
            if i == 1000 { panic!("should have filled up?!"); }
         }
-        assert_eq!(s.write([0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.write(&[0]).err().unwrap().kind, TimedOut);
 
         tx.send(());
-        assert!(s.read([0]).is_ok());
+        assert!(s.read(&mut [0]).is_ok());
     }
 
     #[test]
@@ -1334,7 +1334,7 @@ mod test {
         spawn(proc() {
             let mut s = TcpStream::connect(addr).unwrap();
             rx.recv();
-            assert_eq!(s.write([0]), Ok(()));
+            assert_eq!(s.write(&[0]), Ok(()));
             let _ = rx.recv_opt();
         });
 
@@ -1343,12 +1343,12 @@ mod test {
         let (tx2, rx2) = channel();
         spawn(proc() {
             let mut s2 = s2;
-            assert_eq!(s2.read([0]), Ok(1));
+            assert_eq!(s2.read(&mut [0]), Ok(1));
             tx2.send(());
         });
 
         s.set_read_timeout(Some(20));
-        assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
         tx.send(());
 
         rx2.recv();
diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs
index 4ae054beadb96..4f999adc23467 100644
--- a/src/libstd/io/net/udp.rs
+++ b/src/libstd/io/net/udp.rs
@@ -47,7 +47,7 @@ use rt::rtio;
 ///     };
 ///
 ///     let mut buf = [0, ..10];
-///     match socket.recv_from(buf) {
+///     match socket.recv_from(&mut buf) {
 ///         Ok((amt, src)) => {
 ///             // Send a reply to the socket we received data from
 ///             let buf = buf[mut ..amt];
@@ -288,7 +288,7 @@ mod test {
             match UdpSocket::bind(client_ip) {
                 Ok(ref mut client) => {
                     rx1.recv();
-                    client.send_to([99], server_ip).unwrap()
+                    client.send_to(&[99], server_ip).unwrap()
                 }
                 Err(..) => panic!()
             }
@@ -299,7 +299,7 @@ mod test {
             Ok(ref mut server) => {
                 tx1.send(());
                 let mut buf = [0];
-                match server.recv_from(buf) {
+                match server.recv_from(&mut buf) {
                     Ok((nread, src)) => {
                         assert_eq!(nread, 1);
                         assert_eq!(buf[0], 99);
@@ -323,7 +323,7 @@ mod test {
             match UdpSocket::bind(client_ip) {
                 Ok(ref mut client) => {
                     rx.recv();
-                    client.send_to([99], server_ip).unwrap()
+                    client.send_to(&[99], server_ip).unwrap()
                 }
                 Err(..) => panic!()
             }
@@ -333,7 +333,7 @@ mod test {
             Ok(ref mut server) => {
                 tx.send(());
                 let mut buf = [0];
-                match server.recv_from(buf) {
+                match server.recv_from(&mut buf) {
                     Ok((nread, src)) => {
                         assert_eq!(nread, 1);
                         assert_eq!(buf[0], 99);
@@ -367,8 +367,8 @@ mod test {
                 }
             };
             rx1.recv();
-            send_as(dummy_ip, [98]);
-            send_as(client_ip, [99]);
+            send_as(dummy_ip, &[98]);
+            send_as(client_ip, &[99]);
             tx2.send(());
         });
 
@@ -378,7 +378,7 @@ mod test {
                 let mut stream = server.connect(client_ip);
                 tx1.send(());
                 let mut buf = [0];
-                match stream.read(buf) {
+                match stream.read(&mut buf) {
                     Ok(nread) => {
                         assert_eq!(nread, 1);
                         assert_eq!(buf[0], 99);
@@ -405,7 +405,7 @@ mod test {
                     let client = box client;
                     let mut stream = client.connect(server_ip);
                     rx1.recv();
-                    stream.write([99]).unwrap();
+                    stream.write(&[99]).unwrap();
                 }
                 Err(..) => panic!()
             }
@@ -418,7 +418,7 @@ mod test {
                 let mut stream = server.connect(client_ip);
                 tx1.send(());
                 let mut buf = [0];
-                match stream.read(buf) {
+                match stream.read(&mut buf) {
                     Ok(nread) => {
                         assert_eq!(nread, 1);
                         assert_eq!(buf[0], 99);
@@ -464,9 +464,9 @@ mod test {
         spawn(proc() {
             let mut sock2 = sock2;
             let mut buf = [0, 0];
-            assert_eq!(sock2.recv_from(buf), Ok((1, addr1)));
+            assert_eq!(sock2.recv_from(&mut buf), Ok((1, addr1)));
             assert_eq!(buf[0], 1);
-            sock2.send_to([2], addr1).unwrap();
+            sock2.send_to(&[2], addr1).unwrap();
         });
 
         let sock3 = sock1.clone();
@@ -476,12 +476,12 @@ mod test {
         spawn(proc() {
             let mut sock3 = sock3;
             rx1.recv();
-            sock3.send_to([1], addr2).unwrap();
+            sock3.send_to(&[1], addr2).unwrap();
             tx2.send(());
         });
         tx1.send(());
         let mut buf = [0, 0];
-        assert_eq!(sock1.recv_from(buf), Ok((1, addr2)));
+        assert_eq!(sock1.recv_from(&mut buf), Ok((1, addr2)));
         rx2.recv();
     }
 
@@ -496,9 +496,9 @@ mod test {
 
         spawn(proc() {
             let mut sock2 = sock2;
-            sock2.send_to([1], addr1).unwrap();
+            sock2.send_to(&[1], addr1).unwrap();
             rx.recv();
-            sock2.send_to([2], addr1).unwrap();
+            sock2.send_to(&[2], addr1).unwrap();
             rx.recv();
         });
 
@@ -508,12 +508,12 @@ mod test {
         spawn(proc() {
             let mut sock3 = sock3;
             let mut buf = [0, 0];
-            sock3.recv_from(buf).unwrap();
+            sock3.recv_from(&mut buf).unwrap();
             tx2.send(());
             done.send(());
         });
         let mut buf = [0, 0];
-        sock1.recv_from(buf).unwrap();
+        sock1.recv_from(&mut buf).unwrap();
         tx1.send(());
 
         rx.recv();
@@ -534,7 +534,7 @@ mod test {
             let mut buf = [0, 1];
 
             rx.recv();
-            match sock2.recv_from(buf) {
+            match sock2.recv_from(&mut buf) {
                 Ok(..) => {}
                 Err(e) => panic!("failed receive: {}", e),
             }
@@ -547,13 +547,13 @@ mod test {
         let tx2 = tx.clone();
         spawn(proc() {
             let mut sock3 = sock3;
-            match sock3.send_to([1], addr2) {
+            match sock3.send_to(&[1], addr2) {
                 Ok(..) => { let _ = tx2.send_opt(()); }
                 Err(..) => {}
             }
             done.send(());
         });
-        match sock1.send_to([2], addr2) {
+        match sock1.send_to(&[2], addr2) {
             Ok(..) => { let _ = tx.send_opt(()); }
             Err(..) => {}
         }
@@ -574,28 +574,28 @@ mod test {
         let (tx2, rx2) = channel();
         spawn(proc() {
             let mut a = UdpSocket::bind(addr2).unwrap();
-            assert_eq!(a.recv_from([0]), Ok((1, addr1)));
-            assert_eq!(a.send_to([0], addr1), Ok(()));
+            assert_eq!(a.recv_from(&mut [0]), Ok((1, addr1)));
+            assert_eq!(a.send_to(&[0], addr1), Ok(()));
             rx.recv();
-            assert_eq!(a.send_to([0], addr1), Ok(()));
+            assert_eq!(a.send_to(&[0], addr1), Ok(()));
 
             tx2.send(());
         });
 
         // Make sure that reads time out, but writes can continue
         a.set_read_timeout(Some(20));
-        assert_eq!(a.recv_from([0]).err().unwrap().kind, TimedOut);
-        assert_eq!(a.recv_from([0]).err().unwrap().kind, TimedOut);
-        assert_eq!(a.send_to([0], addr2), Ok(()));
+        assert_eq!(a.recv_from(&mut [0]).err().unwrap().kind, TimedOut);
+        assert_eq!(a.recv_from(&mut [0]).err().unwrap().kind, TimedOut);
+        assert_eq!(a.send_to(&[0], addr2), Ok(()));
 
         // Cloned handles should be able to block
         let mut a2 = a.clone();
-        assert_eq!(a2.recv_from([0]), Ok((1, addr2)));
+        assert_eq!(a2.recv_from(&mut [0]), Ok((1, addr2)));
 
         // Clearing the timeout should allow for receiving
         a.set_timeout(None);
         tx.send(());
-        assert_eq!(a2.recv_from([0]), Ok((1, addr2)));
+        assert_eq!(a2.recv_from(&mut [0]), Ok((1, addr2)));
 
         // Make sure the child didn't die
         rx2.recv();
@@ -610,7 +610,7 @@ mod test {
 
         a.set_write_timeout(Some(1000));
         for _ in range(0u, 100) {
-            match a.send_to([0, ..4*1024], addr2) {
+            match a.send_to(&[0, ..4*1024], addr2) {
                 Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
                 Err(IoError { kind: TimedOut, .. }) => break,
                 Err(e) => panic!("other error: {}", e),
diff --git a/src/libstd/io/pipe.rs b/src/libstd/io/pipe.rs
index c77cffd561e66..be2278dac77cc 100644
--- a/src/libstd/io/pipe.rs
+++ b/src/libstd/io/pipe.rs
@@ -131,12 +131,12 @@ mod test {
         let (tx, rx) = channel();
         spawn(proc() {
             let mut out = out;
-            out.write([10]).unwrap();
+            out.write(&[10]).unwrap();
             rx.recv(); // don't close the pipe until the other read has finished
         });
 
         let mut buf = [0, ..10];
-        input.read(buf).unwrap();
+        input.read(&mut buf).unwrap();
         tx.send(());
     }
 }
diff --git a/src/libstd/io/result.rs b/src/libstd/io/result.rs
index 40793d98ee3b8..ec856e662e33c 100644
--- a/src/libstd/io/result.rs
+++ b/src/libstd/io/result.rs
@@ -85,7 +85,7 @@ mod test {
     #[test]
     fn test_option_writer() {
         let mut writer: io::IoResult<MemWriter> = Ok(MemWriter::new());
-        writer.write([0, 1, 2]).unwrap();
+        writer.write(&[0, 1, 2]).unwrap();
         writer.flush().unwrap();
         assert_eq!(writer.unwrap().unwrap(), vec!(0, 1, 2));
     }
@@ -95,7 +95,7 @@ mod test {
         let mut writer: io::IoResult<MemWriter> =
             Err(io::standard_error(io::EndOfFile));
 
-        match writer.write([0, 0, 0]) {
+        match writer.write(&[0, 0, 0]) {
             Ok(..) => panic!(),
             Err(e) => assert_eq!(e.kind, io::EndOfFile),
         }
@@ -110,7 +110,7 @@ mod test {
         let mut reader: io::IoResult<MemReader> =
             Ok(MemReader::new(vec!(0, 1, 2, 3)));
         let mut buf = [0, 0];
-        reader.read(buf).unwrap();
+        reader.read(&mut buf).unwrap();
         let b: &[_] = &[0, 1];
         assert_eq!(buf.as_slice(), b);
     }
@@ -121,7 +121,7 @@ mod test {
             Err(io::standard_error(io::EndOfFile));
         let mut buf = [];
 
-        match reader.read(buf) {
+        match reader.read(&mut buf) {
             Ok(..) => panic!(),
             Err(e) => assert_eq!(e.kind, io::EndOfFile),
         }
diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs
index 5fd4faff6d250..7ad564690806c 100644
--- a/src/libstd/io/stdio.rs
+++ b/src/libstd/io/stdio.rs
@@ -239,7 +239,7 @@ pub fn print(s: &str) {
 /// `\n` character is printed to the console after the string.
 pub fn println(s: &str) {
     with_task_stdout(|io| {
-        io.write(s.as_bytes()).and_then(|()| io.write([b'\n']))
+        io.write(s.as_bytes()).and_then(|()| io.write(&[b'\n']))
     })
 }
 
diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs
index 5694565b4ea6a..ae4a4f0697508 100644
--- a/src/libstd/io/util.rs
+++ b/src/libstd/io/util.rs
@@ -225,7 +225,7 @@ impl<R: Reader, W: Writer> Reader for TeeReader<R, W> {
 pub fn copy<R: Reader, W: Writer>(r: &mut R, w: &mut W) -> io::IoResult<()> {
     let mut buf = [0, ..super::DEFAULT_BUF_SIZE];
     loop {
-        let len = match r.read(buf) {
+        let len = match r.read(&mut buf) {
             Ok(len) => len,
             Err(ref e) if e.kind == io::EndOfFile => return Ok(()),
             Err(e) => return Err(e),
@@ -352,7 +352,7 @@ mod test {
 
         let mut multi = MultiWriter::new(vec!(box TestWriter as Box<Writer>,
                                               box TestWriter as Box<Writer>));
-        multi.write([1, 2, 3]).unwrap();
+        multi.write(&[1, 2, 3]).unwrap();
         assert_eq!(2, unsafe { writes });
         assert_eq!(0, unsafe { flushes });
         multi.flush().unwrap();
@@ -413,25 +413,25 @@ mod test {
     fn test_iter_reader() {
         let mut r = IterReader::new(range(0u8, 8));
         let mut buf = [0, 0, 0];
-        let len = r.read(buf).unwrap();
+        let len = r.read(&mut buf).unwrap();
         assert_eq!(len, 3);
-        assert!(buf == [0, 1, 2]);
+        assert!(buf == &[0, 1, 2]);
 
-        let len = r.read(buf).unwrap();
+        let len = r.read(&mut buf).unwrap();
         assert_eq!(len, 3);
-        assert!(buf == [3, 4, 5]);
+        assert!(buf == &[3, 4, 5]);
 
-        let len = r.read(buf).unwrap();
+        let len = r.read(&mut buf).unwrap();
         assert_eq!(len, 2);
-        assert!(buf == [6, 7, 5]);
+        assert!(buf == &[6, 7, 5]);
 
-        assert_eq!(r.read(buf).unwrap_err().kind, io::EndOfFile);
+        assert_eq!(r.read(&mut buf).unwrap_err().kind, io::EndOfFile);
     }
 
     #[test]
     fn iter_reader_zero_length() {
         let mut r = IterReader::new(range(0u8, 8));
         let mut buf = [];
-        assert_eq!(Ok(0), r.read(buf));
+        assert_eq!(Ok(0), r.read(&mut buf));
     }
 }
diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs
index aa8e58bab0286..cf59184e3a521 100644
--- a/src/libstd/num/uint_macros.rs
+++ b/src/libstd/num/uint_macros.rs
@@ -54,7 +54,7 @@ pub fn to_str_bytes<U>(n: $T, radix: uint, f: |v: &[u8]| -> U) -> U {
     // base 2 number, and then we need another for a possible '-' character.
     let mut buf = [0u8, ..65];
     let amt = {
-        let mut wr = ::io::BufWriter::new(buf);
+        let mut wr = ::io::BufWriter::new(&mut buf);
         (write!(&mut wr, "{}", ::fmt::radix(n, radix as u8))).unwrap();
         wr.tell().unwrap() as uint
     };
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index 9846f7b653e2b..5b135876457fa 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -2106,7 +2106,7 @@ mod tests {
     fn memory_map_rw() {
         use result::{Ok, Err};
 
-        let chunk = match os::MemoryMap::new(16, [
+        let chunk = match os::MemoryMap::new(16, &[
             os::MapReadable,
             os::MapWritable
         ]) {
@@ -2153,7 +2153,7 @@ mod tests {
             "x".with_c_str(|x| assert!(write(fd, x as *const c_void, 1) == 1));
             fd
         };
-        let chunk = match MemoryMap::new(size / 2, [
+        let chunk = match MemoryMap::new(size / 2, &[
             MapReadable,
             MapWritable,
             MapFd(fd),
@@ -2182,16 +2182,16 @@ mod tests {
                 parsed.iter().map(|s| Path::new(*s)).collect()
         }
 
-        assert!(check_parse("", [""]));
-        assert!(check_parse(r#""""#, [""]));
-        assert!(check_parse(";;", ["", "", ""]));
-        assert!(check_parse(r"c:\", [r"c:\"]));
-        assert!(check_parse(r"c:\;", [r"c:\", ""]));
+        assert!(check_parse("", &mut [""]));
+        assert!(check_parse(r#""""#, &mut [""]));
+        assert!(check_parse(";;", &mut ["", "", ""]));
+        assert!(check_parse(r"c:\", &mut [r"c:\"]));
+        assert!(check_parse(r"c:\;", &mut [r"c:\", ""]));
         assert!(check_parse(r"c:\;c:\Program Files\",
-                            [r"c:\", r"c:\Program Files\"]));
-        assert!(check_parse(r#"c:\;c:\"foo"\"#, [r"c:\", r"c:\foo\"]));
+                            &mut [r"c:\", r"c:\Program Files\"]));
+        assert!(check_parse(r#"c:\;c:\"foo"\"#, &mut [r"c:\", r"c:\foo\"]));
         assert!(check_parse(r#"c:\;c:\"foo;bar"\;c:\baz"#,
-                            [r"c:\", r"c:\foo;bar\", r"c:\baz"]));
+                            &mut [r"c:\", r"c:\foo;bar\", r"c:\baz"]));
     }
 
     #[test]
@@ -2202,11 +2202,11 @@ mod tests {
                 parsed.iter().map(|s| Path::new(*s)).collect()
         }
 
-        assert!(check_parse("", [""]));
-        assert!(check_parse("::", ["", "", ""]));
-        assert!(check_parse("/", ["/"]));
-        assert!(check_parse("/:", ["/", ""]));
-        assert!(check_parse("/:/usr/local", ["/", "/usr/local"]));
+        assert!(check_parse("", &mut [""]));
+        assert!(check_parse("::", &mut ["", "", ""]));
+        assert!(check_parse("/", &mut ["/"]));
+        assert!(check_parse("/:", &mut ["/", ""]));
+        assert!(check_parse("/:/usr/local", &mut ["/", "/usr/local"]));
     }
 
     #[test]
@@ -2216,12 +2216,12 @@ mod tests {
             join_paths(input).unwrap().as_slice() == output.as_bytes()
         }
 
-        assert!(test_eq([], ""));
-        assert!(test_eq(["/bin", "/usr/bin", "/usr/local/bin"],
-                        "/bin:/usr/bin:/usr/local/bin"));
-        assert!(test_eq(["", "/bin", "", "", "/usr/bin", ""],
-                        ":/bin:::/usr/bin:"));
-        assert!(join_paths(["/te:st"]).is_err());
+        assert!(test_eq(&[], ""));
+        assert!(test_eq(&["/bin", "/usr/bin", "/usr/local/bin"],
+                         "/bin:/usr/bin:/usr/local/bin"));
+        assert!(test_eq(&["", "/bin", "", "", "/usr/bin", ""],
+                         ":/bin:::/usr/bin:"));
+        assert!(join_paths(&["/te:st"]).is_err());
     }
 
     #[test]
@@ -2238,7 +2238,7 @@ mod tests {
                         r";c:\windows;;;c:\;"));
         assert!(test_eq([r"c:\te;st", r"c:\"],
                         r#""c:\te;st";c:\"#));
-        assert!(join_paths([r#"c:\te"st"#]).is_err());
+        assert!(join_paths(&[r#"c:\te"st"#]).is_err());
     }
 
     // More recursive_mkdir tests are in extra::tempfile
diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
index 60cfa7a13de94..62606425dcb29 100644
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -463,7 +463,7 @@ mod tests {
 
     #[test]
     fn test_paths() {
-        let empty: &[u8] = [];
+        let empty: &[u8] = &[];
         t!(v: Path::new(empty), b".");
         t!(v: Path::new(b"/"), b"/");
         t!(v: Path::new(b"a/b/c"), b"a/b/c");
@@ -732,14 +732,14 @@ mod tests {
             (s: $path:expr, $push:expr, $exp:expr) => (
                 {
                     let mut p = Path::new($path);
-                    p.push_many($push);
+                    p.push_many(&$push);
                     assert!(p.as_str() == Some($exp));
                 }
             );
             (v: $path:expr, $push:expr, $exp:expr) => (
                 {
                     let mut p = Path::new($path);
-                    p.push_many($push);
+                    p.push_many(&$push);
                     assert!(p.as_vec() == $exp);
                 }
             )
@@ -837,14 +837,14 @@ mod tests {
             (s: $path:expr, $join:expr, $exp:expr) => (
                 {
                     let path = Path::new($path);
-                    let res = path.join_many($join);
+                    let res = path.join_many(&$join);
                     assert!(res.as_str() == Some($exp));
                 }
             );
             (v: $path:expr, $join:expr, $exp:expr) => (
                 {
                     let path = Path::new($path);
-                    let res = path.join_many($join);
+                    let res = path.join_many(&$join);
                     assert!(res.as_vec() == $exp);
                 }
             )
@@ -860,7 +860,7 @@ mod tests {
 
     #[test]
     fn test_with_helpers() {
-        let empty: &[u8] = [];
+        let empty: &[u8] = &[];
 
         t!(v: Path::new(b"a/b/c").with_filename(b"d"), b"a/b/d");
         t!(v: Path::new(b"a/b/c\xFF").with_filename(b"\x80"), b"a/b/\x80");
@@ -1174,7 +1174,7 @@ mod tests {
                 {
                     let path = Path::new($path);
                     let comps = path.components().collect::<Vec<&[u8]>>();
-                    let exp: &[&str] = $exp;
+                    let exp: &[&str] = &$exp;
                     let exps = exp.iter().map(|x| x.as_bytes()).collect::<Vec<&[u8]>>();
                     assert!(comps == exps, "components: Expected {}, found {}",
                             comps, exps);
@@ -1188,7 +1188,7 @@ mod tests {
                 {
                     let path = Path::new($arg);
                     let comps = path.components().collect::<Vec<&[u8]>>();
-                    let exp: &[&[u8]] = [$($exp),*];
+                    let exp: &[&[u8]] = &[$($exp),*];
                     assert_eq!(comps.as_slice(), exp);
                     let comps = path.components().rev().collect::<Vec<&[u8]>>();
                     let exp = exp.iter().rev().map(|&x|x).collect::<Vec<&[u8]>>();
@@ -1220,7 +1220,7 @@ mod tests {
                 {
                     let path = Path::new($arg);
                     let comps = path.str_components().collect::<Vec<Option<&str>>>();
-                    let exp: &[Option<&str>] = $exp;
+                    let exp: &[Option<&str>] = &$exp;
                     assert_eq!(comps.as_slice(), exp);
                     let comps = path.str_components().rev().collect::<Vec<Option<&str>>>();
                     let exp = exp.iter().rev().map(|&x|x).collect::<Vec<Option<&str>>>();
diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs
index 3ef142a2e824c..7ad02c0a7d9b5 100644
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/path/windows.rs
@@ -1196,7 +1196,7 @@ mod tests {
 
     #[test]
     fn test_paths() {
-        let empty: &[u8] = [];
+        let empty: &[u8] = &[];
         t!(v: Path::new(empty), b".");
         t!(v: Path::new(b"\\"), b"\\");
         t!(v: Path::new(b"a\\b\\c"), b"a\\b\\c");
@@ -1572,14 +1572,14 @@ mod tests {
             (s: $path:expr, $push:expr, $exp:expr) => (
                 {
                     let mut p = Path::new($path);
-                    p.push_many($push);
+                    p.push_many(&$push);
                     assert_eq!(p.as_str(), Some($exp));
                 }
             );
             (v: $path:expr, $push:expr, $exp:expr) => (
                 {
                     let mut p = Path::new($path);
-                    p.push_many($push);
+                    p.push_many(&$push);
                     assert_eq!(p.as_vec(), $exp);
                 }
             )
@@ -1713,14 +1713,14 @@ mod tests {
             (s: $path:expr, $join:expr, $exp:expr) => (
                 {
                     let path = Path::new($path);
-                    let res = path.join_many($join);
+                    let res = path.join_many(&$join);
                     assert_eq!(res.as_str(), Some($exp));
                 }
             );
             (v: $path:expr, $join:expr, $exp:expr) => (
                 {
                     let path = Path::new($path);
-                    let res = path.join_many($join);
+                    let res = path.join_many(&$join);
                     assert_eq!(res.as_vec(), $exp);
                 }
             )
@@ -2253,7 +2253,7 @@ mod tests {
                     let path = Path::new($path);
                     let comps = path.str_components().map(|x|x.unwrap())
                                 .collect::<Vec<&str>>();
-                    let exp: &[&str] = $exp;
+                    let exp: &[&str] = &$exp;
                     assert_eq!(comps.as_slice(), exp);
                     let comps = path.str_components().rev().map(|x|x.unwrap())
                                 .collect::<Vec<&str>>();
@@ -2310,7 +2310,7 @@ mod tests {
                 {
                     let path = Path::new($path);
                     let comps = path.components().collect::<Vec<&[u8]>>();
-                    let exp: &[&[u8]] = $exp;
+                    let exp: &[&[u8]] = &$exp;
                     assert_eq!(comps.as_slice(), exp);
                     let comps = path.components().rev().collect::<Vec<&[u8]>>();
                     let exp = exp.iter().rev().map(|&x|x).collect::<Vec<&[u8]>>();
diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index 21e531d211a85..17561f4b22860 100644
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -518,7 +518,7 @@ mod test {
     #[test]
     fn test_choose() {
         let mut r = task_rng();
-        assert_eq!(r.choose([1i, 1, 1]).map(|&x|x), Some(1));
+        assert_eq!(r.choose(&[1i, 1, 1]).map(|&x|x), Some(1));
 
         let v: &[int] = &[];
         assert_eq!(r.choose(v), None);
@@ -530,16 +530,16 @@ mod test {
         let empty: &mut [int] = &mut [];
         r.shuffle(empty);
         let mut one = [1i];
-        r.shuffle(one);
+        r.shuffle(&mut one);
         let b: &[_] = &[1];
         assert_eq!(one.as_slice(), b);
 
         let mut two = [1i, 2];
-        r.shuffle(two);
-        assert!(two == [1, 2] || two == [2, 1]);
+        r.shuffle(&mut two);
+        assert!(two == &[1, 2] || two == &[2, 1]);
 
         let mut x = [1i, 1, 1];
-        r.shuffle(x);
+        r.shuffle(&mut x);
         let b: &[_] = &[1, 1, 1];
         assert_eq!(x.as_slice(), b);
     }
@@ -549,7 +549,7 @@ mod test {
         let mut r = task_rng();
         r.gen::<int>();
         let mut v = [1i, 1, 1];
-        r.shuffle(v);
+        r.shuffle(&mut v);
         let b: &[_] = &[1, 1, 1];
         assert_eq!(v.as_slice(), b);
         assert_eq!(r.gen_range(0u, 1u), 0u);
@@ -669,7 +669,7 @@ mod bench {
     #[bench]
     fn rand_shuffle_100(b: &mut Bencher) {
         let mut rng = weak_rng();
-        let x : &mut[uint] = [1,..100];
+        let x : &mut[uint] = &mut [1,..100];
         b.iter(|| {
             rng.shuffle(x);
         })
diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs
index b7b0858123042..4bb02410a90ee 100644
--- a/src/libstd/rand/os.rs
+++ b/src/libstd/rand/os.rs
@@ -239,7 +239,7 @@ mod test {
         r.next_u64();
 
         let mut v = [0u8, .. 1000];
-        r.fill_bytes(v);
+        r.fill_bytes(&mut v);
     }
 
     #[test]
@@ -264,7 +264,7 @@ mod test {
                     task::deschedule();
                     r.next_u64();
                     task::deschedule();
-                    r.fill_bytes(v);
+                    r.fill_bytes(&mut v);
                     task::deschedule();
                 }
             })
diff --git a/src/libstd/rand/reader.rs b/src/libstd/rand/reader.rs
index c1bb6970f7150..c217b37390911 100644
--- a/src/libstd/rand/reader.rs
+++ b/src/libstd/rand/reader.rs
@@ -107,9 +107,9 @@ mod test {
         let mut w = [0u8, .. 8];
 
         let mut rng = ReaderRng::new(MemReader::new(v.as_slice().to_vec()));
-        rng.fill_bytes(w);
+        rng.fill_bytes(&mut w);
 
-        assert!(v == w);
+        assert!(v == &w);
     }
 
     #[test]
@@ -117,6 +117,6 @@ mod test {
     fn test_reader_rng_insufficient_bytes() {
         let mut rng = ReaderRng::new(MemReader::new(vec!()));
         let mut v = [0u8, .. 3];
-        rng.fill_bytes(v);
+        rng.fill_bytes(&mut v);
     }
 }
diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs
index 5d7aa0509c5d8..3f68694800c9d 100644
--- a/src/libstd/rt/backtrace.rs
+++ b/src/libstd/rt/backtrace.rs
@@ -528,7 +528,7 @@ mod imp {
             Some(string) => try!(super::demangle(w, string)),
             None => try!(write!(w, "<unknown>")),
         }
-        w.write(['\n' as u8])
+        w.write(&['\n' as u8])
     }
 
     /// Unwind library interface used for backtraces
diff --git a/src/libsyntax/ext/deriving/decodable.rs b/src/libsyntax/ext/deriving/decodable.rs
index fd24f5e35a446..9e4dbf930dbae 100644
--- a/src/libsyntax/ext/deriving/decodable.rs
+++ b/src/libsyntax/ext/deriving/decodable.rs
@@ -136,6 +136,7 @@ fn decodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
                                                   cx.expr_ident(trait_span, variant), arms));
             let lambda = cx.lambda_expr(trait_span, vec!(blkarg, variant), result);
             let variant_vec = cx.expr_vec(trait_span, variants);
+            let variant_vec = cx.expr_addr_of(trait_span, variant_vec);
             let result = cx.expr_method_call(trait_span, blkdecoder,
                                              cx.ident_of("read_enum_variant"),
                                              vec!(variant_vec, lambda));
diff --git a/src/libsyntax/ext/format.rs b/src/libsyntax/ext/format.rs
index 486ce910e2b6f..f6b29da38c0a0 100644
--- a/src/libsyntax/ext/format.rs
+++ b/src/libsyntax/ext/format.rs
@@ -14,7 +14,7 @@ use ext::base::*;
 use ext::base;
 use ext::build::AstBuilder;
 use fmt_macros as parse;
-use parse::token::InternedString;
+use parse::token::{InternedString, special_idents};
 use parse::token;
 use ptr::P;
 
@@ -476,12 +476,11 @@ impl<'a, 'b> Context<'a, 'b> {
                          pieces: Vec<P<ast::Expr>>)
                          -> P<ast::Stmt> {
         let fmtsp = piece_ty.span;
-        let pieces_len = ecx.expr_uint(fmtsp, pieces.len());
         let fmt = ecx.expr_vec(fmtsp, pieces);
-        let ty = ast::TyFixedLengthVec(
-            piece_ty,
-            pieces_len
-        );
+        let fmt = ecx.expr_addr_of(fmtsp, fmt);
+        let ty = ast::TyVec(piece_ty);
+        let ty = ast::TyRptr(Some(ecx.lifetime(fmtsp, special_idents::static_lifetime.name)),
+                             ast::MutTy{ mutbl: ast::MutImmutable, ty: ecx.ty(fmtsp, ty) });
         let ty = ecx.ty(fmtsp, ty);
         let st = ast::ItemStatic(ty, ast::MutImmutable, fmt);
         let item = ecx.item(fmtsp, name, Context::static_attrs(ecx, fmtsp), st);
diff --git a/src/libsyntax/util/interner.rs b/src/libsyntax/util/interner.rs
index 105118ff76a9d..abd618a6bf9b1 100644
--- a/src/libsyntax/util/interner.rs
+++ b/src/libsyntax/util/interner.rs
@@ -247,7 +247,7 @@ mod tests {
 
     #[test]
     fn i3 () {
-        let i : Interner<RcStr> = Interner::prefill([
+        let i : Interner<RcStr> = Interner::prefill(&[
             RcStr::new("Alan"),
             RcStr::new("Bob"),
             RcStr::new("Carol")
diff --git a/src/libterm/terminfo/mod.rs b/src/libterm/terminfo/mod.rs
index 416be0e70508a..0b5092a64d0f3 100644
--- a/src/libterm/terminfo/mod.rs
+++ b/src/libterm/terminfo/mod.rs
@@ -81,7 +81,7 @@ impl<T: Writer+Send> Terminal<T> for TerminfoTerminal<T> {
                                .find_equiv("setaf")
                                .unwrap()
                                .as_slice(),
-                           [Number(color as int)], &mut Variables::new());
+                           &[Number(color as int)], &mut Variables::new());
             if s.is_ok() {
                 try!(self.out.write(s.unwrap().as_slice()));
                 return Ok(true)
@@ -98,7 +98,7 @@ impl<T: Writer+Send> Terminal<T> for TerminfoTerminal<T> {
                                .find_equiv("setab")
                                .unwrap()
                                .as_slice(),
-                           [Number(color as int)], &mut Variables::new());
+                           &[Number(color as int)], &mut Variables::new());
             if s.is_ok() {
                 try!(self.out.write(s.unwrap().as_slice()));
                 return Ok(true)
@@ -116,7 +116,7 @@ impl<T: Writer+Send> Terminal<T> for TerminfoTerminal<T> {
                 let parm = self.ti.strings.find_equiv(cap);
                 if parm.is_some() {
                     let s = expand(parm.unwrap().as_slice(),
-                                   [],
+                                   &[],
                                    &mut Variables::new());
                     if s.is_ok() {
                         try!(self.out.write(s.unwrap().as_slice()));
@@ -151,7 +151,7 @@ impl<T: Writer+Send> Terminal<T> for TerminfoTerminal<T> {
             }
         }
         let s = cap.map_or(Err("can't find terminfo capability `sgr0`".to_string()), |op| {
-            expand(op.as_slice(), [], &mut Variables::new())
+            expand(op.as_slice(), &[], &mut Variables::new())
         });
         if s.is_ok() {
             return self.out.write(s.unwrap().as_slice())
diff --git a/src/libterm/terminfo/parm.rs b/src/libterm/terminfo/parm.rs
index 5a0f10ce52072..b492a5321ce07 100644
--- a/src/libterm/terminfo/parm.rs
+++ b/src/libterm/terminfo/parm.rs
@@ -581,13 +581,13 @@ mod test {
     #[test]
     fn test_basic_setabf() {
         let s = b"\\E[48;5;%p1%dm";
-        assert_eq!(expand(s, [Number(1)], &mut Variables::new()).unwrap(),
+        assert_eq!(expand(s, &[Number(1)], &mut Variables::new()).unwrap(),
                    "\\E[48;5;1m".bytes().collect());
     }
 
     #[test]
     fn test_multiple_int_constants() {
-        assert_eq!(expand(b"%{1}%{2}%d%d", [], &mut Variables::new()).unwrap(),
+        assert_eq!(expand(b"%{1}%{2}%d%d", &[], &mut Variables::new()).unwrap(),
                    "21".bytes().collect());
     }
 
@@ -595,9 +595,9 @@ mod test {
     fn test_op_i() {
         let mut vars = Variables::new();
         assert_eq!(expand(b"%p1%d%p2%d%p3%d%i%p1%d%p2%d%p3%d",
-                          [Number(1),Number(2),Number(3)], &mut vars),
+                          &[Number(1),Number(2),Number(3)], &mut vars),
                    Ok("123233".bytes().collect()));
-        assert_eq!(expand(b"%p1%d%p2%d%i%p1%d%p2%d", [], &mut vars),
+        assert_eq!(expand(b"%p1%d%p2%d%i%p1%d%p2%d", &[], &mut vars),
                    Ok("0011".bytes().collect()));
     }
 
@@ -615,7 +615,7 @@ mod test {
 
         let caps = ["%d", "%c", "%s", "%Pa", "%l", "%!", "%~"];
         for &cap in caps.iter() {
-            let res = get_res("", cap, [], vars);
+            let res = get_res("", cap, &[], vars);
             assert!(res.is_err(),
                     "Op {} succeeded incorrectly with 0 stack entries", cap);
             let p = if cap == "%s" || cap == "%l" {
@@ -623,19 +623,19 @@ mod test {
             } else {
                 Number(97)
             };
-            let res = get_res("%p1", cap, [p], vars);
+            let res = get_res("%p1", cap, &[p], vars);
             assert!(res.is_ok(),
                     "Op {} failed with 1 stack entry: {}", cap, res.unwrap_err());
         }
         let caps = ["%+", "%-", "%*", "%/", "%m", "%&", "%|", "%A", "%O"];
         for &cap in caps.iter() {
-            let res = expand(cap.as_bytes(), [], vars);
+            let res = expand(cap.as_bytes(), &[], vars);
             assert!(res.is_err(),
                     "Binop {} succeeded incorrectly with 0 stack entries", cap);
-            let res = get_res("%{1}", cap, [], vars);
+            let res = get_res("%{1}", cap, &[], vars);
             assert!(res.is_err(),
                     "Binop {} succeeded incorrectly with 1 stack entry", cap);
-            let res = get_res("%{1}%{2}", cap, [], vars);
+            let res = get_res("%{1}%{2}", cap, &[], vars);
             assert!(res.is_ok(),
                     "Binop {} failed with 2 stack entries: {}", cap, res.unwrap_err());
         }
@@ -643,7 +643,7 @@ mod test {
 
     #[test]
     fn test_push_bad_param() {
-        assert!(expand(b"%pa", [], &mut Variables::new()).is_err());
+        assert!(expand(b"%pa", &[], &mut Variables::new()).is_err());
     }
 
     #[test]
@@ -651,15 +651,15 @@ mod test {
         let v = [('<', [1u8, 0u8, 0u8]), ('=', [0u8, 1u8, 0u8]), ('>', [0u8, 0u8, 1u8])];
         for &(op, bs) in v.iter() {
             let s = format!("%{{1}}%{{2}}%{}%d", op);
-            let res = expand(s.as_bytes(), [], &mut Variables::new());
+            let res = expand(s.as_bytes(), &[], &mut Variables::new());
             assert!(res.is_ok(), res.unwrap_err());
             assert_eq!(res.unwrap(), vec!(b'0' + bs[0]));
             let s = format!("%{{1}}%{{1}}%{}%d", op);
-            let res = expand(s.as_bytes(), [], &mut Variables::new());
+            let res = expand(s.as_bytes(), &[], &mut Variables::new());
             assert!(res.is_ok(), res.unwrap_err());
             assert_eq!(res.unwrap(), vec!(b'0' + bs[1]));
             let s = format!("%{{2}}%{{1}}%{}%d", op);
-            let res = expand(s.as_bytes(), [], &mut Variables::new());
+            let res = expand(s.as_bytes(), &[], &mut Variables::new());
             assert!(res.is_ok(), res.unwrap_err());
             assert_eq!(res.unwrap(), vec!(b'0' + bs[2]));
         }
@@ -669,15 +669,15 @@ mod test {
     fn test_conditionals() {
         let mut vars = Variables::new();
         let s = b"\\E[%?%p1%{8}%<%t3%p1%d%e%p1%{16}%<%t9%p1%{8}%-%d%e38;5;%p1%d%;m";
-        let res = expand(s, [Number(1)], &mut vars);
+        let res = expand(s, &[Number(1)], &mut vars);
         assert!(res.is_ok(), res.unwrap_err());
         assert_eq!(res.unwrap(),
                    "\\E[31m".bytes().collect());
-        let res = expand(s, [Number(8)], &mut vars);
+        let res = expand(s, &[Number(8)], &mut vars);
         assert!(res.is_ok(), res.unwrap_err());
         assert_eq!(res.unwrap(),
                    "\\E[90m".bytes().collect());
-        let res = expand(s, [Number(42)], &mut vars);
+        let res = expand(s, &[Number(42)], &mut vars);
         assert!(res.is_ok(), res.unwrap_err());
         assert_eq!(res.unwrap(),
                    "\\E[38;5;42m".bytes().collect());
@@ -688,17 +688,17 @@ mod test {
         let mut varstruct = Variables::new();
         let vars = &mut varstruct;
         assert_eq!(expand(b"%p1%s%p2%2s%p3%2s%p4%.2s",
-                          [Words("foo".to_string()),
-                           Words("foo".to_string()),
-                           Words("f".to_string()),
-                           Words("foo".to_string())], vars),
+                          &[Words("foo".to_string()),
+                            Words("foo".to_string()),
+                            Words("f".to_string()),
+                            Words("foo".to_string())], vars),
                    Ok("foofoo ffo".bytes().collect()));
-        assert_eq!(expand(b"%p1%:-4.2s", [Words("foo".to_string())], vars),
+        assert_eq!(expand(b"%p1%:-4.2s", &[Words("foo".to_string())], vars),
                    Ok("fo  ".bytes().collect()));
 
-        assert_eq!(expand(b"%p1%d%p1%.3d%p1%5d%p1%:+d", [Number(1)], vars),
+        assert_eq!(expand(b"%p1%d%p1%.3d%p1%5d%p1%:+d", &[Number(1)], vars),
                    Ok("1001    1+1".bytes().collect()));
-        assert_eq!(expand(b"%p1%o%p1%#o%p2%6.4x%p2%#6.4X", [Number(15), Number(27)], vars),
+        assert_eq!(expand(b"%p1%o%p1%#o%p2%6.4x%p2%#6.4X", &[Number(15), Number(27)], vars),
                    Ok("17017  001b0X001B".bytes().collect()));
     }
 }
diff --git a/src/libterm/terminfo/searcher.rs b/src/libterm/terminfo/searcher.rs
index 61ff88a2fa338..94e234291af98 100644
--- a/src/libterm/terminfo/searcher.rs
+++ b/src/libterm/terminfo/searcher.rs
@@ -61,13 +61,13 @@ pub fn get_dbpath_for_term(term: &str) -> Option<Box<Path>> {
     for p in dirs_to_search.iter() {
         if p.exists() {
             let f = first_char.to_string();
-            let newp = p.join_many([f.as_slice(), term]);
+            let newp = p.join_many(&[f.as_slice(), term]);
             if newp.exists() {
                 return Some(box newp);
             }
             // on some installations the dir is named after the hex of the char (e.g. OS X)
             let f = format!("{:x}", first_char as uint);
-            let newp = p.join_many([f.as_slice(), term]);
+            let newp = p.join_many(&[f.as_slice(), term]);
             if newp.exists() {
                 return Some(box newp);
             }
diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs
index 81d0bb76d1497..cb4cd52682d6a 100644
--- a/src/libtest/lib.rs
+++ b/src/libtest/lib.rs
@@ -1323,7 +1323,7 @@ impl Bencher {
         if n == 0 { n = 1; }
 
         let mut total_run = 0;
-        let samples : &mut [f64] = [0.0_f64, ..50];
+        let samples : &mut [f64] = &mut [0.0_f64, ..50];
         loop {
             let loop_start = precise_time_ns();
 
diff --git a/src/libtest/stats.rs b/src/libtest/stats.rs
index 8c184ccbe43a8..3fd664c7002bf 100644
--- a/src/libtest/stats.rs
+++ b/src/libtest/stats.rs
@@ -1036,11 +1036,11 @@ mod tests {
             assert_eq!(out, expected);
         }
 
-        t(&Summary::new([-2.0f64, -1.0f64]),
+        t(&Summary::new(&[-2.0f64, -1.0f64]),
                         "-2 |[------******#*****---]| -1".to_string());
-        t(&Summary::new([0.0f64, 2.0f64]),
+        t(&Summary::new(&[0.0f64, 2.0f64]),
                         "0 |[-------*****#*******---]| 2".to_string());
-        t(&Summary::new([-2.0f64, 0.0f64]),
+        t(&Summary::new(&[-2.0f64, 0.0f64]),
                         "-2 |[------******#******---]| 0".to_string());
 
     }
diff --git a/src/libtime/lib.rs b/src/libtime/lib.rs
index ac3574f5a03ee..7399e4e29167c 100644
--- a/src/libtime/lib.rs
+++ b/src/libtime/lib.rs
@@ -546,7 +546,7 @@ pub fn strptime(s: &str, format: &str) -> Result<Tm, ParseError> {
     fn parse_type(s: &str, pos: uint, ch: char, tm: &mut Tm)
       -> Result<uint, ParseError> {
         match ch {
-          'A' => match match_strs(s, pos, [
+          'A' => match match_strs(s, pos, &[
               ("Sunday", 0_i32),
               ("Monday", 1_i32),
               ("Tuesday", 2_i32),
@@ -558,7 +558,7 @@ pub fn strptime(s: &str, format: &str) -> Result<Tm, ParseError> {
             Some(item) => { let (v, pos) = item; tm.tm_wday = v; Ok(pos) }
             None => Err(InvalidDay)
           },
-          'a' => match match_strs(s, pos, [
+          'a' => match match_strs(s, pos, &[
               ("Sun", 0_i32),
               ("Mon", 1_i32),
               ("Tue", 2_i32),
@@ -570,7 +570,7 @@ pub fn strptime(s: &str, format: &str) -> Result<Tm, ParseError> {
             Some(item) => { let (v, pos) = item; tm.tm_wday = v; Ok(pos) }
             None => Err(InvalidDay)
           },
-          'B' => match match_strs(s, pos, [
+          'B' => match match_strs(s, pos, &[
               ("January", 0_i32),
               ("February", 1_i32),
               ("March", 2_i32),
@@ -587,7 +587,7 @@ pub fn strptime(s: &str, format: &str) -> Result<Tm, ParseError> {
             Some(item) => { let (v, pos) = item; tm.tm_mon = v; Ok(pos) }
             None => Err(InvalidMonth)
           },
-          'b' | 'h' => match match_strs(s, pos, [
+          'b' | 'h' => match match_strs(s, pos, &[
               ("Jan", 0_i32),
               ("Feb", 1_i32),
               ("Mar", 2_i32),
@@ -713,13 +713,13 @@ pub fn strptime(s: &str, format: &str) -> Result<Tm, ParseError> {
           }
           'n' => parse_char(s, pos, '\n'),
           'P' => match match_strs(s, pos,
-                                  [("am", 0_i32), ("pm", 12_i32)]) {
+                                  &[("am", 0_i32), ("pm", 12_i32)]) {
 
             Some(item) => { let (v, pos) = item; tm.tm_hour += v; Ok(pos) }
             None => Err(InvalidHour)
           },
           'p' => match match_strs(s, pos,
-                                  [("AM", 0_i32), ("PM", 12_i32)]) {
+                                  &[("AM", 0_i32), ("PM", 12_i32)]) {
 
             Some(item) => { let (v, pos) = item; tm.tm_hour += v; Ok(pos) }
             None => Err(InvalidHour)
@@ -867,13 +867,13 @@ pub fn strptime(s: &str, format: &str) -> Result<Tm, ParseError> {
         let next = range.next;
 
         let mut buf = [0];
-        let c = match rdr.read(buf) {
+        let c = match rdr.read(&mut buf) {
             Ok(..) => buf[0] as char,
             Err(..) => break
         };
         match c {
             '%' => {
-                let ch = match rdr.read(buf) {
+                let ch = match rdr.read(&mut buf) {
                     Ok(..) => buf[0] as char,
                     Err(..) => break
                 };
@@ -1119,13 +1119,13 @@ pub fn strftime(format: &str, tm: &Tm) -> Result<String, ParseError> {
     let mut rdr = BufReader::new(format.as_bytes());
     loop {
         let mut b = [0];
-        let ch = match rdr.read(b) {
+        let ch = match rdr.read(&mut b) {
             Ok(_) => b[0],
             Err(_) => break, // EOF.
         };
         match ch as char {
             '%' => {
-                if rdr.read(b).is_err() {
+                if rdr.read(&mut b).is_err() {
                     return Err(MissingFormatConverter)
                 }
                 match parse_type(b[0] as char, tm) {
diff --git a/src/test/bench/noise.rs b/src/test/bench/noise.rs
index 19ccf1b6caf72..bf7be96c4647a 100644
--- a/src/test/bench/noise.rs
+++ b/src/test/bench/noise.rs
@@ -51,7 +51,7 @@ impl Noise2DContext {
         for (i, x) in permutations.iter_mut().enumerate() {
             *x = i as i32;
         }
-        rng.shuffle(permutations);
+        rng.shuffle(&mut permutations);
 
         Noise2DContext { rgradients: rgradients, permutations: permutations }
     }
diff --git a/src/test/bench/shootout-fannkuch-redux.rs b/src/test/bench/shootout-fannkuch-redux.rs
index b4292c2b05033..b38b8e66d7dbd 100644
--- a/src/test/bench/shootout-fannkuch-redux.rs
+++ b/src/test/bench/shootout-fannkuch-redux.rs
@@ -118,7 +118,7 @@ impl Perm {
     fn max(&self) -> u32 { self.fact[self.n as uint] }
 
     fn next(&mut self) -> P {
-        next_permutation(self.perm.p, self.cnt);
+        next_permutation(&mut self.perm.p, &mut self.cnt);
         self.permcount += 1;
 
         self.perm
@@ -141,7 +141,7 @@ fn work(mut perm: Perm, n: uint, max: uint) -> (i32, i32) {
 
         while p.p[0] != 1 {
             let k = p.p[0] as uint;
-            reverse(p.p, k);
+            reverse(&mut p.p, k);
             flips += 1;
         }
 
diff --git a/src/test/bench/shootout-fasta-redux.rs b/src/test/bench/shootout-fasta-redux.rs
index e151369ff38ac..36ff487b0fe84 100644
--- a/src/test/bench/shootout-fasta-redux.rs
+++ b/src/test/bench/shootout-fasta-redux.rs
@@ -198,7 +198,7 @@ impl<'a, W: Writer> RandomFasta<'a, W> {
                 buf[i] = self.nextc();
             }
             buf[LINE_LEN] = '\n' as u8;
-            try!(self.out.write(buf));
+            try!(self.out.write(&buf));
         }
         for i in range(0u, chars_left) {
             buf[i] = self.nextc();
@@ -225,12 +225,12 @@ fn main() {
     }
 
     out.write_line(">TWO IUB ambiguity codes").unwrap();
-    let iub = sum_and_scale(IUB);
+    let iub = sum_and_scale(&IUB);
     let mut random = RandomFasta::new(&mut out, iub.as_slice());
     random.make(n * 3).unwrap();
 
     random.out.write_line(">THREE Homo sapiens frequency").unwrap();
-    let homo_sapiens = sum_and_scale(HOMO_SAPIENS);
+    let homo_sapiens = sum_and_scale(&HOMO_SAPIENS);
     random.lookup = make_lookup(homo_sapiens.as_slice());
     random.make(n * 5).unwrap();
 
diff --git a/src/test/compile-fail/lint-uppercase-variables.rs b/src/test/compile-fail/lint-uppercase-variables.rs
index 902cd63b1e78c..2f840ee0761b1 100644
--- a/src/test/compile-fail/lint-uppercase-variables.rs
+++ b/src/test/compile-fail/lint-uppercase-variables.rs
@@ -30,7 +30,7 @@ fn main() {
 
     let mut f = File::open(&Path::new("something.txt"));
     let mut buff = [0u8, ..16];
-    match f.read(buff) {
+    match f.read(&mut buff) {
         Ok(cnt) => println!("read this many bytes: {}", cnt),
         Err(IoError{ kind: EndOfFile, .. }) => println!("Got end of file: {}", EndOfFile.to_string()),
         //~^ ERROR variable `EndOfFile` should have a snake case name such as `end_of_file`
diff --git a/src/test/compile-fail/non-exhaustive-pattern-witness.rs b/src/test/compile-fail/non-exhaustive-pattern-witness.rs
index b7ff3a18fcf7a..95ebbecaf1671 100644
--- a/src/test/compile-fail/non-exhaustive-pattern-witness.rs
+++ b/src/test/compile-fail/non-exhaustive-pattern-witness.rs
@@ -54,7 +54,7 @@ enum Enum {
 }
 
 fn vectors_with_nested_enums() {
-    let x: &'static [Enum] = [First, Second(false)];
+    let x: &'static [Enum] = &[First, Second(false)];
     match x {
     //~^ ERROR non-exhaustive patterns: `[Second(true), Second(false)]` not covered
         [] => (),
diff --git a/src/test/pretty/issue-4264.pp b/src/test/pretty/issue-4264.pp
index c5229f0f9f971..f3c749da95fe4 100644
--- a/src/test/pretty/issue-4264.pp
+++ b/src/test/pretty/issue-4264.pp
@@ -39,8 +39,9 @@
          () => {
              #[inline]
              #[allow(dead_code)]
-             static __STATIC_FMTSTR: [&'static str, ..(1u as uint)] =
-                 ([("test" as &'static str)] as [&'static str, ..1]);
+             static __STATIC_FMTSTR: &'static [&'static str] =
+                 (&([("test" as &'static str)] as [&'static str, ..1]) as
+                     &'static [&'static str, ..1]);
              let __args_vec =
                  (&([] as [core::fmt::Argument<'_>, ..0]) as
                      &[core::fmt::Argument<'_>, ..0]);
@@ -49,7 +50,7 @@
                       ((::std::fmt::Arguments::new as
                            unsafe fn(&'static [&'static str], &'a [core::fmt::Argument<'a>]) -> core::fmt::Arguments<'a>)((__STATIC_FMTSTR
                                                                                                                               as
-                                                                                                                              [&'static str, ..1]),
+                                                                                                                              &'static [&'static str]),
                                                                                                                           (__args_vec
                                                                                                                               as
                                                                                                                               &[core::fmt::Argument<'_>, ..0]))
diff --git a/src/test/run-pass/assignability-trait.rs b/src/test/run-pass/assignability-trait.rs
index 0d90636ec9140..f822da4cdcfcf 100644
--- a/src/test/run-pass/assignability-trait.rs
+++ b/src/test/run-pass/assignability-trait.rs
@@ -53,5 +53,5 @@ pub fn main() {
     // Call a method
     z.iterate(|y| { assert!(z[*y as uint] == *y); true });
     // Call a parameterized function
-    assert_eq!(length::<int, &[int]>(z), z.len());
+    assert_eq!(length::<int, &[int]>(&z), z.len());
 }
diff --git a/src/test/run-pass/borrowck-freeze-frozen-mut.rs b/src/test/run-pass/borrowck-freeze-frozen-mut.rs
index f224042bc7943..21f5d0e6c1448 100644
--- a/src/test/run-pass/borrowck-freeze-frozen-mut.rs
+++ b/src/test/run-pass/borrowck-freeze-frozen-mut.rs
@@ -21,7 +21,7 @@ fn get<'a, T>(ms: &'a MutSlice<'a, T>, index: uint) -> &'a T {
 pub fn main() {
     let mut data = [1i, 2, 3];
     {
-        let slice = MutSlice { data: data };
+        let slice = MutSlice { data: &mut data };
         slice.data[0] += 4;
         let index0 = get(&slice, 0);
         let index1 = get(&slice, 1);
diff --git a/src/test/run-pass/capture-clauses-boxed-closures.rs b/src/test/run-pass/capture-clauses-boxed-closures.rs
index a1411146ddda6..d24b9332917bf 100644
--- a/src/test/run-pass/capture-clauses-boxed-closures.rs
+++ b/src/test/run-pass/capture-clauses-boxed-closures.rs
@@ -17,7 +17,7 @@ fn each<T>(x: &[T], f: |&T|) {
 fn main() {
     let mut sum = 0u;
     let elems = [ 1u, 2, 3, 4, 5 ];
-    each(elems, |val| sum += *val);
+    each(&elems, |val| sum += *val);
     assert_eq!(sum, 15);
 }
 
diff --git a/src/test/run-pass/capture-clauses-unboxed-closures.rs b/src/test/run-pass/capture-clauses-unboxed-closures.rs
index a826f4df5b349..9f333fd043f07 100644
--- a/src/test/run-pass/capture-clauses-unboxed-closures.rs
+++ b/src/test/run-pass/capture-clauses-unboxed-closures.rs
@@ -19,6 +19,6 @@ fn each<'a,T,F:FnMut(&'a T)>(x: &'a [T], mut f: F) {
 fn main() {
     let mut sum = 0u;
     let elems = [ 1u, 2, 3, 4, 5 ];
-    each(elems, |&mut: val: &uint| sum += *val);
+    each(&elems, |&mut: val: &uint| sum += *val);
     assert_eq!(sum, 15);
 }
diff --git a/src/test/run-pass/cci_iter_exe.rs b/src/test/run-pass/cci_iter_exe.rs
index df03c93dad3ad..7191d5078b81c 100644
--- a/src/test/run-pass/cci_iter_exe.rs
+++ b/src/test/run-pass/cci_iter_exe.rs
@@ -15,7 +15,7 @@ extern crate cci_iter_lib;
 pub fn main() {
     //let bt0 = sys::rusti::frame_address(1u32);
     //println!("%?", bt0);
-    cci_iter_lib::iter([1i, 2, 3], |i| {
+    cci_iter_lib::iter(&[1i, 2, 3], |i| {
         println!("{}", *i);
         //assert!(bt0 == sys::rusti::frame_address(2u32));
     })
diff --git a/src/test/run-pass/const-str-ptr.rs b/src/test/run-pass/const-str-ptr.rs
index 7395a997a05c5..47d59eca26316 100644
--- a/src/test/run-pass/const-str-ptr.rs
+++ b/src/test/run-pass/const-str-ptr.rs
@@ -17,13 +17,13 @@ const C: *const u8 = B as *const u8;
 pub fn main() {
     unsafe {
         let foo = &A as *const u8;
-        assert_eq!(str::raw::from_utf8(A), "hi");
+        assert_eq!(str::raw::from_utf8(&A), "hi");
         assert_eq!(string::raw::from_buf_len(foo, A.len()), "hi".to_string());
         assert_eq!(string::raw::from_buf_len(C, B.len()), "hi".to_string());
         assert!(*C == A[0]);
         assert!(*(&B[0] as *const u8) == A[0]);
 
-        let bar = str::raw::from_utf8(A).to_c_str();
+        let bar = str::raw::from_utf8(&A).to_c_str();
         assert_eq!(bar.as_str(), "hi".to_c_str().as_str());
     }
 }
diff --git a/src/test/run-pass/const-vec-syntax.rs b/src/test/run-pass/const-vec-syntax.rs
index 84ee54cfdde6d..c0566277e4eb1 100644
--- a/src/test/run-pass/const-vec-syntax.rs
+++ b/src/test/run-pass/const-vec-syntax.rs
@@ -12,5 +12,5 @@ fn f(_: &[int]) {}
 
 pub fn main() {
     let v = [ 1, 2, 3 ];
-    f(v);
+    f(&v);
 }
diff --git a/src/test/run-pass/const-vecs-and-slices.rs b/src/test/run-pass/const-vecs-and-slices.rs
index c61f26e0bb6b3..1a2a3e36e8746 100644
--- a/src/test/run-pass/const-vecs-and-slices.rs
+++ b/src/test/run-pass/const-vecs-and-slices.rs
@@ -11,7 +11,7 @@
 static x : [int, ..4] = [1,2,3,4];
 static y : &'static [int] = &[1,2,3,4];
 static z : &'static [int, ..4] = &[1,2,3,4];
-static zz : &'static [int] = [1,2,3,4];
+static zz : &'static [int] = &[1,2,3,4];
 
 pub fn main() {
     println!("{}", x[1]);
diff --git a/src/test/run-pass/deref-rc.rs b/src/test/run-pass/deref-rc.rs
index 03697875d5646..bc2fa3ec4e2c6 100644
--- a/src/test/run-pass/deref-rc.rs
+++ b/src/test/run-pass/deref-rc.rs
@@ -12,5 +12,5 @@ use std::rc::Rc;
 
 fn main() {
     let x = Rc::new([1i, 2, 3, 4]);
-    assert!(*x == [1, 2, 3, 4]);
+    assert!(*x == &[1, 2, 3, 4]);
 }
diff --git a/src/test/run-pass/issue-11205.rs b/src/test/run-pass/issue-11205.rs
index c2c291c0becc8..89224e1fb12c4 100644
--- a/src/test/run-pass/issue-11205.rs
+++ b/src/test/run-pass/issue-11205.rs
@@ -72,11 +72,11 @@ fn main() {
     let r = &1i;
     let r: [&Foo, ..2] = [r, ..2];
     let _n = F {
-        t: r
+        t: &r
     };
     let x: [&Foo, ..2] = [&1i, &2i];
     let _n = F {
-        t: x
+        t: &x
     };
 
     struct M<'a> {
@@ -87,6 +87,6 @@ fn main() {
     };
     let x: [Box<Foo>, ..2] = [box 1i, box 2i];
     let _n = M {
-        t: x
+        t: &x
     };
 }
diff --git a/src/test/run-pass/issue-12028.rs b/src/test/run-pass/issue-12028.rs
index 4d64103e50224..dbfa330d33d9e 100644
--- a/src/test/run-pass/issue-12028.rs
+++ b/src/test/run-pass/issue-12028.rs
@@ -37,7 +37,7 @@ impl<S: Stream, H: StreamHasher<S>> Hash<H> for u8 {
 
 impl<S: Stream, H: StreamHasher<S>> StreamHash<S, H> for u8 {
     fn input_stream(&self, stream: &mut S) {
-        stream.input([*self]);
+        stream.input(&[*self]);
     }
 }
 
diff --git a/src/test/run-pass/issue-14940.rs b/src/test/run-pass/issue-14940.rs
index acadc81df6306..cef09af1fcff2 100644
--- a/src/test/run-pass/issue-14940.rs
+++ b/src/test/run-pass/issue-14940.rs
@@ -15,7 +15,7 @@ fn main() {
     let args = os::args();
     if args.len() > 1 {
         let mut out = stdio::stdout();
-        out.write(['a' as u8, ..128 * 1024]).unwrap();
+        out.write(&['a' as u8, ..128 * 1024]).unwrap();
     } else {
         let out = Command::new(args[0].as_slice()).arg("child").output();
         let out = out.unwrap();
diff --git a/src/test/run-pass/issue-15080.rs b/src/test/run-pass/issue-15080.rs
index 1709321a71cfd..c2c370ae504c7 100644
--- a/src/test/run-pass/issue-15080.rs
+++ b/src/test/run-pass/issue-15080.rs
@@ -26,5 +26,5 @@ fn main() {
                 break
         }
     }
-    assert!(result.as_slice() == [2, 4]);
+    assert!(result.as_slice() == &[2, 4]);
 }
diff --git a/src/test/run-pass/issue-2904.rs b/src/test/run-pass/issue-2904.rs
index 04866c56913b1..f4206312edb06 100644
--- a/src/test/run-pass/issue-2904.rs
+++ b/src/test/run-pass/issue-2904.rs
@@ -63,7 +63,7 @@ fn read_board_grid<rdr:'static + io::Reader>(mut input: rdr)
     let mut input: &mut io::Reader = &mut input;
     let mut grid = Vec::new();
     let mut line = [0, ..10];
-    input.read(line);
+    input.read(&mut line);
     let mut row = Vec::new();
     for c in line.iter() {
         row.push(square_from_char(*c as char))
diff --git a/src/test/run-pass/issue-7784.rs b/src/test/run-pass/issue-7784.rs
index 666847517efde..f0310cd8df3c8 100644
--- a/src/test/run-pass/issue-7784.rs
+++ b/src/test/run-pass/issue-7784.rs
@@ -33,6 +33,6 @@ fn main() {
     let out = bar("baz", "foo");
     let [a, xs.., d] = out;
     assert_eq!(a, "baz");
-    assert!(xs == ["foo", "foo"]);
+    assert!(xs == &["foo", "foo"]);
     assert_eq!(d, "baz");
 }
diff --git a/src/test/run-pass/issue-8398.rs b/src/test/run-pass/issue-8398.rs
index 0884db633264e..185d75743a41e 100644
--- a/src/test/run-pass/issue-8398.rs
+++ b/src/test/run-pass/issue-8398.rs
@@ -11,7 +11,7 @@
 use std::io;
 
 fn foo(a: &mut io::Writer) {
-    a.write([]).unwrap();
+    a.write(&[]).unwrap();
 }
 
 pub fn main(){}
diff --git a/src/test/run-pass/issue-9249.rs b/src/test/run-pass/issue-9249.rs
index 013aef5722359..2795fd59c0c0d 100644
--- a/src/test/run-pass/issue-9249.rs
+++ b/src/test/run-pass/issue-9249.rs
@@ -8,5 +8,5 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-static DATA:&'static [&'static str] = ["my string"];
+static DATA:&'static [&'static str] = &["my string"];
 fn main() { }
diff --git a/src/test/run-pass/packed-struct-generic-layout.rs b/src/test/run-pass/packed-struct-generic-layout.rs
index 999e4aeeb5977..fbff5962dc4eb 100644
--- a/src/test/run-pass/packed-struct-generic-layout.rs
+++ b/src/test/run-pass/packed-struct-generic-layout.rs
@@ -23,15 +23,15 @@ pub fn main() {
         let transd : [u8, .. 9] = mem::transmute(s);
         // Don't worry about endianness, the numbers are palindromic.
         assert!(transd ==
-                   [0xff, 0xff, 0xff, 0xff,
-                    1,
-                    0xaa, 0xaa, 0xaa, 0xaa]);
+                   &[0xff, 0xff, 0xff, 0xff,
+                     1,
+                     0xaa, 0xaa, 0xaa, 0xaa]);
 
 
         let s = S { a: 1u8, b: 2u8, c: 0b10000001_10000001 as i16};
         let transd : [u8, .. 4] = mem::transmute(s);
         // Again, no endianness problems.
         assert!(transd ==
-                   [1, 2, 0b10000001, 0b10000001]);
+                   &[1, 2, 0b10000001, 0b10000001]);
     }
 }
diff --git a/src/test/run-pass/packed-struct-layout.rs b/src/test/run-pass/packed-struct-layout.rs
index b4fbf0820cd46..472833da58be9 100644
--- a/src/test/run-pass/packed-struct-layout.rs
+++ b/src/test/run-pass/packed-struct-layout.rs
@@ -26,11 +26,11 @@ pub fn main() {
     unsafe {
         let s4 = S4 { a: 1, b: [2,3,4] };
         let transd : [u8, .. 4] = mem::transmute(s4);
-        assert!(transd == [1, 2, 3, 4]);
+        assert!(transd == &[1, 2, 3, 4]);
 
         let s5 = S5 { a: 1, b: 0xff_00_00_ff };
         let transd : [u8, .. 5] = mem::transmute(s5);
         // Don't worry about endianness, the u32 is palindromic.
-        assert!(transd == [1, 0xff, 0, 0, 0xff]);
+        assert!(transd == &[1, 0xff, 0, 0, 0xff]);
     }
 }
diff --git a/src/test/run-pass/packed-tuple-struct-layout.rs b/src/test/run-pass/packed-tuple-struct-layout.rs
index 5fb43503ccb26..af8e73eb2a594 100644
--- a/src/test/run-pass/packed-tuple-struct-layout.rs
+++ b/src/test/run-pass/packed-tuple-struct-layout.rs
@@ -20,11 +20,11 @@ pub fn main() {
     unsafe {
         let s4 = S4(1, [2,3,4]);
         let transd : [u8, .. 4] = mem::transmute(s4);
-        assert!(transd == [1, 2, 3, 4]);
+        assert!(transd == &[1, 2, 3, 4]);
 
         let s5 = S5(1, 0xff_00_00_ff);
         let transd : [u8, .. 5] = mem::transmute(s5);
         // Don't worry about endianness, the u32 is palindromic.
-        assert!(transd == [1, 0xff, 0, 0, 0xff]);
+        assert!(transd == &[1, 0xff, 0, 0, 0xff]);
     }
 }
diff --git a/src/test/run-pass/regions-borrow-evec-fixed.rs b/src/test/run-pass/regions-borrow-evec-fixed.rs
index 9022ff92c8f2e..0264e64f70d2a 100644
--- a/src/test/run-pass/regions-borrow-evec-fixed.rs
+++ b/src/test/run-pass/regions-borrow-evec-fixed.rs
@@ -13,6 +13,6 @@ fn foo(x: &[int]) -> int {
 }
 
 pub fn main() {
-    let p = [1,2,3,4,5];
+    let p = &[1,2,3,4,5];
     assert_eq!(foo(p), 1);
 }
diff --git a/src/test/run-pass/rename-directory.rs b/src/test/run-pass/rename-directory.rs
index 43a62524717db..b5cee20232b63 100644
--- a/src/test/run-pass/rename-directory.rs
+++ b/src/test/run-pass/rename-directory.rs
@@ -25,7 +25,7 @@ fn rename_directory() {
 
         let tmpdir = TempDir::new("rename_directory").ok().expect("rename_directory failed");
         let tmpdir = tmpdir.path();
-        let old_path = tmpdir.join_many(["foo", "bar", "baz"]);
+        let old_path = tmpdir.join_many(&["foo", "bar", "baz"]);
         fs::mkdir_recursive(&old_path, io::USER_RWX);
         let test_file = &old_path.join("temp.txt");
 
@@ -46,11 +46,11 @@ fn rename_directory() {
         });
         assert_eq!(libc::fclose(ostream), (0u as libc::c_int));
 
-        let new_path = tmpdir.join_many(["quux", "blat"]);
+        let new_path = tmpdir.join_many(&["quux", "blat"]);
         fs::mkdir_recursive(&new_path, io::USER_RWX);
         fs::rename(&old_path, &new_path.join("newdir"));
         assert!(new_path.join("newdir").is_dir());
-        assert!(new_path.join_many(["newdir", "temp.txt"]).exists());
+        assert!(new_path.join_many(&["newdir", "temp.txt"]).exists());
     }
 }
 
diff --git a/src/test/run-pass/repeat-expr-in-static.rs b/src/test/run-pass/repeat-expr-in-static.rs
index 9955673bb0b12..4c3f64774dfbf 100644
--- a/src/test/run-pass/repeat-expr-in-static.rs
+++ b/src/test/run-pass/repeat-expr-in-static.rs
@@ -12,5 +12,5 @@ static FOO: [int, ..4] = [32, ..4];
 static BAR: [int, ..4] = [32, 32, 32, 32];
 
 pub fn main() {
-    assert!(FOO == BAR);
+    assert!(FOO == &BAR);
 }
diff --git a/src/test/run-pass/sigpipe-should-be-ignored.rs b/src/test/run-pass/sigpipe-should-be-ignored.rs
index 8c68ef173a5e7..1804dd2e1358a 100644
--- a/src/test/run-pass/sigpipe-should-be-ignored.rs
+++ b/src/test/run-pass/sigpipe-should-be-ignored.rs
@@ -21,7 +21,7 @@ fn test() {
     let mut writer = PipeStream::open(writer);
     drop(reader);
 
-    let _ = writer.write([1]);
+    let _ = writer.write(&[1]);
 }
 
 fn main() {
diff --git a/src/test/run-pass/stat.rs b/src/test/run-pass/stat.rs
index 67728e6c8dd44..250eafa2f49d5 100644
--- a/src/test/run-pass/stat.rs
+++ b/src/test/run-pass/stat.rs
@@ -21,7 +21,7 @@ pub fn main() {
             Ok(f) => {
                 let mut f = f;
                 for _ in range(0u, 1000) {
-                    f.write([0]);
+                    f.write(&[0]);
                 }
             }
         }
diff --git a/src/test/run-pass/utf8_chars.rs b/src/test/run-pass/utf8_chars.rs
index 30f6f4b464e4c..d343e485b2481 100644
--- a/src/test/run-pass/utf8_chars.rs
+++ b/src/test/run-pass/utf8_chars.rs
@@ -27,17 +27,17 @@ pub fn main() {
 
     assert!((str::is_utf8(s.as_bytes())));
     // invalid prefix
-    assert!((!str::is_utf8([0x80_u8])));
+    assert!((!str::is_utf8(&[0x80_u8])));
     // invalid 2 byte prefix
-    assert!((!str::is_utf8([0xc0_u8])));
-    assert!((!str::is_utf8([0xc0_u8, 0x10_u8])));
+    assert!((!str::is_utf8(&[0xc0_u8])));
+    assert!((!str::is_utf8(&[0xc0_u8, 0x10_u8])));
     // invalid 3 byte prefix
-    assert!((!str::is_utf8([0xe0_u8])));
-    assert!((!str::is_utf8([0xe0_u8, 0x10_u8])));
-    assert!((!str::is_utf8([0xe0_u8, 0xff_u8, 0x10_u8])));
+    assert!((!str::is_utf8(&[0xe0_u8])));
+    assert!((!str::is_utf8(&[0xe0_u8, 0x10_u8])));
+    assert!((!str::is_utf8(&[0xe0_u8, 0xff_u8, 0x10_u8])));
     // invalid 4 byte prefix
-    assert!((!str::is_utf8([0xf0_u8])));
-    assert!((!str::is_utf8([0xf0_u8, 0x10_u8])));
-    assert!((!str::is_utf8([0xf0_u8, 0xff_u8, 0x10_u8])));
-    assert!((!str::is_utf8([0xf0_u8, 0xff_u8, 0xff_u8, 0x10_u8])));
+    assert!((!str::is_utf8(&[0xf0_u8])));
+    assert!((!str::is_utf8(&[0xf0_u8, 0x10_u8])));
+    assert!((!str::is_utf8(&[0xf0_u8, 0xff_u8, 0x10_u8])));
+    assert!((!str::is_utf8(&[0xf0_u8, 0xff_u8, 0xff_u8, 0x10_u8])));
 }
diff --git a/src/test/run-pass/vec-dst.rs b/src/test/run-pass/vec-dst.rs
index 11b58948e0535..d8bf0a5c627f6 100644
--- a/src/test/run-pass/vec-dst.rs
+++ b/src/test/run-pass/vec-dst.rs
@@ -8,17 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn sub_expr() {
-    // Test for a &[T] => &&[T] coercion in sub-expression position
-    // (surprisingly, this can cause errors which are not caused by either of:
-    //    `let x = vec.slice_mut(0, 2);`
-    //    `foo(vec.slice_mut(0, 2));` ).
-    let mut vec: Vec<int> = vec!(1, 2, 3, 4);
-    let b: &mut [int] = [1, 2];
-    assert!(vec.slice_mut(0, 2) == b);
-}
-
-fn index() {
+pub fn main() {
     // Tests for indexing into box/& [T, ..n]
     let x: [int, ..3] = [1, 2, 3];
     let mut x: Box<[int, ..3]> = box x;
@@ -40,8 +30,3 @@ fn index() {
     assert!(x[1] == 45);
     assert!(x[2] == 3);
 }
-
-pub fn main() {
-    sub_expr();
-    index();
-}
diff --git a/src/test/run-pass/vec-matching-autoslice.rs b/src/test/run-pass/vec-matching-autoslice.rs
index 6476f734ae650..9052df9fdb7f9 100644
--- a/src/test/run-pass/vec-matching-autoslice.rs
+++ b/src/test/run-pass/vec-matching-autoslice.rs
@@ -13,7 +13,7 @@ pub fn main() {
     match x {
         [2, _, _] => panic!(),
         [1, a, b] => {
-            assert!([a, b] == [2, 3]);
+            assert!([a, b] == &[2, 3]);
         }
         [_, _, _] => panic!(),
     }
diff --git a/src/test/run-pass/vec-matching-fold.rs b/src/test/run-pass/vec-matching-fold.rs
index 63914a8df31cd..cc2061c3cf385 100644
--- a/src/test/run-pass/vec-matching-fold.rs
+++ b/src/test/run-pass/vec-matching-fold.rs
@@ -33,7 +33,7 @@ fn foldr<T,U:Clone>(values: &[T],
 }
 
 pub fn main() {
-    let x = [1i, 2, 3, 4, 5];
+    let x = &[1i, 2, 3, 4, 5];
 
     let product = foldl(x, 1i, |a, b| a * *b);
     assert_eq!(product, 120);