Demode vec::push (and convert to method)

Author: nikomatsakis

doc/rust.md

@@ -1016,7 +1016,7 @@ fn iter<T>(seq: ~[T], f: fn(T)) {
 }
 fn map<T, U>(seq: ~[T], f: fn(T) -> U) -> ~[U] {
     let mut acc = ~[];
-    for seq.each |elt| { vec::push(acc, f(elt)); }
+    for seq.each |elt| { acc.push(f(elt)); }
     acc
 }
 ~~~~

doc/tutorial.md

@@ -1651,7 +1651,7 @@ may be invoked on multiple types.
 fn map<T, U>(vector: &[T], function: fn(v: &T) -> U) -> ~[U] {
     let mut accumulator = ~[];
     for vec::each(vector) |element| {
-        vec::push(accumulator, function(element));
+        accumulator.push(function(element));
     }
     return accumulator;
 }

src/cargo/cargo.rs

@@ -345,7 +345,7 @@ fn load_crate(filename: &Path) -> Option<Crate> {
 
                 match *ps.interner.get(attr_name) {
                     ~"std" | ~"core" => (),
-                    _ => vec::push(e.deps, query)
+                    _ => e.deps.push(query)
                 }
             }
             _ => ()
@@ -801,7 +801,7 @@ fn install_source(c: &Cargo, path: &Path) {
     let mut cratefiles = ~[];
     for os::walk_dir(&Path(".")) |p| {
         if p.filetype() == Some(~".rc") {
-            vec::push(cratefiles, *p);
+            cratefiles.push(*p);
         }
     }
 

src/compiletest/compiletest.rs

@@ -141,7 +141,7 @@ fn make_tests(config: config) -> ~[test::TestDesc] {
         let file = copy *file;
         debug!("inspecting file %s", file.to_str());
         if is_test(config, file) {
-            vec::push(tests, make_test(config, file))
+            tests.push(make_test(config, file))
         }
     }
     return tests;

src/compiletest/header.rs

@@ -28,7 +28,7 @@ fn load_props(testfile: &Path) -> test_props {
     let mut pp_exact = option::None;
     for iter_header(testfile) |ln| {
         match parse_error_pattern(ln) {
-          option::Some(ep) => vec::push(error_patterns, ep),
+          option::Some(ep) => error_patterns.push(ep),
           option::None => ()
         };
 
@@ -41,11 +41,11 @@ fn load_props(testfile: &Path) -> test_props {
         }
 
         do parse_aux_build(ln).iter |ab| {
-            vec::push(aux_builds, ab);
+            aux_builds.push(ab);
         }
 
         do parse_exec_env(ln).iter |ee| {
-            vec::push(exec_env, ee);
+            exec_env.push(ee);
         }
     };
     return {

src/compiletest/procsrv.rs

@@ -19,7 +19,7 @@ fn target_env(lib_path: ~str, prog: ~str) -> ~[(~str,~str)] {
         else { (k,v) }
     };
     if str::ends_with(prog, ~"rustc.exe") {
-        vec::push(env, (~"RUST_THREADS", ~"1"));
+        env.push((~"RUST_THREADS", ~"1"));
     }
     return env;
 }

src/compiletest/runtest.rs

@@ -121,7 +121,7 @@ fn run_pretty_test(config: config, props: test_props, testfile: &Path) {
                           procres);
         }
 
-        vec::push(srcs, procres.stdout);
+        srcs.push(procres.stdout);
         round += 1;
     }
 

src/fuzzer/cycles.rs

@@ -62,7 +62,7 @@ fn test_cycles(r : rand::rng, k: uint, n: uint)
 
     // Create a graph with no edges
     range(0u, vlen) {|_i|
-        vec::push(v, empty_pointy());
+        v.push(empty_pointy());
     }
 
     // Fill in the graph with random edges, with density k/n
@@ -77,7 +77,7 @@ fn test_cycles(r : rand::rng, k: uint, n: uint)
           // https://github.com/mozilla/rust/issues/1899
 
         if (likelihood(r, k, n)) { v[i].m = [p(choice(r, v))]; }
-        if (likelihood(r, k, n)) { vec::push(v[i].n, mut p(choice(r, v))); }
+        if (likelihood(r, k, n)) { v[i].n.push(mut p(choice(r, v))); }
         if (likelihood(r, k, n)) { v[i].o = {x: 0, y: p(choice(r, v))}; }
     }
 

src/fuzzer/fuzzer.rs

@@ -30,7 +30,7 @@ fn contains(haystack: ~str, needle: ~str) -> bool {
 fn find_rust_files(files: &mut ~[Path], path: &Path) {
     if path.filetype() == Some(~".rs") && !contains(path.to_str(), ~"utf8") {
         // ignoring "utf8" tests because something is broken
-        vec::push(*files, *path);
+        files.push(*path);
     } else if os::path_is_dir(path)
         && !contains(path.to_str(), ~"compile-fail")
         && !contains(path.to_str(), ~"build") {
@@ -124,7 +124,7 @@ fn stash_ty_if(c: fn@(@ast::ty, test_mode)->bool,
                e: @ast::ty,
                tm: test_mode) {
     if c(e, tm) {
-        vec::push(*es,*e);
+        es.push(e);
     } else {/* now my indices are wrong :( */ }
 }
 

src/fuzzer/ivec_fuzz.rs

@@ -55,11 +55,11 @@ fn vec_edits<T: copy>(v: ~[T], xs: ~[T]) -> ~[~[T]] {
 
     if Lv != 1u {
         // When Lv == 1u, this is redundant with omit.
-        vec::push(edits, ~[]);
+        edits.push(~[]);
     }
     if Lv >= 3u {
         // When Lv == 2u, this is redundant with swap.
-        vec::push(edits, vec::reversed(v));
+        edits.push(vec::reversed(v));
     }
     ix(0u, 1u, Lv) {|i| edits += ~[vec_omit(v, i)]; }
     ix(0u, 1u, Lv) {|i| edits += ~[vec_dup(v, i)]; }
@@ -69,10 +69,10 @@ fn vec_edits<T: copy>(v: ~[T], xs: ~[T]) -> ~[~[T]] {
 
     ix(0u, 1u, len(xs)) {|j|
         ix(0u, 1u, Lv) {|i|
-            vec::push(edits, vec_poke(v, i, xs[j]));
+            edits.push(vec_poke(v, i, xs[j]));
         }
         ix(0u, 0u, Lv) {|i|
-            vec::push(edits, vec_insert(v, i, xs[j]));
+            edits.push(vec_insert(v, i, xs[j]));
         }
     }
 

src/fuzzer/rand_util.rs

@@ -61,7 +61,7 @@ fn weighted_vec<T: copy>(v : ~[weighted<T>]) -> ~[T] {
     for {weight: weight, item: item} in v {
         let i = 0u;
         while i < weight {
-            vec::push(r, item);
+            r.push(item);
             i += 1u;
         }
     }

src/libcore/core.rs

@@ -17,6 +17,7 @@ use tuple::{TupleOps, ExtendedTupleOps};
 use str::{StrSlice, UniqueStr};
 use vec::{ConstVector, CopyableVector, ImmutableVector};
 use vec::{ImmutableEqVector, ImmutableCopyableVector};
+use vec::{MutableVector, MutableCopyableVector};
 use iter::{BaseIter, ExtendedIter, EqIter, CopyableIter};
 use iter::{CopyableOrderedIter, Times, TimesIx};
 use num::Num;
@@ -33,6 +34,7 @@ export Num, Times, TimesIx;
 export StrSlice, UniqueStr;
 export ConstVector, CopyableVector, ImmutableVector;
 export ImmutableEqVector, ImmutableCopyableVector, IterTraitExtensions;
+export MutableVector, MutableCopyableVector;
 export BaseIter, CopyableIter, CopyableOrderedIter, ExtendedIter, EqIter;
 export TupleOps, ExtendedTupleOps;
 export Ptr;

src/libcore/dvec.rs

@@ -172,15 +172,15 @@ impl<A> DVec<A> {
             if data_ptr.is_null() { fail ~"Recursive use of dvec"; }
             log(error, ~"a");
             self.data <- ~[move t];
-            vec::push_all_move(self.data, move data);
+            self.data.push_all_move(move data);
             log(error, ~"b");
         }
     }
 
     /// Append a single item to the end of the list
     fn push(+t: A) {
         self.check_not_borrowed();
-        vec::push(self.data, move t);
+        self.data.push(move t);
     }
 
     /// Remove and return the first element
@@ -240,7 +240,7 @@ impl<A: Copy> DVec<A> {
             vec::reserve(&mut v, new_len);
             let mut i = from_idx;
             while i < to_idx {
-                vec::push(v, ts[i]);
+                v.push(ts[i]);
                 i += 1u;
             }
             move v
@@ -266,7 +266,7 @@ impl<A: Copy> DVec<A> {
             }
            };
 
-        for ts.each |t| { vec::push(v, *t) };
+        for ts.each |t| { v.push(*t) };
            v
         }
     }

src/libcore/either.rs

@@ -32,27 +32,27 @@ fn either<T, U, V>(f_left: fn((&T)) -> V,
 fn lefts<T: Copy, U>(eithers: &[Either<T, U>]) -> ~[T] {
     //! Extracts from a vector of either all the left values
 
-    let mut result: ~[T] = ~[];
-    for vec::each(eithers) |elt| {
-        match *elt {
-          Left(l) => vec::push(result, l),
-          _ => { /* fallthrough */ }
+    do vec::build_sized(eithers.len()) |push| {
+        for vec::each(eithers) |elt| {
+            match *elt {
+                Left(ref l) => { push(*l); }
+                _ => { /* fallthrough */ }
+            }
         }
     }
-    move result
 }
 
 fn rights<T, U: Copy>(eithers: &[Either<T, U>]) -> ~[U] {
     //! Extracts from a vector of either all the right values
 
-    let mut result: ~[U] = ~[];
-    for vec::each(eithers) |elt| {
-        match *elt {
-          Right(r) => vec::push(result, r),
-          _ => { /* fallthrough */ }
+    do vec::build_sized(eithers.len()) |push| {
+        for vec::each(eithers) |elt| {
+            match *elt {
+                Right(ref r) => { push(*r); }
+                _ => { /* fallthrough */ }
+            }
         }
     }
-    move result
 }
 
 fn partition<T: Copy, U: Copy>(eithers: &[Either<T, U>])
@@ -68,8 +68,8 @@ fn partition<T: Copy, U: Copy>(eithers: &[Either<T, U>])
     let mut rights: ~[U] = ~[];
     for vec::each(eithers) |elt| {
         match *elt {
-          Left(l) => vec::push(lefts, l),
-          Right(r) => vec::push(rights, r)
+          Left(l) => lefts.push(l),
+          Right(r) => rights.push(r)
         }
     }
     return {lefts: move lefts, rights: move rights};

src/libcore/extfmt.rs

@@ -90,7 +90,7 @@ mod ct {
         fn flush_buf(+buf: ~str, &pieces: ~[Piece]) -> ~str {
             if str::len(buf) > 0 {
                 let piece = PieceString(move buf);
-                vec::push(pieces, move piece);
+                pieces.push(move piece);
             }
             return ~"";
         }
@@ -110,7 +110,7 @@ mod ct {
                 } else {
                     buf = flush_buf(move buf, pieces);
                     let rs = parse_conversion(s, i, lim, error);
-                    vec::push(pieces, copy rs.piece);
+                    pieces.push(copy rs.piece);
                     i = rs.next;
                 }
             } else { buf += curr; i += size; }

src/libcore/flate.rs

@@ -71,12 +71,12 @@ fn test_flate_round_trip() {
     let r = rand::Rng();
     let mut words = ~[];
     for 20.times {
-        vec::push(words, r.gen_bytes(r.gen_uint_range(1, 10)));
+        words.push(r.gen_bytes(r.gen_uint_range(1, 10)));
     }
     for 20.times {
         let mut in = ~[];
         for 2000.times {
-            vec::push_all(in, r.choose(words));
+            in.push_all(r.choose(words));
         }
         debug!("de/inflate of %u bytes of random word-sequences",
                in.len());

src/libcore/float.rs

@@ -143,7 +143,7 @@ fn to_str_common(num: float, digits: uint, exact: bool) -> ~str {
         // store the next digit
         frac *= 10.0;
         let digit = frac as uint;
-        vec::push(fractionalParts, digit);
+        fractionalParts.push(digit);
 
         // calculate the next frac
         frac -= digit as float;

src/libcore/io.rs

@@ -76,7 +76,7 @@ impl<T: Reader> T : ReaderUtil {
         loop {
             let ch = self.read_byte();
             if ch == -1 || ch == 10 { break; }
-            vec::push(buf, ch as u8);
+            buf.push(ch as u8);
         }
         str::from_bytes(buf)
     }
@@ -94,7 +94,7 @@ impl<T: Reader> T : ReaderUtil {
                 i += 1;
                 assert (w > 0);
                 if w == 1 {
-                    vec::push(*chars, b0 as char);
+                    chars.push(b0 as char);
                     loop;
                 }
                 // can't satisfy this char with the existing data
@@ -113,7 +113,7 @@ impl<T: Reader> T : ReaderUtil {
                 // See str::char_at
                 val += ((b0 << ((w + 1) as u8)) as uint)
                     << (w - 1) * 6 - w - 1u;
-                vec::push(*chars, val as char);
+                chars.push(val as char);
             }
             return (i, 0);
         }
@@ -128,7 +128,7 @@ impl<T: Reader> T : ReaderUtil {
                 // we're split in a unicode char?
                 break;
             }
-            vec::push_all(buf, data);
+            buf.push_all(data);
             let (offset, nbreq) = chars_from_bytes::<T>(&buf, &mut chars);
             let ncreq = n - chars.len();
             // again we either know we need a certain number of bytes
@@ -155,7 +155,7 @@ impl<T: Reader> T : ReaderUtil {
         let mut buf: ~[u8] = ~[];
         loop {
             let ch = self.read_byte();
-            if ch < 1 { break; } else { vec::push(buf, ch as u8); }
+            if ch < 1 { break; } else { buf.push(ch as u8); }
         }
         str::from_bytes(buf)
     }
@@ -190,7 +190,7 @@ impl<T: Reader> T : ReaderUtil {
 
     fn read_whole_stream() -> ~[u8] {
         let mut buf: ~[u8] = ~[];
-        while !self.eof() { vec::push_all(buf, self.read_bytes(2048u)); }
+        while !self.eof() { buf.push_all(self.read_bytes(2048u)); }
         move buf
     }
 
@@ -503,7 +503,7 @@ fn u64_to_le_bytes<T>(n: u64, size: uint, f: fn(v: &[u8]) -> T) -> T {
 
         let mut bytes: ~[u8] = ~[], i = size, n = n;
         while i > 0u {
-            vec::push(bytes, (n & 255_u64) as u8);
+            bytes.push((n & 255_u64) as u8);
             n >>= 8_u64;
             i -= 1u;
         }
@@ -535,7 +535,7 @@ fn u64_to_be_bytes<T>(n: u64, size: uint, f: fn(v: &[u8]) -> T) -> T {
         let mut i = size;
         while i > 0u {
             let shift = ((i - 1u) * 8u) as u64;
-            vec::push(bytes, (n >> shift) as u8);
+            bytes.push((n >> shift) as u8);
             i -= 1u;
         }
         f(bytes)
@@ -737,7 +737,7 @@ fn with_str_writer(f: fn(Writer)) -> ~str {
     let mut v = with_bytes_writer(f);
 
     // Make sure the vector has a trailing null and is proper utf8.
-    vec::push(v, 0);
+    v.push(0);
     assert str::is_utf8(v);
 
     unsafe { move ::cast::transmute(v) }

src/libcore/os.rs

@@ -219,7 +219,7 @@ mod global_env {
             for vec::each(rustrt::rust_env_pairs()) |p| {
                 let vs = str::splitn_char(*p, '=', 1u);
                 assert vec::len(vs) == 2u;
-                vec::push(pairs, (copy vs[0], copy vs[1]));
+                pairs.push((copy vs[0], copy vs[1]));
             }
             move pairs
         }