Demode vec::push (and convert to method)

16 files changed, 55 insertions, 51 deletions

diff --git a/src/libstd/arc.rs b/src/libstd/arc.rs
index 4ffe7245113..1f26822ed9f 100644
--- a/src/libstd/arc.rs
+++ b/src/libstd/arc.rs
@@ -648,7 +648,7 @@ mod tests {
         let mut children = ~[];
         for 5.times {
             let arc3 = ~arc.clone();
-            do task::task().future_result(|+r| vec::push(children, r)).spawn {
+            do task::task().future_result(|+r| children.push(r)).spawn {
                 do arc3.read |num| {
                     assert *num >= 0;
                 }
@@ -676,7 +676,7 @@ mod tests {
         let mut reader_convos = ~[];
         for 10.times {
             let ((rc1,rp1),(rc2,rp2)) = (pipes::stream(),pipes::stream());
-            vec::push(reader_convos, (rc1,rp2));
+            reader_convos.push((rc1,rp2));
             let arcn = ~arc.clone();
             do task::spawn {
                 rp1.recv(); // wait for downgrader to give go-ahead
diff --git a/src/libstd/base64.rs b/src/libstd/base64.rs
index 0da23db7291..e5eacd5c440 100644
--- a/src/libstd/base64.rs
+++ b/src/libstd/base64.rs
@@ -102,12 +102,12 @@ impl ~[u8]: FromBase64 {
                 } else if ch == '=' {
                     match len - i {
                       1u => {
-                        vec::push(r, ((n >> 16u) & 0xFFu) as u8);
-                        vec::push(r, ((n >> 8u ) & 0xFFu) as u8);
+                        r.push(((n >> 16u) & 0xFFu) as u8);
+                        r.push(((n >> 8u ) & 0xFFu) as u8);
                         return copy r;
                       }
                       2u => {
-                        vec::push(r, ((n >> 10u) & 0xFFu) as u8);
+                        r.push(((n >> 10u) & 0xFFu) as u8);
                         return copy r;
                       }
                       _ => fail ~"invalid base64 padding"
@@ -119,9 +119,9 @@ impl ~[u8]: FromBase64 {
                 i += 1u;
             };
 
-            vec::push(r, ((n >> 16u) & 0xFFu) as u8);
-            vec::push(r, ((n >> 8u ) & 0xFFu) as u8);
-            vec::push(r, ((n       ) & 0xFFu) as u8);
+            r.push(((n >> 16u) & 0xFFu) as u8);
+            r.push(((n >> 8u ) & 0xFFu) as u8);
+            r.push(((n       ) & 0xFFu) as u8);
         }
 
         r
diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs
index 17d4b39b01e..8506bd5f6fc 100644
--- a/src/libstd/deque.rs
+++ b/src/libstd/deque.rs
@@ -38,8 +38,8 @@ fn create<T: Copy>() -> Deque<T> {
         let nalloc = uint::next_power_of_two(nelts + 1u);
         while i < nalloc {
             if i < nelts {
-                vec::push(rv, elts[(lo + i) % nelts]);
-            } else { vec::push(rv, None); }
+                rv.push(elts[(lo + i) % nelts]);
+            } else { rv.push(None); }
             i += 1u;
         }
 
diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index 9b7f7a79f22..3f6bcd31a73 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -211,7 +211,7 @@ impl Writer {
         write_vuint(self.writer, tag_id);
 
         // Write a placeholder four-byte size.
-        vec::push(self.size_positions, self.writer.tell());
+        self.size_positions.push(self.writer.tell());
         let zeroes: &[u8] = &[0u8, 0u8, 0u8, 0u8];
         self.writer.write(zeroes);
     }
diff --git a/src/libstd/ebml2.rs b/src/libstd/ebml2.rs
index 8b37dea6210..496010d579e 100644
--- a/src/libstd/ebml2.rs
+++ b/src/libstd/ebml2.rs
@@ -220,7 +220,7 @@ impl Serializer {
         write_vuint(self.writer, tag_id);
 
         // Write a placeholder four-byte size.
-        vec::push(self.size_positions, self.writer.tell());
+        self.size_positions.push(self.writer.tell());
         let zeroes: &[u8] = &[0u8, 0u8, 0u8, 0u8];
         self.writer.write(zeroes);
     }
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index f8b86d80061..7a47db8a7f0 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -234,10 +234,10 @@ fn getopts(args: &[~str], opts: &[Opt]) -> Result unsafe {
         let cur = args[i];
         let curlen = str::len(cur);
         if !is_arg(cur) {
-            vec::push(free, cur);
+            free.push(cur);
         } else if cur == ~"--" {
             let mut j = i + 1u;
-            while j < l { vec::push(free, args[j]); j += 1u; }
+            while j < l { free.push(args[j]); j += 1u; }
             break;
         } else {
             let mut names;
@@ -287,7 +287,7 @@ fn getopts(args: &[~str], opts: &[Opt]) -> Result unsafe {
                         }
                       }
                     }
-                    vec::push(names, opt);
+                    names.push(opt);
                     j = range.next;
                 }
             }
@@ -303,23 +303,22 @@ fn getopts(args: &[~str], opts: &[Opt]) -> Result unsafe {
                     if !i_arg.is_none() {
                         return Err(UnexpectedArgument(name_str(nm)));
                     }
-                    vec::push(vals[optid], Given);
+                    vals[optid].push(Given);
                   }
                   Maybe => {
                     if !i_arg.is_none() {
-                        vec::push(vals[optid], Val(i_arg.get()));
+                        vals[optid].push(Val(i_arg.get()));
                     } else if name_pos < vec::len::<Name>(names) ||
                                   i + 1u == l || is_arg(args[i + 1u]) {
-                        vec::push(vals[optid], Given);
-                    } else { i += 1u; vec::push(vals[optid], Val(args[i])); }
+                        vals[optid].push(Given);
+                    } else { i += 1u; vals[optid].push(Val(args[i])); }
                   }
                   Yes => {
                     if !i_arg.is_none() {
-                        vec::push(vals[optid],
-                                  Val(i_arg.get()));
+                        vals[optid].push(Val(i_arg.get()));
                     } else if i + 1u == l {
                         return Err(ArgumentMissing(name_str(nm)));
-                    } else { i += 1u; vec::push(vals[optid], Val(args[i])); }
+                    } else { i += 1u; vals[optid].push(Val(args[i])); }
                   }
                 }
             }
@@ -412,7 +411,7 @@ fn opts_str(+mm: Matches, names: &[~str]) -> ~str {
 fn opt_strs(+mm: Matches, nm: &str) -> ~[~str] {
     let mut acc: ~[~str] = ~[];
     for vec::each(opt_vals(mm, nm)) |v| {
-        match *v { Val(s) => vec::push(acc, s), _ => () }
+        match *v { Val(s) => acc.push(s), _ => () }
     }
     return acc;
 }
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index f75f033bb8e..29535c62b5e 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -594,7 +594,7 @@ priv impl Parser {
 
         loop {
             match move self.parse_value() {
-              Ok(move v) => vec::push(values, v),
+              Ok(move v) => values.push(v),
               Err(move e) => return Err(e)
             }
 
@@ -690,13 +690,13 @@ pub fn Deserializer(rdr: io::Reader) -> Result<Deserializer, Error> {
 }
 
 priv impl Deserializer {
-    fn peek() -> &self/Json {
-        if self.stack.len() == 0 { vec::push(self.stack, &self.json); }
+    fn peek(&self) -> &self/Json {
+        if self.stack.len() == 0 { self.stack.push(&self.json); }
         vec::last(self.stack)
     }
 
-    fn pop() -> &self/Json {
-        if self.stack.len() == 0 { vec::push(self.stack, &self.json); }
+    fn pop(&self) -> &self/Json {
+        if self.stack.len() == 0 { self.stack.push(&self.json); }
         vec::pop(self.stack)
     }
 }
@@ -772,7 +772,7 @@ pub impl Deserializer: serialization2::Deserializer {
     fn read_vec<T>(&self, f: fn(uint) -> T) -> T {
         debug!("read_vec()");
         let len = match *self.peek() {
-            List(list) => list.len(),
+            List(ref list) => list.len(),
             _ => fail ~"not a list",
         };
         let res = f(len);
@@ -784,7 +784,10 @@ pub impl Deserializer: serialization2::Deserializer {
         debug!("read_vec_elt(idx=%u)", idx);
         match *self.peek() {
             List(ref list) => {
-                vec::push(self.stack, &list[idx]);
+                // FIXME(#3148)---should be inferred
+                let list: &self/~[Json] = list;
+
+                self.stack.push(&list[idx]);
                 f()
             }
             _ => fail ~"not a list",
@@ -820,7 +823,7 @@ pub impl Deserializer: serialization2::Deserializer {
                 match obj.find_ref(&f_name) {
                     None => fail fmt!("no such field: %s", f_name),
                     Some(json) => {
-                        vec::push(self.stack, json);
+                        self.stack.push(json);
                         f()
                     }
                 }
@@ -845,8 +848,10 @@ pub impl Deserializer: serialization2::Deserializer {
     fn read_tup_elt<T>(&self, idx: uint, f: fn() -> T) -> T {
         debug!("read_tup_elt(idx=%u)", idx);
         match *self.peek() {
-            List(list) => {
-                vec::push(self.stack, &list[idx]);
+            List(ref list) => {
+                // FIXME(#3148)---should be inferred
+                let list: &self/~[Json] = list;
+                self.stack.push(&list[idx]);
                 f()
             }
             _ => fail ~"not a list"
@@ -939,12 +944,12 @@ impl Json : Ord {
 
                             // XXX: this is horribly inefficient...
                             for d0.each |k, v| {
-                                 vec::push(d0_flat, (@copy *k, @copy *v));
+                                 d0_flat.push((@copy *k, @copy *v));
                             }
                             d0_flat.qsort();
 
                             for d1.each |k, v| {
-                                vec::push(d1_flat, (@copy *k, @copy *v));
+                                d1_flat.push((@copy *k, @copy *v));
                             }
                             d1_flat.qsort();
 
diff --git a/src/libstd/md4.rs b/src/libstd/md4.rs
index a4272324670..0bf4f6f8610 100644
--- a/src/libstd/md4.rs
+++ b/src/libstd/md4.rs
@@ -11,14 +11,14 @@ fn md4(msg: &[u8]) -> {a: u32, b: u32, c: u32, d: u32} {
     let mut msg = vec::append(vec::from_slice(msg), ~[0x80u8]);
     let mut bitlen = orig_len + 8u64;
     while (bitlen + 64u64) % 512u64 > 0u64 {
-        vec::push(msg, 0u8);
+        msg.push(0u8);
         bitlen += 8u64;
     }
 
     // append length
     let mut i = 0u64;
     while i < 8u64 {
-        vec::push(msg, (orig_len >> (i * 8u64)) as u8);
+        msg.push((orig_len >> (i * 8u64)) as u8);
         i += 1u64;
     }
 
diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs
index 445bc62e4c9..347f2b271a1 100644
--- a/src/libstd/net_ip.rs
+++ b/src/libstd/net_ip.rs
@@ -277,7 +277,7 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
                         result::Err(GetAddrUnknownError));
                     break;
                 };
-                vec::push(out_vec, move new_ip_addr);
+                out_vec.push(move new_ip_addr);
 
                 let next_addr = ll::get_next_addrinfo(curr_addr);
                 if next_addr == ptr::null::<addrinfo>() as *addrinfo {
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index a1c7637dee6..a0ba8aae3f1 100644
--- a/src/libstd/net_tcp.rs
+++ b/src/libstd/net_tcp.rs
@@ -779,7 +779,7 @@ impl TcpSocketBuf: io::Reader {
                 }
             }
             else {
-                vec::push_all(self.data.buf, result::unwrap(read_result));
+                self.data.buf.push_all(result::unwrap(read_result));
             }
         }
 
@@ -790,7 +790,7 @@ impl TcpSocketBuf: io::Reader {
 
         vec::bytes::memcpy(buf, vec::view(data, 0, data.len()), count);
 
-        vec::push_all(self.data.buf, vec::view(data, count, data.len()));
+        self.data.buf.push_all(vec::view(data, count, data.len()));
 
         count
     }
diff --git a/src/libstd/net_url.rs b/src/libstd/net_url.rs
index 8116bd4fb30..33e657c390b 100644
--- a/src/libstd/net_url.rs
+++ b/src/libstd/net_url.rs
@@ -329,7 +329,7 @@ fn query_from_str(rawquery: &str) -> Query {
     if str::len(rawquery) != 0 {
         for str::split_char(rawquery, '&').each |p| {
             let (k, v) = split_char_first(*p, '=');
-            vec::push(query, (decode_component(k), decode_component(v)));
+            query.push((decode_component(k), decode_component(v)));
         };
     }
     return query;
diff --git a/src/libstd/par.rs b/src/libstd/par.rs
index 38a814b22e0..2f98c4bad34 100644
--- a/src/libstd/par.rs
+++ b/src/libstd/par.rs
@@ -55,7 +55,7 @@ fn map_slices<A: Copy Send, B: Copy Send>(
                         f(base, slice)
                     }
                 };
-                vec::push(futures, move f);
+                futures.push(move f);
             };
             base += items_per_task;
         }
diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs
index 2d49ede3507..4680448e275 100644
--- a/src/libstd/rope.rs
+++ b/src/libstd/rope.rs
@@ -869,7 +869,7 @@ mod node {
         loop {
             match (leaf_iterator::next(&it)) {
               option::None    => break,
-              option::Some(x) => vec::push(forest, @Leaf(x))
+              option::Some(x) => forest.push(@Leaf(x))
             }
         }
         //2. Rebuild tree from forest
diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs
index 46f79c01948..f1abe5be5a5 100644
--- a/src/libstd/sort.rs
+++ b/src/libstd/sort.rs
@@ -47,9 +47,9 @@ fn merge_sort<T: Copy>(le: Le<T>, v: &[const T]) -> ~[T] {
         let mut b_ix = 0u;
         while a_ix < a_len && b_ix < b_len {
             if le(&a[a_ix], &b[b_ix]) {
-                vec::push(rs, a[a_ix]);
+                rs.push(a[a_ix]);
                 a_ix += 1u;
-            } else { vec::push(rs, b[b_ix]); b_ix += 1u; }
+            } else { rs.push(b[b_ix]); b_ix += 1u; }
         }
         rs = vec::append(rs, vec::slice(a, a_ix, a_len));
         rs = vec::append(rs, vec::slice(b, b_ix, b_len));
diff --git a/src/libstd/sync.rs b/src/libstd/sync.rs
index 8fdcc22b4c1..7638b43ad86 100644
--- a/src/libstd/sync.rs
+++ b/src/libstd/sync.rs
@@ -82,7 +82,7 @@ fn new_sem_and_signal(count: int, num_condvars: uint)
         -> Sem<~[mut Waitqueue]> {
     let mut queues = ~[];
     for num_condvars.times {
-        vec::push(queues, new_waitqueue());
+        queues.push(new_waitqueue());
     }
     new_sem(count, vec::to_mut(move queues))
 }
@@ -840,7 +840,7 @@ mod tests {
         for num_waiters.times {
             let mi = ~m.clone();
             let (chan, port) = pipes::stream();
-            vec::push(ports, port);
+            ports.push(port);
             do task::spawn {
                 do mi.lock_cond |cond| {
                     chan.send(());
@@ -930,7 +930,7 @@ mod tests {
             for 2.times {
                 let (c,p) = pipes::stream();
                 let c = ~mut Some(c);
-                vec::push(sibling_convos, p);
+                sibling_convos.push(p);
                 let mi = ~m2.clone();
                 // spawn sibling task
                 do task::spawn { // linked
@@ -1194,7 +1194,7 @@ mod tests {
         for num_waiters.times {
             let xi = ~x.clone();
             let (chan, port) = pipes::stream();
-            vec::push(ports, port);
+            ports.push(port);
             do task::spawn {
                 do lock_cond(xi, dg1) |cond| {
                     chan.send(());
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index e872cba5dc9..facc43f6273 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -141,7 +141,7 @@ fn run_tests_console(opts: &TestOpts,
                 st.failed += 1u;
                 write_failed(st.out, st.use_color);
                 st.out.write_line(~"");
-                vec::push(st.failures, copy test);
+                st.failures.push(copy test);
               }
               TrIgnored => {
                 st.ignored += 1u;
@@ -545,7 +545,7 @@ mod tests {
             for vec::each(names) |name| {
                 let test = {name: *name, testfn: copy testfn, ignore: false,
                             should_fail: false};
-                vec::push(tests, test);
+                tests.push(test);
             }
             tests
         };