From a2a8596c3dd963e7b51f11998cffc46033bf6d63 Mon Sep 17 00:00:00 2001
From: Youngmin Yoo <youngmin.yoo@samsung.com>
Date: Tue, 14 May 2013 18:52:12 +0900
Subject: [PATCH] Rename vec::len(var) to var.len()

---
 .swo                                          | Bin 0 -> 73728 bytes
 src/compiletest/runtest.rs                    |  12 +++++------
 src/libcore/either.rs                         |  20 +++++++++---------
 src/libcore/io.rs                             |  12 +++++------
 src/libcore/os.rs                             |   6 +++---
 src/libcore/ptr.rs                            |   2 +-
 src/libcore/rt/uvll.rs                        |   2 +-
 src/libcore/str.rs                            |   8 +++----
 src/libfuzzer/ast_match.rs                    |   4 ++--
 src/libfuzzer/cycles.rs                       |   2 +-
 src/libfuzzer/rand_util.rs                    |   6 +++---
 src/librustc/back/rpath.rs                    |   4 ++--
 src/librustc/driver/driver.rs                 |   3 +--
 src/librustc/front/test.rs                    |   2 +-
 src/librustc/metadata/decoder.rs              |   2 +-
 src/librustc/metadata/loader.rs               |   2 +-
 src/librustc/metadata/tydecode.rs             |   2 +-
 src/librustc/middle/kind.rs                   |   2 +-
 src/librustc/middle/region.rs                 |   4 ++--
 src/librustc/middle/resolve.rs                |   2 +-
 src/librustc/middle/resolve_stage0.rs         |   2 +-
 src/librustc/middle/trans/cabi.rs             |   6 +++---
 src/librustc/middle/trans/cabi_x86_64.rs      |   8 +++----
 src/librustc/middle/trans/foreign.rs          |   2 +-
 src/librustc/middle/trans/reflect.rs          |  10 ++++-----
 src/librustc/middle/trans/shape.rs            |   3 +--
 src/librustc/middle/ty.rs                     |   2 +-
 src/librustc/middle/typeck/check/mod.rs       |   2 +-
 src/librustc/middle/typeck/collect.rs         |   8 +++----
 src/librustc/middle/typeck/mod.rs             |   2 +-
 src/librustc/util/ppaux.rs                    |   2 +-
 src/librustdoc/tystr_pass.rs                  |   2 +-
 src/libstd/ebml.rs                            |   5 ++---
 src/libstd/md4.rs                             |   4 ++--
 src/libstd/net_ip.rs                          |   5 ++---
 src/libstd/net_tcp.rs                         |   6 +++---
 src/libstd/par.rs                             |   5 ++---
 src/libstd/rope.rs                            |   4 ++--
 src/libstd/sha1.rs                            |   6 +++---
 src/libstd/sync.rs                            |  13 ++++++------
 src/libstd/test.rs                            |   4 ++--
 src/libstd/uv_ll.rs                           |   2 +-
 src/libsyntax/diagnostic.rs                   |   6 +++---
 src/libsyntax/ext/auto_encode.rs              |   4 ++--
 src/libsyntax/ext/base.rs                     |   2 +-
 src/libsyntax/parse/comments.rs               |   2 +-
 src/libsyntax/parse/parser.rs                 |   4 ++--
 src/libsyntax/print/pp.rs                     |   4 ++--
 src/libsyntax/print/pprust.rs                 |   6 +++---
 src/test/auxiliary/cci_iter_lib.rs            |   2 +-
 src/test/auxiliary/cci_no_inline_lib.rs       |   2 +-
 src/test/bench/graph500-bfs.rs                |   4 ++--
 src/test/bench/shootout-k-nucleotide-pipes.rs |   2 +-
 src/test/bench/sudoku.rs                      |   6 +++---
 src/test/run-pass/assignability-trait.rs      |   6 +++---
 .../class-implements-multiple-traits.rs       |   2 +-
 src/test/run-pass/hashmap-memory.rs           |   2 +-
 src/test/run-pass/vec-self-append.rs          |   8 +++----
 58 files changed, 128 insertions(+), 134 deletions(-)
 create mode 100644 .swo

diff --git a/.swo b/.swo
new file mode 100644
index 0000000000000000000000000000000000000000..89f7479da33151987cc73f04a49464fb3bd39866
GIT binary patch
literal 73728
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
Op#j0b0x8k7W&i+m<^SXW

literal 0
HcmV?d00001

diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs
index 73e1e3ee7638..d58c2e596bd7 100644
--- a/src/compiletest/runtest.rs
+++ b/src/compiletest/runtest.rs
@@ -264,7 +264,7 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
         fatal(~"gdb failed to execute");
     }
 
-    let num_check_lines = vec::len(check_lines);
+    let num_check_lines = check_lines.len();
     if num_check_lines > 0 {
         // check if each line in props.check_lines appears in the
         // output (in order)
@@ -303,7 +303,7 @@ fn check_error_patterns(props: &TestProps,
         if str::contains(line, *next_err_pat) {
             debug!("found error pattern %s", *next_err_pat);
             next_err_idx += 1u;
-            if next_err_idx == vec::len(props.error_patterns) {
+            if next_err_idx == props.error_patterns.len() {
                 debug!("found all error patterns");
                 done = true;
                 break;
@@ -315,8 +315,8 @@ fn check_error_patterns(props: &TestProps,
 
     let missing_patterns =
         vec::slice(props.error_patterns, next_err_idx,
-                   vec::len(props.error_patterns));
-    if vec::len(missing_patterns) == 1u {
+                   props.error_patterns.len());
+    if missing_patterns.len() == 1u {
         fatal_ProcRes(fmt!("error pattern '%s' not found!",
                            missing_patterns[0]), ProcRes);
     } else {
@@ -333,7 +333,7 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
 
     // true if we found the error in question
     let mut found_flags = vec::from_elem(
-        vec::len(expected_errors), false);
+        expected_errors.len(), false);
 
     if ProcRes.status == 0 {
         fatal(~"process did not return an error status");
@@ -377,7 +377,7 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
         }
     }
 
-    for uint::range(0u, vec::len(found_flags)) |i| {
+    for uint::range(0u, found_flags.len()) |i| {
         if !found_flags[i] {
             let ee = &expected_errors[i];
             fatal_ProcRes(fmt!("expected %s on line %u not found: %s",
diff --git a/src/libcore/either.rs b/src/libcore/either.rs
index 618a484a515e..8c16f5c64824 100644
--- a/src/libcore/either.rs
+++ b/src/libcore/either.rs
@@ -201,14 +201,14 @@ fn test_lefts() {
 fn test_lefts_none() {
     let input: ~[Either<int, int>] = ~[Right(10), Right(10)];
     let result = lefts(input);
-    assert_eq!(vec::len(result), 0u);
+    assert_eq!(result.len(), 0u);
 }
 
 #[test]
 fn test_lefts_empty() {
     let input: ~[Either<int, int>] = ~[];
     let result = lefts(input);
-    assert_eq!(vec::len(result), 0u);
+    assert_eq!(result.len(), 0u);
 }
 
 #[test]
@@ -222,14 +222,14 @@ fn test_rights() {
 fn test_rights_none() {
     let input: ~[Either<int, int>] = ~[Left(10), Left(10)];
     let result = rights(input);
-    assert_eq!(vec::len(result), 0u);
+    assert_eq!(result.len(), 0u);
 }
 
 #[test]
 fn test_rights_empty() {
     let input: ~[Either<int, int>] = ~[];
     let result = rights(input);
-    assert_eq!(vec::len(result), 0u);
+    assert_eq!(result.len(), 0u);
 }
 
 #[test]
@@ -247,22 +247,22 @@ fn test_partition() {
 fn test_partition_no_lefts() {
     let input: ~[Either<int, int>] = ~[Right(10), Right(11)];
     let (lefts, rights) = partition(input);
-    assert_eq!(vec::len(lefts), 0u);
-    assert_eq!(vec::len(rights), 2u);
+    assert_eq!(lefts.len(), 0u);
+    assert_eq!(rights.len(), 2u);
 }
 
 #[test]
 fn test_partition_no_rights() {
     let input: ~[Either<int, int>] = ~[Left(10), Left(11)];
     let (lefts, rights) = partition(input);
-    assert_eq!(vec::len(lefts), 2u);
-    assert_eq!(vec::len(rights), 0u);
+    assert_eq!(lefts.len(), 2u);
+    assert_eq!(rights.len(), 0u);
 }
 
 #[test]
 fn test_partition_empty() {
     let input: ~[Either<int, int>] = ~[];
     let (lefts, rights) = partition(input);
-    assert_eq!(vec::len(lefts), 0u);
-    assert_eq!(vec::len(rights), 0u);
+    assert_eq!(lefts.len(), 0u);
+    assert_eq!(rights.len(), 0u);
 }
diff --git a/src/libcore/io.rs b/src/libcore/io.rs
index ab5db67ddb6f..7b7d278380f1 100644
--- a/src/libcore/io.rs
+++ b/src/libcore/io.rs
@@ -673,10 +673,10 @@ impl<T:Reader> ReaderUtil for T {
 
     fn read_char(&self) -> char {
         let c = self.read_chars(1);
-        if vec::len(c) == 0 {
+        if c.len() == 0 {
             return -1 as char; // FIXME will this stay valid? // #2004
         }
-        assert!((vec::len(c) == 1));
+        assert!(c.len() == 1);
         return c[0];
     }
 
@@ -1802,7 +1802,7 @@ mod tests {
     fn test_readchars_empty() {
         do io::with_str_reader(~"") |inp| {
             let res : ~[char] = inp.read_chars(128);
-            assert!((vec::len(res) == 0));
+            assert!(res.len() == 0);
         }
     }
 
@@ -1841,10 +1841,10 @@ mod tests {
         fn check_read_ln(len : uint, s: &str, ivals: &[int]) {
             do io::with_str_reader(s) |inp| {
                 let res : ~[char] = inp.read_chars(len);
-                if (len <= vec::len(ivals)) {
-                    assert!((vec::len(res) == len));
+                if len <= ivals.len() {
+                    assert!(res.len() == len);
                 }
-                assert!(vec::slice(ivals, 0u, vec::len(res)) ==
+                assert!(vec::slice(ivals, 0u, res.len()) ==
                              vec::map(res, |x| *x as int));
             }
         }
diff --git a/src/libcore/os.rs b/src/libcore/os.rs
index 9129b33fff54..daad9cee0fc2 100644
--- a/src/libcore/os.rs
+++ b/src/libcore/os.rs
@@ -410,7 +410,7 @@ pub fn self_exe_path() -> Option<Path> {
                            KERN_PROC as c_int,
                            KERN_PROC_PATHNAME as c_int, -1 as c_int];
                 let mut sz = sz;
-                sysctl(vec::raw::to_ptr(mib), vec::len(mib) as ::libc::c_uint,
+                sysctl(vec::raw::to_ptr(mib), mib.len() as ::libc::c_uint,
                        buf as *mut c_void, &mut sz, ptr::null(),
                        0u as size_t) == (0 as c_int)
             }
@@ -1490,7 +1490,7 @@ mod tests {
     #[ignore]
     fn test_env_getenv() {
         let e = env();
-        assert!(vec::len(e) > 0u);
+        assert!(e.len() > 0u);
         for e.each |p| {
             let (n, v) = copy *p;
             debug!(copy n);
@@ -1581,7 +1581,7 @@ mod tests {
     fn list_dir() {
         let dirs = os::list_dir(&Path("."));
         // Just assuming that we've got some contents in the current directory
-        assert!((vec::len(dirs) > 0u));
+        assert!(dirs.len() > 0u);
 
         for dirs.each |dir| {
             debug!(copy *dir);
diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs
index 9feb8676036d..e116dc019431 100644
--- a/src/libcore/ptr.rs
+++ b/src/libcore/ptr.rs
@@ -441,7 +441,7 @@ pub mod ptr_tests {
             let arr_ptr = &arr[0];
             let mut ctr = 0;
             let mut iteration_count = 0;
-            array_each_with_len(arr_ptr, vec::len(arr),
+            array_each_with_len(arr_ptr, arr.len(),
                                 |e| {
                                          let actual = str::raw::from_c_str(e);
                                          let expected = copy expected_arr[ctr];
diff --git a/src/libcore/rt/uvll.rs b/src/libcore/rt/uvll.rs
index 4bff3bff7d3a..0d298bde6b50 100644
--- a/src/libcore/rt/uvll.rs
+++ b/src/libcore/rt/uvll.rs
@@ -221,7 +221,7 @@ pub unsafe fn accept(server: *c_void, client: *c_void) -> c_int {
 
 pub unsafe fn write<T>(req: *uv_write_t, stream: *T, buf_in: &[uv_buf_t], cb: *u8) -> 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 *c_void, stream as *c_void, buf_ptr, buf_cnt, cb);
 }
 pub unsafe fn read_start(stream: *uv_stream_t, on_alloc: *u8, on_read: *u8) -> c_int {
diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index ce9db796b674..ec7177e52114 100644
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -2059,7 +2059,7 @@ pub fn is_utf8(v: &const [u8]) -> bool {
 
 /// Determines if a vector of `u16` contains valid UTF-16
 pub fn is_utf16(v: &[u16]) -> bool {
-    let len = vec::len(v);
+    let len = v.len();
     let mut i = 0u;
     while (i < len) {
         let u = v[i];
@@ -2103,7 +2103,7 @@ pub fn to_utf16(s: &str) -> ~[u16] {
 }
 
 pub fn utf16_chars(v: &[u16], f: &fn(char)) {
-    let len = vec::len(v);
+    let len = v.len();
     let mut i = 0u;
     while (i < len && v[i] != 0u16) {
         let u = v[i];
@@ -2128,7 +2128,7 @@ pub fn utf16_chars(v: &[u16], f: &fn(char)) {
 
 pub fn from_utf16(v: &[u16]) -> ~str {
     let mut buf = ~"";
-    reserve(&mut buf, vec::len(v));
+    reserve(&mut buf, v.len());
     utf16_chars(v, |ch| push_char(&mut buf, ch));
     buf
 }
@@ -2398,7 +2398,7 @@ static tag_six_b: uint = 252u;
  * # Example
  *
  * ~~~
- * let i = str::as_bytes("Hello World") { |bytes| vec::len(bytes) };
+ * let i = str::as_bytes("Hello World") { |bytes| bytes.len() };
  * ~~~
  */
 #[inline]
diff --git a/src/libfuzzer/ast_match.rs b/src/libfuzzer/ast_match.rs
index 806a7aedd310..2502830250db 100644
--- a/src/libfuzzer/ast_match.rs
+++ b/src/libfuzzer/ast_match.rs
@@ -15,8 +15,8 @@ fn vec_equal<T>(v: ~[T],
                 u: ~[T],
                 element_equality_test: @fn(&&T, &&T) -> bool) ->
    bool {
-    let Lv = vec::len(v);
-    if Lv != vec::len(u) { return false; }
+    let Lv = v.len();
+    if Lv != u.len() { return false; }
     let i = 0u;
     while i < Lv {
         if !element_equality_test(v[i], u[i]) { return false; }
diff --git a/src/libfuzzer/cycles.rs b/src/libfuzzer/cycles.rs
index c18d1f43b567..a6434d64cdc3 100644
--- a/src/libfuzzer/cycles.rs
+++ b/src/libfuzzer/cycles.rs
@@ -19,7 +19,7 @@ fn under(r : rand::rng, n : uint) -> uint {
 
 // random choice from a vec
 fn choice<T:copy>(r : rand::rng, v : ~[const T]) -> T {
-    assert!(vec::len(v) != 0u); v[under(r, vec::len(v))]
+    assert!(v.len() != 0u); v[under(r, v.len())]
 }
 
 // k in n chance of being true
diff --git a/src/libfuzzer/rand_util.rs b/src/libfuzzer/rand_util.rs
index 2422c146e245..c239e8ab9332 100644
--- a/src/libfuzzer/rand_util.rs
+++ b/src/libfuzzer/rand_util.rs
@@ -18,7 +18,7 @@ fn under(r : rand::rng, n : uint) -> uint {
 
 // random choice from a vec
 fn choice<T:copy>(r : rand::rng, v : ~[T]) -> T {
-    assert!(vec::len(v) != 0u); v[under(r, vec::len(v))]
+    assert!(v.len() != 0u); v[under(r, v.len())]
 }
 
 // 1 in n chance of being true
@@ -26,7 +26,7 @@ fn unlikely(r : rand::rng, n : uint) -> bool { under(r, n) == 0u }
 
 // shuffle a vec in place
 fn shuffle<T>(r : rand::rng, &v : ~[T]) {
-    let i = vec::len(v);
+    let i = v.len();
     while i >= 2u {
         // Loop invariant: elements with index >= i have been locked in place.
         i -= 1u;
@@ -49,7 +49,7 @@ fn shuffled<T:copy>(r : rand::rng, v : ~[T]) -> ~[T] {
 // * weighted_vec is O(total weight) space
 type weighted<T> = { weight: uint, item: T };
 fn weighted_choice<T:copy>(r : rand::rng, v : ~[weighted<T>]) -> T {
-    assert!(vec::len(v) != 0u);
+    assert!(v.len() != 0u);
     let total = 0u;
     for {weight: weight, item: _} in v {
         total += weight;
diff --git a/src/librustc/back/rpath.rs b/src/librustc/back/rpath.rs
index eebb20b19f5e..37a025cd8205 100644
--- a/src/librustc/back/rpath.rs
+++ b/src/librustc/back/rpath.rs
@@ -137,8 +137,8 @@ pub fn get_relative_to(abs1: &Path, abs2: &Path) -> Path {
            abs1.to_str(), abs2.to_str());
     let split1: &[~str] = abs1.components;
     let split2: &[~str] = abs2.components;
-    let len1 = vec::len(split1);
-    let len2 = vec::len(split2);
+    let len1 = split1.len();
+    let len2 = split2.len();
     assert!(len1 > 0);
     assert!(len2 > 0);
 
diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs
index b11aec5b8417..0e37653e5c48 100644
--- a/src/librustc/driver/driver.rs
+++ b/src/librustc/driver/driver.rs
@@ -905,7 +905,6 @@ mod test {
     use driver::driver::{build_configuration, build_session};
     use driver::driver::{build_session_options, optgroups, str_input};
 
-    use core::vec;
     use std::getopts::groups::getopts;
     use std::getopts;
     use syntax::attr;
@@ -942,6 +941,6 @@ mod test {
         let sess = build_session(sessopts, diagnostic::emit);
         let cfg = build_configuration(sess, @~"whatever", &str_input(~""));
         let test_items = attr::find_meta_items_by_name(cfg, ~"test");
-        assert!((vec::len(test_items) == 1u));
+        assert!(test_items.len() == 1u);
     }
 }
diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs
index f556baee918f..be03ed99ad77 100644
--- a/src/librustc/front/test.rs
+++ b/src/librustc/front/test.rs
@@ -206,7 +206,7 @@ fn is_bench_fn(i: @ast::item) -> bool {
     fn has_test_signature(i: @ast::item) -> bool {
         match i.node {
             ast::item_fn(ref decl, _, _, ref generics, _) => {
-                let input_cnt = vec::len(decl.inputs);
+                let input_cnt = decl.inputs.len();
                 let no_output = match decl.output.node {
                     ast::ty_nil => true,
                     _ => false
diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs
index c3dd9cdf23bf..3bda02f8b3b9 100644
--- a/src/librustc/metadata/decoder.rs
+++ b/src/librustc/metadata/decoder.rs
@@ -1061,7 +1061,7 @@ fn get_attributes(md: ebml::Doc) -> ~[ast::attribute] {
             let meta_items = get_meta_items(attr_doc);
             // Currently it's only possible to have a single meta item on
             // an attribute
-            assert!((vec::len(meta_items) == 1u));
+            assert!(meta_items.len() == 1u);
             let meta_item = meta_items[0];
             attrs.push(
                 codemap::spanned {
diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs
index ba2e336b6394..cfb2bd4b837f 100644
--- a/src/librustc/metadata/loader.rs
+++ b/src/librustc/metadata/loader.rs
@@ -171,7 +171,7 @@ pub fn metadata_matches(extern_metas: &[@ast::meta_item],
                         local_metas: &[@ast::meta_item]) -> bool {
 
     debug!("matching %u metadata requirements against %u items",
-           vec::len(local_metas), vec::len(extern_metas));
+           local_metas.len(), extern_metas.len());
 
     for local_metas.each |needed| {
         if !attr::contains(extern_metas, *needed) {
diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs
index cc9a18ea3a37..95e48baead86 100644
--- a/src/librustc/metadata/tydecode.rs
+++ b/src/librustc/metadata/tydecode.rs
@@ -519,7 +519,7 @@ fn parse_sig(st: @mut PState, conv: conv_did) -> ty::FnSig {
 // Rust metadata parsing
 pub fn parse_def_id(buf: &[u8]) -> ast::def_id {
     let mut colon_idx = 0u;
-    let len = vec::len(buf);
+    let len = buf.len();
     while colon_idx < len && buf[colon_idx] != ':' as u8 { colon_idx += 1u; }
     if colon_idx == len {
         error!("didn't find ':' when parsing def id");
diff --git a/src/librustc/middle/kind.rs b/src/librustc/middle/kind.rs
index b220379e330f..a891e8d3b7f8 100644
--- a/src/librustc/middle/kind.rs
+++ b/src/librustc/middle/kind.rs
@@ -360,7 +360,7 @@ fn is_nullary_variant(cx: Context, ex: @expr) -> bool {
       expr_path(_) => {
         match cx.tcx.def_map.get_copy(&ex.id) {
           def_variant(edid, vdid) => {
-            vec::len(ty::enum_variant_with_id(cx.tcx, edid, vdid).args) == 0u
+              vec::len(ty::enum_variant_with_id(cx.tcx, edid, vdid).args) == 0u
           }
           _ => false
         }
diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs
index 2c62130feb17..27b627387939 100644
--- a/src/librustc/middle/region.rs
+++ b/src/librustc/middle/region.rs
@@ -283,8 +283,8 @@ pub impl RegionMaps {
 
         let a_ancestors = ancestors_of(self, scope_a);
         let b_ancestors = ancestors_of(self, scope_b);
-        let mut a_index = vec::len(a_ancestors) - 1u;
-        let mut b_index = vec::len(b_ancestors) - 1u;
+        let mut a_index = a_ancestors.len() - 1u;
+        let mut b_index = b_ancestors.len() - 1u;
 
         // Here, ~[ab]_ancestors is a vector going from narrow to broad.
         // The end of each vector will be the item where the scope is
diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs
index a962ea07c542..2f13343c5fa0 100644
--- a/src/librustc/middle/resolve.rs
+++ b/src/librustc/middle/resolve.rs
@@ -4693,7 +4693,7 @@ pub impl Resolver {
             }
         }
 
-        if vec::len(values) > 0 &&
+        if values.len() > 0 &&
             values[smallest] != uint::max_value &&
             values[smallest] < str::len(name) + 2 &&
             values[smallest] <= max_distance &&
diff --git a/src/librustc/middle/resolve_stage0.rs b/src/librustc/middle/resolve_stage0.rs
index 2fc0fdca3172..0932feb9ce51 100644
--- a/src/librustc/middle/resolve_stage0.rs
+++ b/src/librustc/middle/resolve_stage0.rs
@@ -4720,7 +4720,7 @@ pub impl Resolver {
             }
         }
 
-        if vec::len(values) > 0 &&
+        if values.len() > 0 &&
             values[smallest] != uint::max_value &&
             values[smallest] < str::len(name) + 2 &&
             values[smallest] <= max_distance &&
diff --git a/src/librustc/middle/trans/cabi.rs b/src/librustc/middle/trans/cabi.rs
index 702d62f13634..e103bbc5de7a 100644
--- a/src/librustc/middle/trans/cabi.rs
+++ b/src/librustc/middle/trans/cabi.rs
@@ -65,7 +65,7 @@ pub impl FnType {
 
         let mut llargvals = ~[];
         let mut i = 0u;
-        let n = vec::len(arg_tys);
+        let n = arg_tys.len();
 
         if self.sret {
             let llretptr = GEPi(bcx, llargbundle, [0u, n]);
@@ -113,7 +113,7 @@ pub impl FnType {
         if self.sret || !ret_def {
             return;
         }
-        let n = vec::len(arg_tys);
+        let n = arg_tys.len();
         // R** llretptr = &args->r;
         let llretptr = GEPi(bcx, llargbundle, [0u, n]);
         // R* llretloc = *llretptr; /* (args->r) */
@@ -149,7 +149,7 @@ pub impl FnType {
         };
 
         let mut i = 0u;
-        let n = vec::len(atys);
+        let n = atys.len();
         while i < n {
             let mut argval = get_param(llwrapfn, i + j);
             if attrs[i].is_some() {
diff --git a/src/librustc/middle/trans/cabi_x86_64.rs b/src/librustc/middle/trans/cabi_x86_64.rs
index 3a2ab74c33aa..a44f203c7ab7 100644
--- a/src/librustc/middle/trans/cabi_x86_64.rs
+++ b/src/librustc/middle/trans/cabi_x86_64.rs
@@ -50,7 +50,7 @@ fn is_sse(c: x86_64_reg_class) -> bool {
 }
 
 fn is_ymm(cls: &[x86_64_reg_class]) -> bool {
-    let len = vec::len(cls);
+    let len = cls.len();
     return (len > 2u &&
          is_sse(cls[0]) &&
          cls[1] == sseup_class &&
@@ -223,8 +223,8 @@ fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] {
         unsafe {
             let mut i = 0u;
             let llty = llvm::LLVMGetTypeKind(ty) as int;
-            let e = vec::len(cls);
-            if vec::len(cls) > 2u &&
+            let e = cls.len();
+            if cls.len() > 2u &&
                (llty == 10 /* struct */ ||
                 llty == 11 /* array */) {
                 if is_sse(cls[i]) {
@@ -295,7 +295,7 @@ fn llreg_ty(cls: &[x86_64_reg_class]) -> TypeRef {
     unsafe {
         let mut tys = ~[];
         let mut i = 0u;
-        let e = vec::len(cls);
+        let e = cls.len();
         while i < e {
             match cls[i] {
                 integer_class => {
diff --git a/src/librustc/middle/trans/foreign.rs b/src/librustc/middle/trans/foreign.rs
index fcf5d05a7441..498881fcfc60 100644
--- a/src/librustc/middle/trans/foreign.rs
+++ b/src/librustc/middle/trans/foreign.rs
@@ -509,7 +509,7 @@ pub fn trans_foreign_mod(ccx: @CrateContext,
                       llargbundle: ValueRef) {
             let _icx = bcx.insn_ctxt("foreign::wrap::build_args");
             let ccx = bcx.ccx();
-            let n = vec::len(tys.llsig.llarg_tys);
+            let n = tys.llsig.llarg_tys.len();
             let implicit_args = first_real_arg; // return + env
             for uint::range(0, n) |i| {
                 let mut llargval = get_param(llwrapfn, i + implicit_args);
diff --git a/src/librustc/middle/trans/reflect.rs b/src/librustc/middle/trans/reflect.rs
index 2183472d5915..9aea12fa8e2b 100644
--- a/src/librustc/middle/trans/reflect.rs
+++ b/src/librustc/middle/trans/reflect.rs
@@ -93,7 +93,7 @@ pub impl Reflector {
         let mth_ty =
             ty::mk_bare_fn(tcx, copy self.visitor_methods[mth_idx].fty);
         let v = self.visitor_val;
-        debug!("passing %u args:", vec::len(args));
+        debug!("passing %u args:", args.len());
         let bcx = self.bcx;
         for args.eachi |i, a| {
             debug!("arg %u: %s", i, val_str(bcx.ccx().tn, *a));
@@ -224,7 +224,7 @@ pub impl Reflector {
             let retval = if ty::type_is_bot(fty.sig.output) {0u} else {1u};
             let extra = ~[self.c_uint(pureval),
                           self.c_uint(sigilval),
-                          self.c_uint(vec::len(fty.sig.inputs)),
+                          self.c_uint(fty.sig.inputs.len()),
                           self.c_uint(retval)];
             self.visit(~"enter_fn", copy extra);    // XXX: Bad copy.
             self.visit_sig(retval, &fty.sig);
@@ -239,7 +239,7 @@ pub impl Reflector {
             let retval = if ty::type_is_bot(fty.sig.output) {0u} else {1u};
             let extra = ~[self.c_uint(pureval),
                           self.c_uint(sigilval),
-                          self.c_uint(vec::len(fty.sig.inputs)),
+                          self.c_uint(fty.sig.inputs.len()),
                           self.c_uint(retval)];
             self.visit(~"enter_fn", copy extra);    // XXX: Bad copy.
             self.visit_sig(retval, &fty.sig);
@@ -309,13 +309,13 @@ pub impl Reflector {
                 llfdecl
             };
 
-            let enum_args = ~[self.c_uint(vec::len(variants)), make_get_disr()]
+            let enum_args = ~[self.c_uint(variants.len()), make_get_disr()]
                 + self.c_size_and_align(t);
             do self.bracketed(~"enum", enum_args) |this| {
                 for variants.eachi |i, v| {
                     let variant_args = ~[this.c_uint(i),
                                          this.c_int(v.disr_val),
-                                         this.c_uint(vec::len(v.args)),
+                                         this.c_uint(v.args.len()),
                                          this.c_slice(ccx.sess.str_of(v.name))];
                     do this.bracketed(~"enum_variant", variant_args) |this| {
                         for v.args.eachi |j, a| {
diff --git a/src/librustc/middle/trans/shape.rs b/src/librustc/middle/trans/shape.rs
index 6ff9e1cfc571..31de12807411 100644
--- a/src/librustc/middle/trans/shape.rs
+++ b/src/librustc/middle/trans/shape.rs
@@ -18,7 +18,6 @@ use middle::trans::common::*;
 use middle::trans;
 
 use core::str;
-use core::vec;
 
 pub struct Ctxt {
     next_tag_id: u16,
@@ -71,6 +70,6 @@ pub fn add_u16(dest: &mut ~[u8], val: u16) {
 }
 
 pub fn add_substr(dest: &mut ~[u8], src: ~[u8]) {
-    add_u16(&mut *dest, vec::len(src) as u16);
+    add_u16(&mut *dest, src.len() as u16);
     *dest += src;
 }
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index fbb84751d030..96e2e28e6f3f 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -2616,7 +2616,7 @@ pub fn deref_sty(cx: ctxt, sty: &sty, explicit: bool) -> Option<mt> {
 
       ty_enum(did, ref substs) => {
         let variants = enum_variants(cx, did);
-        if vec::len(*variants) == 1u && vec::len(variants[0].args) == 1u {
+        if (*variants).len() == 1u && variants[0].args.len() == 1u {
             let v_t = subst(cx, substs, variants[0].args[0]);
             Some(mt {ty: v_t, mutbl: ast::m_imm})
         } else {
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index fd511b6fc53e..1783e336f5aa 100644
--- a/src/librustc/middle/typeck/check/mod.rs
+++ b/src/librustc/middle/typeck/check/mod.rs
@@ -3281,7 +3281,7 @@ pub fn instantiate_path(fcx: @mut FnCtxt,
     debug!(">>> instantiate_path");
 
     let ty_param_count = tpt.generics.type_param_defs.len();
-    let ty_substs_len = vec::len(pth.types);
+    let ty_substs_len = pth.types.len();
 
     debug!("ty_param_count=%? ty_substs_len=%?",
            ty_param_count,
diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs
index dd4323524320..608986d600ca 100644
--- a/src/librustc/middle/typeck/collect.rs
+++ b/src/librustc/middle/typeck/collect.rs
@@ -499,15 +499,15 @@ pub fn compare_impl_method(tcx: ty::ctxt,
         return;
     }
 
-    if vec::len(impl_m.fty.sig.inputs) != vec::len(trait_m.fty.sig.inputs) {
+    if impl_m.fty.sig.inputs.len() != trait_m.fty.sig.inputs.len() {
         tcx.sess.span_err(
             cm.span,
             fmt!("method `%s` has %u parameter%s \
                   but the trait has %u",
                  *tcx.sess.str_of(trait_m.ident),
-                 vec::len(impl_m.fty.sig.inputs),
-                 if vec::len(impl_m.fty.sig.inputs) == 1 { "" } else { "s" },
-                 vec::len(trait_m.fty.sig.inputs)));
+                 impl_m.fty.sig.inputs.len(),
+                 if impl_m.fty.sig.inputs.len() == 1 { "" } else { "s" },
+                 trait_m.fty.sig.inputs.len()));
         return;
     }
 
diff --git a/src/librustc/middle/typeck/mod.rs b/src/librustc/middle/typeck/mod.rs
index 5da14d991717..6e73b8d27def 100644
--- a/src/librustc/middle/typeck/mod.rs
+++ b/src/librustc/middle/typeck/mod.rs
@@ -310,7 +310,7 @@ fn check_main_fn_ty(ccx: @mut CrateCtxt,
                 _ => ()
             }
             let mut ok = ty::type_is_nil(fn_ty.sig.output);
-            let num_args = vec::len(fn_ty.sig.inputs);
+            let num_args = fn_ty.sig.inputs.len();
             ok &= num_args == 0u;
             if !ok {
                 tcx.sess.span_err(
diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
index 804b23025f09..1807c7955f96 100644
--- a/src/librustc/util/ppaux.rs
+++ b/src/librustc/util/ppaux.rs
@@ -470,7 +470,7 @@ pub fn parameterized(cx: ctxt,
       }
     };
 
-    if vec::len(tps) > 0u {
+    if tps.len() > 0u {
         let strs = vec::map(tps, |t| ty_to_str(cx, *t));
         fmt!("%s%s<%s>", base, r_str, str::connect(strs, ","))
     } else {
diff --git a/src/librustdoc/tystr_pass.rs b/src/librustdoc/tystr_pass.rs
index bd6777df4afd..a08c98d2b726 100644
--- a/src/librustdoc/tystr_pass.rs
+++ b/src/librustdoc/tystr_pass.rs
@@ -405,7 +405,7 @@ mod test {
     #[test]
     fn should_not_add_impl_trait_types_if_none() {
         let doc = mk_doc(~"impl int { fn a() { } }");
-        assert!(vec::len(doc.cratemod().impls()[0].trait_types) == 0);
+        assert!(doc.cratemod().impls()[0].trait_types.len() == 0);
     }
 
     #[test]
diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index 062ad403dd6b..07c1c226d1f6 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -628,7 +628,6 @@ pub mod writer {
 
     use core::io;
     use core::str;
-    use core::vec;
 
     // ebml writing
     pub struct Encoder {
@@ -707,7 +706,7 @@ pub mod writer {
 
         fn wr_tagged_bytes(&mut self, tag_id: uint, b: &[u8]) {
             write_vuint(self.writer, tag_id);
-            write_vuint(self.writer, vec::len(b));
+            write_vuint(self.writer, b.len());
             self.writer.write(b);
         }
 
@@ -760,7 +759,7 @@ pub mod writer {
         }
 
         fn wr_bytes(&mut self, b: &[u8]) {
-            debug!("Write %u bytes", vec::len(b));
+            debug!("Write %u bytes", b.len());
             self.writer.write(b);
         }
 
diff --git a/src/libstd/md4.rs b/src/libstd/md4.rs
index 71b62ca36a5e..84561256cd1d 100644
--- a/src/libstd/md4.rs
+++ b/src/libstd/md4.rs
@@ -23,7 +23,7 @@ pub fn md4(msg: &[u8]) -> Quad {
     // subtle: if orig_len is merely uint, then the code below
     // which performs shifts by 32 bits or more has undefined
     // results.
-    let orig_len: u64 = (vec::len(msg) * 8u) as u64;
+    let orig_len: u64 = (msg.len() * 8u) as u64;
 
     // pad message
     let mut msg = vec::append(vec::to_owned(msg), ~[0x80u8]);
@@ -51,7 +51,7 @@ pub fn md4(msg: &[u8]) -> Quad {
     }
 
     let mut i = 0u;
-    let e = vec::len(msg);
+    let e = msg.len();
     let mut x = vec::from_elem(16u, 0u32);
     while i < e {
         let aa = a, bb = b, cc = c, dd = d;
diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs
index f928f10b5fc1..cc4e7ee02046 100644
--- a/src/libstd/net_ip.rs
+++ b/src/libstd/net_ip.rs
@@ -15,7 +15,6 @@ use core::comm::{stream, SharedChan};
 use core::ptr;
 use core::result;
 use core::str;
-use core::vec;
 
 use iotask = uv::iotask::IoTask;
 use interact = uv::iotask::interact;
@@ -340,7 +339,7 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t,
                     }
                 }
                 debug!("successful process addrinfo result, len: %?",
-                                vec::len(out_vec));
+                                out_vec.len());
                 output_ch.send(result::Ok(out_vec));
             }
             else {
@@ -424,7 +423,7 @@ mod test {
         // this.. mostly just wanting to see it work, atm.
         let results = result::unwrap(ga_result);
         debug!("test_get_addr: Number of results for %s: %?",
-                        localhost_name, vec::len(results));
+                        localhost_name, results.len());
         for results.each |r| {
             let ipv_prefix = match *r {
               Ipv4(_) => ~"IPv4",
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index 9387903d8421..37578e42baff 100644
--- a/src/libstd/net_tcp.rs
+++ b/src/libstd/net_tcp.rs
@@ -1802,7 +1802,7 @@ mod test {
         debug!("BUF_WRITE: val len %?", str::len(val));
         do str::byte_slice(val) |b_slice| {
             debug!("BUF_WRITE: b_slice len %?",
-                            vec::len(b_slice));
+                            b_slice.len());
             w.write(b_slice)
         }
     }
@@ -1810,7 +1810,7 @@ mod test {
     fn buf_read<R:io::Reader>(r: &R, len: uint) -> ~str {
         let new_bytes = (*r).read_bytes(len);
         debug!("in buf_read.. new_bytes len: %?",
-                        vec::len(new_bytes));
+                        new_bytes.len());
         str::from_bytes(new_bytes)
     }
 
@@ -1863,7 +1863,7 @@ mod test {
                           result::Ok(data) => {
                             debug!("SERVER: got REQ str::from_bytes..");
                             debug!("SERVER: REQ data len: %?",
-                                            vec::len(data));
+                                            data.len());
                             server_ch.send(
                                 str::from_bytes(data));
                             debug!("SERVER: before write");
diff --git a/src/libstd/par.rs b/src/libstd/par.rs
index cf0eba9d30ce..d1af484cb22b 100644
--- a/src/libstd/par.rs
+++ b/src/libstd/par.rs
@@ -58,9 +58,8 @@ fn map_slices<A:Copy + Owned,B:Copy + Owned>(
                         info!("pre-slice: %?", (base, slice));
                         let slice : &[A] =
                             cast::transmute(slice);
-                        info!("slice: %?",
-                                       (base, vec::len(slice), end - base));
-                        assert!((vec::len(slice) == end - base));
+                        info!("slice: %?", (base, slice.len(), end - base));
+                        assert!(slice.len() == end - base);
                         f(base, slice)
                     }
                 };
diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs
index 2fa12809db6f..9afa7262ce47 100644
--- a/src/libstd/rope.rs
+++ b/src/libstd/rope.rs
@@ -164,7 +164,7 @@ pub fn append_rope(left: Rope, right: Rope) -> Rope {
  */
 pub fn concat(v: ~[Rope]) -> Rope {
     //Copy `v` into a mut vector
-    let mut len = vec::len(v);
+    let mut len = v.len();
     if len == 0u { return node::Empty; }
     let mut ropes = vec::from_elem(len, v[0]);
     for uint::range(1u, len) |i| {
@@ -770,7 +770,7 @@ pub mod node {
      */
     pub fn tree_from_forest_destructive(forest: &mut [@Node]) -> @Node {
         let mut i;
-        let mut len = vec::len(forest);
+        let mut len = forest.len();
         while len > 1u {
             i = 0u;
             while i < len - 1u {//Concat nodes 0 with 1, 2 with 3 etc.
diff --git a/src/libstd/sha1.rs b/src/libstd/sha1.rs
index 4b410ebfdd2f..6d8bf20d837c 100644
--- a/src/libstd/sha1.rs
+++ b/src/libstd/sha1.rs
@@ -90,8 +90,8 @@ pub fn sha1() -> @Sha1 {
         }
     }
     fn process_msg_block(st: &mut Sha1State) {
-        assert!((vec::len(st.h) == digest_buf_len));
-        assert!((vec::uniq_len(st.work_buf) == work_buf_len));
+        assert!(st.h.len() == digest_buf_len);
+        assert!(vec::uniq_len(st.work_buf) == work_buf_len);
         let mut t: int; // Loop counter
         let w = st.work_buf;
 
@@ -230,7 +230,7 @@ pub fn sha1() -> @Sha1 {
 
     impl Sha1 for Sha1State {
         fn reset(&mut self) {
-            assert!((vec::len(self.h) == digest_buf_len));
+            assert!(self.h.len() == digest_buf_len);
             self.len_low = 0u32;
             self.len_high = 0u32;
             self.msg_block_idx = 0u;
diff --git a/src/libstd/sync.rs b/src/libstd/sync.rs
index 59c6a804408b..449edacad32b 100644
--- a/src/libstd/sync.rs
+++ b/src/libstd/sync.rs
@@ -19,7 +19,6 @@ use core::unstable::sync::{Exclusive, exclusive};
 use core::ptr;
 use core::task;
 use core::util;
-use core::vec;
 
 /****************************************************************************
  * Internals
@@ -220,7 +219,7 @@ pub impl<'self> Condvar<'self> {
             do task::unkillable {
                 // Release lock, 'atomically' enqueuing ourselves in so doing.
                 do (**self.sem).with |state| {
-                    if condvar_id < vec::len(state.blocked) {
+                    if condvar_id < state.blocked.len() {
                         // Drop the lock.
                         state.count += 1;
                         if state.count <= 0 {
@@ -230,7 +229,7 @@ pub impl<'self> Condvar<'self> {
                         let SignalEnd = SignalEnd.swap_unwrap();
                         state.blocked[condvar_id].tail.send(SignalEnd);
                     } else {
-                        out_of_bounds = Some(vec::len(state.blocked));
+                        out_of_bounds = Some(state.blocked.len());
                     }
                 }
 
@@ -285,10 +284,10 @@ pub impl<'self> Condvar<'self> {
         let mut out_of_bounds = None;
         let mut result = false;
         do (**self.sem).with |state| {
-            if condvar_id < vec::len(state.blocked) {
+            if condvar_id < state.blocked.len() {
                 result = signal_waitqueue(&state.blocked[condvar_id]);
             } else {
-                out_of_bounds = Some(vec::len(state.blocked));
+                out_of_bounds = Some(state.blocked.len());
             }
         }
         do check_cvar_bounds(out_of_bounds, condvar_id, "cond.signal_on()") {
@@ -304,14 +303,14 @@ pub impl<'self> Condvar<'self> {
         let mut out_of_bounds = None;
         let mut queue = None;
         do (**self.sem).with |state| {
-            if condvar_id < vec::len(state.blocked) {
+            if condvar_id < state.blocked.len() {
                 // To avoid :broadcast_heavy, we make a new waitqueue,
                 // swap it out with the old one, and broadcast on the
                 // old one outside of the little-lock.
                 queue = Some(util::replace(&mut state.blocked[condvar_id],
                                            new_waitqueue()));
             } else {
-                out_of_bounds = Some(vec::len(state.blocked));
+                out_of_bounds = Some(state.blocked.len());
             }
         }
         do check_cvar_bounds(out_of_bounds, condvar_id, "cond.signal_on()") {
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index 78f46b4ca03f..b2f73df316da 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -144,7 +144,7 @@ pub fn parse_opts(args: &[~str]) -> OptRes {
         };
 
     let filter =
-        if vec::len(matches.free) > 0 {
+        if matches.free.len() > 0 {
             option::Some(copy (matches).free[0])
         } else { option::None };
 
@@ -901,7 +901,7 @@ mod tests {
         ];
         let filtered = filter_tests(&opts, tests);
 
-        assert!((vec::len(filtered) == 1));
+        assert!(filtered.len() == 1);
         assert!((filtered[0].desc.name.to_str() == ~"1"));
         assert!((filtered[0].desc.ignore == false));
     }
diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs
index a14c048b8ded..37052f7d1b7f 100644
--- a/src/libstd/uv_ll.rs
+++ b/src/libstd/uv_ll.rs
@@ -1358,7 +1358,7 @@ mod test {
             let req_msg_ptr: *u8 = vec::raw::to_ptr(req_str_bytes);
             debug!("req_msg ptr: %u", req_msg_ptr as uint);
             let req_msg = ~[
-                buf_init(req_msg_ptr, vec::len(req_str_bytes))
+                buf_init(req_msg_ptr, req_str_bytes.len())
             ];
             // this is the enclosing record, we'll pass a ptr to
             // this to C..
diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs
index 6b2aa2416f8c..993fa612a270 100644
--- a/src/libsyntax/diagnostic.rs
+++ b/src/libsyntax/diagnostic.rs
@@ -232,7 +232,7 @@ fn highlight_lines(cm: @codemap::CodeMap,
     let max_lines = 6u;
     let mut elided = false;
     let mut display_lines = /* FIXME (#2543) */ copy lines.lines;
-    if vec::len(display_lines) > max_lines {
+    if display_lines.len() > max_lines {
         display_lines = vec::slice(display_lines, 0u, max_lines).to_vec();
         elided = true;
     }
@@ -243,7 +243,7 @@ fn highlight_lines(cm: @codemap::CodeMap,
         io::stderr().write_str(s);
     }
     if elided {
-        let last_line = display_lines[vec::len(display_lines) - 1u];
+        let last_line = display_lines[display_lines.len() - 1u];
         let s = fmt!("%s:%u ", fm.name, last_line + 1u);
         let mut indent = str::len(s);
         let mut out = ~"";
@@ -254,7 +254,7 @@ fn highlight_lines(cm: @codemap::CodeMap,
 
     // FIXME (#3260)
     // If there's one line at fault we can easily point to the problem
-    if vec::len(lines.lines) == 1u {
+    if lines.lines.len() == 1u {
         let lo = cm.lookup_char_pos(sp.lo);
         let mut digits = 0u;
         let mut num = (lines.lines[0] + 1u) / 10u;
diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs
index ac86d266d736..2283802208aa 100644
--- a/src/libsyntax/ext/auto_encode.rs
+++ b/src/libsyntax/ext/auto_encode.rs
@@ -824,7 +824,7 @@ fn mk_struct_ser_impl(
         cx.ident_of("emit_struct"),
         ~[
             cx.lit_str(span, @cx.str_of(ident)),
-            cx.lit_uint(span, vec::len(fields)),
+            cx.lit_uint(span, fields.len()),
             cx.lambda_stmts_1(span, fields, cx.ident_of("__s")),
         ]
     );
@@ -886,7 +886,7 @@ fn mk_struct_deser_impl(
         cx.ident_of("read_struct"),
         ~[
             cx.lit_str(span, @cx.str_of(ident)),
-            cx.lit_uint(span, vec::len(fields)),
+            cx.lit_uint(span, fields.len()),
             cx.lambda_expr_1(
                 cx.expr(
                     span,
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 20bf01c0dc1d..30470d2ebe75 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -351,7 +351,7 @@ pub fn expr_to_ident(cx: @ext_ctxt,
                      err_msg: &str) -> ast::ident {
     match expr.node {
       ast::expr_path(p) => {
-        if vec::len(p.types) > 0u || vec::len(p.idents) != 1u {
+        if p.types.len() > 0u || p.idents.len() != 1u {
             cx.span_fatal(expr.span, err_msg);
         }
         return p.idents[0];
diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs
index fa91b968f696..89873b279356 100644
--- a/src/libsyntax/parse/comments.rs
+++ b/src/libsyntax/parse/comments.rs
@@ -276,7 +276,7 @@ fn read_block_comment(rdr: @mut StringReader,
 
     let mut style = if code_to_the_left { trailing } else { isolated };
     consume_non_eol_whitespace(rdr);
-    if !is_eof(rdr) && rdr.curr != '\n' && vec::len(lines) == 1u {
+    if !is_eof(rdr) && rdr.curr != '\n' && lines.len() == 1u {
         style = mixed;
     }
     debug!("<<< block comment");
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index e1fe20695c7c..db3f407ccc18 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -2471,7 +2471,7 @@ pub impl Parser {
                                   }
                               },
                               _ => {
-                                  if vec::len(enum_path.idents)==1u {
+                                  if enum_path.idents.len()==1u {
                                       // it could still be either an enum
                                       // or an identifier pattern, resolve
                                       // will sort it out:
@@ -4337,7 +4337,7 @@ pub impl Parser {
           }
           _ => ()
         }
-        let last = path[vec::len(path) - 1u];
+        let last = path[path.len() - 1u];
         let path = @ast::Path { span: mk_sp(lo, self.span.hi),
                                 global: false,
                                 idents: path,
diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs
index 7944469cb963..38c58612f43a 100644
--- a/src/libsyntax/print/pp.rs
+++ b/src/libsyntax/print/pp.rs
@@ -110,8 +110,8 @@ pub fn tok_str(t: token) -> ~str {
 
 pub fn buf_str(toks: ~[token], szs: ~[int], left: uint, right: uint,
                lim: uint) -> ~str {
-    let n = vec::len(toks);
-    assert!(n == vec::len(szs));
+    let n = toks.len();
+    assert!(n == szs.len());
     let mut i = left;
     let mut L = lim;
     let mut s = ~"[";
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 1e94c16f87ab..4ba079fd65a5 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -1798,7 +1798,7 @@ pub fn print_meta_item(s: @ps, item: @ast::meta_item) {
 pub fn print_view_path(s: @ps, vp: @ast::view_path) {
     match vp.node {
       ast::view_path_simple(ident, path, _) => {
-        if path.idents[vec::len(path.idents)-1u] != ident {
+        if path.idents[path.idents.len()-1u] != ident {
             print_ident(s, ident);
             space(s.s);
             word_space(s, ~"=");
@@ -2067,7 +2067,7 @@ pub fn maybe_print_comment(s: @ps, pos: BytePos) {
 pub fn print_comment(s: @ps, cmnt: &comments::cmnt) {
     match cmnt.style {
       comments::mixed => {
-        assert!((vec::len(cmnt.lines) == 1u));
+        assert!(cmnt.lines.len() == 1u);
         zerobreak(s.s);
         word(s.s, cmnt.lines[0]);
         zerobreak(s.s);
@@ -2083,7 +2083,7 @@ pub fn print_comment(s: @ps, cmnt: &comments::cmnt) {
       }
       comments::trailing => {
         word(s.s, ~" ");
-        if vec::len(cmnt.lines) == 1u {
+        if cmnt.lines.len() == 1u {
             word(s.s, cmnt.lines[0]);
             hardbreak(s.s);
         } else {
diff --git a/src/test/auxiliary/cci_iter_lib.rs b/src/test/auxiliary/cci_iter_lib.rs
index e44267373efb..a264c7d238f5 100644
--- a/src/test/auxiliary/cci_iter_lib.rs
+++ b/src/test/auxiliary/cci_iter_lib.rs
@@ -13,7 +13,7 @@
 #[inline]
 pub fn iter<T>(v: &[T], f: &fn(&T)) {
     let mut i = 0u;
-    let n = vec::len(v);
+    let n = v.len();
     while i < n {
         f(&v[i]);
         i += 1u;
diff --git a/src/test/auxiliary/cci_no_inline_lib.rs b/src/test/auxiliary/cci_no_inline_lib.rs
index f79227d87cd1..fbdb7806b5e6 100644
--- a/src/test/auxiliary/cci_no_inline_lib.rs
+++ b/src/test/auxiliary/cci_no_inline_lib.rs
@@ -13,7 +13,7 @@
 // same as cci_iter_lib, more-or-less, but not marked inline
 pub fn iter(v: ~[uint], f: &fn(uint)) {
     let mut i = 0u;
-    let n = vec::len(v);
+    let n = v.len();
     while i < n {
         f(v[i]);
         i += 1u;
diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs
index 6fd31aa7b9f3..ddf6f4bfc55c 100644
--- a/src/test/bench/graph500-bfs.rs
+++ b/src/test/bench/graph500-bfs.rs
@@ -126,7 +126,7 @@ fn gen_search_keys(graph: &[~[node_id]], n: uint) -> ~[node_id] {
  */
 fn bfs(graph: graph, key: node_id) -> bfs_result {
     let mut marks : ~[node_id]
-        = vec::from_elem(vec::len(graph), -1i64);
+        = vec::from_elem(graph.len(), -1i64);
 
     let mut q = Deque::new();
 
@@ -429,7 +429,7 @@ fn main() {
     let stop = time::precise_time_s();
 
     io::stdout().write_line(fmt!("Generated %? edges in %? seconds.",
-                                 vec::len(edges), stop - start));
+                                 edges.len(), stop - start));
 
     let start = time::precise_time_s();
     let graph = make_graph(1 << scale, copy edges);
diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs
index fa6b7066e405..3c32ec338b7e 100644
--- a/src/test/bench/shootout-k-nucleotide-pipes.rs
+++ b/src/test/bench/shootout-k-nucleotide-pipes.rs
@@ -95,7 +95,7 @@ fn windows_with_carry(bb: &[u8], nn: uint,
                       it: &fn(window: &[u8])) -> ~[u8] {
    let mut ii = 0u;
 
-   let len = vec::len(bb);
+   let len = bb.len();
    while ii < len - (nn - 1u) {
       it(vec::slice(bb, ii, ii+nn));
       ii += 1u;
diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs
index c383cdf4318a..c18c1eaedd61 100644
--- a/src/test/bench/sudoku.rs
+++ b/src/test/bench/sudoku.rs
@@ -70,7 +70,7 @@ pub impl Sudoku {
             let line = reader.read_line();
             let mut comps = ~[];
             for str::each_split_char(line.trim(), ',') |s| { comps.push(s.to_owned()) }
-            if vec::len(comps) == 3u {
+            if comps.len() == 3u {
                 let row     = uint::from_str(comps[0]).get() as u8;
                 let col     = uint::from_str(comps[1]).get() as u8;
                 g[row][col] = uint::from_str(comps[2]).get() as u8;
@@ -103,7 +103,7 @@ pub impl Sudoku {
         }
 
         let mut ptr = 0u;
-        let end = vec::len(work);
+        let end = work.len();
         while (ptr < end) {
             let (row, col) = work[ptr];
             // is there another color to try?
@@ -265,7 +265,7 @@ fn check_default_sudoku_solution() {
 
 fn main() {
     let args        = os::args();
-    let use_default = vec::len(args) == 1u;
+    let use_default = args.len() == 1u;
     let mut sudoku = if use_default {
         Sudoku::from_vec(&default_sudoku)
     } else {
diff --git a/src/test/run-pass/assignability-trait.rs b/src/test/run-pass/assignability-trait.rs
index 6946ed3fbcfc..b21213bb221b 100644
--- a/src/test/run-pass/assignability-trait.rs
+++ b/src/test/run-pass/assignability-trait.rs
@@ -39,15 +39,15 @@ pub fn main() {
     // Call a method
     for x.iterate() |y| { assert!(x[*y] == *y); }
     // Call a parameterized function
-    assert!(length(x.clone()) == vec::len(x));
+    assert!(length(x.clone()) == x.len());
     // Call a parameterized function, with type arguments that require
     // a borrow
-    assert!(length::<int, &[int]>(x) == vec::len(x));
+    assert!(length::<int, &[int]>(x) == x.len());
 
     // Now try it with a type that *needs* to be borrowed
     let z = [0,1,2,3];
     // Call a method
     for z.iterate() |y| { assert!(z[*y] == *y); }
     // Call a parameterized function
-    assert!(length::<int, &[int]>(z) == vec::len(z));
+    assert!(length::<int, &[int]>(z) == z.len());
 }
diff --git a/src/test/run-pass/class-implements-multiple-traits.rs b/src/test/run-pass/class-implements-multiple-traits.rs
index 3a5bd648639a..61dfcfed7bdf 100644
--- a/src/test/run-pass/class-implements-multiple-traits.rs
+++ b/src/test/run-pass/class-implements-multiple-traits.rs
@@ -103,7 +103,7 @@ fn annoy_neighbors<T:noisy>(critter: T) {
 
 fn bite_everything<T:bitey>(critter: T) -> bool {
   let mut left : ~[body_part] = ~[finger, toe, nose, ear];
-  while vec::len(left) > 0u {
+  while left.len() > 0u {
     let part = critter.bite();
     debug!("%? %?", left, part);
     if vec_includes(left, part) {
diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs
index bca4cbafc6cc..c6ae2047147b 100644
--- a/src/test/run-pass/hashmap-memory.rs
+++ b/src/test/run-pass/hashmap-memory.rs
@@ -71,7 +71,7 @@ mod map_reduce {
 
         start_mappers(ctrl_chan, inputs.clone());
 
-        let mut num_mappers = vec::len(inputs) as int;
+        let mut num_mappers = inputs.len() as int;
 
         while num_mappers > 0 {
             match ctrl_port.recv() {
diff --git a/src/test/run-pass/vec-self-append.rs b/src/test/run-pass/vec-self-append.rs
index acd9cf6f01bd..7507a78378e8 100644
--- a/src/test/run-pass/vec-self-append.rs
+++ b/src/test/run-pass/vec-self-append.rs
@@ -14,7 +14,7 @@ fn test_heap_to_heap() {
     // a spills onto the heap
     let mut a = ~[0, 1, 2, 3, 4];
     a = a + a; // FIXME(#3387)---can't write a += a
-    assert!((vec::len(a) == 10u));
+    assert!(a.len() == 10u);
     assert!((a[0] == 0));
     assert!((a[1] == 1));
     assert!((a[2] == 2));
@@ -32,7 +32,7 @@ fn test_stack_to_heap() {
     let mut a = ~[0, 1, 2];
     // a spills to the heap
     a = a + a; // FIXME(#3387)---can't write a += a
-    assert!((vec::len(a) == 6u));
+    assert!(a.len() == 6u);
     assert!((a[0] == 0));
     assert!((a[1] == 1));
     assert!((a[2] == 2));
@@ -47,8 +47,8 @@ fn test_loop() {
     let mut i = 20;
     let mut expected_len = 1u;
     while i > 0 {
-        error!(vec::len(a));
-        assert!((vec::len(a) == expected_len));
+        error!(a.len());
+        assert!(a.len() == expected_len);
         a = a + a; // FIXME(#3387)---can't write a += a
         i -= 1;
         expected_len *= 2u;