Fallout from renaming

src/test/bench/core-uint-to-str.rs

@@ -18,7 +18,7 @@ fn main() {
     } else if args.len() <= 1u {
         vec!("".to_string(), "100000".to_string())
     } else {
-        args.move_iter().collect()
+        args.into_iter().collect()
     };
 
     let n = from_str::<uint>(args.get(1).as_slice()).unwrap();

src/test/bench/msgsend-pipes-shared.rs

@@ -75,7 +75,7 @@ fn run(args: &[String]) {
         server(&from_parent, &to_parent);
     });
 
-    for r in worker_results.move_iter() {
+    for r in worker_results.into_iter() {
         r.unwrap();
     }
 
@@ -99,7 +99,7 @@ fn main() {
     } else if args.len() <= 1u {
         vec!("".to_string(), "10000".to_string(), "4".to_string())
     } else {
-        args.move_iter().map(|x| x.to_string()).collect()
+        args.into_iter().map(|x| x.to_string()).collect()
     };
 
     println!("{}", args);

src/test/bench/msgsend-pipes.rs

@@ -83,7 +83,7 @@ fn run(args: &[String]) {
         server(&from_parent, &to_parent);
     });
 
-    for r in worker_results.move_iter() {
+    for r in worker_results.into_iter() {
         r.unwrap();
     }
 
@@ -107,7 +107,7 @@ fn main() {
     } else if args.len() <= 1u {
         vec!("".to_string(), "10000".to_string(), "4".to_string())
     } else {
-        args.clone().move_iter().map(|x| x.to_string()).collect()
+        args.clone().into_iter().map(|x| x.to_string()).collect()
     };
 
     println!("{:?}", args);

src/test/bench/msgsend-ring-mutex-arcs.rs

@@ -69,7 +69,7 @@ fn main() {
     } else if args.len() <= 1u {
         vec!("".to_string(), "10".to_string(), "100".to_string())
     } else {
-        args.clone().move_iter().collect()
+        args.clone().into_iter().collect()
     };
 
     let num_tasks = from_str::<uint>(args.get(1).as_slice()).unwrap();
@@ -97,7 +97,7 @@ fn main() {
     thread_ring(0, msg_per_task, num_chan, num_port);
 
     // synchronize
-    for f in futures.mut_iter() {
+    for f in futures.iter_mut() {
         f.get()
     }
 

src/test/bench/msgsend-ring-rw-arcs.rs

@@ -69,7 +69,7 @@ fn main() {
     } else if args.len() <= 1u {
         vec!("".to_string(), "10".to_string(), "100".to_string())
     } else {
-        args.clone().move_iter().collect()
+        args.clone().into_iter().collect()
     };
 
     let num_tasks = from_str::<uint>(args.get(1).as_slice()).unwrap();
@@ -97,7 +97,7 @@ fn main() {
     thread_ring(0, msg_per_task, num_chan, num_port);
 
     // synchronize
-    for f in futures.mut_iter() {
+    for f in futures.iter_mut() {
         let _ = f.get();
     }
 

src/test/bench/noise.rs

@@ -43,12 +43,12 @@ impl Noise2DContext {
         let mut rng = StdRng::new().unwrap();
 
         let mut rgradients = [Vec2 { x: 0.0, y: 0.0 }, ..256];
-        for x in rgradients.mut_iter() {
+        for x in rgradients.iter_mut() {
             *x = random_gradient(&mut rng);
         }
 
         let mut permutations = [0i32, ..256];
-        for (i, x) in permutations.mut_iter().enumerate() {
+        for (i, x) in permutations.iter_mut().enumerate() {
             *x = i as i32;
         }
         rng.shuffle(permutations);

src/test/bench/shootout-ackermann.rs

@@ -29,7 +29,7 @@ fn main() {
     } else if args.len() <= 1u {
         vec!("".to_string(), "8".to_string())
     } else {
-        args.move_iter().collect()
+        args.into_iter().collect()
     };
     let n = from_str::<int>(args.get(1).as_slice()).unwrap();
     println!("Ack(3,{}): {}\n", n, ack(3, n));

src/test/bench/shootout-binarytrees.rs

@@ -108,7 +108,7 @@ fn main() {
             })
         }).collect::<Vec<Future<String>>>();
 
-    for message in messages.mut_iter() {
+    for message in messages.iter_mut() {
         println!("{}", *message.get_ref());
     }
 

src/test/bench/shootout-fannkuch-redux.rs

@@ -43,14 +43,14 @@ use std::sync::Future;
 
 fn rotate(x: &mut [i32]) {
     let mut prev = x[0];
-    for place in x.mut_iter().rev() {
+    for place in x.iter_mut().rev() {
         prev = mem::replace(place, prev)
     }
 }
 
 fn next_permutation(perm: &mut [i32], count: &mut [i32]) {
     for i in range(1, perm.len()) {
-        rotate(perm.mut_slice_to(i + 1));
+        rotate(perm.slice_to_mut(i + 1));
         let count_i = &mut count[i];
         if *count_i >= i as i32 {
             *count_i = 0;
@@ -91,7 +91,7 @@ impl Perm {
     fn get(&mut self, mut idx: i32) -> P {
         let mut pp = [0u8, .. 16];
         self.permcount = idx as u32;
-        for (i, place) in self.perm.p.mut_iter().enumerate() {
+        for (i, place) in self.perm.p.iter_mut().enumerate() {
             *place = i as i32 + 1;
         }
 
@@ -99,7 +99,7 @@ impl Perm {
             let d = idx / self.fact[i] as i32;
             self.cnt[i] = d;
             idx %= self.fact[i] as i32;
-            for (place, val) in pp.mut_iter().zip(self.perm.p.slice_to(i + 1).iter()) {
+            for (place, val) in pp.iter_mut().zip(self.perm.p.slice_to(i + 1).iter()) {
                 *place = (*val) as u8
             }
 
@@ -125,7 +125,7 @@ impl Perm {
 
 
 fn reverse(tperm: &mut [i32], mut k: uint) {
-    tperm.mut_slice_to(k).reverse()
+    tperm.slice_to_mut(k).reverse()
 }
 
 fn work(mut perm: Perm, n: uint, max: uint) -> (i32, i32) {
@@ -169,7 +169,7 @@ fn fannkuch(n: i32) -> (i32, i32) {
 
     let mut checksum = 0;
     let mut maxflips = 0;
-    for fut in futures.mut_iter() {
+    for fut in futures.iter_mut() {
         let (cs, mf) = fut.get();
         checksum += cs;
         maxflips = cmp::max(maxflips, mf);

src/test/bench/shootout-fasta-redux.rs

@@ -94,7 +94,7 @@ impl<'a, W: Writer> RepeatFasta<'a, W> {
 
         copy_memory(buf.as_mut_slice(), alu);
         let buf_len = buf.len();
-        copy_memory(buf.mut_slice(alu_len, buf_len),
+        copy_memory(buf.slice_mut(alu_len, buf_len),
                     alu.slice_to(LINE_LEN));
 
         let mut pos = 0;
@@ -117,7 +117,7 @@ impl<'a, W: Writer> RepeatFasta<'a, W> {
 fn make_lookup(a: &[AminoAcid]) -> [AminoAcid, ..LOOKUP_SIZE] {
     let mut lookup = [ NULL_AMINO_ACID, ..LOOKUP_SIZE ];
     let mut j = 0;
-    for (i, slot) in lookup.mut_iter().enumerate() {
+    for (i, slot) in lookup.iter_mut().enumerate() {
         while a[j].p < (i as f32) {
             j += 1;
         }

src/test/bench/shootout-fibo.rs

@@ -25,7 +25,7 @@ fn main() {
     } else if args.len() <= 1u {
         vec!("".to_string(), "30".to_string())
     } else {
-        args.move_iter().collect()
+        args.into_iter().collect()
     };
     let n = from_str::<int>(args.get(1).as_slice()).unwrap();
     println!("{}\n", fib(n));

src/test/bench/shootout-k-nucleotide-pipes.rs

@@ -157,7 +157,7 @@ fn main() {
     let sizes = vec!(1u,2,3,4,6,12,18);
     let mut streams = Vec::from_fn(sizes.len(), |_| Some(channel::<String>()));
     let mut from_child = Vec::new();
-    let to_child  = sizes.iter().zip(streams.mut_iter()).map(|(sz, stream_ref)| {
+    let to_child  = sizes.iter().zip(streams.iter_mut()).map(|(sz, stream_ref)| {
         let sz = *sz;
         let stream = replace(stream_ref, None);
         let (to_parent_, from_child_) = stream.unwrap();

src/test/bench/shootout-k-nucleotide.rs

@@ -283,7 +283,7 @@ fn get_sequence<R: Buffer>(r: &mut R, key: &str) -> Vec<u8> {
     {
         res.push_all(l.as_slice().trim().as_bytes());
     }
-    for b in res.mut_iter() {
+    for b in res.iter_mut() {
         *b = b.to_ascii().to_upper().to_byte();
     }
     res
@@ -307,10 +307,10 @@ fn main() {
         Future::spawn(proc() generate_frequencies(input.as_slice(), occ.len()))
     }).collect();
 
-    for (i, freq) in nb_freqs.move_iter() {
+    for (i, freq) in nb_freqs.into_iter() {
         print_frequencies(&freq.unwrap(), i);
     }
-    for (&occ, freq) in OCCURRENCES.iter().zip(occ_freqs.move_iter()) {
+    for (&occ, freq) in OCCURRENCES.iter().zip(occ_freqs.into_iter()) {
         print_occurrences(&mut freq.unwrap(), occ);
     }
 }

src/test/bench/shootout-mandelbrot.rs

@@ -107,7 +107,7 @@ fn mandelbrot<W: io::Writer>(w: uint, mut out: W) -> io::IoResult<()> {
         })
     });
 
-    for res in precalc_futures.move_iter() {
+    for res in precalc_futures.into_iter() {
         let (rs, is) = res.unwrap();
         precalc_r.push_all_move(rs);
         precalc_i.push_all_move(is);
@@ -135,7 +135,7 @@ fn mandelbrot<W: io::Writer>(w: uint, mut out: W) -> io::IoResult<()> {
     });
 
     try!(writeln!(&mut out as &mut Writer, "P4\n{} {}", w, h));
-    for res in data.move_iter() {
+    for res in data.into_iter() {
         try!(out.write(res.unwrap().as_slice()));
     }
     out.flush()

src/test/bench/shootout-meteor.rs

@@ -114,9 +114,9 @@ fn transform(piece: Vec<(int, int)> , all: bool) -> Vec<Vec<(int, int)>> {
         }).collect();
 
     // translating to (0, 0) as minimum coordinates.
-    for cur_piece in res.mut_iter() {
+    for cur_piece in res.iter_mut() {
         let (dy, dx) = *cur_piece.iter().min_by(|e| *e).unwrap();
-        for &(ref mut y, ref mut x) in cur_piece.mut_iter() {
+        for &(ref mut y, ref mut x) in cur_piece.iter_mut() {
             *y -= dy; *x -= dx;
         }
     }
@@ -163,7 +163,7 @@ fn make_masks() -> Vec<Vec<Vec<u64> > > {
     // transformation must be taken except for one piece (piece 3
     // here).
     let transforms: Vec<Vec<Vec<(int, int)>>> =
-        pieces.move_iter().enumerate()
+        pieces.into_iter().enumerate()
         .map(|(id, p)| transform(p, id != 3))
         .collect();
 

src/test/bench/shootout-nbody.rs

@@ -106,7 +106,7 @@ fn advance(bodies: &mut [Planet, ..N_BODIES], dt: f64, steps: int) {
                 Some(bi) => bi,
                 None => break
             };
-            for bj in b_slice.mut_iter() {
+            for bj in b_slice.iter_mut() {
                 let dx = bi.x - bj.x;
                 let dy = bi.y - bj.y;
                 let dz = bi.z - bj.z;

src/test/bench/shootout-pfib.rs

@@ -82,7 +82,7 @@ fn stress(num_tasks: int) {
             stress_task(i);
         }));
     }
-    for r in results.move_iter() {
+    for r in results.into_iter() {
         r.unwrap();
     }
 }
@@ -94,7 +94,7 @@ fn main() {
     } else if args.len() <= 1u {
         vec!("".to_string(), "8".to_string())
     } else {
-        args.move_iter().map(|x| x.to_string()).collect()
+        args.into_iter().map(|x| x.to_string()).collect()
     };
 
     let opts = parse_opts(args.clone());

src/test/bench/shootout-regex-dna.rs

@@ -87,7 +87,7 @@ fn main() {
             (regex!("Y"), "(c|t)"),
         ];
         let mut seq = seq;
-        for (re, replacement) in substs.move_iter() {
+        for (re, replacement) in substs.into_iter() {
             seq = re.replace_all(seq.as_slice(), NoExpand(replacement));
         }
         seq.len()
@@ -105,7 +105,7 @@ fn main() {
         regex!("agggtaa[cgt]|[acg]ttaccct"),
     ];
     let (mut variant_strs, mut counts) = (vec!(), vec!());
-    for variant in variants.move_iter() {
+    for variant in variants.into_iter() {
         let seq_arc_copy = seq_arc.clone();
         variant_strs.push(variant.to_string());
         counts.push(Future::spawn(proc() {

src/test/bench/shootout-reverse-complement.rs

@@ -54,7 +54,7 @@ fn make_complements() -> [u8, ..256] {
         ('H', 'D'), ('D', 'H'), ('B', 'V'), ('N', 'N'),
         ('\n', '\n')];
     let mut complements: [u8, ..256] = [0, ..256];
-    for (i, c) in complements.mut_iter().enumerate() {
+    for (i, c) in complements.iter_mut().enumerate() {
         *c = i as u8;
     }
     let lower = 'A' as u8 - 'a' as u8;
@@ -74,14 +74,14 @@ fn main() {
     };
     let mut data = data.unwrap();
 
-    for seq in data.as_mut_slice().mut_split(|c| *c == '>' as u8) {
+    for seq in data.as_mut_slice().split_mut(|c| *c == '>' as u8) {
         // skip header and last \n
         let begin = match seq.iter().position(|c| *c == '\n' as u8) {
             None => continue,
             Some(c) => c
         };
         let len = seq.len();
-        let seq = seq.mut_slice(begin + 1, len - 1);
+        let seq = seq.slice_mut(begin + 1, len - 1);
 
         // arrange line breaks
         let len = seq.len();
@@ -94,9 +94,9 @@ fn main() {
         }
 
         // reverse complement, as
-        //    seq.reverse(); for c in seq.mut_iter() {*c = complements[*c]}
+        //    seq.reverse(); for c in seq.iter_mut() {*c = complements[*c]}
         // but faster:
-        let mut it = seq.mut_iter();
+        let mut it = seq.iter_mut();
         loop {
             match (it.next(), it.next_back()) {
                 (Some(front), Some(back)) => {

src/test/bench/std-smallintmap.rs

@@ -37,7 +37,7 @@ fn main() {
     } else if args.len() <= 1u {
         vec!("".to_string(), "10000".to_string(), "50".to_string())
     } else {
-        args.move_iter().collect()
+        args.into_iter().collect()
     };
     let max = from_str::<uint>(args.get(1).as_slice()).unwrap();
     let rep = from_str::<uint>(args.get(2).as_slice()).unwrap();

src/test/bench/task-perf-jargon-metal-smoke.rs

@@ -45,7 +45,7 @@ fn main() {
     } else if args.len() <= 1 {
         vec!("".to_string(), "100".to_string())
     } else {
-        args.clone().move_iter().collect()
+        args.clone().into_iter().collect()
     };
 
     let (tx, rx) = channel();

src/test/bench/task-perf-one-million.rs

@@ -28,20 +28,20 @@ fn calc(children: uint, parent_wait_chan: &Sender<Sender<Sender<int>>>) {
     });
 
     let child_start_chans: Vec<Sender<Sender<int>>> =
-        wait_ports.move_iter().map(|port| port.recv()).collect();
+        wait_ports.into_iter().map(|port| port.recv()).collect();
 
     let (start_port, start_chan) = stream::<Sender<int>>();
     parent_wait_chan.send(start_chan);
     let parent_result_chan: Sender<int> = start_port.recv();
 
     let child_sum_ports: Vec<Reciever<int>> =
-        child_start_chans.move_iter().map(|child_start_chan| {
+        child_start_chans.into_iter().map(|child_start_chan| {
             let (child_sum_port, child_sum_chan) = stream::<int>();
             child_start_chan.send(child_sum_chan);
             child_sum_port
     }).collect();
 
-    let sum = child_sum_ports.move_iter().fold(0, |sum, sum_port| sum + sum_port.recv() );
+    let sum = child_sum_ports.into_iter().fold(0, |sum, sum_port| sum + sum_port.recv() );
 
     parent_result_chan.send(sum + 1);
 }

src/test/bench/task-perf-spawnalot.rs

@@ -29,7 +29,7 @@ fn main() {
     } else if args.len() <= 1u {
         vec!("".to_string(), "10".to_string())
     } else {
-        args.move_iter().collect()
+        args.into_iter().collect()
     };
     let n = from_str::<uint>(args.get(1).as_slice()).unwrap();
     let mut i = 0u;

src/test/compile-fail/borrowck-move-out-of-overloaded-auto-deref.rs

@@ -11,6 +11,6 @@
 use std::rc::Rc;
 
 pub fn main() {
-    let _x = Rc::new(vec!(1i, 2)).move_iter();
+    let _x = Rc::new(vec!(1i, 2)).into_iter();
     //~^ ERROR cannot move out of dereference of `&`-pointer
 }

src/test/compile-fail/moves-based-on-type-access-to-field.rs

@@ -19,7 +19,7 @@ fn touch<A>(_a: &A) {}
 
 fn f20() {
     let x = vec!("hi".to_string());
-    consume(x.move_iter().next().unwrap());
+    consume(x.into_iter().next().unwrap());
     touch(x.get(0)); //~ ERROR use of moved value: `x`
 }
 

src/test/compile-fail/moves-based-on-type-exprs.rs

@@ -83,13 +83,13 @@ fn f80() {
 
 fn f100() {
     let x = vec!("hi".to_string());
-    let _y = x.move_iter().next().unwrap();
+    let _y = x.into_iter().next().unwrap();
     touch(&x); //~ ERROR use of moved value: `x`
 }
 
 fn f110() {
     let x = vec!("hi".to_string());
-    let _y = [x.move_iter().next().unwrap(), ..1];
+    let _y = [x.into_iter().next().unwrap(), ..1];
     touch(&x); //~ ERROR use of moved value: `x`
 }
 

src/test/compile-fail/std-uncopyable-atomics.rs

@@ -22,7 +22,7 @@ fn main() {
     let x = *&x; //~ ERROR: cannot move out of dereference
     let x = INIT_ATOMIC_UINT; //~ ERROR cannot move out of static item
     let x = *&x; //~ ERROR: cannot move out of dereference
-    let x: AtomicPtr<uint> = AtomicPtr::new(ptr::mut_null());
+    let x: AtomicPtr<uint> = AtomicPtr::new(ptr::null_mut());
     let x = *&x; //~ ERROR: cannot move out of dereference
     let x: AtomicOption<uint> = AtomicOption::empty();
     let x = *&x; //~ ERROR: cannot move out of dereference

src/test/compile-fail/vec-mut-iter-borrow.rs

@@ -11,7 +11,7 @@
 fn main() {
     let mut xs: Vec<int> = vec!();
 
-    for x in xs.mut_iter() {
+    for x in xs.iter_mut() {
         xs.push(1i) //~ ERROR cannot borrow `xs`
     }
 }

src/test/debuginfo/type-names.rs

@@ -269,9 +269,9 @@ fn main() {
     let mut_ref2 = (&mut mut_generic_struct, 0i32);
 
     // Raw Pointers
-    let mut_ptr1: (*mut Struct1, int) = (ptr::mut_null(), 0);
-    let mut_ptr2: (*mut int, int) = (ptr::mut_null(), 0);
-    let mut_ptr3: (*mut Mod1::Mod2::Enum3<Struct1>, int) = (ptr::mut_null(), 0);
+    let mut_ptr1: (*mut Struct1, int) = (ptr::null_mut(), 0);
+    let mut_ptr2: (*mut int, int) = (ptr::null_mut(), 0);
+    let mut_ptr3: (*mut Mod1::Mod2::Enum3<Struct1>, int) = (ptr::null_mut(), 0);
 
     let const_ptr1: (*const Struct1, int) = (ptr::null(), 0);
     let const_ptr2: (*const int, int) = (ptr::null(), 0);

src/test/run-pass/autobind.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 
-fn f<T>(x: Vec<T>) -> T { return x.move_iter().next().unwrap(); }
+fn f<T>(x: Vec<T>) -> T { return x.into_iter().next().unwrap(); }
 
 fn g(act: |Vec<int> | -> int) -> int { return act(vec!(1, 2, 3)); }
 

src/test/run-pass/const-vec-of-fns.rs

@@ -23,7 +23,7 @@ static mut closures: &'static mut [S<'static>] = &mut [S(f), S(f)];
 pub fn main() {
     unsafe {
         for &bare_fn in bare_fns.iter() { bare_fn() }
-        for closure in closures.mut_iter() {
+        for closure in closures.iter_mut() {
             let S(ref mut closure) = *closure;
             (*closure)()
         }

src/test/run-pass/dst-raw.rs

@@ -109,4 +109,4 @@ pub fn main() {
         let len = (&*c).f.len();
         assert!(len == 3);
     }
-}
+}

src/test/run-pass/issue-16151.rs

@@ -26,7 +26,7 @@ fn main() {
     {
         let mut fragments = vec![Fragment, Fragment, Fragment];
         let _new_fragments: Vec<Fragment> = mem::replace(&mut fragments, vec![])
-            .move_iter()
+            .into_iter()
             .skip_while(|_fragment| {
                 true
             }).collect();

src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs

@@ -16,7 +16,7 @@ fn test1() {
 
 fn test2() {
     let mut ints = [0i, ..32];
-    for i in ints.mut_iter() { *i += 22; }
+    for i in ints.iter_mut() { *i += 22; }
     for i in ints.iter() { assert!(*i == 22); }
 }
 

src/test/run-pass/newtype-polymorphic.rs

@@ -19,7 +19,7 @@ fn myvec_deref<X:Clone>(mv: myvec<X>) -> Vec<X> {
 
 fn myvec_elt<X>(mv: myvec<X>) -> X {
     let myvec(v) = mv;
-    return v.move_iter().next().unwrap();
+    return v.into_iter().next().unwrap();
 }
 
 pub fn main() {

src/test/run-pass/realloc-16687.rs

@@ -26,7 +26,7 @@ fn main() {
 
 unsafe fn test_triangle() -> bool {
     static COUNT : uint = 16;
-    let mut ascend = Vec::from_elem(COUNT, ptr::mut_null());
+    let mut ascend = Vec::from_elem(COUNT, ptr::null_mut());
     let ascend = ascend.as_mut_slice();
     static ALIGN : uint = 1;
 

src/test/run-pass/reflect-visit-type.rs

@@ -141,7 +141,7 @@ pub fn main() {
         println!("type: {}", (*s).clone());
     }
 
-    let vec_types: Vec<String> = v.types.clone().move_iter().collect();
+    let vec_types: Vec<String> = v.types.clone().into_iter().collect();
     assert_eq!(vec_types, vec!("bool".to_string(), "int".to_string(),
                                "i8".to_string(), "i16".to_string()));
 }

src/test/run-pass/send_str_treemap.rs

@@ -61,7 +61,7 @@ pub fn main() {
     assert_eq!(map.find(&Owned("def".to_string())), Some(&d));
 
     assert!(map.pop(&Slice("foo")).is_some());
-    assert_eq!(map.move_iter().map(|(k, v)| format!("{}{}", k, v))
+    assert_eq!(map.into_iter().map(|(k, v)| format!("{}{}", k, v))
                               .collect::<Vec<String>>()
                               .concat(),
                "abc50bcd51cde52def53".to_string());

src/test/run-pass/task-comm-3.rs

@@ -62,7 +62,7 @@ fn test00() {
     }
 
     // Join spawned tasks...
-    for r in results.mut_iter() { r.get_ref(); }
+    for r in results.iter_mut() { r.get_ref(); }
 
     println!("Completed: Final number is: ");
     println!("{:?}", sum);

src/test/run-pass/vec-dst.rs

@@ -78,11 +78,11 @@ fn reflect() {
 fn sub_expr() {
     // Test for a &[T] => &&[T] coercion in sub-expression position
     // (surpisingly, this can cause errors which are not caused by either of:
-    //    `let x = vec.mut_slice(0, 2);`
-    //    `foo(vec.mut_slice(0, 2));` ).
+    //    `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.mut_slice(0, 2) == b);
+    assert!(vec.slice_mut(0, 2) == b);
 }
 
 fn index() {