Add [X].len() to core, use it in trans modules

10 files changed, 83 insertions, 82 deletions

diff --git a/src/comp/middle/trans/alt.rs b/src/comp/middle/trans/alt.rs
index af6c859b039..bc5d12ea96a 100644
--- a/src/comp/middle/trans/alt.rs
+++ b/src/comp/middle/trans/alt.rs
@@ -106,7 +106,7 @@ fn expand_nested_bindings(m: match, col: uint, val: ValueRef) -> match {
       alt br.pats[col].node {
           ast::pat_ident(name, some(inner)) {
             let pats = vec::slice(br.pats, 0u, col) + [inner] +
-                vec::slice(br.pats, col + 1u, vec::len(br.pats));
+                vec::slice(br.pats, col + 1u, br.pats.len());
             result += [@{pats: pats,
                         bound: br.bound + [{ident: path_to_ident(name),
                                 val: val}]
@@ -126,7 +126,7 @@ fn enter_match(m: match, col: uint, val: ValueRef, e: enter_pat) -> match {
         alt e(br.pats[col]) {
           some(sub) {
             let pats = sub + vec::slice(br.pats, 0u, col) +
-                vec::slice(br.pats, col + 1u, vec::len(br.pats));
+                vec::slice(br.pats, col + 1u, br.pats.len());
             let new_br = @{pats: pats,
                            bound: alt br.pats[col].node {
                              ast::pat_ident(name, none) {
@@ -197,7 +197,7 @@ fn enter_rec(m: match, col: uint, fields: [ast::ident], val: ValueRef) ->
             }
             ret some(pats);
           }
-          _ { ret some(vec::init_elt(vec::len(fields), dummy)); }
+          _ { ret some(vec::init_elt(fields.len(), dummy)); }
         }
     }
     ret enter_match(m, col, val, bind e(dummy, fields, _));
@@ -269,9 +269,9 @@ fn extract_variant_args(bcx: @block_ctxt, pat_id: ast::node_id,
     let blobptr = val;
     let variants = ty::enum_variants(ccx.tcx, vdefs.enm);
     let args = [];
-    let size =
-       vec::len(ty::enum_variant_with_id(ccx.tcx, vdefs.enm, vdefs.var).args);
-    if size > 0u && vec::len(*variants) != 1u {
+    let size = ty::enum_variant_with_id(ccx.tcx, vdefs.enm,
+                                        vdefs.var).args.len();
+    if size > 0u && (*variants).len() != 1u {
         let enumptr =
             PointerCast(bcx, val, T_opaque_enum_ptr(ccx));
         blobptr = GEPi(bcx, enumptr, [0, 1]);
@@ -343,7 +343,7 @@ fn pick_col(m: match) -> uint {
           _ { 0u }
         }
     }
-    let scores = vec::init_elt_mut(vec::len(m[0].pats), 0u);
+    let scores = vec::init_elt_mut(m[0].pats.len(), 0u);
     for br: match_branch in m {
         let i = 0u;
         for p: @ast::pat in br.pats { scores[i] += score(p); i += 1u; }
@@ -366,8 +366,8 @@ fn pick_col(m: match) -> uint {
 fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail,
                     &exits: [exit_node]) {
     let bcx = bcx;
-    if vec::len(m) == 0u { Br(bcx, f()); ret; }
-    if vec::len(m[0].pats) == 0u {
+    if m.len() == 0u { Br(bcx, f()); ret; }
+    if m[0].pats.len() == 0u {
         let data = m[0].data;
         alt data.guard {
           some(e) {
@@ -385,7 +385,7 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail,
             let next_cx = new_sub_block_ctxt(guard_cx, "submatch_next");
             let else_cx = new_sub_block_ctxt(guard_cx, "submatch_else");
             CondBr(guard_bcx, guard_val, next_cx.llbb, else_cx.llbb);
-            compile_submatch(else_cx, vec::slice(m, 1u, vec::len(m)), vals, f,
+            compile_submatch(else_cx, vec::slice(m, 1u, m.len()), vals, f,
                              exits);
             bcx = next_cx;
           }
@@ -408,7 +408,7 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail,
 
     let vals_left =
         vec::slice(vals, 0u, col) +
-            vec::slice(vals, col + 1u, vec::len(vals));
+            vec::slice(vals, col + 1u, vals.len());
     let ccx = bcx.fcx.ccx;
     let pat_id = 0;
     for br: match_branch in m {
@@ -419,7 +419,7 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail,
 
     let rec_fields = collect_record_fields(m, col);
     // Separate path for extracting and binding record fields
-    if vec::len(rec_fields) > 0u {
+    if rec_fields.len() > 0u {
         let rec_ty = node_id_type(bcx, pat_id);
         let fields = ty::get_fields(rec_ty);
         let rec_vals = [];
@@ -437,7 +437,7 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail,
     if any_tup_pat(m, col) {
         let tup_ty = node_id_type(bcx, pat_id);
         let n_tup_elts = alt ty::get(tup_ty).struct {
-          ty::ty_tup(elts) { vec::len(elts) }
+          ty::ty_tup(elts) { elts.len() }
           _ { ccx.sess.bug("Non-tuple type in tuple pattern"); }
         };
         let tup_vals = [], i = 0u;
@@ -473,10 +473,10 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail,
     enum branch_kind { no_branch, single, switch, compare, }
     let kind = no_branch;
     let test_val = val;
-    if vec::len(opts) > 0u {
+    if opts.len() > 0u {
         alt opts[0] {
           var(_, vdef) {
-            if vec::len(*ty::enum_variants(ccx.tcx, vdef.enm)) == 1u {
+            if (*ty::enum_variants(ccx.tcx, vdef.enm)).len() == 1u {
                 kind = single;
             } else {
                 let enumptr =
@@ -511,7 +511,7 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail,
         };
     let sw;
     if kind == switch {
-        sw = Switch(bcx, test_val, else_cx.llbb, vec::len(opts));
+        sw = Switch(bcx, test_val, else_cx.llbb, opts.len());
         // FIXME This statement is purely here as a work-around for a bug that
         // I expect to be the same as issue #951. If I remove it, sw ends up
         // holding a corrupted value (when the compiler is optimized).
@@ -573,7 +573,7 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail,
         alt opt {
           var(_, vdef) {
             let args = extract_variant_args(opt_cx, pat_id, vdef, val);
-            size = vec::len(args.vals);
+            size = args.vals.len();
             unpacked = args.vals;
             opt_cx = args.bcx;
           }
@@ -607,7 +607,7 @@ fn make_phi_bindings(bcx: @block_ctxt, map: [exit_node],
                 }
             }
         }
-        if vec::len(vals) > 0u {
+        if vals.len() > 0u {
             let local = Phi(bcx, val_ty(vals[0]), vals, llbbs);
             bcx.fcx.lllocals.insert(node_id, local_mem(local));
         } else { success = false; }
@@ -728,7 +728,7 @@ fn bind_irrefutable_pat(bcx: @block_ctxt, pat: @ast::pat, val: ValueRef,
         }
       }
       ast::pat_enum(_, sub) {
-        if vec::len(sub) == 0u { ret bcx; }
+        if sub.len() == 0u { ret bcx; }
         let vdefs = ast_util::variant_def_ids(ccx.tcx.def_map.get(pat.id));
         let args = extract_variant_args(bcx, pat.id, vdefs, val);
         let i = 0;
diff --git a/src/comp/middle/trans/base.rs b/src/comp/middle/trans/base.rs
index f5eebd3bb88..9bf815c459b 100644
--- a/src/comp/middle/trans/base.rs
+++ b/src/comp/middle/trans/base.rs
@@ -162,7 +162,7 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
 
 fn type_of_enum(cx: @crate_ctxt, did: ast::def_id, t: ty::t)
     -> TypeRef {
-    let degen = vec::len(*ty::enum_variants(cx.tcx, did)) == 1u;
+    let degen = (*ty::enum_variants(cx.tcx, did)).len() == 1u;
     if check type_has_static_size(cx, t) {
         let size = static_size_of_enum(cx, t);
         if !degen { T_enum(cx, size) }
@@ -289,7 +289,7 @@ fn get_simple_extern_fn(cx: @block_ctxt,
 fn trans_native_call(cx: @block_ctxt, externs: hashmap<str, ValueRef>,
                      llmod: ModuleRef, name: str, args: [ValueRef]) ->
    ValueRef {
-    let n: int = vec::len::<ValueRef>(args) as int;
+    let n = args.len() as int;
     let llnative: ValueRef =
         get_simple_extern_fn(cx, externs, llmod, name, n);
     let call_args: [ValueRef] = [];
@@ -388,7 +388,7 @@ fn GEP_tup_like(bcx: @block_ctxt, t: ty::t, base: ValueRef, ixs: [int])
                    t: ty::t,
                    ixs: [int],
                    n: uint) -> (@block_ctxt, ValueRef, ty::t) {
-        if n == vec::len(ixs) {
+        if n == ixs.len() {
             ret (bcx, off, t);
         }
 
@@ -638,8 +638,8 @@ fn get_derived_tydesc(cx: @block_ctxt, t: ty::t, escapes: bool,
     // promising to do so itself.
     let n_params = ty::count_ty_params(bcx_tcx(bcx), t);
 
-    assert (n_params == vec::len::<uint>(tys.params));
-    assert (n_params == vec::len::<ValueRef>(tys.descs));
+    assert n_params == tys.params.len();
+    assert n_params == tys.descs.len();
 
     let llparamtydescs =
         alloca(bcx, T_array(T_ptr(bcx_ccx(bcx).tydesc_type), n_params + 1u));
@@ -687,7 +687,7 @@ fn get_tydesc(cx: @block_ctxt, t: ty::t, escapes: bool,
     // Is the supplied type a type param? If so, return the passed-in tydesc.
     alt ty::type_param(t) {
       some(id) {
-        if id < vec::len(cx.fcx.lltyparams) {
+        if id < cx.fcx.lltyparams.len() {
             ret {kind: tk_param,
                  result: rslt(cx, cx.fcx.lltyparams[id].desc)};
         } else {
@@ -821,7 +821,7 @@ fn make_generic_glue_inner(ccx: @crate_ctxt, t: ty::t,
         T_ptr(type_of(ccx, t))
     } else { T_ptr(T_i8()) };
 
-    let ty_param_count = vec::len(ty_params);
+    let ty_param_count = ty_params.len();
     let lltyparams = llvm::LLVMGetParam(llfn, 2u as c_uint);
     let load_env_bcx = new_raw_block_ctxt(fcx, fcx.llloadenv);
     let lltydescs = [mutable];
@@ -1072,7 +1072,7 @@ fn trans_res_drop(cx: @block_ctxt, rs: ValueRef, did: ast::def_id,
     // for type variables.
     let val_llty = lib::llvm::fn_ty_param_tys
         (llvm::LLVMGetElementType
-         (llvm::LLVMTypeOf(dtor_addr)))[vec::len(args)];
+         (llvm::LLVMTypeOf(dtor_addr)))[args.len()];
     let val_cast = BitCast(cx, val.val, val_llty);
     Call(cx, dtor_addr, args + [val_cast]);
 
@@ -1244,7 +1244,7 @@ fn iter_structural_ty(cx: @block_ctxt, av: ValueRef, t: ty::t,
     fn iter_variant(cx: @block_ctxt, a_tup: ValueRef,
                     variant: ty::variant_info, tps: [ty::t], tid: ast::def_id,
                     f: val_and_ty_fn) -> @block_ctxt {
-        if vec::len::<ty::t>(variant.args) == 0u { ret cx; }
+        if variant.args.len() == 0u { ret cx; }
         let fn_ty = variant.ctor_ty;
         let ccx = bcx_ccx(cx);
         let cx = cx;
@@ -1299,7 +1299,7 @@ fn iter_structural_ty(cx: @block_ctxt, av: ValueRef, t: ty::t,
       }
       ty::ty_enum(tid, tps) {
         let variants = ty::enum_variants(bcx_tcx(cx), tid);
-        let n_variants = vec::len(*variants);
+        let n_variants = (*variants).len();
 
         // Cast the enums to types we can GEP into.
         if n_variants == 1u {
@@ -1912,8 +1912,7 @@ fn autoderef(cx: @block_ctxt, v: ValueRef, t: ty::t) -> result_t {
           }
           ty::ty_enum(did, tps) {
             let variants = ty::enum_variants(ccx.tcx, did);
-            if vec::len(*variants) != 1u ||
-                   vec::len(variants[0].args) != 1u {
+            if (*variants).len() != 1u || variants[0].args.len() != 1u {
                 break;
             }
             t1 =
@@ -2278,7 +2277,7 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, substs: [ty::t],
         let this_tv = option::get(vec::find(*tvs, {|tv|
             tv.id.node == fn_id.node}));
         trans_enum_variant(ccx, enum_id.node, v, this_tv.disr_val,
-                           vec::len(*tvs) == 1u, [], psubsts, lldecl);
+                           (*tvs).len() == 1u, [], psubsts, lldecl);
       }
       ast_map::node_method(mth, impl_id, _) {
         let selfty = ty::node_id_to_type(ccx.tcx, impl_id);
@@ -2301,12 +2300,12 @@ fn lval_static_fn(bcx: @block_ctxt, fn_id: ast::def_id, id: ast::node_id,
     // monomorphized and non-monomorphized functions at the moment. If
     // monomorphizing becomes the only approach, this'll be much simpler.
     if ccx.sess.opts.monomorphize &&
-       (option::is_some(substs) || vec::len(tys) > 0u) &&
+       (option::is_some(substs) || tys.len() > 0u) &&
        fn_id.crate == ast::local_crate &&
        !vec::any(tys, {|t| ty::type_has_params(t)}) {
         let mono = alt substs {
           some((stys, dicts)) {
-            if (vec::len(stys) + vec::len(tys)) > 0u {
+            if (stys.len() + tys.len()) > 0u {
                 monomorphic_fn(ccx, fn_id, stys + tys, some(dicts))
             } else { none }
           }
@@ -2340,7 +2339,7 @@ fn lval_static_fn(bcx: @block_ctxt, fn_id: ast::def_id, id: ast::node_id,
         trans_external_path(bcx, fn_id, tpt)
     };
     let gen = generic_none, bcx = bcx;
-    if vec::len(tys) > 0u {
+    if tys.len() > 0u {
         let tydescs = [], tis = [];
         for t in tys {
             // TODO: Doesn't always escape.
@@ -2424,7 +2423,7 @@ fn trans_var(cx: @block_ctxt, def: ast::def, id: ast::node_id)
         ret lval_static_fn(cx, did, id, none);
       }
       ast::def_variant(tid, vid) {
-        if vec::len(ty::enum_variant_with_id(ccx.tcx, tid, vid).args) > 0u {
+        if ty::enum_variant_with_id(ccx.tcx, tid, vid).args.len() > 0u {
             // N-ary variant.
             ret lval_static_fn(cx, vid, id, none);
         } else {
@@ -2616,7 +2615,7 @@ fn maybe_add_env(bcx: @block_ctxt, c: lval_maybe_callee)
 fn lval_maybe_callee_to_lval(c: lval_maybe_callee, ty: ty::t) -> lval_result {
     alt c.generic {
       generic_full(gi) {
-        let n_args = vec::len(ty::ty_fn_args(ty));
+        let n_args = ty::ty_fn_args(ty).len();
         let args = vec::init_elt(n_args, none::<@ast::expr>);
         let space = alloc_ty(c.bcx, ty);
         let bcx = closure::trans_bind_1(space.bcx, ty, c, args, ty,
@@ -3877,10 +3876,8 @@ fn new_raw_block_ctxt(fcx: @fn_ctxt, llbb: BasicBlockRef) -> @block_ctxt {
 fn trans_block_cleanups(bcx: @block_ctxt, cleanup_cx: @block_ctxt) ->
    @block_ctxt {
     if bcx.unreachable { ret bcx; }
-    if cleanup_cx.kind == NON_SCOPE_BLOCK {
-        assert (vec::len::<cleanup>(cleanup_cx.cleanups) == 0u);
-    }
-    let i = vec::len::<cleanup>(cleanup_cx.cleanups), bcx = bcx;
+    let i = cleanup_cx.cleanups.len(), bcx = bcx;
+    if cleanup_cx.kind == NON_SCOPE_BLOCK { assert i == 0u; }
     while i > 0u {
         i -= 1u;
         let c = cleanup_cx.cleanups[i];
@@ -4535,7 +4532,7 @@ fn trans_native_mod(ccx: @crate_ctxt,
         let bcx = new_top_block_ctxt(fcx, none);
         let lltop = bcx.llbb;
         let llargbundle = llvm::LLVMGetParam(llshimfn, 0 as c_uint);
-        let i = 0u, n = vec::len(tys.arg_tys);
+        let i = 0u, n = tys.arg_tys.len();
         let llargvals = [];
         while i < n {
             let llargval = load_inbounds(bcx, llargbundle, [0, i as int]);
@@ -4573,7 +4570,7 @@ fn trans_native_mod(ccx: @crate_ctxt,
 
         // Allocate the struct and write the arguments into it.
         let llargbundle = alloca(bcx, tys.bundle_ty);
-        let i = 0u, n = vec::len(tys.arg_tys);
+        let i = 0u, n = tys.arg_tys.len();
         let implicit_args = 2u + num_tps; // ret + env
         while i < n {
             let llargval = llvm::LLVMGetParam(llwrapfn,
@@ -4608,7 +4605,7 @@ fn trans_native_mod(ccx: @crate_ctxt,
           alt ccx.item_ids.find(id) {
             some(llwrapfn) {
               let llshimfn = build_shim_fn(ccx, native_item, tys, cc);
-              build_wrap_fn(ccx, tys, vec::len(tps), llshimfn, llwrapfn);
+              build_wrap_fn(ccx, tys, tps.len(), llshimfn, llwrapfn);
             }
             none {
               ccx.sess.span_fatal(
@@ -4661,11 +4658,11 @@ fn trans_item(ccx: @crate_ctxt, item: ast::item) {
         trans_mod(ccx, m);
       }
       ast::item_enum(variants, tps) {
-        let degen = vec::len(variants) == 1u;
+        let degen = variants.len() == 1u;
         let vi = ty::enum_variants(ccx.tcx, local_def(item.id));
         let i = 0;
         for variant: ast::variant in variants {
-            if vec::len(variant.node.args) > 0u {
+            if variant.node.args.len() > 0u {
                 trans_enum_variant(ccx, item.id, variant,
                                    vi[i].disr_val, degen, tps,
                                    none, ccx.item_ids.get(variant.node.id));
@@ -4737,7 +4734,7 @@ fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef,
     let main_takes_argv =
         // invariant!
         alt ty::get(main_node_type).struct {
-          ty::ty_fn({inputs, _}) { vec::len(inputs) != 0u }
+          ty::ty_fn({inputs, _}) { inputs.len() != 0u }
           _ { ccx.sess.span_fatal(sp, "main has a non-function type"); }
         };
 
@@ -4800,7 +4797,7 @@ fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef,
                     llvm::LLVMGetParam(llfn, 1 as c_uint), crate_map];
         let result = unsafe {
             llvm::LLVMBuildCall(bld, start, vec::to_ptr(args),
-                                vec::len(args) as c_uint, noname())
+                                args.len() as c_uint, noname())
         };
         llvm::LLVMBuildRet(bld, result);
     }
@@ -4938,7 +4935,7 @@ fn collect_item(ccx: @crate_ctxt, abi: @mutable option<ast::native_abi>,
       }
       ast::item_enum(variants, tps) {
         for variant in variants {
-            if vec::len(variant.node.args) != 0u {
+            if variant.node.args.len() != 0u {
                 register_fn(ccx, i.span,
                             my_path + [path_name(variant.node.name)],
                             "enum", tps, variant.node.id);
diff --git a/src/comp/middle/trans/build.rs b/src/comp/middle/trans/build.rs
index 9ed3d714feb..a65636d0e62 100644
--- a/src/comp/middle/trans/build.rs
+++ b/src/comp/middle/trans/build.rs
@@ -43,7 +43,7 @@ fn AggregateRet(cx: @block_ctxt, RetVals: [ValueRef]) {
     cx.terminated = true;
     unsafe {
         llvm::LLVMBuildAggregateRet(B(cx), vec::to_ptr(RetVals),
-                                    vec::len(RetVals) as c_uint);
+                                    RetVals.len() as c_uint);
     }
 }
 
@@ -100,7 +100,7 @@ fn Invoke(cx: @block_ctxt, Fn: ValueRef, Args: [ValueRef],
                         ", ")];
     unsafe {
         llvm::LLVMBuildInvoke(B(cx), Fn, vec::to_ptr(Args),
-                              vec::len(Args) as c_uint, Then, Catch,
+                              Args.len() as c_uint, Then, Catch,
                               noname());
     }
 }
@@ -112,7 +112,7 @@ fn FastInvoke(cx: @block_ctxt, Fn: ValueRef, Args: [ValueRef],
     cx.terminated = true;
     unsafe {
         let v = llvm::LLVMBuildInvoke(B(cx), Fn, vec::to_ptr(Args),
-                                      vec::len(Args) as c_uint,
+                                      Args.len() as c_uint,
                                       Then, Catch, noname());
         lib::llvm::SetInstructionCallConv(v, lib::llvm::FastCallConv);
     }
@@ -330,7 +330,7 @@ fn GEP(cx: @block_ctxt, Pointer: ValueRef, Indices: [ValueRef]) -> ValueRef {
     if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_nil())); }
     unsafe {
         ret llvm::LLVMBuildGEP(B(cx), Pointer, vec::to_ptr(Indices),
-                               vec::len(Indices) as c_uint, noname());
+                               Indices.len() as c_uint, noname());
     }
 }
 
@@ -348,7 +348,7 @@ fn InBoundsGEP(cx: @block_ctxt, Pointer: ValueRef, Indices: [ValueRef]) ->
     unsafe {
         ret llvm::LLVMBuildInBoundsGEP(B(cx), Pointer,
                                        vec::to_ptr(Indices),
-                                       vec::len(Indices) as c_uint,
+                                       Indices.len() as c_uint,
                                        noname());
     }
 }
@@ -491,11 +491,11 @@ fn EmptyPhi(cx: @block_ctxt, Ty: TypeRef) -> ValueRef {
 fn Phi(cx: @block_ctxt, Ty: TypeRef, vals: [ValueRef], bbs: [BasicBlockRef])
    -> ValueRef {
     if cx.unreachable { ret llvm::LLVMGetUndef(Ty); }
-    assert (vec::len::<ValueRef>(vals) == vec::len::<BasicBlockRef>(bbs));
+    assert vals.len() == bbs.len();
     let phi = EmptyPhi(cx, Ty);
     unsafe {
         llvm::LLVMAddIncoming(phi, vec::to_ptr(vals), vec::to_ptr(bbs),
-                              vec::len(vals) as c_uint);
+                              vals.len() as c_uint);
         ret phi;
     }
 }
@@ -547,7 +547,7 @@ fn Call(cx: @block_ctxt, Fn: ValueRef, Args: [ValueRef]) -> ValueRef {
     if cx.unreachable { ret _UndefReturn(cx, Fn); }
     unsafe {
         ret llvm::LLVMBuildCall(B(cx), Fn, vec::to_ptr(Args),
-                                vec::len(Args) as c_uint, noname());
+                                Args.len() as c_uint, noname());
     }
 }
 
@@ -555,7 +555,7 @@ fn FastCall(cx: @block_ctxt, Fn: ValueRef, Args: [ValueRef]) -> ValueRef {
     if cx.unreachable { ret _UndefReturn(cx, Fn); }
     unsafe {
         let v = llvm::LLVMBuildCall(B(cx), Fn, vec::to_ptr(Args),
-                                    vec::len(Args) as c_uint, noname());
+                                    Args.len() as c_uint, noname());
         lib::llvm::SetInstructionCallConv(v, lib::llvm::FastCallConv);
         ret v;
     }
@@ -566,7 +566,7 @@ fn CallWithConv(cx: @block_ctxt, Fn: ValueRef, Args: [ValueRef],
     if cx.unreachable { ret _UndefReturn(cx, Fn); }
     unsafe {
         let v = llvm::LLVMBuildCall(B(cx), Fn, vec::to_ptr(Args),
-                                    vec::len(Args) as c_uint, noname());
+                                    Args.len() as c_uint, noname());
         lib::llvm::SetInstructionCallConv(v, Conv);
         ret v;
     }
@@ -642,7 +642,7 @@ fn Trap(cx: @block_ctxt) {
     let Args: [ValueRef] = [];
     unsafe {
         llvm::LLVMBuildCall(b, T, vec::to_ptr(Args),
-                            vec::len(Args) as c_uint, noname());
+                            Args.len() as c_uint, noname());
     }
 }
 
diff --git a/src/comp/middle/trans/closure.rs b/src/comp/middle/trans/closure.rs
index 9255119379e..16466eb092a 100644
--- a/src/comp/middle/trans/closure.rs
+++ b/src/comp/middle/trans/closure.rs
@@ -529,7 +529,7 @@ fn trans_bind_1(cx: @block_ctxt, outgoing_fty: ty::t,
       _ { (outgoing_fty, [], @[]) }
     };
 
-    if vec::len(bound) == 0u && vec::len(lltydescs) == 0u {
+    if bound.len() == 0u && lltydescs.len() == 0u {
         // Trivial 'binding': just return the closure
         let lv = lval_maybe_callee_to_lval(f_res, pair_ty);
         bcx = lv.bcx;
diff --git a/src/comp/middle/trans/common.rs b/src/comp/middle/trans/common.rs
index c8965bd3f60..d39759ad211 100644
--- a/src/comp/middle/trans/common.rs
+++ b/src/comp/middle/trans/common.rs
@@ -283,7 +283,7 @@ fn revoke_clean(cx: @block_ctxt, val: ValueRef) {
     sc_cx.cleanups =
         vec::slice(sc_cx.cleanups, 0u, found as uint) +
             vec::slice(sc_cx.cleanups, (found as uint) + 1u,
-                            vec::len(sc_cx.cleanups));
+                            sc_cx.cleanups.len());
     sc_cx.lpad_dirty = true;
     ret;
 }
@@ -495,7 +495,7 @@ fn T_size_t(targ_cfg: @session::config) -> TypeRef {
 
 fn T_fn(inputs: [TypeRef], output: TypeRef) -> TypeRef unsafe {
     ret llvm::LLVMFunctionType(output, to_ptr(inputs),
-                               vec::len::<TypeRef>(inputs) as unsigned,
+                               inputs.len() as unsigned,
                                False);
 }
 
@@ -508,7 +508,7 @@ fn T_ptr(t: TypeRef) -> TypeRef {
 }
 
 fn T_struct(elts: [TypeRef]) -> TypeRef unsafe {
-    ret llvm::LLVMStructType(to_ptr(elts), vec::len(elts) as unsigned, False);
+    ret llvm::LLVMStructType(to_ptr(elts), elts.len() as unsigned, False);
 }
 
 fn T_named_struct(name: str) -> TypeRef {
@@ -518,7 +518,7 @@ fn T_named_struct(name: str) -> TypeRef {
 
 fn set_struct_body(t: TypeRef, elts: [TypeRef]) unsafe {
     llvm::LLVMStructSetBody(t, to_ptr(elts),
-                            vec::len(elts) as unsigned, False);
+                            elts.len() as unsigned, False);
 }
 
 fn T_empty_struct() -> TypeRef { ret T_struct([]); }
@@ -790,28 +790,28 @@ fn C_zero_byte_arr(size: uint) -> ValueRef unsafe {
     let elts: [ValueRef] = [];
     while i < size { elts += [C_u8(0u)]; i += 1u; }
     ret llvm::LLVMConstArray(T_i8(), vec::to_ptr(elts),
-                             vec::len(elts) as unsigned);
+                             elts.len() as unsigned);
 }
 
 fn C_struct(elts: [ValueRef]) -> ValueRef unsafe {
-    ret llvm::LLVMConstStruct(vec::to_ptr(elts), vec::len(elts) as unsigned,
+    ret llvm::LLVMConstStruct(vec::to_ptr(elts), elts.len() as unsigned,
                               False);
 }
 
 fn C_named_struct(T: TypeRef, elts: [ValueRef]) -> ValueRef unsafe {
     ret llvm::LLVMConstNamedStruct(T, vec::to_ptr(elts),
-                                   vec::len(elts) as unsigned);
+                                   elts.len() as unsigned);
 }
 
 fn C_array(ty: TypeRef, elts: [ValueRef]) -> ValueRef unsafe {
     ret llvm::LLVMConstArray(ty, vec::to_ptr(elts),
-                             vec::len(elts) as unsigned);
+                             elts.len() as unsigned);
 }
 
 fn C_bytes(bytes: [u8]) -> ValueRef unsafe {
     ret llvm::LLVMConstString(
         unsafe::reinterpret_cast(vec::to_ptr(bytes)),
-        vec::len(bytes) as unsigned, False);
+        bytes.len() as unsigned, False);
 }
 
 fn C_shape(ccx: @crate_ctxt, bytes: [u8]) -> ValueRef {
@@ -835,7 +835,7 @@ pure fn valid_variant_index(ix: uint, cx: @block_ctxt, enum_id: ast::def_id,
     unchecked{
         let variant =
             ty::enum_variant_with_id(bcx_tcx(cx), enum_id, variant_id);
-        ix < vec::len(variant.args)
+        ix < variant.args.len()
     }
 }
 
diff --git a/src/comp/middle/trans/impl.rs b/src/comp/middle/trans/impl.rs
index be751de7d68..e72bbe04ae8 100644
--- a/src/comp/middle/trans/impl.rs
+++ b/src/comp/middle/trans/impl.rs
@@ -122,10 +122,10 @@ fn trans_vtable_callee(bcx: @block_ctxt, self: ValueRef, dict: ValueRef,
                              T_ptr(T_array(T_ptr(llfty), n_method + 1u)));
     let mptr = Load(bcx, GEPi(bcx, vtable, [0, n_method as int]));
     let generic = generic_none;
-    if vec::len(*method.tps) > 0u || ty::type_has_params(fty) {
+    if (*method.tps).len() > 0u || ty::type_has_params(fty) {
         let tydescs = [], tis = [];
         let tptys = node_id_type_params(bcx, callee_id);
-        for t in vec::tail_n(tptys, vec::len(tptys) - vec::len(*method.tps)) {
+        for t in vec::tail_n(tptys, tptys.len() - (*method.tps).len()) {
             let ti = none;
             let td = get_tydesc(bcx, t, true, ti).result;
             tis += [ti];
@@ -297,10 +297,10 @@ fn trans_impl_wrapper(ccx: @crate_ctxt, pt: path,
         }
     }
     let env_ty = T_ptr(T_struct([T_ptr(T_i8())] + extra_ptrs));
-    let n_extra_ptrs = vec::len(extra_ptrs);
+    let n_extra_ptrs = extra_ptrs.len();
 
     let wrap_args = [T_ptr(T_dict())] + vec::slice(real_args, 0u, 2u) +
-        vec::slice(real_args, 2u + vec::len(extra_ptrs), vec::len(real_args));
+        vec::slice(real_args, 2u + n_extra_ptrs, real_args.len());
     let llfn_ty = T_fn(wrap_args, real_ret);
     trans_wrapper(ccx, pt, llfn_ty, {|llfn, bcx|
         let dict = PointerCast(bcx, LLVMGetParam(llfn, 0 as c_uint), env_ty);
@@ -407,14 +407,14 @@ fn get_dict(bcx: @block_ctxt, origin: typeck::dict_origin) -> result {
             ret rslt(bcx, get_static_dict(bcx, origin));
         }
         let {bcx, ptrs} = get_dict_ptrs(bcx, origin);
-        let pty = T_ptr(T_i8()), dict_ty = T_array(pty, vec::len(ptrs));
+        let pty = T_ptr(T_i8()), dict_ty = T_array(pty, ptrs.len());
         let dict = alloca(bcx, dict_ty), i = 0;
         for ptr in ptrs {
             Store(bcx, PointerCast(bcx, ptr, pty), GEPi(bcx, dict, [0, i]));
             i += 1;
         }
         dict = Call(bcx, ccx.upcalls.intern_dict,
-                    [C_uint(ccx, vec::len(ptrs)),
+                    [C_uint(ccx, ptrs.len()),
                      PointerCast(bcx, dict, T_ptr(T_dict()))]);
         rslt(bcx, dict)
       }
@@ -431,7 +431,7 @@ fn dict_id(tcx: ty::ctxt, origin: typeck::dict_origin) -> dict_id {
     alt origin {
       typeck::dict_static(did, ts, origs) {
         let d_params = [], orig = 0u;
-        if vec::len(ts) == 0u { ret @{def: did, params: d_params}; }
+        if ts.len() == 0u { ret @{def: did, params: d_params}; }
         let impl_params = ty::lookup_item_type(tcx, did).bounds;
         vec::iter2(ts, *impl_params) {|t, bounds|
             d_params += [dict_param_ty(t)];
diff --git a/src/comp/middle/trans/tvec.rs b/src/comp/middle/trans/tvec.rs
index a3700ca423e..72cb133163c 100644
--- a/src/comp/middle/trans/tvec.rs
+++ b/src/comp/middle/trans/tvec.rs
@@ -110,7 +110,7 @@ fn trans_vec(bcx: @block_ctxt, args: [@ast::expr], id: ast::node_id,
          llunitsz: llunitsz,
          unit_ty: unit_ty,
          llunitty: llunitty} =
-        alloc(bcx, vec_ty, vec::len(args));
+        alloc(bcx, vec_ty, args.len());
 
     add_clean_free(bcx, vptr, true);
     // Store the individual elements.
diff --git a/src/libcore/core.rs b/src/libcore/core.rs
index 23ac02b7584..0c6d4daa4aa 100644
--- a/src/libcore/core.rs
+++ b/src/libcore/core.rs
@@ -5,7 +5,8 @@
 
 import option::{some,  none};
 import option = option::t;
-export option, some, none;
+import vec::vec_len;
+export option, some, none, vec_len;
 
 // Export the log levels as global constants. Higher levels mean
 // more-verbosity. Error is the bottom level, default logging level is
diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index 38809da7eb4..1f0abca0255 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -1088,6 +1088,9 @@ fn as_buf<E,T>(v: [const E], f: fn(*E) -> T) -> T unsafe {
     let buf = unsafe::to_ptr(v); f(buf)
 }
 
+impl vec_len<T> for [T] {
+    fn len() -> uint { len(self) }
+}
 
 /*
 Module: unsafe
diff --git a/src/test/run-pass/static-impl.rs b/src/test/run-pass/static-impl.rs
index fbc29c55a31..c2b698be1bc 100644
--- a/src/test/run-pass/static-impl.rs
+++ b/src/test/run-pass/static-impl.rs
@@ -18,7 +18,7 @@ impl util for uint {
 }
 
 impl util<T> for [T] {
-    fn len() -> uint { vec::len(self) }
+    fn length() -> uint { vec::len(self) }
     fn iter(f: fn(T)) { for x in self { f(x); } }
     fn map<U>(f: fn(T) -> U) -> [U] {
         let r = [];
@@ -33,7 +33,7 @@ fn main() {
     assert 10u.plus() == 30;
     assert "hi".plus() == 200;
 
-    assert [1].len().str() == "1";
+    assert [1].length().str() == "1";
     assert [3, 4].map({|a| a + 4})[0] == 7;
     assert [3, 4].map::<uint>({|a| a as uint + 4u})[0] == 7u;
     let x = 0u;