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

Author: marijnh

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;

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);