issue #1352: change param order on vec::init_elt, putting block in final position.

To match the init_fn() and init_fn_mut() changes.

Author: gmfawcett

src/comp/lib/llvm.rs

@@ -972,7 +972,7 @@ fn type_to_str_inner(names: type_names, outer0: [TypeRef], ty: TypeRef) ->
         let s = "fn(";
         let out_ty: TypeRef = llvm::LLVMGetReturnType(ty);
         let n_args = llvm::LLVMCountParamTypes(ty) as uint;
-        let args: [TypeRef] = vec::init_elt::<TypeRef>(0 as TypeRef, n_args);
+        let args: [TypeRef] = vec::init_elt::<TypeRef>(n_args, 0 as TypeRef);
         unsafe {
             llvm::LLVMGetParamTypes(ty, vec::to_ptr(args));
         }
@@ -984,7 +984,7 @@ fn type_to_str_inner(names: type_names, outer0: [TypeRef], ty: TypeRef) ->
       10 {
         let s: str = "{";
         let n_elts = llvm::LLVMCountStructElementTypes(ty) as uint;
-        let elts: [TypeRef] = vec::init_elt::<TypeRef>(0 as TypeRef, n_elts);
+        let elts: [TypeRef] = vec::init_elt::<TypeRef>(n_elts, 0 as TypeRef);
         unsafe {
             llvm::LLVMGetStructElementTypes(ty, vec::to_ptr(elts));
         }
@@ -1027,8 +1027,8 @@ fn float_width(llt: TypeRef) -> uint {
 }
 
 fn fn_ty_param_tys(fn_ty: TypeRef) -> [TypeRef] unsafe {
-    let args = vec::init_elt(0 as TypeRef,
-                             llvm::LLVMCountParamTypes(fn_ty) as uint);
+    let args = vec::init_elt(llvm::LLVMCountParamTypes(fn_ty) as uint,
+                             0 as TypeRef);
     llvm::LLVMGetParamTypes(fn_ty, vec::to_ptr(args));
     ret args;
 }

src/comp/middle/trans.rs

@@ -338,7 +338,7 @@ fn get_simple_extern_fn(cx: @block_ctxt,
                         llmod: ModuleRef,
                         name: str, n_args: int) -> ValueRef {
     let ccx = cx.fcx.lcx.ccx;
-    let inputs = vec::init_elt::<TypeRef>(ccx.int_type, n_args as uint);
+    let inputs = vec::init_elt::<TypeRef>(n_args as uint, ccx.int_type);
     let output = ccx.int_type;
     let t = T_fn(inputs, output);
     ret get_extern_fn(externs, llmod, name,
@@ -2869,7 +2869,7 @@ fn lval_maybe_callee_to_lval(c: lval_maybe_callee, ty: ty::t) -> lval_result {
     alt c.generic {
       some(gi) {
         let n_args = vec::len(ty::ty_fn_args(bcx_tcx(c.bcx), ty));
-        let args = vec::init_elt(none::<@ast::expr>, n_args);
+        let args = vec::init_elt(n_args, none::<@ast::expr>);
         let space = alloc_ty(c.bcx, ty);
         let bcx = trans_closure::trans_bind_1(space.bcx, ty, c, args, ty,
                                               save_in(space.val));

src/comp/middle/trans_alt.rs

@@ -174,7 +174,7 @@ fn enter_opt(ccx: @crate_ctxt, m: match, opt: opt, col: uint, tag_size: uint,
           ast::pat_range(l1, l2) {
             ret if opt_eq(range(l1, l2), opt) { some([]) } else { none };
           }
-          _ { ret some(vec::init_elt(dummy, size)); }
+          _ { ret some(vec::init_elt(size, dummy)); }
         }
     }
     ret enter_match(m, col, val, bind e(ccx, dummy, opt, tag_size, _));
@@ -197,7 +197,7 @@ fn enter_rec(m: match, col: uint, fields: [ast::ident], val: ValueRef) ->
             }
             ret some(pats);
           }
-          _ { ret some(vec::init_elt(dummy, vec::len(fields))); }
+          _ { ret some(vec::init_elt(vec::len(fields), dummy)); }
         }
     }
     ret enter_match(m, col, val, bind e(dummy, fields, _));
@@ -209,7 +209,7 @@ fn enter_tup(m: match, col: uint, val: ValueRef, n_elts: uint) -> match {
        option::t<[@ast::pat]> {
         alt p.node {
           ast::pat_tup(elts) { ret some(elts); }
-          _ { ret some(vec::init_elt(dummy, n_elts)); }
+          _ { ret some(vec::init_elt(n_elts, dummy)); }
         }
     }
     ret enter_match(m, col, val, bind e(dummy, n_elts, _));
@@ -343,7 +343,7 @@ fn pick_col(m: match) -> uint {
           _ { 0u }
         }
     }
-    let scores = vec::init_elt_mut(0u, vec::len(m[0].pats));
+    let scores = vec::init_elt_mut(vec::len(m[0].pats), 0u);
     for br: match_branch in m {
         let i = 0u;
         for p: @ast::pat in br.pats { scores[i] += score(p); i += 1u; }

src/comp/middle/trans_common.rs

@@ -413,7 +413,7 @@ fn val_str(tn: type_names, v: ValueRef) -> str { ret ty_str(tn, val_ty(v)); }
 fn struct_elt(llstructty: TypeRef, n: uint) -> TypeRef unsafe {
     let elt_count = llvm::LLVMCountStructElementTypes(llstructty) as uint;
     assert (n < elt_count);
-    let elt_tys = vec::init_elt(T_nil(), elt_count);
+    let elt_tys = vec::init_elt(elt_count, T_nil());
     llvm::LLVMGetStructElementTypes(llstructty, to_ptr(elt_tys));
     ret llvm::LLVMGetElementType(elt_tys[n]);
 }
@@ -594,8 +594,8 @@ fn T_tydesc_field(cx: @crate_ctxt, field: int) -> TypeRef unsafe {
     // Bit of a kludge: pick the fn typeref out of the tydesc..
 
     let tydesc_elts: [TypeRef] =
-        vec::init_elt::<TypeRef>(T_nil(),
-                                      abi::n_tydesc_fields as uint);
+        vec::init_elt::<TypeRef>(abi::n_tydesc_fields as uint,
+                                 T_nil());
     llvm::LLVMGetStructElementTypes(cx.tydesc_type,
                                     to_ptr::<TypeRef>(tydesc_elts));
     let t = llvm::LLVMGetElementType(tydesc_elts[field]);
@@ -729,7 +729,7 @@ fn T_opaque_tag_ptr(cx: @crate_ctxt) -> TypeRef {
 }
 
 fn T_captured_tydescs(cx: @crate_ctxt, n: uint) -> TypeRef {
-    ret T_struct(vec::init_elt::<TypeRef>(T_ptr(cx.tydesc_type), n));
+    ret T_struct(vec::init_elt::<TypeRef>(n, T_ptr(cx.tydesc_type)));
 }
 
 fn T_opaque_iface_ptr(cx: @crate_ctxt) -> TypeRef {

src/comp/middle/trans_impl.rs

@@ -139,7 +139,7 @@ fn trans_iface_callee(bcx: @block_ctxt, fld_expr: @ast::expr,
 fn llfn_arg_tys(ft: TypeRef) -> {inputs: [TypeRef], output: TypeRef} {
     let out_ty = llvm::LLVMGetReturnType(ft);
     let n_args = llvm::LLVMCountParamTypes(ft);
-    let args = vec::init_elt(0 as TypeRef, n_args as uint);
+    let args = vec::init_elt(n_args as uint, 0 as TypeRef);
     unsafe { llvm::LLVMGetParamTypes(ft, vec::to_ptr(args)); }
     {inputs: args, output: out_ty}
 }

src/comp/middle/tstate/states.rs

@@ -343,8 +343,8 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool {
     alt e.node {
       expr_vec(elts, _) {
         ret find_pre_post_state_exprs(fcx, pres, e.id,
-                                      vec::init_elt(init_assign,
-                                                    vec::len(elts)), elts,
+                                      vec::init_elt(vec::len(elts),
+                                                    init_assign), elts,
                                       return_val);
       }
       expr_call(operator, operands, _) {
@@ -386,8 +386,8 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool {
       expr_rec(fields, maybe_base) {
         let changed =
             find_pre_post_state_exprs(fcx, pres, e.id,
-                                      vec::init_elt(init_assign,
-                                                    vec::len(fields)),
+                                      vec::init_elt(vec::len(fields),
+                                                    init_assign),
                                       field_exprs(fields), return_val);
         alt maybe_base {
           none. {/* do nothing */ }
@@ -402,8 +402,8 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool {
       }
       expr_tup(elts) {
         ret find_pre_post_state_exprs(fcx, pres, e.id,
-                                      vec::init_elt(init_assign,
-                                                    vec::len(elts)), elts,
+                                      vec::init_elt(vec::len(elts),
+                                                    init_assign), elts,
                                       return_val);
       }
       expr_copy(a) { ret find_pre_post_state_sub(fcx, pres, a, e.id, none); }

src/comp/middle/typeck.rs

@@ -1650,7 +1650,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, expr: @ast::expr, unify: unifier,
             // HACK: build an arguments list with dummy arguments to
             // check against
             let dummy = {mode: ast::by_ref, ty: ty::mk_bot(fcx.ccx.tcx)};
-            arg_tys = vec::init_elt(dummy, supplied_arg_count);
+            arg_tys = vec::init_elt(supplied_arg_count, dummy);
         }
 
         // Check the arguments.

src/comp/syntax/print/pp.rs

@@ -102,9 +102,9 @@ fn mk_printer(out: io::writer, linewidth: uint) -> printer {
     // fall behind.
     let n: uint = 3u * linewidth;
     #debug("mk_printer %u", linewidth);
-    let token: [mutable token] = vec::init_elt_mut(EOF, n);
-    let size: [mutable int] = vec::init_elt_mut(0, n);
-    let scan_stack: [mutable uint] = vec::init_elt_mut(0u, n);
+    let token: [mutable token] = vec::init_elt_mut(n, EOF);
+    let size: [mutable int] = vec::init_elt_mut(n, 0);
+    let scan_stack: [mutable uint] = vec::init_elt_mut(n, 0u);
     let print_stack: [print_stack_elt] = [];
     @{out: out,
       buf_len: n,

src/compiletest/runtest.rs

@@ -231,7 +231,7 @@ fn check_expected_errors(expected_errors: [errors::expected_error],
                          procres: procres) {
 
     // true if we found the error in question
-    let found_flags = vec::init_elt_mut(false, vec::len(expected_errors));
+    let found_flags = vec::init_elt_mut(vec::len(expected_errors), false);
 
     if procres.status == 0 {
         fatal("process did not return an error status");

src/libcore/extfmt.rs

@@ -387,7 +387,7 @@ mod rt {
 
     // FIXME: This might be useful in str: but needs to be utf8 safe first
     fn str_init_elt(c: char, n_elts: uint) -> str {
-        let svec = vec::init_elt::<u8>(c as u8, n_elts);
+        let svec = vec::init_elt::<u8>(n_elts, c as u8);
 
         ret str::unsafe_from_bytes(svec);
     }