rustc: Change function argument types to interior vectors

Author: pcwalton

src/comp/metadata/tydecode.rs

@@ -334,9 +334,9 @@ fn parse_hex(@pstate st) -> uint {
 }
 
 fn parse_ty_fn(@pstate st, str_def sd) ->
-   tup(vec[ty::arg], ty::t, ast::controlflow, vec[@ty::constr_def]) {
+   tup(ty::arg[], ty::t, ast::controlflow, vec[@ty::constr_def]) {
     assert (next(st) as char == '[');
-    let vec[ty::arg] inputs = [];
+    let ty::arg[] inputs = ~[];
     while (peek(st) as char != ']') {
         auto mode = ty::mo_val;
         if (peek(st) as char == '&') {
@@ -347,7 +347,7 @@ fn parse_ty_fn(@pstate st, str_def sd) ->
                 st.pos += 1u;
             }
         }
-        inputs += [rec(mode=mode, ty=parse_ty(st, sd))];
+        inputs += ~[rec(mode=mode, ty=parse_ty(st, sd))];
     }
     st.pos += 1u; // eat the ']'
     auto cs = parse_constrs(st, sd);

src/comp/metadata/tyencode.rs

@@ -199,7 +199,7 @@ fn enc_proto(&io::writer w, proto proto) {
         case (proto_fn) { w.write_char('F'); }
     }
 }
-fn enc_ty_fn(&io::writer w, &@ctxt cx, &vec[ty::arg] args, &ty::t out,
+fn enc_ty_fn(&io::writer w, &@ctxt cx, &ty::arg[] args, &ty::t out,
              &controlflow cf, &vec[@ty::constr_def] constrs) {
     w.write_char('[');
     for (ty::arg arg in args) {

src/comp/middle/alias.rs

@@ -662,7 +662,7 @@ fn def_is_local(&ast::def d, bool objfields_count) -> bool {
         };
 }
 
-fn fty_args(&ctx cx, ty::t fty) -> vec[ty::arg] {
+fn fty_args(&ctx cx, ty::t fty) -> ty::arg[] {
     ret alt (ty::struct(*cx.tcx, fty)) {
             case (ty::ty_fn(_, ?args, _, _, _)) { args }
             case (ty::ty_native_fn(_, ?args, _)) { args }

src/comp/middle/trans.rs

@@ -472,7 +472,7 @@ fn T_glue_fn(&type_names tn) -> TypeRef {
 
 fn T_dtor(&@crate_ctxt ccx, &span sp, TypeRef llself_ty) -> TypeRef {
     ret type_of_fn_full(ccx, sp, ast::proto_fn, some[TypeRef](llself_ty),
-                        vec::empty[ty::arg](), ty::mk_nil(ccx.tcx), 0u);
+                        ~[], ty::mk_nil(ccx.tcx), 0u);
 }
 
 fn T_cmp_glue_fn(&type_names tn) -> TypeRef {
@@ -681,7 +681,7 @@ fn type_of(&@crate_ctxt cx, &span sp, &ty::t t) -> TypeRef {
     ret type_of_inner(cx, sp, t);
 }
 
-fn type_of_explicit_args(&@crate_ctxt cx, &span sp, &vec[ty::arg] inputs) ->
+fn type_of_explicit_args(&@crate_ctxt cx, &span sp, &ty::arg[] inputs) ->
    vec[TypeRef] {
     let vec[TypeRef] atys = [];
     for (ty::arg arg in inputs) {
@@ -710,7 +710,7 @@ fn type_of_explicit_args(&@crate_ctxt cx, &span sp, &vec[ty::arg] inputs) ->
 //  - new_fn_ctxt
 //  - trans_args
 fn type_of_fn_full(&@crate_ctxt cx, &span sp, ast::proto proto,
-                   &option::t[TypeRef] obj_self, &vec[ty::arg] inputs,
+                   &option::t[TypeRef] obj_self, &ty::arg[] inputs,
                    &ty::t output, uint ty_param_count) -> TypeRef {
     let vec[TypeRef] atys = [];
 
@@ -743,7 +743,7 @@ fn type_of_fn_full(&@crate_ctxt cx, &span sp, ast::proto proto,
         atys +=
             [T_fn_pair(cx.tn,
                        type_of_fn_full(cx, sp, ast::proto_fn, none[TypeRef],
-                                       [rec(mode=ty::mo_alias(false),
+                                       ~[rec(mode=ty::mo_alias(false),
                                             ty=output)], ty::mk_nil(cx.tcx),
                                        0u))];
     }
@@ -754,14 +754,14 @@ fn type_of_fn_full(&@crate_ctxt cx, &span sp, ast::proto proto,
 }
 
 fn type_of_fn(&@crate_ctxt cx, &span sp, ast::proto proto,
-              &vec[ty::arg] inputs, &ty::t output, uint ty_param_count) ->
+              &ty::arg[] inputs, &ty::t output, uint ty_param_count) ->
    TypeRef {
     ret type_of_fn_full(cx, sp, proto, none[TypeRef], inputs, output,
                         ty_param_count);
 }
 
 fn type_of_native_fn(&@crate_ctxt cx, &span sp, ast::native_abi abi,
-                     &vec[ty::arg] inputs, &ty::t output, uint ty_param_count)
+                     &ty::arg[] inputs, &ty::t output, uint ty_param_count)
    -> TypeRef {
     let vec[TypeRef] atys = [];
     if (abi == ast::native_abi_rust) {
@@ -2137,7 +2137,7 @@ fn trans_res_drop(@block_ctxt cx, ValueRef rs, &ast::def_id did,
     } else {
         auto params = decoder::get_type_param_count(ccx.tcx, did);
         auto f_t = type_of_fn(ccx, cx.sp, ast::proto_fn,
-                              [rec(mode=ty::mo_alias(false), ty=inner_t)],
+                              ~[rec(mode=ty::mo_alias(false), ty=inner_t)],
                               ty::mk_nil(ccx.tcx), params);
         get_extern_const(ccx.externs, ccx.llmod,
                          decoder::get_symbol(ccx.sess, did),
@@ -4526,7 +4526,7 @@ fn trans_for_each(&@block_ctxt cx, &@ast::local local, &@ast::expr seq,
     // and pass it in as a first class fn-arg to the iterator.
     auto iter_body_llty =
         type_of_fn_full(lcx.ccx, cx.sp, ast::proto_fn, none[TypeRef],
-                        [rec(mode=ty::mo_alias(false), ty=decl_ty)],
+                        ~[rec(mode=ty::mo_alias(false), ty=decl_ty)],
                         ty::mk_nil(lcx.ccx.tcx), 0u);
     let ValueRef lliterbody =
         decl_internal_fastcall_fn(lcx.ccx.llmod, s, iter_body_llty);
@@ -5551,7 +5551,7 @@ fn trans_args(&@block_ctxt cx, ValueRef llenv, &option::t[ValueRef] llobj,
               &option::t[generic_info] gen, &option::t[ValueRef] lliterbody,
               &vec[@ast::expr] es, &ty::t fn_ty) ->
    tup(@block_ctxt, vec[ValueRef], ValueRef) {
-    let vec[ty::arg] args = ty::ty_fn_args(cx.fcx.lcx.ccx.tcx, fn_ty);
+    let ty::arg[] args = ty::ty_fn_args(cx.fcx.lcx.ccx.tcx, fn_ty);
     let vec[ValueRef] llargs = [];
     let vec[ValueRef] lltydescs = [];
     let @block_ctxt bcx = cx;
@@ -6342,7 +6342,7 @@ fn trans_put(&@block_ctxt cx, &option::t[@ast::expr] e) -> result {
             auto e_ty = ty::expr_ty(cx.fcx.lcx.ccx.tcx, x);
             auto arg = rec(mode=ty::mo_alias(false), ty=e_ty);
             auto arg_tys =
-                type_of_explicit_args(cx.fcx.lcx.ccx, x.span, [arg]);
+                type_of_explicit_args(cx.fcx.lcx.ccx, x.span, ~[arg]);
             auto r = trans_arg_expr(bcx, arg, arg_tys.(0), x);
             bcx = r.bcx;
             llargs += [r.val];
@@ -6578,7 +6578,7 @@ fn mk_spawn_wrapper(&@block_ctxt cx, &@ast::expr func, &ty::t args_ty) ->
     auto llmod = cx.fcx.lcx.ccx.llmod;
     let TypeRef wrapper_fn_type =
         type_of_fn(cx.fcx.lcx.ccx, cx.sp, ast::proto_fn,
-                   [rec(mode=ty::mo_alias(false), ty=args_ty)], ty::idx_nil,
+                   ~[rec(mode=ty::mo_alias(false), ty=args_ty)], ty::idx_nil,
                    0u);
     // TODO: construct a name based on tname
 
@@ -7450,7 +7450,7 @@ fn copy_any_self_to_alloca(@fn_ctxt fcx, option::t[ty_self_pair] ty_self) {
 }
 
 fn copy_args_to_allocas(@fn_ctxt fcx, vec[ast::arg] args,
-                        vec[ty::arg] arg_tys) {
+                        &ty::arg[] arg_tys) {
     auto bcx = new_raw_block_ctxt(fcx, fcx.llcopyargs);
     let uint arg_n = 0u;
     for (ast::arg aarg in args) {
@@ -7468,7 +7468,7 @@ fn copy_args_to_allocas(@fn_ctxt fcx, vec[ast::arg] args,
 }
 
 fn add_cleanups_for_args(&@block_ctxt bcx, vec[ast::arg] args,
-                         vec[ty::arg] arg_tys) {
+                         &ty::arg[] arg_tys) {
     let uint arg_n = 0u;
     for (ast::arg aarg in args) {
         if (aarg.mode == ast::val) {
@@ -7485,7 +7485,7 @@ fn is_terminated(&@block_ctxt cx) -> bool {
     ret llvm::LLVMIsATerminatorInst(inst) as int != 0;
 }
 
-fn arg_tys_of_fn(&@crate_ctxt ccx,ast::node_id id) -> vec[ty::arg] {
+fn arg_tys_of_fn(&@crate_ctxt ccx,ast::node_id id) -> ty::arg[] {
     alt (ty::struct(ccx.tcx, ty::node_id_to_type(ccx.tcx, id))) {
         case (ty::ty_fn(_, ?arg_tys, _, _, _)) { ret arg_tys; }
     }
@@ -7699,7 +7699,7 @@ fn trans_obj(@local_ctxt cx, &span sp, &ast::_obj ob, ast::node_id ctor_id,
     create_llargs_for_fn_args(fcx, ast::proto_fn, none[ty_self_pair],
                               ty::ret_ty_of_fn(ccx.tcx, ctor_id),
                               fn_args, ty_params);
-    let vec[ty::arg] arg_tys = arg_tys_of_fn(ccx, ctor_id);
+    let ty::arg[] arg_tys = arg_tys_of_fn(ccx, ctor_id);
     copy_args_to_allocas(fcx, fn_args, arg_tys);
 
     //  Create the first block context in the function and keep a handle on it
@@ -7747,7 +7747,7 @@ fn trans_obj(@local_ctxt cx, &span sp, &ast::_obj ob, ast::node_id ctor_id,
     // a dtor, since otherwise they are never dropped, and the dtor never
     // runs.
     if (vec::len[ast::ty_param](ty_params) == 0u &&
-            vec::len[ty::arg](arg_tys) == 0u) {
+            std::ivec::len[ty::arg](arg_tys) == 0u) {
         // If the object we're translating has no fields or type parameters,
         // there's not much to do.
 

src/comp/middle/ty.rs

@@ -192,7 +192,7 @@ type field = rec(ast::ident ident, mt mt);
 type method =
     rec(ast::proto proto,
         ast::ident ident,
-        vec[arg] inputs,
+        arg[] inputs,
         t output,
         controlflow cf,
         vec[@constr_def] constrs);
@@ -266,8 +266,8 @@ tag sty {
     ty_task;
     ty_tup(mt[]);
     ty_rec(field[]);
-    ty_fn(ast::proto, vec[arg], t, controlflow, vec[@constr_def]);
-    ty_native_fn(ast::native_abi, vec[arg], t);
+    ty_fn(ast::proto, arg[], t, controlflow, vec[@constr_def]);
+    ty_native_fn(ast::native_abi, arg[], t);
     ty_obj(vec[method]);
     ty_res(def_id, t, vec[t]);
     ty_var(int); // type variable
@@ -445,7 +445,7 @@ fn mk_raw_ty(&ctxt cx, &sty st, &option::t[str] cname) -> raw_t {
         derive_flags_t(cx, has_params, has_vars, a.ty);
     }
     fn derive_flags_sig(&ctxt cx, &mutable bool has_params,
-                        &mutable bool has_vars, &vec[arg] args, &t tt) {
+                        &mutable bool has_vars, &arg[] args, &t tt) {
         for (arg a in args) { derive_flags_arg(cx, has_params, has_vars, a); }
         derive_flags_t(cx, has_params, has_vars, tt);
     }
@@ -597,12 +597,12 @@ fn mk_imm_tup(&ctxt cx, &t[] tys) -> t {
 
 fn mk_rec(&ctxt cx, &field[] fs) -> t { ret gen_ty(cx, ty_rec(fs)); }
 
-fn mk_fn(&ctxt cx, &ast::proto proto, &vec[arg] args, &t ty, &controlflow cf,
+fn mk_fn(&ctxt cx, &ast::proto proto, &arg[] args, &t ty, &controlflow cf,
          &vec[@constr_def] constrs) -> t {
     ret gen_ty(cx, ty_fn(proto, args, ty, cf, constrs));
 }
 
-fn mk_native_fn(&ctxt cx, &ast::native_abi abi, &vec[arg] args, &t ty) -> t {
+fn mk_native_fn(&ctxt cx, &ast::native_abi abi, &arg[] args, &t ty) -> t {
     ret gen_ty(cx, ty_native_fn(abi, args, ty));
 }
 
@@ -792,21 +792,21 @@ fn fold_ty(&ctxt cx, fold_mode fld, t ty_0) -> t {
             ty = copy_cname(cx, mk_rec(cx, new_fields), ty);
         }
         case (ty_fn(?proto, ?args, ?ret_ty, ?cf, ?constrs)) {
-            let vec[arg] new_args = [];
+            let arg[] new_args = ~[];
             for (arg a in args) {
                 auto new_ty = fold_ty(cx, fld, a.ty);
-                new_args += [rec(mode=a.mode, ty=new_ty)];
+                new_args += ~[rec(mode=a.mode, ty=new_ty)];
             }
             ty =
                 copy_cname(cx,
                            mk_fn(cx, proto, new_args,
                                  fold_ty(cx, fld, ret_ty), cf, constrs), ty);
         }
         case (ty_native_fn(?abi, ?args, ?ret_ty)) {
-            let vec[arg] new_args = [];
+            let arg[] new_args = ~[];
             for (arg a in args) {
                 auto new_ty = fold_ty(cx, fld, a.ty);
-                new_args += [rec(mode=a.mode, ty=new_ty)];
+                new_args += ~[rec(mode=a.mode, ty=new_ty)];
             }
             ty =
                 copy_cname(cx,
@@ -816,9 +816,10 @@ fn fold_ty(&ctxt cx, fold_mode fld, t ty_0) -> t {
         case (ty_obj(?methods)) {
             let vec[method] new_methods = [];
             for (method m in methods) {
-                let vec[arg] new_args = [];
+                let arg[] new_args = ~[];
                 for (arg a in m.inputs) {
-                    new_args += [rec(mode=a.mode, ty=fold_ty(cx, fld, a.ty))];
+                    new_args += ~[rec(mode=a.mode,
+                                      ty=fold_ty(cx, fld, a.ty))];
                 }
                 new_methods +=
                     [rec(proto=m.proto,
@@ -1302,7 +1303,7 @@ fn hash_type_structure(&sty st) -> uint {
         h += h << 5u + hash_ty(subty);
         ret h;
     }
-    fn hash_fn(uint id, &vec[arg] args, &t rty) -> uint {
+    fn hash_fn(uint id, &arg[] args, &t rty) -> uint {
         auto h = id;
         for (arg a in args) { h += h << 5u + hash_ty(a.ty); }
         h += h << 5u + hash_ty(rty);
@@ -1448,11 +1449,11 @@ fn equal_type_structures(&sty a, &sty b) -> bool {
     fn equal_mt(&mt a, &mt b) -> bool {
         ret a.mut == b.mut && eq_ty(a.ty, b.ty);
     }
-    fn equal_fn(&vec[arg] args_a, &t rty_a, &vec[arg] args_b, &t rty_b) ->
+    fn equal_fn(&arg[] args_a, &t rty_a, &arg[] args_b, &t rty_b) ->
        bool {
         if (!eq_ty(rty_a, rty_b)) { ret false; }
-        auto len = vec::len[arg](args_a);
-        if (len != vec::len[arg](args_b)) { ret false; }
+        auto len = ivec::len[arg](args_a);
+        if (len != ivec::len[arg](args_b)) { ret false; }
         auto i = 0u;
         while (i < len) {
             auto arg_a = args_a.(i);
@@ -1788,7 +1789,7 @@ fn type_contains_params(&ctxt cx, &t typ) -> bool {
 
 
 // Type accessors for substructures of types
-fn ty_fn_args(&ctxt cx, &t fty) -> vec[arg] {
+fn ty_fn_args(&ctxt cx, &t fty) -> arg[] {
     alt (struct(cx, fty)) {
         case (ty::ty_fn(_, ?a, _, _, _)) { ret a; }
         case (ty::ty_native_fn(_, ?a, _)) { ret a; }
@@ -2073,20 +2074,20 @@ mod unify {
     }
     tag fn_common_res {
         fn_common_res_err(result);
-        fn_common_res_ok(vec[arg], t);
+        fn_common_res_ok(arg[], t);
     }
     fn unify_fn_common(&@ctxt cx, &t expected, &t actual,
-                       &vec[arg] expected_inputs, &t expected_output,
-                       &vec[arg] actual_inputs, &t actual_output) ->
+                       &arg[] expected_inputs, &t expected_output,
+                       &arg[] actual_inputs, &t actual_output) ->
        fn_common_res {
-        auto expected_len = vec::len[arg](expected_inputs);
-        auto actual_len = vec::len[arg](actual_inputs);
+        auto expected_len = ivec::len[arg](expected_inputs);
+        auto actual_len = ivec::len[arg](actual_inputs);
         if (expected_len != actual_len) {
             ret fn_common_res_err(ures_err(terr_arg_count));
         }
         // TODO: as above, we should have an iter2 iterator.
 
-        let vec[arg] result_ins = [];
+        let arg[] result_ins = ~[];
         auto i = 0u;
         while (i < expected_len) {
             auto expected_input = expected_inputs.(i);
@@ -2101,7 +2102,7 @@ mod unify {
             auto result = unify_step(cx, expected_input.ty, actual_input.ty);
             alt (result) {
                 case (ures_ok(?rty)) {
-                    result_ins += [rec(mode=result_mode, ty=rty)];
+                    result_ins += ~[rec(mode=result_mode, ty=rty)];
                 }
                 case (_) { ret fn_common_res_err(result); }
             }
@@ -2116,8 +2117,8 @@ mod unify {
         }
     }
     fn unify_fn(&@ctxt cx, &ast::proto e_proto, &ast::proto a_proto,
-                &t expected, &t actual, &vec[arg] expected_inputs,
-                &t expected_output, &vec[arg] actual_inputs, &t actual_output,
+                &t expected, &t actual, &arg[] expected_inputs,
+                &t expected_output, &arg[] actual_inputs, &t actual_output,
                 &controlflow expected_cf, &controlflow actual_cf,
                 &vec[@constr_def] expected_constrs,
                 &vec[@constr_def] actual_constrs) -> result {
@@ -2158,8 +2159,8 @@ mod unify {
     }
     fn unify_native_fn(&@ctxt cx, &ast::native_abi e_abi,
                        &ast::native_abi a_abi, &t expected, &t actual,
-                       &vec[arg] expected_inputs, &t expected_output,
-                       &vec[arg] actual_inputs, &t actual_output) -> result {
+                       &arg[] expected_inputs, &t expected_output,
+                       &arg[] actual_inputs, &t actual_output) -> result {
         if (e_abi != a_abi) { ret ures_err(terr_mismatch); }
         auto t =
             unify_fn_common(cx, expected, actual, expected_inputs,