remove deprecated vec::{is_empty, len} functions

Author: thestinger

doc/tutorial.md

@@ -2046,7 +2046,7 @@ trait Seq<T> {
 }
 
 impl<T> Seq<T> for ~[T] {
-    fn len(&self) -> uint { vec::len(*self) }
+    fn len(&self) -> uint { self.len() }
     fn iter(&self, b: &fn(v: &T)) {
         for vec::each(*self) |elt| { b(elt); }
     }

src/compiletest/compiletest.rc

@@ -97,7 +97,7 @@ pub fn parse_config(args: ~[~str]) -> config {
         mode: str_mode(getopts::opt_str(matches, "mode")),
         run_ignored: getopts::opt_present(matches, "ignored"),
         filter:
-             if vec::len(matches.free) > 0u {
+             if !matches.free.is_empty() {
                  option::Some(copy matches.free[0])
              } else { option::None },
         logfile: getopts::opt_maybe_str(matches, "logfile").map(|s| Path(*s)),

src/compiletest/runtest.rs

@@ -297,7 +297,7 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
 fn check_error_patterns(props: &TestProps,
                         testfile: &Path,
                         ProcRes: &ProcRes) {
-    if vec::is_empty(props.error_patterns) {
+    if props.error_patterns.is_empty() {
         fatal(~"no error pattern specified in " + testfile.to_str());
     }
 

src/libextra/ebml.rs

@@ -179,7 +179,7 @@ pub mod reader {
     }
 
     pub fn Doc(data: @~[u8]) -> Doc {
-        Doc { data: data, start: 0u, end: vec::len::<u8>(*data) }
+        Doc { data: data, start: 0u, end: data.len() }
     }
 
     pub fn doc_at(data: @~[u8], start: uint) -> TaggedDoc {

src/libextra/getopts.rs

@@ -427,7 +427,7 @@ pub fn opt_strs(mm: &Matches, nm: &str) -> ~[~str] {
 /// Returns the string argument supplied to a matching option or none
 pub fn opt_maybe_str(mm: &Matches, nm: &str) -> Option<~str> {
     let vals = opt_vals(mm, nm);
-    if vec::len::<Optval>(vals) == 0u { return None::<~str>; }
+    if vals.is_empty() { return None::<~str>; }
     return match vals[0] {
         Val(ref s) => Some(copy *s),
         _ => None
@@ -444,7 +444,7 @@ pub fn opt_maybe_str(mm: &Matches, nm: &str) -> Option<~str> {
  */
 pub fn opt_default(mm: &Matches, nm: &str, def: &str) -> Option<~str> {
     let vals = opt_vals(mm, nm);
-    if vec::len::<Optval>(vals) == 0u { return None::<~str>; }
+    if vals.is_empty() { return None::<~str>; }
     return match vals[0] { Val(ref s) => Some::<~str>(copy *s),
                            _      => Some::<~str>(str::to_owned(def)) }
 }

src/libextra/sha1.rs

@@ -195,7 +195,7 @@ pub fn sha1() -> @Sha1 {
      * can be assumed that the message digest has been computed.
      */
     fn pad_msg(st: &mut Sha1State) {
-        assert_eq!(vec::len((*st).msg_block), msg_block_len);
+        assert_eq!((*st).msg_block.len(), msg_block_len);
 
         /*
          * Check to see if the current message block is too small to hold
@@ -368,8 +368,8 @@ mod tests {
         ];
         let tests = fips_180_1_tests + wikipedia_tests;
         fn check_vec_eq(v0: ~[u8], v1: ~[u8]) {
-            assert_eq!(vec::len::<u8>(v0), vec::len::<u8>(v1));
-            let len = vec::len::<u8>(v0);
+            assert_eq!(v0.len(), v1.len());
+            let len = v0.len();
             let mut i = 0u;
             while i < len {
                 let a = v0[i];

src/libextra/sort.rs

@@ -15,7 +15,6 @@ use core::prelude::*;
 use core::cmp::{Eq, Ord};
 use core::uint;
 use core::util::swap;
-use core::vec::len;
 use core::vec;
 
 type Le<'self, T> = &'self fn(v1: &T, v2: &T) -> bool;
@@ -29,7 +28,7 @@ type Le<'self, T> = &'self fn(v1: &T, v2: &T) -> bool;
 pub fn merge_sort<T:Copy>(v: &[T], le: Le<T>) -> ~[T] {
     type Slice = (uint, uint);
 
-    return merge_sort_(v, (0u, len(v)), le);
+    return merge_sort_(v, (0u, v.len()), le);
 
     fn merge_sort_<T:Copy>(v: &[T], slice: Slice, le: Le<T>)
         -> ~[T] {
@@ -47,10 +46,10 @@ pub fn merge_sort<T:Copy>(v: &[T], le: Le<T>) -> ~[T] {
     }
 
     fn merge<T:Copy>(le: Le<T>, a: &[T], b: &[T]) -> ~[T] {
-        let mut rs = vec::with_capacity(len(a) + len(b));
-        let a_len = len(a);
+        let mut rs = vec::with_capacity(a.len() + b.len());
+        let a_len = a.len();
         let mut a_ix = 0;
-        let b_len = len(b);
+        let b_len = b.len();
         let mut b_ix = 0;
         while a_ix < a_len && b_ix < b_len {
             if le(&a[a_ix], &b[b_ix]) {
@@ -100,8 +99,9 @@ fn qsort<T>(arr: &mut [T], left: uint,
  * This is an unstable sort.
  */
 pub fn quick_sort<T>(arr: &mut [T], compare_func: Le<T>) {
-    if len::<T>(arr) == 0u { return; }
-    qsort::<T>(arr, 0u, len::<T>(arr) - 1u, compare_func);
+    let len = arr.len();
+    if len == 0u { return; }
+    qsort::<T>(arr, 0u, len - 1u, compare_func);
 }
 
 fn qsort3<T:Copy + Ord + Eq>(arr: &mut [T], left: int, right: int) {
@@ -138,7 +138,7 @@ fn qsort3<T:Copy + Ord + Eq>(arr: &mut [T], left: int, right: int) {
         vec::swap(arr, k as uint, j as uint);
         k += 1;
         j -= 1;
-        if k == len::<T>(arr) as int { break; }
+        if k == arr.len() as int { break; }
     }
     k = right - 1;
     while k > q {
@@ -754,7 +754,7 @@ mod test_qsort3 {
     use core::vec;
 
     fn check_sort(v1: &mut [int], v2: &mut [int]) {
-        let len = vec::len::<int>(v1);
+        let len = v1.len();
         quick_sort3::<int>(v1);
         let mut i = 0;
         while i < len {
@@ -799,7 +799,7 @@ mod test_qsort {
     use core::vec;
 
     fn check_sort(v1: &mut [int], v2: &mut [int]) {
-        let len = vec::len::<int>(v1);
+        let len = v1.len();
         fn leual(a: &int, b: &int) -> bool { *a <= *b }
         quick_sort::<int>(v1, leual);
         let mut i = 0u;
@@ -864,7 +864,7 @@ mod tests {
     use core::vec;
 
     fn check_sort(v1: &[int], v2: &[int]) {
-        let len = vec::len::<int>(v1);
+        let len = v1.len();
         pub fn le(a: &int, b: &int) -> bool { *a <= *b }
         let f = le;
         let v3 = merge_sort::<int>(v1, f);
@@ -951,7 +951,7 @@ mod test_tim_sort {
     }
 
     fn check_sort(v1: &mut [int], v2: &mut [int]) {
-        let len = vec::len::<int>(v1);
+        let len = v1.len();
         tim_sort::<int>(v1);
         let mut i = 0u;
         while i < len {

src/libextra/uv_ll.rs

@@ -988,7 +988,7 @@ pub unsafe fn accept(server: *libc::c_void, client: *libc::c_void)
 pub unsafe fn write<T>(req: *uv_write_t, stream: *T,
          buf_in: *~[uv_buf_t], cb: *u8) -> libc::c_int {
     let buf_ptr = vec::raw::to_ptr(*buf_in);
-    let buf_cnt = vec::len(*buf_in) as i32;
+    let buf_cnt = (*buf_in).len() as i32;
     return rust_uv_write(req as *libc::c_void,
                               stream as *libc::c_void,
                               buf_ptr, buf_cnt, cb);

src/libfuzzer/fuzzer.rc

@@ -624,7 +624,7 @@ pub fn check_roundtrip_convergence(code: @~str, maxIters: uint) {
 }
 
 pub fn check_convergence(files: &[Path]) {
-    error!("pp convergence tests: %u files", vec::len(files));
+    error!("pp convergence tests: %u files", files.len());
     for files.each |file| {
         if !file_might_not_converge(file) {
             let s = @result::get(&io::read_whole_file_str(file));
@@ -689,7 +689,7 @@ pub fn check_variants(files: &[Path], cx: Context) {
 
 pub fn main() {
     let args = os::args();
-    if vec::len(args) != 2u {
+    if args.len() != 2u {
         error!("usage: %s <testdir>", args[0]);
         return;
     }

src/librustc/front/test.rs

@@ -203,8 +203,7 @@ fn is_test_fn(cx: @mut TestCtxt, i: @ast::item) -> bool {
 }
 
 fn is_bench_fn(i: @ast::item) -> bool {
-    let has_bench_attr =
-        vec::len(attr::find_attrs_by_name(i.attrs, "bench")) > 0u;
+    let has_bench_attr = !attr::find_attrs_by_name(i.attrs, "bench").is_empty();
 
     fn has_test_signature(i: @ast::item) -> bool {
         match i.node {
@@ -242,7 +241,7 @@ fn is_ignored(cx: @mut TestCtxt, i: @ast::item) -> bool {
 }
 
 fn should_fail(i: @ast::item) -> bool {
-    vec::len(attr::find_attrs_by_name(i.attrs, "should_fail")) > 0u
+    !attr::find_attrs_by_name(i.attrs, "should_fail").is_empty()
 }
 
 fn add_test_module(cx: &TestCtxt, m: &ast::_mod) -> ast::_mod {