core: Rename to_mut and from_mut to cast_to_mut and cast_from_mut

8 files changed, 22 insertions, 21 deletions

diff --git a/src/libstd/bitv.rs b/src/libstd/bitv.rs
index 288163accfe..fc5040e0e31 100644
--- a/src/libstd/bitv.rs
+++ b/src/libstd/bitv.rs
@@ -13,7 +13,7 @@
 use core::ops;
 use core::prelude::*;
 use core::uint;
-use core::vec::{to_mut, from_elem};
+use core::vec::{cast_to_mut, from_elem};
 use core::vec;
 
 struct SmallBitv {
@@ -231,7 +231,7 @@ pub fn Bitv (nbits: uint, init: bool) -> Bitv {
         let nelems = nbits/uint_bits +
                      if nbits % uint_bits == 0 {0} else {1};
         let elem = if init {!0} else {0};
-        let s = to_mut(from_elem(nelems, elem));
+        let s = cast_to_mut(from_elem(nelems, elem));
         Big(~BigBitv(move s))
     };
     Bitv {rep: move rep, nbits: nbits}
@@ -516,7 +516,7 @@ impl Bitv: Clone {
             Bitv{nbits: self.nbits, rep: Small(~SmallBitv{bits: b.bits})}
           }
           Big(ref b) => {
-            let st = to_mut(from_elem(self.nbits / uint_bits + 1, 0));
+            let st = cast_to_mut(from_elem(self.nbits / uint_bits + 1, 0));
             let len = st.len();
             for uint::range(0, len) |i| { st[i] = b.storage[i]; };
             Bitv{nbits: self.nbits, rep: Big(~BigBitv{storage: move st})}
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index 93eb2095c5e..2fcf3b68521 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -222,7 +222,7 @@ pub type Result = result::Result<Matches, Fail_>;
 pub fn getopts(args: &[~str], opts: &[Opt]) -> Result unsafe {
     let n_opts = opts.len();
     fn f(_x: uint) -> ~[Optval] { return ~[]; }
-    let vals = vec::to_mut(vec::from_fn(n_opts, f));
+    let vals = vec::cast_to_mut(vec::from_fn(n_opts, f));
     let mut free: ~[~str] = ~[];
     let l = args.len();
     let mut i = 0;
@@ -337,7 +337,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result unsafe {
         i += 1;
     }
     return Ok(Matches {opts: vec::from_slice(opts),
-               vals: vec::from_mut(move vals),
+               vals: vec::cast_from_mut(move vals),
                free: free});
 }
 
diff --git a/src/libstd/map.rs b/src/libstd/map.rs
index d76fd85c587..47b75e901f1 100644
--- a/src/libstd/map.rs
+++ b/src/libstd/map.rs
@@ -450,7 +450,7 @@ pub mod chained {
     }
 
     fn chains<K,V>(nchains: uint) -> ~[mut Option<@Entry<K,V>>] {
-        vec::to_mut(vec::from_elem(nchains, None))
+        vec::cast_to_mut(vec::from_elem(nchains, None))
     }
 
     pub fn mk<K:Eq IterBytes Hash, V: Copy>() -> T<K,V> {
diff --git a/src/libstd/md4.rs b/src/libstd/md4.rs
index d10533008d9..06b6aca6895 100644
--- a/src/libstd/md4.rs
+++ b/src/libstd/md4.rs
@@ -47,7 +47,7 @@ pub pure fn md4(msg: &[u8]) -> {a: u32, b: u32, c: u32, d: u32} {
 
     let mut i = 0u;
     let e = vec::len(msg);
-    let x = vec::to_mut(vec::from_elem(16u, 0u32));
+    let x = vec::cast_to_mut(vec::from_elem(16u, 0u32));
     while i < e {
         let aa = a, bb = b, cc = c, dd = d;
 
diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs
index d478970ca9f..8b769cea2c9 100644
--- a/src/libstd/rope.rs
+++ b/src/libstd/rope.rs
@@ -176,7 +176,7 @@ pub fn concat(v: ~[Rope]) -> Rope {
     //Copy `v` into a mut vector
     let mut len = vec::len(v);
     if len == 0u { return node::Empty; }
-    let ropes = vec::to_mut(vec::from_elem(len, v[0]));
+    let ropes = vec::cast_to_mut(vec::from_elem(len, v[0]));
     for uint::range(1u, len) |i| {
        ropes[i] = v[i];
     }
@@ -720,7 +720,7 @@ pub mod node {
             //Firstly, split `str` in slices of hint_max_leaf_char_len
             let mut leaves = uint::div_ceil(char_len, hint_max_leaf_char_len);
             //Number of leaves
-            let nodes  = vec::to_mut(vec::from_elem(leaves, candidate));
+            let nodes  = vec::cast_to_mut(vec::from_elem(leaves, candidate));
 
             let mut i = 0u;
             let mut offset = byte_start;
@@ -832,7 +832,7 @@ pub mod node {
     }
 
     pub fn serialize_node(node: @Node) -> ~str unsafe {
-        let mut buf = vec::to_mut(vec::from_elem(byte_len(node), 0u8));
+        let mut buf = vec::cast_to_mut(vec::from_elem(byte_len(node), 0u8));
         let mut offset = 0u;//Current position in the buffer
         let it = leaf_iterator::start(node);
         loop {
@@ -1158,7 +1158,8 @@ pub mod node {
         }
 
         pub fn start(node: @Node) -> T {
-            let stack = vec::to_mut(vec::from_elem(height(node)+1u, node));
+            let stack = vec::cast_to_mut(
+                vec::from_elem(height(node)+1u, node));
             return {
                 stack:         move stack,
                 mut stackpos:  0
diff --git a/src/libstd/sha1.rs b/src/libstd/sha1.rs
index 2fb12460498..56f490f7673 100644
--- a/src/libstd/sha1.rs
+++ b/src/libstd/sha1.rs
@@ -259,13 +259,13 @@ pub fn sha1() -> Sha1 {
         }
     }
     let st = {
-        h: vec::to_mut(vec::from_elem(digest_buf_len, 0u32)),
+        h: vec::cast_to_mut(vec::from_elem(digest_buf_len, 0u32)),
         mut len_low: 0u32,
         mut len_high: 0u32,
-        msg_block: vec::to_mut(vec::from_elem(msg_block_len, 0u8)),
+        msg_block: vec::cast_to_mut(vec::from_elem(msg_block_len, 0u8)),
         mut msg_block_idx: 0u,
         mut computed: false,
-        work_buf: @vec::to_mut(vec::from_elem(work_buf_len, 0u32))
+        work_buf: @vec::cast_to_mut(vec::from_elem(work_buf_len, 0u32))
     };
     let sh = (move st) as Sha1;
     sh.reset();
diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs
index d83568ddd94..cce3dc725da 100644
--- a/src/libstd/sort.rs
+++ b/src/libstd/sort.rs
@@ -457,7 +457,7 @@ impl<T: Copy Ord> MergeState<T> {
                 base2: uint, len2: uint) {
         assert len1 != 0 && len2 != 0 && base1+len1 == base2;
 
-        let tmp = vec::to_mut(vec::slice(array, base1, base1+len1));
+        let tmp = vec::cast_to_mut(vec::slice(array, base1, base1+len1));
 
         let mut c1 = 0;
         let mut c2 = base2;
@@ -560,7 +560,7 @@ impl<T: Copy Ord> MergeState<T> {
                 base2: uint, len2: uint) {
         assert len1 != 1 && len2 != 0 && base1 + len1 == base2;
 
-        let tmp = vec::to_mut(vec::slice(array, base2, base2+len2));
+        let tmp = vec::cast_to_mut(vec::slice(array, base2, base2+len2));
 
         let mut c1 = base1 + len1 - 1;
         let mut c2 = len2 - 1;
@@ -816,7 +816,7 @@ mod test_qsort {
 
         do quick_sort(names) |x, y| { int::le(*x, *y) };
 
-        let immut_names = vec::from_mut(move names);
+        let immut_names = vec::cast_from_mut(move names);
 
         let pairs = vec::zip_slice(expected, immut_names);
         for vec::each(pairs) |p| {
@@ -1025,7 +1025,7 @@ mod big_tests {
         let res = do vec::from_fn(num) |i| {
             arr[i % size]
         };
-        vec::to_mut(move res)
+        vec::cast_to_mut(move res)
     }
 
     fn makeRange(n: uint) -> ~[uint] {
@@ -1051,7 +1051,7 @@ mod big_tests {
             let arr = do vec::from_fn(n) |_i| {
                 rng.gen_float()
             };
-            let arr = vec::to_mut(move arr);
+            let arr = vec::cast_to_mut(move arr);
 
             tim_sort(arr); // *sort
             isSorted(arr);
@@ -1123,7 +1123,7 @@ mod big_tests {
             let arr = do vec::from_fn(n) |_i| {
                 @rng.gen_float()
             };
-            let arr = vec::to_mut(move arr);
+            let arr = vec::cast_to_mut(move arr);
 
             tim_sort(arr); // *sort
             isSorted(arr);
diff --git a/src/libstd/sync.rs b/src/libstd/sync.rs
index f12114bfd8e..03ef98d09c5 100644
--- a/src/libstd/sync.rs
+++ b/src/libstd/sync.rs
@@ -97,7 +97,7 @@ fn new_sem_and_signal(count: int, num_condvars: uint)
     for num_condvars.times {
         queues.push(new_waitqueue());
     }
-    new_sem(count, vec::to_mut(move queues))
+    new_sem(count, vec::cast_to_mut(move queues))
 }
 
 #[doc(hidden)]