From 0e2fff53375eba748b6d6727f69a2560f96bc8ec Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Wed, 6 Jul 2011 19:00:00 -0700 Subject: [PATCH] rustc: Change lots of AST nodes to use interior vectors --- src/comp/front/config.rs | 4 +- src/comp/front/test.rs | 6 +- src/comp/metadata/encoder.rs | 11 +- src/comp/middle/alias.rs | 6 +- src/comp/middle/resolve.rs | 37 +++-- src/comp/middle/trans.rs | 150 +++++++++--------- src/comp/middle/tstate/annotate.rs | 6 +- src/comp/middle/tstate/ck.rs | 6 +- src/comp/middle/tstate/collect_locals.rs | 12 +- src/comp/middle/tstate/pre_post_conditions.rs | 83 +++++----- src/comp/middle/tstate/states.rs | 21 ++- src/comp/middle/typeck.rs | 78 ++++----- src/comp/syntax/ast.rs | 44 ++--- src/comp/syntax/ext/base.rs | 4 +- src/comp/syntax/ext/env.rs | 5 +- src/comp/syntax/ext/fmt.rs | 29 ++-- src/comp/syntax/ext/simplext.rs | 21 +-- src/comp/syntax/fold.rs | 41 ++--- src/comp/syntax/parse/parser.rs | 122 +++++++------- src/comp/syntax/print/pprust.rs | 37 ++--- src/comp/syntax/visit.rs | 14 +- src/comp/syntax/walk.rs | 18 +-- src/comp/util/common.rs | 18 ++- 23 files changed, 400 insertions(+), 373 deletions(-) diff --git a/src/comp/front/config.rs b/src/comp/front/config.rs index dd6c6b574f3c..8c4118137afd 100644 --- a/src/comp/front/config.rs +++ b/src/comp/front/config.rs @@ -82,8 +82,8 @@ fn filter_stmt(&ast::crate_cfg cfg, fn fold_block(&ast::crate_cfg cfg, &ast::block_ b, fold::ast_fold fld) -> ast::block_ { auto filter = bind filter_stmt(cfg, _); - auto filtered_stmts = vec::filter_map(filter, b.stmts); - ret rec(stmts=vec::map(fld.fold_stmt, filtered_stmts), + auto filtered_stmts = ivec::filter_map(filter, b.stmts); + ret rec(stmts=ivec::map(fld.fold_stmt, filtered_stmts), expr=option::map(fld.fold_expr, b.expr), id=b.id); } diff --git a/src/comp/front/test.rs b/src/comp/front/test.rs index aae0af125363..1f910575e1f1 100644 --- a/src/comp/front/test.rs +++ b/src/comp/front/test.rs @@ -71,14 +71,14 @@ fn mk_main(&test_ctxt cx) -> @ast::item { auto ret_ty = @rec(node=ast::ty_nil, span=rec(lo=0u, hi=0u)); - let ast::fn_decl decl = rec(inputs = [], + let ast::fn_decl decl = rec(inputs = ~[], output = ret_ty, purity = ast::impure_fn, cf = ast::return, constraints = ~[]); auto proto = ast::proto_fn; - let ast::block_ body_ = rec(stmts = [], + let ast::block_ body_ = rec(stmts = ~[], expr = option::none, id = cx.next_node_id()); auto body = rec(node = body_, span = rec(lo=0u, hi=0u)); @@ -87,7 +87,7 @@ fn mk_main(&test_ctxt cx) -> @ast::item { proto = proto, body = body); - auto item_ = ast::item_fn(fn_, []); + auto item_ = ast::item_fn(fn_, ~[]); let ast::item item = rec(ident = "main", attrs = ~[], id = cx.next_node_id(), diff --git a/src/comp/metadata/encoder.rs b/src/comp/metadata/encoder.rs index 148fb12a13b3..435fa1a0a8f6 100644 --- a/src/comp/metadata/encoder.rs +++ b/src/comp/metadata/encoder.rs @@ -1,5 +1,6 @@ // Metadata encoding +import std::ivec; import std::str; import std::vec; import std::uint; @@ -33,7 +34,7 @@ fn encode_def_id(&ebml::writer ebml_w, &def_id id) { ebml::end_tag(ebml_w); } -fn encode_tag_variant_paths(&ebml::writer ebml_w, &vec[variant] variants, +fn encode_tag_variant_paths(&ebml::writer ebml_w, &variant[] variants, &vec[str] path, &mutable vec[tup(str, uint)] index) { for (variant variant in variants) { @@ -164,9 +165,9 @@ fn encode_kind(&ebml::writer ebml_w, u8 c) { fn def_to_str(&def_id did) -> str { ret #fmt("%d:%d", did._0, did._1); } -fn encode_type_param_count(&ebml::writer ebml_w, &vec[ty_param] tps) { +fn encode_type_param_count(&ebml::writer ebml_w, &ty_param[] tps) { ebml::start_tag(ebml_w, tag_items_data_item_ty_param_count); - ebml::write_vint(ebml_w.writer, vec::len[ty_param](tps)); + ebml::write_vint(ebml_w.writer, ivec::len[ty_param](tps)); ebml::end_tag(ebml_w); } @@ -207,9 +208,9 @@ fn encode_tag_id(&ebml::writer ebml_w, &def_id id) { } fn encode_tag_variant_info(&@crate_ctxt cx, &ebml::writer ebml_w, - node_id id, &vec[variant] variants, + node_id id, &variant[] variants, &mutable vec[tup(int, uint)] index, - &vec[ty_param] ty_params) { + &ty_param[] ty_params) { for (variant variant in variants) { index += [tup(variant.node.id, ebml_w.writer.tell())]; ebml::start_tag(ebml_w, tag_items_data_item); diff --git a/src/comp/middle/alias.rs b/src/comp/middle/alias.rs index e2c6036be981..eeccfd401b6d 100644 --- a/src/comp/middle/alias.rs +++ b/src/comp/middle/alias.rs @@ -53,7 +53,7 @@ fn check_crate(@ty::ctxt tcx, &@ast::crate crate) { tcx.sess.abort_if_errors(); } -fn visit_fn(@ctx cx, &ast::_fn f, &vec[ast::ty_param] tp, &span sp, +fn visit_fn(@ctx cx, &ast::_fn f, &ast::ty_param[] tp, &span sp, &fn_ident name, ast::node_id id, &scope sc, &vt[scope] v) { visit::visit_fn_decl(f.decl, sc, v); for (ast::arg arg_ in f.decl.inputs) { @@ -132,7 +132,7 @@ fn visit_expr(@ctx cx, &@ast::expr ex, &scope sc, &vt[scope] v) { if (!handled) { visit::visit_expr(ex, sc, v); } } -fn check_call(&ctx cx, &@ast::expr f, &vec[@ast::expr] args, &scope sc) -> +fn check_call(&ctx cx, &@ast::expr f, &(@ast::expr)[] args, &scope sc) -> rec(vec[node_id] root_vars, vec[ty::t] unsafe_ts) { auto fty = ty::expr_ty(*cx.tcx, f); auto arg_ts = fty_args(cx, fty); @@ -261,7 +261,7 @@ fn check_tail_call(&ctx cx, &@ast::expr call) { } } -fn check_alt(&ctx cx, &@ast::expr input, &vec[ast::arm] arms, &scope sc, +fn check_alt(&ctx cx, &@ast::expr input, &ast::arm[] arms, &scope sc, &vt[scope] v) { visit::visit_expr(input, sc, v); auto root = expr_root(cx, input, true); diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs index 28a02e869dc7..97ab74e1e1fe 100644 --- a/src/comp/middle/resolve.rs +++ b/src/comp/middle/resolve.rs @@ -47,7 +47,7 @@ export crate_map; tag scope { scope_crate(@ast::crate); scope_item(@ast::item); - scope_fn(ast::fn_decl, vec[ast::ty_param]); + scope_fn(ast::fn_decl, ast::ty_param[]); scope_native_item(@ast::native_item); scope_loop(@ast::local); // there's only 1 decl per loop. scope_block(ast::block); @@ -346,7 +346,7 @@ fn visit_native_item_with_scope(&@ast::native_item ni, &scopes sc, visit::visit_native_item(ni, cons(scope_native_item(ni), @sc), v); } -fn visit_fn_with_scope(&@env e, &ast::_fn f, &vec[ast::ty_param] tp, &span sp, +fn visit_fn_with_scope(&@env e, &ast::_fn f, &ast::ty_param[] tp, &span sp, &fn_ident name, node_id id, &scopes sc, &vt[scopes] v) { // here's where we need to set up the mapping @@ -376,7 +376,7 @@ fn visit_expr_with_scope(&@ast::expr x, &scopes sc, &vt[scopes] v) { case (ast::expr_for_each(?d, _, _)) { cons[scope](scope_loop(d), @sc) } - case (ast::expr_fn(?f)) { cons(scope_fn(f.decl, []), @sc) } + case (ast::expr_fn(?f)) { cons(scope_fn(f.decl, ~[]), @sc) } case (_) { sc } }; visit::visit_expr(x, new_sc, v); @@ -638,8 +638,7 @@ fn lookup_in_scope(&env e, scopes sc, &span sp, &ident name, namespace ns) -> } case (scope_native_item(?it)) { alt (it.node) { - case (ast::native_item_fn(_, ?decl, ?ty_params)) - { + case (ast::native_item_fn(_, ?decl, ?ty_params)) { ret lookup_in_fn(name, decl, ty_params, ns); } } @@ -690,7 +689,7 @@ fn lookup_in_scope(&env e, scopes sc, &span sp, &ident name, namespace ns) -> } -fn lookup_in_ty_params(&ident name, &vec[ast::ty_param] ty_params) -> +fn lookup_in_ty_params(&ident name, &ast::ty_param[] ty_params) -> option::t[def] { auto i = 0u; for (ast::ty_param tp in ty_params) { @@ -720,7 +719,7 @@ fn lookup_in_pat(&ident name, &ast::pat pat) -> option::t[def] { } fn lookup_in_fn(&ident name, &ast::fn_decl decl, - &vec[ast::ty_param] ty_params, + &ast::ty_param[] ty_params, namespace ns) -> option::t[def] { alt (ns) { case (ns_value) { @@ -736,7 +735,7 @@ fn lookup_in_fn(&ident name, &ast::fn_decl decl, } } -fn lookup_in_obj(&ident name, &ast::_obj ob, &vec[ast::ty_param] ty_params, +fn lookup_in_obj(&ident name, &ast::_obj ob, &ast::ty_param[] ty_params, namespace ns) -> option::t[def] { alt (ns) { case (ns_value) { @@ -1229,18 +1228,22 @@ fn check_item(@env e, &@ast::item i, &() x, &vt[()] v) { alt (i.node) { case (ast::item_fn(?f, ?ty_params)) { check_fn(*e, i.span, f); - ensure_unique(*e, i.span, ty_params, ident_id, "type parameter"); + ensure_unique_ivec(*e, i.span, ty_params, ident_id, + "type parameter"); } case (ast::item_obj(?ob, ?ty_params, _)) { fn field_name(&ast::obj_field field) -> ident { ret field.ident; } - ensure_unique(*e, i.span, ob.fields, field_name, "object field"); + ensure_unique_ivec(*e, i.span, ob.fields, field_name, + "object field"); for (@ast::method m in ob.methods) { check_fn(*e, m.span, m.node.meth); } - ensure_unique(*e, i.span, ty_params, ident_id, "type parameter"); + ensure_unique_ivec(*e, i.span, ty_params, ident_id, + "type parameter"); } case (ast::item_tag(_, ?ty_params)) { - ensure_unique(*e, i.span, ty_params, ident_id, "type parameter"); + ensure_unique_ivec(*e, i.span, ty_params, ident_id, + "type parameter"); } case (_) { } } @@ -1315,7 +1318,7 @@ fn check_block(@env e, &ast::block b, &() x, &vt[()] v) { fn check_fn(&env e, &span sp, &ast::_fn f) { fn arg_name(&ast::arg a) -> ident { ret a.ident; } - ensure_unique(e, sp, f.decl.inputs, arg_name, "argument"); + ensure_unique_ivec(e, sp, f.decl.inputs, arg_name, "argument"); } type checker = @rec(mutable vec[ident] seen, str kind, session sess); @@ -1341,6 +1344,14 @@ fn ensure_unique[T](&env e, &span sp, &vec[T] elts, fn(&T) -> ident id, auto ch = checker(e, kind); for (T elt in elts) { add_name(ch, sp, id(elt)); } } + +// FIXME: Remove me. +fn ensure_unique_ivec[T](&env e, &span sp, &T[] elts, fn(&T) -> ident id, + &str kind) { + auto ch = checker(e, kind); + for (T elt in elts) { add_name(ch, sp, id(elt)); } +} + // Local Variables: // mode: rust // fill-column: 78; diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs index 293db34e8328..8f7f26e16934 100644 --- a/src/comp/middle/trans.rs +++ b/src/comp/middle/trans.rs @@ -155,8 +155,8 @@ type crate_ctxt = type local_ctxt = rec(vec[str] path, vec[str] module_path, - vec[ast::ty_param] obj_typarams, - vec[ast::obj_field] obj_fields, + ast::ty_param[] obj_typarams, + ast::obj_field[] obj_fields, @crate_ctxt ccx); @@ -4382,8 +4382,10 @@ fn trans_if(&@block_ctxt cx, &@ast::expr cond, &ast::block thn, fn trans_for(&@block_ctxt cx, &@ast::local local, &@ast::expr seq, &ast::block body) -> result { + // FIXME: We bind to an alias here to avoid a segfault... this is + // obviously a bug. fn inner(&@block_ctxt cx, @ast::local local, ValueRef curr, ty::t t, - ast::block body, @block_ctxt outer_next_cx) -> result { + &ast::block body, @block_ctxt outer_next_cx) -> result { auto next_cx = new_sub_block_ctxt(cx, "next"); auto scope_cx = new_loop_scope_block_ctxt(cx, option::some[@block_ctxt](next_cx), @@ -4778,7 +4780,7 @@ fn trans_pat_match(&@block_ctxt cx, &@ast::pat pat, ValueRef llval, cx.build.ICmp(lib::llvm::LLVMIntEQ, lldiscrim, C_int(variant_tag)); cx.build.CondBr(lleq, matched_cx.llbb, next_cx.llbb); - if (vec::len(subpats) > 0u) { + if (std::ivec::len(subpats) > 0u) { llblobptr = matched_cx.build.GEP(lltagptr, [C_int(0), C_int(1)]); } @@ -4790,7 +4792,7 @@ fn trans_pat_match(&@block_ctxt cx, &@ast::pat pat, ValueRef llval, auto tps_ivec = ~[]; for (ty::t tp in ty_params) { tps_ivec += ~[tp]; } - if (vec::len(subpats) > 0u) { + if (std::ivec::len(subpats) > 0u) { auto i = 0; for (@ast::pat subpat in subpats) { auto rslt = @@ -4834,9 +4836,11 @@ fn trans_pat_binding(&@block_ctxt cx, &@ast::pat pat, ValueRef llval, } } case (ast::pat_tag(_, ?subpats)) { - if (vec::len[@ast::pat](subpats) == 0u) { ret rslt(cx, llval); } - // Get the appropriate variant for this tag. + if (std::ivec::len[@ast::pat](subpats) == 0u) { + ret rslt(cx, llval); + } + // Get the appropriate variant for this tag. auto vdef; alt (cx.fcx.lcx.ccx.tcx.def_map.find(pat.id)) { case (some(?x)) { vdef = ast::variant_def_ids(x); } @@ -4874,7 +4878,7 @@ fn trans_pat_binding(&@block_ctxt cx, &@ast::pat pat, ValueRef llval, } } -fn trans_alt(&@block_ctxt cx, &@ast::expr expr, &vec[ast::arm] arms, +fn trans_alt(&@block_ctxt cx, &@ast::expr expr, &ast::arm[] arms, ast::node_id id, &out_method output) -> result { auto expr_res = trans_expr(cx, expr); auto this_cx = expr_res.bcx; @@ -5308,7 +5312,7 @@ fn trans_cast(&@block_ctxt cx, &@ast::expr e, ast::node_id id) -> result { } fn trans_bind_thunk(&@local_ctxt cx, &span sp, &ty::t incoming_fty, - &ty::t outgoing_fty, &vec[option::t[@ast::expr]] args, + &ty::t outgoing_fty, &(option::t[@ast::expr])[] args, &ty::t closure_ty, &vec[ty::t] bound_tys, uint ty_param_count) -> ValueRef { @@ -5474,7 +5478,7 @@ fn trans_bind_thunk(&@local_ctxt cx, &span sp, &ty::t incoming_fty, } fn trans_bind(&@block_ctxt cx, &@ast::expr f, - &vec[option::t[@ast::expr]] args, ast::node_id id) -> result { + &(option::t[@ast::expr])[] args, ast::node_id id) -> result { auto f_res = trans_lval(cx, f); if (f_res.is_mem) { cx.fcx.lcx.ccx.sess.unimpl("re-binding existing function"); @@ -5720,7 +5724,7 @@ fn trans_arg_expr(&@block_ctxt cx, &ty::arg arg, TypeRef lldestty0, // - trans_args 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) -> + &(@ast::expr)[] es, &ty::t fn_ty) -> tup(@block_ctxt, vec[ValueRef], ValueRef) { let ty::arg[] args = ty::ty_fn_args(cx.fcx.lcx.ccx.tcx, fn_ty); let vec[ValueRef] llargs = []; @@ -5812,7 +5816,7 @@ fn trans_args(&@block_ctxt cx, ValueRef llenv, &option::t[ValueRef] llobj, } fn trans_call(&@block_ctxt cx, &@ast::expr f, &option::t[ValueRef] lliterbody, - &vec[@ast::expr] args, ast::node_id id) -> result { + &(@ast::expr)[] args, ast::node_id id) -> result { // NB: 'f' isn't necessarily a function; it might be an entire self-call // expression because of the hack that allows us to process self-calls // with trans_call. @@ -5896,8 +5900,7 @@ fn trans_call(&@block_ctxt cx, &@ast::expr f, &option::t[ValueRef] lliterbody, ret rslt(bcx, retval); } -fn trans_tup(&@block_ctxt cx, &vec[ast::elt] elts, ast::node_id id) - -> result { +fn trans_tup(&@block_ctxt cx, &ast::elt[] elts, ast::node_id id) -> result { auto bcx = cx; auto t = node_id_type(bcx.fcx.lcx.ccx, id); auto tup_res = alloc_ty(bcx, t); @@ -5916,7 +5919,7 @@ fn trans_tup(&@block_ctxt cx, &vec[ast::elt] elts, ast::node_id id) ret rslt(bcx, tup_val); } -fn trans_vec(&@block_ctxt cx, &vec[@ast::expr] args, ast::node_id id) -> +fn trans_vec(&@block_ctxt cx, &(@ast::expr)[] args, ast::node_id id) -> result { auto t = node_id_type(cx.fcx.lcx.ccx, id); auto unit_ty = t; @@ -5928,7 +5931,7 @@ fn trans_vec(&@block_ctxt cx, &vec[@ast::expr] args, ast::node_id id) -> auto unit_sz = size_of(bcx, unit_ty); bcx = unit_sz.bcx; auto data_sz = - bcx.build.Mul(C_int(vec::len[@ast::expr](args) as int), unit_sz.val); + bcx.build.Mul(C_uint(std::ivec::len[@ast::expr](args)), unit_sz.val); // FIXME: pass tydesc properly. auto vec_val = @@ -5941,7 +5944,8 @@ fn trans_vec(&@block_ctxt cx, &vec[@ast::expr] args, ast::node_id id) -> auto body = bcx.build.GEP(vec_val, [C_int(0), C_int(abi::vec_elt_data)]); auto pseudo_tup_ty = ty::mk_imm_tup(cx.fcx.lcx.ccx.tcx, - std::ivec::init_elt[ty::t](unit_ty, vec::len(args))); + std::ivec::init_elt[ty::t](unit_ty, + std::ivec::len(args))); let int i = 0; for (@ast::expr e in args) { auto src = trans_lval(bcx, e); @@ -5975,7 +5979,7 @@ fn trans_vec(&@block_ctxt cx, &vec[@ast::expr] args, ast::node_id id) -> // TODO: Move me to ivec:: -fn trans_ivec(@block_ctxt bcx, &vec[@ast::expr] args, ast::node_id id) -> +fn trans_ivec(@block_ctxt bcx, &(@ast::expr)[] args, ast::node_id id) -> result { auto typ = node_id_type(bcx.fcx.lcx.ccx, id); auto unit_ty; @@ -5993,11 +5997,12 @@ fn trans_ivec(@block_ctxt bcx, &vec[@ast::expr] args, ast::node_id id) -> add_clean_temp(bcx, llvecptr, typ); - auto lllen = bcx.build.Mul(C_uint(vec::len(args)), unit_sz); + auto lllen = bcx.build.Mul(C_uint(std::ivec::len(args)), unit_sz); // Allocate the vector pieces and store length and allocated length. auto llfirsteltptr; - if (vec::len(args) > 0u && vec::len(args) <= abi::ivec_default_length) { + if (std::ivec::len(args) > 0u && + std::ivec::len(args) <= abi::ivec_default_length) { // Interior case. bcx.build.Store(lllen, @@ -6022,7 +6027,7 @@ fn trans_ivec(@block_ctxt bcx, &vec[@ast::expr] args, ast::node_id id) -> auto llstubptr = bcx.build.PointerCast(llvecptr, T_ptr(llstubty)); bcx.build.Store(C_int(0), bcx.build.InBoundsGEP(llstubptr, stub_z)); auto llheapty = T_ivec_heap_part(llunitty); - if (vec::len(args) == 0u) { + if (std::ivec::len(args) == 0u) { // Null heap pointer indicates a zero-length vector. bcx.build.Store(llalen, bcx.build.InBoundsGEP(llstubptr, stub_a)); @@ -6067,7 +6072,7 @@ fn trans_ivec(@block_ctxt bcx, &vec[@ast::expr] args, ast::node_id id) -> ret rslt(bcx, llvecptr); } -fn trans_rec(&@block_ctxt cx, &vec[ast::field] fields, +fn trans_rec(&@block_ctxt cx, &ast::field[] fields, &option::t[@ast::expr] base, ast::node_id id) -> result { auto bcx = cx; auto t = node_id_type(bcx.fcx.lcx.ccx, id); @@ -6172,7 +6177,7 @@ fn trans_expr_out(&@block_ctxt cx, &@ast::expr e, out_method output) -> auto sub_cx = extend_path(cx.fcx.lcx, ccx.names.next("anon")); auto s = mangle_internal_name_by_path(ccx, sub_cx.path); auto llfn = decl_internal_fastcall_fn(ccx.llmod, s, llfnty); - trans_fn(sub_cx, e.span, f, llfn, none, [], e.id); + trans_fn(sub_cx, e.span, f, llfn, none, ~[], e.id); ret rslt(cx, create_fn_pair(ccx, s, llfnty, llfn, false)); } case (ast::expr_block(?blk)) { @@ -6696,16 +6701,17 @@ fn trans_chan(&@block_ctxt cx, &@ast::expr e, ast::node_id id) -> result { } fn trans_spawn(&@block_ctxt cx, &ast::spawn_dom dom, &option::t[str] name, - &@ast::expr func, &vec[@ast::expr] args, ast::node_id id) -> - result { + &@ast::expr func, &(@ast::expr)[] args, ast::node_id id) + -> result { auto bcx = cx; // Make the task name auto tname = alt (name) { case (none) { - auto argss = vec::map(expr_to_str, args); - #fmt("%s(%s)", expr_to_str(func), str::connect(argss, ", ")) + auto argss = std::ivec::map(expr_to_str, args); + #fmt("%s(%s)", expr_to_str(func), + str::connect_ivec(argss, ", ")) } case (some(?n)) { n } }; @@ -6979,7 +6985,7 @@ fn recv_val(&@block_ctxt cx, ValueRef to, &@ast::expr from, &ty::t unit_ty, // instead "inlining" the construction of the object and returning the object // itself. fn trans_anon_obj(@block_ctxt bcx, &span sp, &ast::anon_obj anon_obj, - &vec[ast::ty_param] ty_params, ast::node_id id) -> result { + &ast::ty_param[] ty_params, ast::node_id id) -> result { // Right now, we're assuming that anon objs don't take ty params, even // though the AST supports it. It's nonsensical to write an expression @@ -6987,13 +6993,13 @@ fn trans_anon_obj(@block_ctxt bcx, &span sp, &ast::anon_obj anon_obj, // nevertheless, such an expression will parse. Idea for the future: // support typarams. - assert (vec::len(ty_params) == 0u); + assert (std::ivec::len(ty_params) == 0u); auto ccx = bcx.fcx.lcx.ccx; // Fields. // FIXME (part of issue #538): Where do we fill in the field *values* from // the outer object? - let vec[ast::anon_obj_field] additional_fields = []; + let ast::anon_obj_field[] additional_fields = ~[]; let vec[result] additional_field_vals = []; let ty::t[] additional_field_tys = ~[]; alt (anon_obj.fields) { @@ -7021,8 +7027,8 @@ fn trans_anon_obj(@block_ctxt bcx, &span sp, &ast::anon_obj anon_obj, ret rec(mut=f.mut, ty=f.ty, ident=f.ident, id=f.id); } let ast::_obj wrapper_obj = rec( - fields = vec::map(anon_obj_field_to_obj_field, - additional_fields), + fields = std::ivec::map(anon_obj_field_to_obj_field, + additional_fields), methods = anon_obj.methods, dtor = none[@ast::method]); @@ -7079,8 +7085,7 @@ fn trans_anon_obj(@block_ctxt bcx, &span sp, &ast::anon_obj anon_obj, auto pair = alloca(bcx, T_struct([val_ty(vtbl), - T_obj_ptr(ccx.tn, - vec::len[ast::ty_param](ty_params))])); + T_obj_ptr(ccx.tn, std::ivec::len(ty_params))])); // Take care of cleanups. auto t = node_id_type(ccx, id); @@ -7101,8 +7106,8 @@ fn trans_anon_obj(@block_ctxt bcx, &span sp, &ast::anon_obj anon_obj, // typarams, fields, and a pointer to our with_obj. let TypeRef llbox_ty = T_opaque_obj_ptr(ccx.tn); - if (vec::len[ast::ty_param](ty_params) == 0u && - vec::len[ast::anon_obj_field](additional_fields) == 0u && + if (std::ivec::len[ast::ty_param](ty_params) == 0u && + std::ivec::len[ast::anon_obj_field](additional_fields) == 0u && anon_obj.with_obj == none) { // If the object we're translating has no fields or type parameters // and no with_obj, there's not much to do. @@ -7544,12 +7549,10 @@ fn trans_block(&@block_ctxt cx, &ast::block b, &out_method output) -> result { fn new_local_ctxt(&@crate_ctxt ccx) -> @local_ctxt { let vec[str] pth = []; - let vec[ast::ty_param] obj_typarams = []; - let vec[ast::obj_field] obj_fields = []; ret @rec(path=pth, module_path=[ccx.link_meta.name], - obj_typarams=obj_typarams, - obj_fields=obj_fields, + obj_typarams=~[], + obj_fields=~[], ccx=ccx); } @@ -7621,8 +7624,8 @@ fn new_fn_ctxt(@local_ctxt cx, &span sp, ValueRef llfndecl) -> @fn_ctxt { // field of the fn_ctxt with fn create_llargs_for_fn_args(&@fn_ctxt cx, ast::proto proto, option::t[ty_self_pair] ty_self, ty::t ret_ty, - &vec[ast::arg] args, - &vec[ast::ty_param] ty_params) { + &ast::arg[] args, + &ast::ty_param[] ty_params) { // Skip the implicit arguments 0, 1, and 2. TODO: Pull out 3u and define // it as a constant, since we're using it in several places in trans this // way. @@ -7684,8 +7687,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, - &ty::arg[] arg_tys) { +fn copy_args_to_allocas(@fn_ctxt fcx, &ast::arg[] args, &ty::arg[] arg_tys) { auto bcx = new_raw_block_ctxt(fcx, fcx.llcopyargs); let uint arg_n = 0u; for (ast::arg aarg in args) { @@ -7707,7 +7709,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, +fn add_cleanups_for_args(&@block_ctxt bcx, &ast::arg[] args, &ty::arg[] arg_tys) { let uint arg_n = 0u; for (ast::arg aarg in args) { @@ -7745,7 +7747,7 @@ fn populate_fn_ctxt_from_llself(@fn_ctxt fcx, val_self_pair llself) { // its magic. auto fields_tup_ty = ty::mk_imm_tup(fcx.lcx.ccx.tcx, field_tys); - auto n_typarams = vec::len[ast::ty_param](bcx.fcx.lcx.obj_typarams); + auto n_typarams = std::ivec::len[ast::ty_param](bcx.fcx.lcx.obj_typarams); let TypeRef llobj_box_ty = T_obj_ptr(bcx.fcx.lcx.ccx.tn, n_typarams); auto box_cell = bcx.build.GEP(llself.v, [C_int(0), C_int(abi::obj_field_box)]); @@ -7801,7 +7803,7 @@ fn finish_fn(&@fn_ctxt fcx, BasicBlockRef lltop) { // trans_fn: creates an LLVM function corresponding to a source language // function. fn trans_fn(@local_ctxt cx, &span sp, &ast::_fn f, ValueRef llfndecl, - option::t[ty_self_pair] ty_self, &vec[ast::ty_param] ty_params, + option::t[ty_self_pair] ty_self, &ast::ty_param[] ty_params, ast::node_id id) { set_uwtable(llfndecl); @@ -7847,11 +7849,11 @@ fn trans_fn(@local_ctxt cx, &span sp, &ast::_fn f, ValueRef llfndecl, // process_fwding_mthd: Create the forwarding function that appears in a // vtable slot for method calls that "fall through" to an inner object. A // helper function for create_vtbl. -fn process_fwding_mthd(@local_ctxt cx, &span sp, @ty::method m, +fn process_fwding_mthd(@local_ctxt cx, &span sp, @ty::method m, TypeRef llself_ty, ty::t self_ty, - &vec[ast::ty_param] ty_params, + &ast::ty_param[] ty_params, ty::t with_obj_ty, - ty::t[] additional_field_tys) -> ValueRef { + &ty::t[] additional_field_tys) -> ValueRef { // NB: self_ty (and llself_ty) is the type of the outer object; // with_obj_ty is the type of the inner object. @@ -7880,7 +7882,7 @@ fn process_fwding_mthd(@local_ctxt cx, &span sp, @ty::method m, type_of_fn_full( cx.ccx, sp, m.proto, some[TypeRef](llself_ty), m.inputs, m.output, - vec::len[ast::ty_param](ty_params)); + std::ivec::len[ast::ty_param](ty_params)); let ValueRef llforwarding_fn = decl_internal_fastcall_fn(cx.ccx.llmod, s, llforwarding_fn_ty); @@ -7997,7 +7999,7 @@ fn process_fwding_mthd(@local_ctxt cx, &span sp, @ty::method m, some[TypeRef](llself_ty), m.inputs, m.output, - vec::len[ast::ty_param](ty_params)); + std::ivec::len[ast::ty_param](ty_params)); llorig_mthd = bcx.build.PointerCast(llorig_mthd, T_ptr(T_ptr(llorig_mthd_ty))); llorig_mthd = bcx.build.Load(llorig_mthd); @@ -8032,7 +8034,7 @@ fn process_fwding_mthd(@local_ctxt cx, &span sp, @ty::method m, // process_normal_mthd: Create the contents of a normal vtable slot. A helper // function for create_vtbl. fn process_normal_mthd(@local_ctxt cx, @ast::method m, TypeRef llself_ty, - ty::t self_ty, &vec[ast::ty_param] ty_params) + ty::t self_ty, &ast::ty_param[] ty_params) -> ValueRef { auto llfnty = T_nil(); @@ -8042,7 +8044,7 @@ fn process_normal_mthd(@local_ctxt cx, @ast::method m, TypeRef llself_ty, type_of_fn_full( cx.ccx, m.span, proto, some[TypeRef](llself_ty), inputs, output, - vec::len[ast::ty_param](ty_params)); + std::ivec::len[ast::ty_param](ty_params)); } } let @local_ctxt mcx = @@ -8066,9 +8068,9 @@ fn process_normal_mthd(@local_ctxt cx, @ast::method m, TypeRef llself_ty, // Create a vtable for an object being translated. Returns a pointer into // read-only memory. fn create_vtbl(@local_ctxt cx, &span sp, TypeRef llself_ty, ty::t self_ty, - &ast::_obj ob, &vec[ast::ty_param] ty_params, + &ast::_obj ob, &ast::ty_param[] ty_params, option::t[ty::t] with_obj_ty, - ty::t[] additional_field_tys) -> ValueRef { + &ty::t[] additional_field_tys) -> ValueRef { // Used only inside create_vtbl to distinguish different kinds of slots // we'll have to create. @@ -8232,7 +8234,7 @@ fn create_vtbl(@local_ctxt cx, &span sp, TypeRef llself_ty, ty::t self_ty, } fn trans_dtor(@local_ctxt cx, TypeRef llself_ty, ty::t self_ty, - &vec[ast::ty_param] ty_params, &@ast::method dtor) -> ValueRef { + &ast::ty_param[] ty_params, &@ast::method dtor) -> ValueRef { auto llfnty = T_dtor(cx.ccx, dtor.span, llself_ty); let str s = mangle_internal_name_by_path(cx.ccx, cx.path + ["drop"]); let ValueRef llfn = decl_internal_fastcall_fn(cx.ccx.llmod, s, llfnty); @@ -8247,7 +8249,7 @@ fn trans_dtor(@local_ctxt cx, TypeRef llself_ty, ty::t self_ty, // trans_obj: creates an LLVM function that is the object constructor for the // object being translated. fn trans_obj(@local_ctxt cx, &span sp, &ast::_obj ob, ast::node_id ctor_id, - &vec[ast::ty_param] ty_params) { + &ast::ty_param[] ty_params) { // To make a function, we have to create a function context and, inside // that, a number of block contexts for which code is generated. @@ -8265,10 +8267,10 @@ fn trans_obj(@local_ctxt cx, &span sp, &ast::_obj ob, ast::node_id ctor_id, // The fields of our object will become the arguments to the function // we're creating. - let vec[ast::arg] fn_args = []; + let ast::arg[] fn_args = ~[]; for (ast::obj_field f in ob.fields) { fn_args += - [rec(mode=ast::alias(false), ty=f.ty, ident=f.ident, id=f.id)]; + ~[rec(mode=ast::alias(false), ty=f.ty, ident=f.ident, id=f.id)]; } auto fcx = new_fn_ctxt(cx, sp, llctor_decl); @@ -8325,7 +8327,7 @@ fn trans_obj(@local_ctxt cx, &span sp, &ast::_obj ob, ast::node_id ctor_id, // FIXME: we should probably also allocate a box for empty objs that have // a dtor, since otherwise they are never dropped, and the dtor never // runs. - if (vec::len[ast::ty_param](ty_params) == 0u && + if (std::ivec::len[ast::ty_param](ty_params) == 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. @@ -8449,7 +8451,7 @@ fn trans_obj(@local_ctxt cx, &span sp, &ast::_obj ob, ast::node_id ctor_id, } fn trans_res_ctor(@local_ctxt cx, &span sp, &ast::_fn dtor, - ast::node_id ctor_id, &vec[ast::ty_param] ty_params) { + ast::node_id ctor_id, &ast::ty_param[] ty_params) { // Create a function for the constructor auto llctor_decl; alt (cx.ccx.item_ids.find(ctor_id)) { @@ -8493,21 +8495,21 @@ fn trans_res_ctor(@local_ctxt cx, &span sp, &ast::_fn dtor, fn trans_tag_variant(@local_ctxt cx, ast::node_id tag_id, &ast::variant variant, int index, bool is_degen, - &vec[ast::ty_param] ty_params) { + &ast::ty_param[] ty_params) { if (vec::len[ast::variant_arg](variant.node.args) == 0u) { ret; // nullary constructors are just constants } // Translate variant arguments to function arguments. - let vec[ast::arg] fn_args = []; + let ast::arg[] fn_args = ~[]; auto i = 0u; for (ast::variant_arg varg in variant.node.args) { fn_args += - [rec(mode=ast::alias(false), - ty=varg.ty, - ident="arg" + uint::to_str(i, 10u), - id=varg.id)]; + ~[rec(mode=ast::alias(false), + ty=varg.ty, + ident="arg" + uint::to_str(i, 10u), + id=varg.id)]; } assert (cx.ccx.item_ids.contains_key(variant.node.id)); let ValueRef llfndecl; @@ -8650,7 +8652,7 @@ fn trans_item(@local_ctxt cx, &ast::item item) { } case (ast::item_tag(?variants, ?tps)) { auto sub_cx = extend_path(cx, item.ident); - auto degen = vec::len(variants) == 1u; + auto degen = std::ivec::len(variants) == 1u; auto i = 0; for (ast::variant variant in variants) { trans_tag_variant(sub_cx, item.id, variant, i, degen, tps); @@ -8681,20 +8683,20 @@ fn get_pair_fn_ty(TypeRef llpairty) -> TypeRef { } fn decl_fn_and_pair(&@crate_ctxt ccx, &span sp, &vec[str] path, str flav, - vec[ast::ty_param] ty_params, ast::node_id node_id) { + &ast::ty_param[] ty_params, ast::node_id node_id) { decl_fn_and_pair_full(ccx, sp, path, flav, ty_params, node_id, node_id_type(ccx, node_id)); } fn decl_fn_and_pair_full(&@crate_ctxt ccx, &span sp, &vec[str] path, str flav, - vec[ast::ty_param] ty_params, ast::node_id node_id, + &ast::ty_param[] ty_params, ast::node_id node_id, ty::t node_type) { auto llfty; alt (ty::struct(ccx.tcx, node_type)) { case (ty::ty_fn(?proto, ?inputs, ?output, _, _)) { llfty = type_of_fn(ccx, sp, proto, inputs, output, - vec::len[ast::ty_param](ty_params)); + std::ivec::len[ast::ty_param](ty_params)); } case (_) { ccx.sess.bug("decl_fn_and_pair(): fn item doesn't have fn type!"); @@ -8764,7 +8766,7 @@ fn native_fn_ty_param_count(&@crate_ctxt cx, ast::node_id id) -> uint { "actually a fn"); } case (ast::native_item_fn(_, _, ?tps)) { - count = vec::len[ast::ty_param](tps); + count = std::ivec::len[ast::ty_param](tps); } } ret count; @@ -9035,7 +9037,7 @@ fn trans_constant(@crate_ctxt ccx, &@ast::item it, &vec[str] pt, alt (it.node) { case (ast::item_tag(?variants, _)) { auto i = 0u; - auto n_variants = vec::len[ast::variant](variants); + auto n_variants = std::ivec::len[ast::variant](variants); while (i < n_variants) { auto variant = variants.(i); auto p = new_pt + [it.ident, variant.node.name, "discrim"]; diff --git a/src/comp/middle/tstate/annotate.rs b/src/comp/middle/tstate/annotate.rs index b306eda57371..e82414959ac8 100644 --- a/src/comp/middle/tstate/annotate.rs +++ b/src/comp/middle/tstate/annotate.rs @@ -52,7 +52,7 @@ fn collect_ids_local(&@local l, @mutable node_id[] rs) { *rs += ~[l.node.id]; } -fn node_ids_in_fn(&_fn f, &vec[ty_param] tps, &span sp, &fn_ident i, +fn node_ids_in_fn(&_fn f, &ty_param[] tps, &span sp, &fn_ident i, node_id id, @mutable node_id[] rs) { auto collect_ids = walk::default_visitor(); collect_ids = @@ -70,7 +70,7 @@ fn init_vecs(&crate_ctxt ccx, &node_id[] node_ids, uint len) { } } -fn visit_fn(&crate_ctxt ccx, uint num_constraints, &_fn f, &vec[ty_param] tps, +fn visit_fn(&crate_ctxt ccx, uint num_constraints, &_fn f, &ty_param[] tps, &span sp, &fn_ident i, node_id id) { let @mutable node_id[] node_ids = @mutable ~[]; node_ids_in_fn(f, tps, sp, i, id, node_ids); @@ -78,7 +78,7 @@ fn visit_fn(&crate_ctxt ccx, uint num_constraints, &_fn f, &vec[ty_param] tps, init_vecs(ccx, node_id_vec, num_constraints); } -fn annotate_in_fn(&crate_ctxt ccx, &_fn f, &vec[ty_param] tps, +fn annotate_in_fn(&crate_ctxt ccx, &_fn f, &ty_param[] tps, &span sp, &fn_ident i, node_id id) { auto f_info = get_fn_info(ccx, id); visit_fn(ccx, num_constraints(f_info), f, tps, sp, i, id); diff --git a/src/comp/middle/tstate/ck.rs b/src/comp/middle/tstate/ck.rs index 37d7cc9f91a2..217f253ab60f 100644 --- a/src/comp/middle/tstate/ck.rs +++ b/src/comp/middle/tstate/ck.rs @@ -120,7 +120,7 @@ fn check_states_stmt(&fn_ctxt fcx, &@stmt s) { } fn check_states_against_conditions(&fn_ctxt fcx, &_fn f, - &vec[ast::ty_param] tps, + &ast::ty_param[] tps, node_id id, &span sp, &fn_ident i) { /* Postorder traversal instead of pre is important because we want the smallest possible erroneous statement @@ -176,7 +176,7 @@ fn check_states_against_conditions(&fn_ctxt fcx, &_fn f, check_unused_vars(fcx); } -fn check_fn_states(&fn_ctxt fcx, &_fn f, &vec[ast::ty_param] tps, +fn check_fn_states(&fn_ctxt fcx, &_fn f, &ast::ty_param[] tps, node_id id, &span sp, &fn_ident i) { /* Compute the pre- and post-states for this function */ @@ -189,7 +189,7 @@ fn check_fn_states(&fn_ctxt fcx, &_fn f, &vec[ast::ty_param] tps, check_states_against_conditions(fcx, f, tps, id, sp, i); } -fn fn_states(&crate_ctxt ccx, &_fn f, &vec[ast::ty_param] tps, +fn fn_states(&crate_ctxt ccx, &_fn f, &ast::ty_param[] tps, &span sp, &fn_ident i, node_id id) { /* Look up the var-to-bit-num map for this function */ diff --git a/src/comp/middle/tstate/collect_locals.rs b/src/comp/middle/tstate/collect_locals.rs index 526a730fd4b0..95b0723eb341 100644 --- a/src/comp/middle/tstate/collect_locals.rs +++ b/src/comp/middle/tstate/collect_locals.rs @@ -64,13 +64,12 @@ fn collect_pred(&@expr e, &ctxt cx, &visit::vt[ctxt] v) { visit::visit_expr(e, cx, v); } -fn do_nothing(&_fn f, &vec[ty_param] tp, &span sp, &fn_ident i, +fn do_nothing(&_fn f, &ty_param[] tp, &span sp, &fn_ident i, node_id iid, &ctxt cx, &visit::vt[ctxt] v) { } -fn find_locals(&ty::ctxt tcx, &_fn f, &vec[ty_param] tps, - &span sp, &fn_ident i, node_id id) - -> ctxt { +fn find_locals(&ty::ctxt tcx, &_fn f, &ty_param[] tps, &span sp, &fn_ident i, + node_id id) -> ctxt { let ctxt cx = rec(cs=@mutable ~[], tcx=tcx); auto visitor = visit::default_visitor[ctxt](); @@ -118,9 +117,8 @@ fn add_constraint(&ty::ctxt tcx, aux::constr c, uint next, constr_map tbl) -> /* builds a table mapping each local var defined in f to a bit number in the precondition/postcondition vectors */ -fn mk_fn_info(&crate_ctxt ccx, &_fn f, &vec[ty_param] tp, - &span f_sp, &fn_ident f_name, - node_id id) { +fn mk_fn_info(&crate_ctxt ccx, &_fn f, &ty_param[] tp, + &span f_sp, &fn_ident f_name, node_id id) { auto res_map = @new_int_hash[constraint](); let uint next = 0u; diff --git a/src/comp/middle/tstate/pre_post_conditions.rs b/src/comp/middle/tstate/pre_post_conditions.rs index 8a65df496ff8..7318fd28f86b 100644 --- a/src/comp/middle/tstate/pre_post_conditions.rs +++ b/src/comp/middle/tstate/pre_post_conditions.rs @@ -102,9 +102,8 @@ fn find_pre_post_obj(&crate_ctxt ccx, _obj o) { ccx=ccx); find_pre_post_fn(fcx, m.node.meth); } - auto f = bind do_a_method(ccx, _); - vec::map[@method, ()](f, o.methods); - option::map[@method, ()](f, o.dtor); + for (@method m in o.methods) { do_a_method(ccx, m); } + option::map[@method, ()](bind do_a_method(ccx, _), o.dtor); } fn find_pre_post_item(&crate_ctxt ccx, &item i) { @@ -151,26 +150,21 @@ fn find_pre_post_item(&crate_ctxt ccx, &item i) { sets the precondition in a to be the result of combining the preconditions for , and the postcondition in a to be the union of all postconditions for */ -fn find_pre_post_exprs(&fn_ctxt fcx, &vec[@expr] args, node_id id) { - if (vec::len[@expr](args) > 0u) { +fn find_pre_post_exprs(&fn_ctxt fcx, &(@expr)[] args, node_id id) { + if (ivec::len[@expr](args) > 0u) { log "find_pre_post_exprs: oper ="; log_expr(*args.(0)); } fn do_one(fn_ctxt fcx, &@expr e) { find_pre_post_expr(fcx, e); } - auto f = bind do_one(fcx, _); - vec::map[@expr, ()](f, args); + for (@expr e in args) { do_one(fcx, e); } + fn get_pp(crate_ctxt ccx, &@expr e) -> pre_and_post { ret expr_pp(ccx, e); } - auto g = bind get_pp(fcx.ccx, _); - auto pps = vec::map[@expr, pre_and_post](g, args); + auto pps = ivec::map[@expr, pre_and_post](bind get_pp(fcx.ccx, _), args); - // TODO: Remove this vec->ivec conversion. - auto pps_ivec = ~[]; - for (pre_and_post pp in pps) { pps_ivec += ~[pp]; } - - set_pre_and_post(fcx.ccx, id, seq_preconds(fcx, pps_ivec), - seq_postconds(fcx, ivec::map(get_post, pps_ivec))); + set_pre_and_post(fcx.ccx, id, seq_preconds(fcx, pps), + seq_postconds(fcx, ivec::map(get_post, pps))); } fn find_pre_post_loop(&fn_ctxt fcx, &@local l, &@expr index, &block body, @@ -264,10 +258,10 @@ fn gen_if_local(&fn_ctxt fcx, @expr lhs, @expr rhs, node_id larger_id, rec(id=d_id._1, c=ninit(path_to_ident(fcx.ccx.tcx, pth)))); } - case (_) { find_pre_post_exprs(fcx, [lhs, rhs], larger_id); } + case (_) { find_pre_post_exprs(fcx, ~[lhs, rhs], larger_id); } } } - case (_) { find_pre_post_exprs(fcx, [lhs, rhs], larger_id); } + case (_) { find_pre_post_exprs(fcx, ~[lhs, rhs], larger_id); } } } @@ -280,12 +274,8 @@ fn find_pre_post_expr(&fn_ctxt fcx, @expr e) { alt (e.node) { case (expr_call(?operator, ?operands)) { - auto args = vec::clone(operands); - vec::push(args, operator); - - // TODO: Remove this vec->ivec conversion. - auto operands_ivec = ~[]; - for (@expr e in operands) { operands_ivec += ~[e]; } + auto args = /* copy */ operands; + args += ~[operator]; find_pre_post_exprs(fcx, args, e.id); /* see if the call has any constraints on its type */ @@ -295,8 +285,7 @@ fn find_pre_post_expr(&fn_ctxt fcx, @expr e) { bit_num(fcx, rec(id=c.node.id._1, c=substitute_constr_args(fcx.ccx.tcx, - operands_ivec, - c))); + args, c))); require(i, expr_pp(fcx.ccx, e)); } @@ -307,8 +296,8 @@ fn find_pre_post_expr(&fn_ctxt fcx, @expr e) { } } case (expr_spawn(_, _, ?operator, ?operands)) { - auto args = vec::clone(operands); - vec::push(args, operator); + auto args = /* copy */ operands; + args += ~[operator]; find_pre_post_exprs(fcx, args, e.id); } case (expr_vec(?args, _, _)) { @@ -359,7 +348,10 @@ fn find_pre_post_expr(&fn_ctxt fcx, @expr e) { } case (expr_rec(?fields, ?maybe_base)) { auto es = field_exprs(fields); - vec::plus_option(es, maybe_base); + alt (maybe_base) { + case (none) { /* no-op */ } + case (some(?b)) { es += ~[b]; } + } find_pre_post_exprs(fcx, es, e.id); } case (expr_move(?lhs, ?rhs)) { @@ -367,7 +359,7 @@ fn find_pre_post_expr(&fn_ctxt fcx, @expr e) { case (expr_path(?p)) { gen_if_local(fcx, lhs, rhs, e.id, lhs.id, p); } - case (_) { find_pre_post_exprs(fcx, [lhs, rhs], e.id); } + case (_) { find_pre_post_exprs(fcx, ~[lhs, rhs], e.id); } } if (is_path(rhs)) { forget_in_postcond(fcx, e.id, rhs.id); @@ -375,7 +367,7 @@ fn find_pre_post_expr(&fn_ctxt fcx, @expr e) { } case (expr_swap(?lhs, ?rhs)) { // Both sides must already be initialized - find_pre_post_exprs(fcx, [lhs, rhs], e.id); + find_pre_post_exprs(fcx, ~[lhs, rhs], e.id); forget_in_postcond_still_init(fcx, e.id, lhs.id); forget_in_postcond_still_init(fcx, e.id, rhs.id); // Could be more precise and swap the roles of lhs and rhs @@ -387,7 +379,7 @@ fn find_pre_post_expr(&fn_ctxt fcx, @expr e) { gen_if_local(fcx, lhs, rhs, e.id, lhs.id, p); forget_in_postcond_still_init(fcx, e.id, lhs.id); } - case (_) { find_pre_post_exprs(fcx, [lhs, rhs], e.id); } + case (_) { find_pre_post_exprs(fcx, ~[lhs, rhs], e.id); } } } case (expr_recv(?lhs, ?rhs)) { @@ -400,7 +392,7 @@ fn find_pre_post_expr(&fn_ctxt fcx, @expr e) { // doesn't check that rhs is an lval, but // that's probably ok - find_pre_post_exprs(fcx, [lhs, rhs], e.id); + find_pre_post_exprs(fcx, ~[lhs, rhs], e.id); } } } @@ -408,7 +400,7 @@ fn find_pre_post_expr(&fn_ctxt fcx, @expr e) { /* Different from expr_assign in that the lhs *must* already be initialized */ - find_pre_post_exprs(fcx, [lhs, rhs], e.id); + find_pre_post_exprs(fcx, ~[lhs, rhs], e.id); forget_in_postcond_still_init(fcx, e.id, lhs.id); } case (expr_lit(_)) { clear_pp(expr_pp(fcx.ccx, e)); } @@ -449,11 +441,11 @@ fn find_pre_post_expr(&fn_ctxt fcx, @expr e) { expr_postcond(fcx.ccx, l)); } else { - find_pre_post_exprs(fcx, [l, r], e.id); + find_pre_post_exprs(fcx, ~[l, r], e.id); } } case (expr_send(?l, ?r)) { - find_pre_post_exprs(fcx, [l, r], e.id); + find_pre_post_exprs(fcx, ~[l, r], e.id); } case (expr_unary(_, ?operand)) { find_pre_post_expr(fcx, operand); @@ -497,7 +489,7 @@ fn find_pre_post_expr(&fn_ctxt fcx, @expr e) { find_pre_post_loop(fcx, d, index, body, e.id); } case (expr_index(?val, ?sub)) { - find_pre_post_exprs(fcx, [val, sub], e.id); + find_pre_post_exprs(fcx, ~[val, sub], e.id); } case (expr_alt(?ex, ?alts)) { find_pre_post_expr(fcx, ex); @@ -505,8 +497,8 @@ fn find_pre_post_expr(&fn_ctxt fcx, @expr e) { find_pre_post_block(fcx, an_alt.block); ret block_pp(fcx.ccx, an_alt.block); } - auto f = bind do_an_alt(fcx, _); - auto alt_pps = vec::map[arm, pre_and_post](f, alts); + auto alt_pps = []; + for (arm a in alts) { alt_pps += [do_an_alt(fcx, a)]; } fn combine_pp(pre_and_post antec, fn_ctxt fcx, &pre_and_post pp, &pre_and_post next) -> pre_and_post { union(pp.precondition, seq_preconds(fcx, ~[antec, next])); @@ -559,8 +551,14 @@ fn find_pre_post_expr(&fn_ctxt fcx, @expr e) { } case (expr_bind(?operator, ?maybe_args)) { - auto args = vec::cat_options[@expr](maybe_args); - vec::push[@expr](args, operator); /* ??? order of eval? */ + auto args = ~[]; + for (option::t[@expr] expr_opt in maybe_args) { + alt (expr_opt) { + case (none) { /* no-op */ } + case (some(?expr)) { args += ~[expr]; } + } + } + args += ~[operator]; /* ??? order of eval? */ find_pre_post_exprs(fcx, args, e.id); } @@ -659,8 +657,7 @@ fn find_pre_post_block(&fn_ctxt fcx, block b) { log "is:"; log_pp(stmt_pp(fcx.ccx, *s)); } - auto do_one = bind do_one_(fcx, _); - vec::map[@stmt, ()](do_one, b.node.stmts); + for (@stmt s in b.node.stmts) { do_one_(fcx, s); } fn do_inner_(fn_ctxt fcx, &@expr e) { find_pre_post_expr(fcx, e); } auto do_inner = bind do_inner_(fcx, _); option::map[@expr, ()](do_inner, b.node.expr); @@ -705,7 +702,7 @@ fn find_pre_post_fn(&fn_ctxt fcx, &_fn f) { } } -fn fn_pre_post(crate_ctxt ccx, &_fn f, &vec[ty_param] tps, +fn fn_pre_post(crate_ctxt ccx, &_fn f, &ty_param[] tps, &span sp, &fn_ident i, node_id id) { assert (ccx.fm.contains_key(id)); auto fcx = rec(enclosing=ccx.fm.get(id), id=id, diff --git a/src/comp/middle/tstate/states.rs b/src/comp/middle/tstate/states.rs index 229bd1765443..4e206add7443 100644 --- a/src/comp/middle/tstate/states.rs +++ b/src/comp/middle/tstate/states.rs @@ -1,3 +1,4 @@ +import std::ivec; import std::vec; import std::vec::plus_option; import std::vec::cat_options; @@ -100,7 +101,7 @@ tag oper_type { oper_pure; } -fn seq_states(&fn_ctxt fcx, prestate pres, vec[@expr] exprs) -> +fn seq_states(&fn_ctxt fcx, prestate pres, &(@expr)[] exprs) -> tup(bool, poststate) { auto changed = false; auto post = pres; @@ -162,7 +163,7 @@ fn find_pre_post_state_two(&fn_ctxt fcx, &prestate pres, &@expr a, &@expr b, } fn find_pre_post_state_call(&fn_ctxt fcx, &prestate pres, &@expr a, - node_id id, &vec[@expr] bs, + node_id id, &(@expr)[] bs, controlflow cf) -> bool { auto changed = find_pre_post_state_expr(fcx, pres, a); ret find_pre_post_state_exprs(fcx, @@ -170,7 +171,7 @@ fn find_pre_post_state_call(&fn_ctxt fcx, &prestate pres, &@expr a, } fn find_pre_post_state_exprs(&fn_ctxt fcx, &prestate pres, node_id id, - &vec[@expr] es, controlflow cf) -> bool { + &(@expr)[] es, controlflow cf) -> bool { auto rs = seq_states(fcx, pres, es); auto changed = rs._0 | set_prestate_ann(fcx.ccx, id, pres); /* if this is a failing call, it sets everything as initialized */ @@ -313,8 +314,16 @@ fn find_pre_post_state_expr(&fn_ctxt fcx, &prestate pres, @expr e) -> bool { return); } case (expr_bind(?operator, ?maybe_args)) { - ret find_pre_post_state_call(fcx, pres, operator, e.id, - cat_options(maybe_args), return); + auto args = ~[]; + for (option::t[@expr] a_opt in maybe_args) { + alt (a_opt) { + case (none) { /* no-op */ } + case (some(?a)) { args += ~[a]; } + } + } + + ret find_pre_post_state_call(fcx, pres, operator, e.id, args, + return); } case (expr_path(_)) { ret pure_exp(fcx.ccx, e.id, pres); } case (expr_log(_, ?ex)) { @@ -514,7 +523,7 @@ fn find_pre_post_state_expr(&fn_ctxt fcx, &prestate pres, @expr e) -> bool { find_pre_post_state_expr(fcx, pres, val); auto e_post = expr_poststate(fcx.ccx, val); auto a_post; - if (vec::len(alts) > 0u) { + if (ivec::len(alts) > 0u) { a_post = false_postcond(num_constrs); for (arm an_alt in alts) { changed |= find_pre_post_state_block diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs index 0a90b657cc56..d6673b558005 100644 --- a/src/comp/middle/typeck.rs +++ b/src/comp/middle/typeck.rs @@ -52,7 +52,7 @@ export check_crate; type ty_table = hashmap[ast::def_id, ty::t]; -type obj_info = rec(vec[ast::obj_field] obj_fields, ast::node_id this_obj); +type obj_info = rec(ast::obj_field[] obj_fields, ast::node_id this_obj); type crate_ctxt = rec(mutable vec[obj_info] obj_infos, @@ -481,7 +481,7 @@ mod collect { } fn ty_of_fn_decl(&@ctxt cx, &fn(&@ast::ty) -> ty::t convert, &fn(&ast::arg) -> arg ty_of_arg, &ast::fn_decl decl, - ast::proto proto, &vec[ast::ty_param] ty_params, + ast::proto proto, &ast::ty_param[] ty_params, &option::t[ast::def_id] def_id) -> ty::ty_param_count_and_ty { auto input_tys = ~[]; @@ -495,7 +495,7 @@ mod collect { auto t_fn = ty::mk_fn(cx.tcx, proto, input_tys, output_ty, decl.cf, out_constrs); - auto ty_param_count = vec::len[ast::ty_param](ty_params); + auto ty_param_count = ivec::len[ast::ty_param](ty_params); auto tpt = tup(ty_param_count, t_fn); alt (def_id) { case (some(?did)) { cx.tcx.tcache.insert(did, tpt); } @@ -506,7 +506,7 @@ mod collect { fn ty_of_native_fn_decl(&@ctxt cx, &fn(&@ast::ty) -> ty::t convert, &fn(&ast::arg) -> arg ty_of_arg, &ast::fn_decl decl, ast::native_abi abi, - &vec[ast::ty_param] ty_params, + &ast::ty_param[] ty_params, &ast::def_id def_id) -> ty::ty_param_count_and_ty { auto input_tys = ~[]; @@ -514,7 +514,7 @@ mod collect { auto output_ty = convert(decl.output); auto t_fn = ty::mk_native_fn(cx.tcx, abi, input_tys, output_ty); - auto ty_param_count = vec::len[ast::ty_param](ty_params); + auto ty_param_count = ivec::len[ast::ty_param](ty_params); auto tpt = tup(ty_param_count, t_fn); cx.tcx.tcache.insert(def_id, tpt); ret tpt; @@ -577,14 +577,14 @@ mod collect { constrs=out_constrs); } fn ty_of_obj(@ctxt cx, &ast::ident id, &ast::_obj obj_info, - &vec[ast::ty_param] ty_params) -> ty::ty_param_count_and_ty { + &ast::ty_param[] ty_params) -> ty::ty_param_count_and_ty { auto methods = get_obj_method_types(cx, obj_info); auto t_obj = ty::mk_obj(cx.tcx, ty::sort_methods(methods)); t_obj = ty::rename(cx.tcx, t_obj, id); - ret tup(vec::len(ty_params), t_obj); + ret tup(ivec::len(ty_params), t_obj); } fn ty_of_obj_ctor(@ctxt cx, &ast::ident id, &ast::_obj obj_info, - ast::node_id ctor_id, &vec[ast::ty_param] ty_params) -> + ast::node_id ctor_id, &ast::ty_param[] ty_params) -> ty::ty_param_count_and_ty { auto t_obj = ty_of_obj(cx, id, obj_info, ty_params); @@ -630,23 +630,23 @@ mod collect { // call to resolve any named types. auto typ = convert(t); - auto ty_param_count = vec::len[ast::ty_param](tps); + auto ty_param_count = ivec::len[ast::ty_param](tps); auto tpt = tup(ty_param_count, typ); cx.tcx.tcache.insert(local_def(it.id), tpt); ret tpt; } case (ast::item_res(?f, _, ?tps, _)) { auto t_arg = ty_of_arg(cx, f.decl.inputs.(0)); - auto t_res = tup(vec::len(tps), ty::mk_res + auto t_res = tup(ivec::len(tps), ty::mk_res (cx.tcx, local_def(it.id), t_arg.ty, - mk_ty_params(cx, vec::len(tps)))); + mk_ty_params(cx, ivec::len(tps)))); cx.tcx.tcache.insert(local_def(it.id), t_res); ret t_res; } case (ast::item_tag(_, ?tps)) { // Create a new generic polytype. - auto ty_param_count = vec::len[ast::ty_param](tps); + auto ty_param_count = ivec::len[ast::ty_param](tps); let ty::t[] subtys = mk_ty_params(cx, ty_param_count); auto t = ty::mk_tag(cx.tcx, local_def(it.id), subtys); @@ -681,11 +681,11 @@ mod collect { } } fn get_tag_variant_types(&@ctxt cx, &ast::def_id tag_id, - &vec[ast::variant] variants, - &vec[ast::ty_param] ty_params) { + &ast::variant[] variants, + &ast::ty_param[] ty_params) { // Create a set of parameter types shared among all the variants. - auto ty_param_count = vec::len[ast::ty_param](ty_params); + auto ty_param_count = ivec::len[ast::ty_param](ty_params); let ty::t[] ty_param_tys = mk_ty_params(cx, ty_param_count); for (ast::variant variant in variants) { // Nullary tag constructors get turned into constants; n-ary tag @@ -757,7 +757,7 @@ mod collect { auto method_types = get_obj_method_types(cx, object); auto i = 0u; - while (i < vec::len[@ast::method](object.methods)) { + while (i < ivec::len[@ast::method](object.methods)) { write::ty_only(cx.tcx, object.methods.(i).node.id, ty::method_ty_to_fn_ty(cx.tcx, method_types.(i))); @@ -789,7 +789,7 @@ mod collect { case (ast::item_res(?f, ?dtor_id, ?tps, ?ctor_id)) { auto t_arg = ty_of_arg(cx, f.decl.inputs.(0)); auto t_res = ty::mk_res(cx.tcx, local_def(it.id), t_arg.ty, - mk_ty_params(cx, vec::len(tps))); + mk_ty_params(cx, ivec::len(tps))); auto t_ctor = ty::mk_fn(cx.tcx, ast::proto_fn, ~[t_arg], t_res, ast::return, ~[]); auto t_dtor = ty::mk_fn(cx.tcx, ast::proto_fn, ~[t_arg], @@ -797,7 +797,7 @@ mod collect { write::ty_only(cx.tcx, it.id, t_res); write::ty_only(cx.tcx, ctor_id, t_ctor); cx.tcx.tcache.insert(local_def(ctor_id), - tup(vec::len(tps), t_ctor)); + tup(ivec::len(tps), t_ctor)); write::ty_only(cx.tcx, dtor_id, t_dtor); } case (_) { @@ -995,8 +995,8 @@ fn are_compatible(&@fn_ctxt fcx, &ty::t expected, &ty::t actual) -> bool { // Returns the types of the arguments to a tag variant. fn variant_arg_types(&@crate_ctxt ccx, &span sp, &ast::def_id vid, - &ty::t[] tag_ty_params) -> vec[ty::t] { - let vec[ty::t] result = []; + &ty::t[] tag_ty_params) -> ty::t[] { + let ty::t[] result = ~[]; auto tpt = ty::lookup_item_type(ccx.tcx, vid); alt (ty::struct(ccx.tcx, tpt._1)) { case (ty::ty_fn(_, ?ins, _, _, _)) { @@ -1006,7 +1006,7 @@ fn variant_arg_types(&@crate_ctxt ccx, &span sp, &ast::def_id vid, auto arg_ty = ty::substitute_type_params(ccx.tcx, tag_ty_params, arg.ty); - result += [arg_ty]; + result += ~[arg_ty]; } } case (_) { @@ -1121,12 +1121,12 @@ mod writeback { wbcx.ignore = false; } fn visit_fn_pre(@wb_ctxt wbcx, &ast::_fn f, - &vec[ast::ty_param] tps, &span sp, + &ast::ty_param[] tps, &span sp, &ast::fn_ident i, ast::node_id d) { wbcx.ignore = true; } fn visit_fn_post(@wb_ctxt wbcx, &ast::_fn f, - &vec[ast::ty_param] tps, &span sp, + &ast::ty_param[] tps, &span sp, &ast::fn_ident i, ast::node_id d) { wbcx.ignore = false; } @@ -1335,11 +1335,11 @@ fn check_pat(&@fn_ctxt fcx, &@ast::pat pat, ty::t expected) { auto arg_types = variant_arg_types(fcx.ccx, pat.span, v_def_ids._1, expected_tps); - auto subpats_len = vec::len[@ast::pat](subpats); - if (vec::len[ty::t](arg_types) > 0u) { + auto subpats_len = std::ivec::len[@ast::pat](subpats); + if (std::ivec::len[ty::t](arg_types) > 0u) { // N-ary variant. - auto arg_len = vec::len[ty::t](arg_types); + auto arg_len = ivec::len[ty::t](arg_types); if (arg_len != subpats_len) { // TODO: note definition of tag variant // TODO (issue #448): Wrap a #fmt string over multiple @@ -1430,7 +1430,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) { // expressions. fn check_call_or_bind(&@fn_ctxt fcx, &span sp, &@ast::expr f, - &vec[option::t[@ast::expr]] args, bool is_call) { + &(option::t[@ast::expr])[] args, bool is_call) { // Check the function. check_expr(fcx, f); @@ -1458,7 +1458,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) { // Check that the correct number of arguments were supplied. auto expected_arg_count = ivec::len[ty::arg](arg_tys); - auto supplied_arg_count = vec::len[option::t[@ast::expr]](args); + auto supplied_arg_count = ivec::len[option::t[@ast::expr]](args); if (expected_arg_count != supplied_arg_count) { fcx.ccx.tcx.sess.span_fatal(sp, #fmt("this function takes %u \ @@ -1501,10 +1501,10 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) { // A generic function for checking call expressions fn check_call(&@fn_ctxt fcx, &span sp, &@ast::expr f, - &vec[@ast::expr] args) { - let vec[option::t[@ast::expr]] args_opt_0 = []; + &(@ast::expr)[] args) { + let (option::t[@ast::expr])[] args_opt_0 = ~[]; for (@ast::expr arg in args) { - args_opt_0 += [some[@ast::expr](arg)]; + args_opt_0 += ~[some[@ast::expr](arg)]; } // Call the generic checker. @@ -1909,7 +1909,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) { auto ty_of_arg = bind collect::ty_of_arg(cx, _); auto fty = collect::ty_of_fn_decl(cx, convert, ty_of_arg, f.decl, - f.proto, [], none)._1; + f.proto, ~[], none)._1; write::ty_only_fixup(fcx, id, fty); check_fn(fcx.ccx, f.decl, f.proto, f.body, id); } @@ -1949,7 +1949,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) { // to the resulting function type. auto i = 0u; - while (i < vec::len[option::t[@ast::expr]](args)) { + while (i < ivec::len[option::t[@ast::expr]](args)) { alt (args.(i)) { case (some(_)) {/* no-op */ } case (none) { arg_tys_1 += ~[arg_tys.(i)]; } @@ -2051,7 +2051,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) { } case (ast::expr_vec(?args, ?mut, ?kind)) { let ty::t t; - if (vec::len[@ast::expr](args) == 0u) { + if (ivec::len[@ast::expr](args) == 0u) { t = next_ty_var(fcx); } else { check_expr(fcx, args.(0)); @@ -2075,7 +2075,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) { } case (ast::expr_tup(?elts)) { let ty::mt[] elts_mt = ~[]; - ivec::reserve(elts_mt, vec::len(elts)); + ivec::reserve(elts_mt, ivec::len(elts)); for (ast::elt e in elts) { check_expr(fcx, e.expr); auto ety = expr_ty(fcx.ccx.tcx, e.expr); @@ -2250,7 +2250,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) { // We're entering an object, so gather up the info we need. - let vec[ast::anon_obj_field] fields = []; + let ast::anon_obj_field[] fields = ~[]; alt (anon_obj.fields) { case (none) { } case (some(?v)) { fields = v; } @@ -2265,8 +2265,8 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) { vec::push[obj_info](fcx.ccx.obj_infos, rec(obj_fields= - vec::map(anon_obj_field_to_obj_field, - fields), + ivec::map(anon_obj_field_to_obj_field, + fields), this_obj=id)); // FIXME: These next three functions are largely ripped off from @@ -2343,7 +2343,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) { // collect::convert for regular objects.) auto i = 0u; - while (i < vec::len[@ast::method](anon_obj.methods)) { + while (i < ivec::len[@ast::method](anon_obj.methods)) { write::ty_only(fcx.ccx.tcx, anon_obj.methods.(i).node.id, ty::method_ty_to_fn_ty(fcx.ccx.tcx, method_types.(i))); diff --git a/src/comp/syntax/ast.rs b/src/comp/syntax/ast.rs index 5cf379ca2116..1597feb3dc3d 100644 --- a/src/comp/syntax/ast.rs +++ b/src/comp/syntax/ast.rs @@ -111,7 +111,7 @@ tag meta_item_ { type block = spanned[block_]; -type block_ = rec(vec[@stmt] stmts, option::t[@expr] expr, node_id id); +type block_ = rec((@stmt)[] stmts, option::t[@expr] expr, node_id id); type pat = rec(node_id id, pat_ node, @@ -121,7 +121,7 @@ tag pat_ { pat_wild; pat_bind(ident); pat_lit(@lit); - pat_tag(path, vec[@pat]); + pat_tag(path, (@pat)[]); } tag mutability { mut; imm; maybe_mut; } @@ -246,13 +246,13 @@ type expr = rec(node_id id, span span); tag expr_ { - expr_vec(vec[@expr], mutability, seq_kind); - expr_tup(vec[elt]); - expr_rec(vec[field], option::t[@expr]); - expr_call(@expr, vec[@expr]); + expr_vec((@expr)[], mutability, seq_kind); + expr_tup(elt[]); + expr_rec(field[], option::t[@expr]); + expr_call(@expr, (@expr)[]); expr_self_method(ident); - expr_bind(@expr, vec[option::t[@expr]]); - expr_spawn(spawn_dom, option::t[str], @expr, vec[@expr]); + expr_bind(@expr, (option::t[@expr])[]); + expr_spawn(spawn_dom, option::t[str], @expr, (@expr)[]); expr_binary(binop, @expr, @expr); expr_unary(unop, @expr); expr_lit(@lit); @@ -263,7 +263,7 @@ tag expr_ { expr_for(@local, @expr, block); expr_for_each(@local, @expr, block); expr_do_while(block, @expr); - expr_alt(@expr, vec[arm]); + expr_alt(@expr, arm[]); expr_fn(_fn); expr_block(block); /* @@ -279,7 +279,7 @@ tag expr_ { expr_field(@expr, ident); expr_index(@expr, @expr); expr_path(path); - expr_ext(path, vec[@expr], option::t[str], @expr); + expr_ext(path, (@expr)[], option::t[str], @expr); expr_fail(option::t[@expr]); expr_break; expr_cont; @@ -298,7 +298,7 @@ tag expr_ { expr_if_check(@expr, block, option::t[@expr]); expr_port(option::t[@ty]); expr_chan(@expr); - expr_anon_obj(anon_obj, vec[ty_param]); + expr_anon_obj(anon_obj, ty_param[]); } type lit = spanned[lit_]; @@ -438,7 +438,7 @@ type constr = spanned[constr_]; type arg = rec(mode mode, @ty ty, ident ident, node_id id); type fn_decl = - rec(vec[arg] inputs, + rec(arg[] inputs, @ty output, purity purity, controlflow cf, @@ -470,13 +470,13 @@ type anon_obj_field = rec(mutability mut, @ty ty, @expr expr, ident ident, node_id id); type _obj = - rec(vec[obj_field] fields, vec[@method] methods, option::t[@method] dtor); + rec(obj_field[] fields, (@method)[] methods, option::t[@method] dtor); type anon_obj = rec( // New fields and methods, if they exist. - option::t[vec[anon_obj_field]] fields, - vec[@method] methods, + option::t[anon_obj_field[]] fields, + (@method)[] methods, // with_obj: the original object being extended, if it exists. option::t[@expr] with_obj); @@ -533,14 +533,14 @@ type item = rec(ident ident, tag item_ { item_const(@ty, @expr); - item_fn(_fn, vec[ty_param]); + item_fn(_fn, ty_param[]); item_mod(_mod); item_native_mod(native_mod); - item_ty(@ty, vec[ty_param]); - item_tag(vec[variant], vec[ty_param]); - item_obj(_obj, vec[ty_param], node_id /* constructor id */); + item_ty(@ty, ty_param[]); + item_tag(variant[], ty_param[]); + item_obj(_obj, ty_param[], node_id /* constructor id */); item_res(_fn /* dtor */, node_id /* dtor id */, - vec[ty_param], node_id /* ctor id */); + ty_param[], node_id /* ctor id */); } type native_item = rec(ident ident, @@ -551,7 +551,7 @@ type native_item = rec(ident ident, tag native_item_ { native_item_ty; - native_item_fn(option::t[str], fn_decl, vec[ty_param]); + native_item_fn(option::t[str], fn_decl, ty_param[]); } fn is_exported(ident i, _mod m) -> bool { @@ -609,7 +609,7 @@ fn hash_ty(&@ty t) -> uint { ret t.span.lo << 16u + t.span.hi; } fn block_from_expr(@expr e) -> block { let block_ blk_ = - rec(stmts=[], + rec(stmts=~[], expr=option::some[@expr](e), id=e.id); ret rec(node=blk_, span=e.span); diff --git a/src/comp/syntax/ext/base.rs b/src/comp/syntax/ext/base.rs index 766dd9f3f288..7b0accb573be 100644 --- a/src/comp/syntax/ext/base.rs +++ b/src/comp/syntax/ext/base.rs @@ -8,8 +8,8 @@ import std::map::new_str_hash; import codemap; type syntax_expander = - fn(&ext_ctxt, span, &vec[@ast::expr], option::t[str]) -> @ast::expr; -type macro_definer = fn(&ext_ctxt, span, &vec[@ast::expr], + fn(&ext_ctxt, span, &(@ast::expr)[], option::t[str]) -> @ast::expr; +type macro_definer = fn(&ext_ctxt, span, &(@ast::expr)[], option::t[str]) -> tup(str, syntax_extension); tag syntax_extension { diff --git a/src/comp/syntax/ext/env.rs b/src/comp/syntax/ext/env.rs index 7b12c0458980..fad55953519c 100644 --- a/src/comp/syntax/ext/env.rs +++ b/src/comp/syntax/ext/env.rs @@ -5,6 +5,7 @@ * should all get sucked into either the compiler syntax extension plugin * interface. */ +import std::ivec; import std::str; import std::vec; import std::option; @@ -12,9 +13,9 @@ import std::generic_os; import base::*; export expand_syntax_ext; -fn expand_syntax_ext(&ext_ctxt cx, codemap::span sp, &vec[@ast::expr] args, +fn expand_syntax_ext(&ext_ctxt cx, codemap::span sp, &(@ast::expr)[] args, option::t[str] body) -> @ast::expr { - if (vec::len[@ast::expr](args) != 1u) { + if (ivec::len[@ast::expr](args) != 1u) { cx.span_fatal(sp, "malformed #env call"); } // FIXME: if this was more thorough it would manufacture an diff --git a/src/comp/syntax/ext/fmt.rs b/src/comp/syntax/ext/fmt.rs index c7e2787d502e..0f3b38a808bd 100644 --- a/src/comp/syntax/ext/fmt.rs +++ b/src/comp/syntax/ext/fmt.rs @@ -5,6 +5,7 @@ * should all get sucked into either the standard library extfmt module or the * compiler syntax extension plugin interface. */ +import std::ivec; import std::str; import std::vec; import std::option; @@ -15,9 +16,9 @@ import base::*; import codemap::span; export expand_syntax_ext; -fn expand_syntax_ext(&ext_ctxt cx, span sp, &vec[@ast::expr] args, +fn expand_syntax_ext(&ext_ctxt cx, span sp, &(@ast::expr)[] args, option::t[str] body) -> @ast::expr { - if (vec::len[@ast::expr](args) == 0u) { + if (ivec::len[@ast::expr](args) == 0u) { cx.span_fatal(sp, "#fmt requires a format string"); } auto fmt = expr_to_str(cx, args.(0), "first argument to #fmt must be a " @@ -37,7 +38,7 @@ fn expand_syntax_ext(&ext_ctxt cx, span sp, &vec[@ast::expr] args, // be factored out in common with other code that builds expressions. // FIXME: Cleanup the naming of these functions fn pieces_to_expr(&ext_ctxt cx, span sp, vec[piece] pieces, - vec[@ast::expr] args) -> @ast::expr { + &(@ast::expr)[] args) -> @ast::expr { fn make_new_lit(&ext_ctxt cx, span sp, ast::lit_ lit) -> @ast::expr { auto sp_lit = @rec(node=lit, span=sp); @@ -67,26 +68,26 @@ fn pieces_to_expr(&ext_ctxt cx, span sp, vec[piece] pieces, auto pathexpr = ast::expr_path(sp_path); ret @rec(id=cx.next_id(), node=pathexpr, span=sp); } - fn make_vec_expr(&ext_ctxt cx, span sp, vec[@ast::expr] exprs) -> + fn make_vec_expr(&ext_ctxt cx, span sp, &(@ast::expr)[] exprs) -> @ast::expr { auto vecexpr = ast::expr_vec(exprs, ast::imm, ast::sk_rc); ret @rec(id=cx.next_id(), node=vecexpr, span=sp); } fn make_call(&ext_ctxt cx, span sp, &ast::ident[] fn_path, - vec[@ast::expr] args) -> @ast::expr { + &(@ast::expr)[] args) -> @ast::expr { auto pathexpr = make_path_expr(cx, sp, fn_path); auto callexpr = ast::expr_call(pathexpr, args); ret @rec(id=cx.next_id(), node=callexpr, span=sp); } fn make_rec_expr(&ext_ctxt cx, span sp, vec[tup(ast::ident, @ast::expr)] fields) -> @ast::expr { - let vec[ast::field] astfields = []; + let ast::field[] astfields = ~[]; for (tup(ast::ident, @ast::expr) field in fields) { auto ident = field._0; auto val = field._1; auto astfield = rec(node=rec(mut=ast::imm, ident=ident, expr=val), span=sp); - astfields += [astfield]; + astfields += ~[astfield]; } auto recexpr = ast::expr_rec(astfields, option::none[@ast::expr]); ret @rec(id=cx.next_id(), node=recexpr, span=sp); @@ -109,7 +110,7 @@ fn pieces_to_expr(&ext_ctxt cx, span sp, vec[piece] pieces, @ast::expr { fn make_flags(&ext_ctxt cx, span sp, vec[flag] flags) -> @ast::expr { - let vec[@ast::expr] flagexprs = []; + let (@ast::expr)[] flagexprs = ~[]; for (flag f in flags) { auto fstr; alt (f) { @@ -121,14 +122,14 @@ fn pieces_to_expr(&ext_ctxt cx, span sp, vec[piece] pieces, case (flag_sign_always) { fstr = "flag_sign_always"; } case (flag_alternate) { fstr = "flag_alternate"; } } - flagexprs += [make_rt_path_expr(cx, sp, fstr)]; + flagexprs += ~[make_rt_path_expr(cx, sp, fstr)]; } // FIXME: 0-length vectors can't have their type inferred // through the rec that these flags are a member of, so // this is a hack placeholder flag - if (vec::len[@ast::expr](flagexprs) == 0u) { - flagexprs += [make_rt_path_expr(cx, sp, "flag_none")]; + if (ivec::len[@ast::expr](flagexprs) == 0u) { + flagexprs += ~[make_rt_path_expr(cx, sp, "flag_none")]; } ret make_vec_expr(cx, sp, flagexprs); } @@ -141,7 +142,7 @@ fn pieces_to_expr(&ext_ctxt cx, span sp, vec[piece] pieces, case (count_is(?c)) { auto count_lit = make_new_int(cx, sp, c); auto count_is_path = make_path_vec("count_is"); - auto count_is_args = [count_lit]; + auto count_is_args = ~[count_lit]; ret make_call(cx, sp, count_is_path, count_is_args); } case (_) { @@ -185,7 +186,7 @@ fn pieces_to_expr(&ext_ctxt cx, span sp, vec[piece] pieces, auto fname = "conv_" + conv_type; auto path = make_path_vec(fname); auto cnv_expr = make_rt_conv_expr(cx, sp, cnv); - auto args = [cnv_expr, arg]; + auto args = ~[cnv_expr, arg]; ret make_call(cx, arg.span, path, args); } fn make_new_conv(&ext_ctxt cx, span sp, conv cnv, @ast::expr arg) @@ -328,7 +329,7 @@ fn pieces_to_expr(&ext_ctxt cx, span sp, vec[piece] pieces, auto fmt_sp = args.(0).span; auto n = 0u; auto tmp_expr = make_new_str(cx, sp, ""); - auto nargs = vec::len[@ast::expr](args); + auto nargs = ivec::len[@ast::expr](args); for (piece pc in pieces) { alt (pc) { case (piece_string(?s)) { diff --git a/src/comp/syntax/ext/simplext.rs b/src/comp/syntax/ext/simplext.rs index 53b37da6c277..46b1fd636ce6 100644 --- a/src/comp/syntax/ext/simplext.rs +++ b/src/comp/syntax/ext/simplext.rs @@ -34,7 +34,7 @@ fn position[T](&T x, &vec[T] v) -> option::t[uint] { } // substitute, in a position that's required to be an ident -fn subst_ident(&ext_ctxt cx, &vec[@ast::expr] args, +fn subst_ident(&ext_ctxt cx, &(@ast::expr)[] args, @vec[ident] param_names, &ident i, ast_fold fld) -> ident { alt (position(i, *param_names)) { case (some[uint](?idx)) { @@ -48,7 +48,7 @@ fn subst_ident(&ext_ctxt cx, &vec[@ast::expr] args, } } -fn subst_path(&ext_ctxt cx, &vec[@ast::expr] args, +fn subst_path(&ext_ctxt cx, &(@ast::expr)[] args, @vec[ident] param_names, &path_ p, ast_fold fld) -> path_ { // Don't substitute into qualified names. if (ivec::len(p.types) > 0u || ivec::len(p.idents) != 1u) { ret p; } @@ -70,7 +70,7 @@ fn subst_path(&ext_ctxt cx, &vec[@ast::expr] args, } -fn subst_expr(&ext_ctxt cx, &vec[@ast::expr] args, @vec[ident] param_names, +fn subst_expr(&ext_ctxt cx, &(@ast::expr)[] args, @vec[ident] param_names, &ast::expr_ e, ast_fold fld, fn(&ast::expr_, ast_fold) -> ast::expr_ orig) -> ast::expr_ { ret alt(e) { @@ -90,20 +90,21 @@ fn subst_expr(&ext_ctxt cx, &vec[@ast::expr] args, @vec[ident] param_names, } -fn add_new_extension(&ext_ctxt cx, span sp, &vec[@ast::expr] args, +fn add_new_extension(&ext_ctxt cx, span sp, &(@ast::expr)[] args, option::t[str] body) -> tup(str, syntax_extension) { - if (len(args) < 2u) { + if (ivec::len(args) < 2u) { cx.span_fatal(sp, "malformed extension description"); } - fn generic_extension(&ext_ctxt cx, span sp, &vec[@ast::expr] args, + fn generic_extension(&ext_ctxt cx, span sp, &(@ast::expr)[] args, option::t[str] body, @vec[ident] param_names, @ast::expr dest_form) -> @ast::expr { - if (len(args) != len(*param_names)) { + if (ivec::len(args) != len(*param_names)) { cx.span_fatal(sp, #fmt("extension expects %u arguments, got %u", - len(*param_names), len(args))); + len(*param_names), ivec::len(args))); } + // FIXME: This binds to alias arguments. auto afp = default_ast_fold(); auto f_pre = rec(fold_ident = bind subst_ident(cx, args, param_names, _, _), @@ -120,7 +121,7 @@ fn add_new_extension(&ext_ctxt cx, span sp, &vec[@ast::expr] args, let vec[ident] param_names = vec::empty[ident](); let uint idx = 1u; - while(1u+idx < len(args)) { + while(1u+idx < ivec::len(args)) { param_names += [expr_to_ident(cx, args.(idx), "this parameter name must be an identifier.")]; @@ -129,7 +130,7 @@ fn add_new_extension(&ext_ctxt cx, span sp, &vec[@ast::expr] args, ret tup(expr_to_str(cx, args.(0), "first arg must be a literal string."), normal(bind generic_extension(_,_,_,_,@param_names, - args.(len(args)-1u)))); + args.(ivec::len(args)-1u)))); } diff --git a/src/comp/syntax/fold.rs b/src/comp/syntax/fold.rs index 3a8fd4260fe0..780ffaf13b1e 100644 --- a/src/comp/syntax/fold.rs +++ b/src/comp/syntax/fold.rs @@ -172,7 +172,8 @@ fn noop_fold_native_item(&@native_item ni, ast_fold fld) -> @native_item { case (native_item_ty) { native_item_ty } case (native_item_fn(?st, ?fdec, ?typms)) { native_item_fn(st, - rec(inputs=map(fold_arg, fdec.inputs), + rec(inputs=ivec::map(fold_arg, + fdec.inputs), output=fld.fold_ty(fdec.output), purity=fdec.purity, cf=fdec.cf, constraints=ivec::map(fld.fold_constr, @@ -216,11 +217,11 @@ fn noop_fold_item_underscore(&item_ i, ast_fold fld) -> item_ { item_ty(fld.fold_ty(t), typms) } case (item_tag(?variants, ?typms)) { - item_tag(map(fld.fold_variant, variants), typms) + item_tag(ivec::map(fld.fold_variant, variants), typms) } case (item_obj(?o, ?typms, ?d)) { - item_obj(rec(fields=map(fold_obj_field,o.fields), - methods=map(fld.fold_method,o.methods), + item_obj(rec(fields=ivec::map(fold_obj_field,o.fields), + methods=ivec::map(fld.fold_method,o.methods), dtor=option::map(fld.fold_method,o.dtor)), typms, d) } @@ -237,7 +238,7 @@ fn noop_fold_method(&method_ m, ast_fold fld) -> method_ { fn noop_fold_block(&block_ b, ast_fold fld) -> block_ { - ret rec(stmts=map(fld.fold_stmt, b.stmts), + ret rec(stmts=ivec::map(fld.fold_stmt, b.stmts), expr=option::map(fld.fold_expr, b.expr), id=b.id); } @@ -261,7 +262,7 @@ fn noop_fold_pat(&pat_ p, ast_fold fld) -> pat_ { case (pat_bind(?ident)) { pat_bind(fld.fold_ident(ident))} case (pat_lit(_)) { p } case (pat_tag(?pth, ?pats)) { - pat_tag(fld.fold_path(pth), map(fld.fold_pat, pats)) + pat_tag(fld.fold_path(pth), ivec::map(fld.fold_pat, pats)) } }; } @@ -298,12 +299,12 @@ fn noop_fold_expr(&expr_ e, ast_fold fld) -> expr_ { auto fold_anon_obj_field = bind fold_anon_obj_field_(_,fld); ret rec(fields=alt(ao.fields) { - case (option::none[vec[anon_obj_field]]) { ao.fields } - case (option::some[vec[anon_obj_field]](?v)) { - option::some[vec[anon_obj_field]] - (map(fold_anon_obj_field, v)) + case (option::none[anon_obj_field[]]) { ao.fields } + case (option::some[anon_obj_field[]](?v)) { + option::some[anon_obj_field[]] + (ivec::map(fold_anon_obj_field, v)) }}, - methods=map(fld.fold_method, ao.methods), + methods=ivec::map(fld.fold_method, ao.methods), with_obj=option::map(fld.fold_expr, ao.with_obj)) } auto fold_anon_obj = bind fold_anon_obj_(_,fld); @@ -311,28 +312,28 @@ fn noop_fold_expr(&expr_ e, ast_fold fld) -> expr_ { ret alt (e) { case (expr_vec(?exprs, ?mut, ?seq_kind)) { - expr_vec(map(fld.fold_expr, exprs), mut, seq_kind) + expr_vec(ivec::map(fld.fold_expr, exprs), mut, seq_kind) } case (expr_tup(?elts)) { - expr_tup(map(fold_elt, elts)) + expr_tup(ivec::map(fold_elt, elts)) } case (expr_rec(?fields, ?maybe_expr)) { - expr_rec(map(fold_field, fields), + expr_rec(ivec::map(fold_field, fields), option::map(fld.fold_expr, maybe_expr)) } case (expr_call(?f, ?args)) { - expr_call(fld.fold_expr(f), map(fld.fold_expr, args)) + expr_call(fld.fold_expr(f), ivec::map(fld.fold_expr, args)) } case (expr_self_method(?id)) { expr_self_method(fld.fold_ident(id)) } case (expr_bind(?f, ?args)) { auto opt_map_se = bind option::map(fld.fold_expr,_); - expr_bind(fld.fold_expr(f), map(opt_map_se, args)) + expr_bind(fld.fold_expr(f), ivec::map(opt_map_se, args)) } case (expr_spawn(?spawn_dom, ?name, ?f, ?args)) { expr_spawn(spawn_dom, name, fld.fold_expr(f), - map(fld.fold_expr, args)) + ivec::map(fld.fold_expr, args)) } case (expr_binary(?binop, ?lhs, ?rhs)) { expr_binary(binop, fld.fold_expr(lhs), fld.fold_expr(rhs)) @@ -368,7 +369,7 @@ fn noop_fold_expr(&expr_ e, ast_fold fld) -> expr_ { expr_do_while(fld.fold_block(block), fld.fold_expr(expr)) } case (expr_alt(?expr, ?arms)) { - expr_alt(fld.fold_expr(expr), map(fld.fold_arm, arms)) + expr_alt(fld.fold_expr(expr), ivec::map(fld.fold_arm, arms)) } case (expr_fn(?f)) { expr_fn(fld.fold_fn(f)) @@ -404,7 +405,7 @@ fn noop_fold_expr(&expr_ e, ast_fold fld) -> expr_ { expr_path(fld.fold_path(pth)) } case (expr_ext(?pth, ?args, ?body, ?expanded)) { - expr_ext(fld.fold_path(pth), map(fld.fold_expr, args), + expr_ext(fld.fold_path(pth), ivec::map(fld.fold_expr, args), body, fld.fold_expr(expanded)) } case (expr_fail(_)) { e } @@ -450,7 +451,7 @@ fn noop_fold_constr(&constr_ c, ast_fold fld) -> constr_ { fn noop_fold_fn(&_fn f, ast_fold fld) -> _fn { auto fold_arg = bind fold_arg_(_, fld); - ret rec(decl= rec(inputs=vec::map(fold_arg, f.decl.inputs), + ret rec(decl= rec(inputs=ivec::map(fold_arg, f.decl.inputs), output=fld.fold_ty(f.decl.output), purity=f.decl.purity, cf=f.decl.cf, diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs index d51e0b61c0fa..455d95e0f930 100644 --- a/src/comp/syntax/parse/parser.rs +++ b/src/comp/syntax/parse/parser.rs @@ -260,7 +260,7 @@ fn parse_ty_fn(ast::proto proto, &parser p, uint lo) -> ast::ty_ { auto inputs = parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA), parse_fn_input_ty, p); - auto constrs = parse_constrs([], p); + auto constrs = parse_constrs(~[], p); let @ast::ty output; auto cf = ast::return; if (p.peek() == token::RARROW) { @@ -329,13 +329,13 @@ fn parse_ty_field(&parser p) -> ast::ty_field { // if i is the jth ident in args, return j // otherwise, fail -fn ident_index(&parser p, &vec[ast::arg] args, &ast::ident i) -> uint { +fn ident_index(&parser p, &ast::arg[] args, &ast::ident i) -> uint { auto j = 0u; for (ast::arg a in args) { if (a.ident == i) { ret j; } j += 1u; } p.fatal("Unbound variable " + i + " in constraint arg"); } -fn parse_constr_arg(vec[ast::arg] args, &parser p) -> @ast::constr_arg { +fn parse_constr_arg(&ast::arg[] args, &parser p) -> @ast::constr_arg { auto sp = p.get_span(); auto carg = ast::carg_base; if (p.peek() == token::BINOP(token::STAR)) { @@ -347,7 +347,7 @@ fn parse_constr_arg(vec[ast::arg] args, &parser p) -> @ast::constr_arg { ret @rec(node=carg, span=sp); } -fn parse_ty_constr(&vec[ast::arg] fn_args, &parser p) -> @ast::constr { +fn parse_ty_constr(&ast::arg[] fn_args, &parser p) -> @ast::constr { auto lo = p.get_lo_pos(); auto path = parse_path(p); auto pf = bind parse_constr_arg(fn_args, _); @@ -364,7 +364,7 @@ fn parse_ty_constr(&vec[ast::arg] fn_args, &parser p) -> @ast::constr { // Use the args list to translate each bound variable // mentioned in a constraint to an arg index. // Seems weird to do this in the parser, but I'm not sure how else to. -fn parse_constrs(&vec[ast::arg] args, &parser p) +fn parse_constrs(&ast::arg[] args, &parser p) -> ast::spanned[(@ast::constr)[]] { auto lo = p.get_lo_pos(); auto hi = p.get_hi_pos(); @@ -383,7 +383,7 @@ fn parse_constrs(&vec[ast::arg] args, &parser p) fn parse_ty_constrs(@ast::ty t, &parser p) -> @ast::ty { if (p.peek() == token::COLON) { - auto constrs = parse_constrs([], p); + auto constrs = parse_constrs(~[], p); ret @spanned(t.span.lo, constrs.span.hi, ast::ty_constr(t, constrs.node)); } @@ -776,16 +776,16 @@ fn parse_bottom_expr(&parser p) -> @ast::expr { ret rec(mut=m, expr=e); } auto es = - parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), - parse_elt, p); + parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA), + parse_elt, p); hi = es.span.hi; ex = ast::expr_tup(es.node); } else if (p.peek() == token::LBRACKET) { p.bump(); auto mut = parse_mutability(p); auto es = - parse_seq_to_end(token::RBRACKET, some(token::COMMA), parse_expr, - p); + parse_seq_to_end_ivec(token::RBRACKET, some(token::COMMA), + parse_expr, p); ex = ast::expr_vec(es, mut, ast::sk_rc); } else if (p.peek() == token::TILDE) { p.bump(); @@ -795,8 +795,8 @@ fn parse_bottom_expr(&parser p) -> @ast::expr { p.bump(); auto mut = parse_mutability(p); auto es = - parse_seq_to_end(token::RBRACKET, some(token::COMMA), - parse_expr, p); + parse_seq_to_end_ivec(token::RBRACKET, some(token::COMMA), + parse_expr, p); ex = ast::expr_vec(es, mut, ast::sk_unique); } case (token::LIT_STR(?s)) { @@ -817,20 +817,22 @@ fn parse_bottom_expr(&parser p) -> @ast::expr { auto ty_params = parse_ty_params(p); // Only make people type () if they're actually adding new fields - let option::t[vec[ast::anon_obj_field]] fields = none; + let option::t[ast::anon_obj_field[]] fields = none; if (p.peek() == token::LPAREN) { p.bump(); fields = - some(parse_seq_to_end(token::RPAREN, some(token::COMMA), - parse_anon_obj_field, p)); + some(parse_seq_to_end_ivec(token::RPAREN, some(token::COMMA), + parse_anon_obj_field, p)); } - let vec[@ast::method] meths = []; + let (@ast::method)[] meths = ~[]; let option::t[@ast::expr] with_obj = none; expect(p, token::LBRACE); while (p.peek() != token::RBRACE) { if (eat_word(p, "with")) { with_obj = some(parse_expr(p)); - } else { vec::push(meths, parse_method(p)); } + } else { + meths += ~[parse_method(p)]; + } } hi = p.get_hi_pos(); expect(p, token::RBRACE); @@ -845,7 +847,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr { ex = ast::expr_anon_obj(ob, ty_params); } else if (eat_word(p, "rec")) { expect(p, token::LPAREN); - auto fields = [parse_field(p)]; + auto fields = ~[parse_field(p)]; auto more = true; auto base = none; while (more) { @@ -860,7 +862,7 @@ fn parse_bottom_expr(&parser p) -> @ast::expr { more = false; } else if (p.peek() == token::COMMA) { p.bump(); - fields += [parse_field(p)]; + fields += ~[parse_field(p)]; } else { unexpected(p, p.peek()); } } ex = ast::expr_rec(fields, base); @@ -873,8 +875,8 @@ fn parse_bottom_expr(&parser p) -> @ast::expr { } } auto es = - parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), - parse_expr_opt, p); + parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA), + parse_expr_opt, p); hi = es.span.hi; ex = ast::expr_bind(e, es.node); } else if (p.peek() == token::POUND) { @@ -969,8 +971,8 @@ fn parse_bottom_expr(&parser p) -> @ast::expr { let @ast::expr f = parse_self_method(p); auto es = - parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), - parse_expr, p); + parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA), + parse_expr, p); hi = es.span.hi; ex = ast::expr_call(f, es.node); } else if (is_ident(p.peek()) && !is_word(p, "true") && @@ -998,8 +1000,8 @@ fn parse_syntax_ext_naked(&parser p, uint lo) -> @ast::expr { if (ivec::len(pth.node.idents) == 0u) { p.fatal("expected a syntax expander name"); } - auto es = parse_seq(token::LPAREN, token::RPAREN, - some(token::COMMA), parse_expr, p); + auto es = parse_seq_ivec(token::LPAREN, token::RPAREN, + some(token::COMMA), parse_expr, p); auto hi = es.span.hi; auto ext_span = rec(lo=lo, hi=hi); auto ex = expand_syntax_ext(p, ext_span, pth, es.node, none); @@ -1013,7 +1015,7 @@ fn parse_syntax_ext_naked(&parser p, uint lo) -> @ast::expr { * loading rust crates to process extensions. */ fn expand_syntax_ext(&parser p, span sp, &ast::path path, - vec[@ast::expr] args, option::t[str] body) -> + &(@ast::expr)[] args, option::t[str] body) -> ast::expr_ { assert (ivec::len(path.node.idents) > 0u); auto extname = path.node.idents.(0); @@ -1030,7 +1032,7 @@ fn expand_syntax_ext(&parser p, span sp, &ast::path path, auto name_and_extension = ext(ext_cx, sp, args, body); p.get_syntax_expanders().insert(name_and_extension._0, name_and_extension._1); - ret ast::expr_tup(vec::empty[ast::elt]()); + ret ast::expr_tup(~[]); } } } @@ -1057,8 +1059,8 @@ fn parse_dot_or_call_expr_with(&parser p, @ast::expr e) -> @ast::expr { // Call expr. auto es = - parse_seq(token::LPAREN, token::RPAREN, - some(token::COMMA), parse_expr, p); + parse_seq_ivec(token::LPAREN, token::RPAREN, + some(token::COMMA), parse_expr, p); hi = es.span.hi; e = mk_expr(p, lo, hi, ast::expr_call(e, es.node)); } @@ -1349,7 +1351,7 @@ fn parse_alt_expr(&parser p) -> @ast::expr { auto lo = p.get_last_lo_pos(); auto discriminant = parse_expr(p); expect(p, token::LBRACE); - let vec[ast::arm] arms = []; + let ast::arm[] arms = ~[]; while (p.peek() != token::RBRACE) { // Optionally eat the case keyword. // FIXME remove this (and the optional parens) once we've updated our @@ -1360,7 +1362,7 @@ fn parse_alt_expr(&parser p) -> @ast::expr { auto pat = parse_pat(p); if (parens) { expect(p, token::RPAREN); } auto block = parse_block(p); - arms += [rec(pat=pat, block=block)]; + arms += ~[rec(pat=pat, block=block)]; } auto hi = p.get_hi_pos(); p.bump(); @@ -1374,8 +1376,8 @@ fn parse_spawn_expr(&parser p) -> @ast::expr { auto fn_expr = parse_bottom_expr(p); auto es = - parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), - parse_expr, p); + parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA), + parse_expr, p); auto hi = es.span.hi; ret mk_expr(p, lo, hi, ast::expr_spawn (ast::dom_implicit, option::none, fn_expr, es.node)); @@ -1449,17 +1451,17 @@ fn parse_pat(&parser p) -> @ast::pat { } else { auto tag_path = parse_path_and_ty_param_substs(p); hi = tag_path.span.hi; - let vec[@ast::pat] args; + let (@ast::pat)[] args; alt (p.peek()) { case (token::LPAREN) { auto f = parse_pat; auto a = - parse_seq(token::LPAREN, token::RPAREN, - some(token::COMMA), f, p); + parse_seq_ivec(token::LPAREN, token::RPAREN, + some(token::COMMA), f, p); args = a.node; hi = a.span.hi; } - case (_) { args = []; } + case (_) { args = ~[]; } } pat = ast::pat_tag(tag_path, args); } @@ -1645,7 +1647,7 @@ fn stmt_ends_with_semi(&ast::stmt stmt) -> bool { fn parse_block(&parser p) -> ast::block { auto lo = p.get_lo_pos(); - let vec[@ast::stmt] stmts = []; + let (@ast::stmt)[] stmts = ~[]; let option::t[@ast::expr] expr = none; expect(p, token::LBRACE); while (p.peek() != token::RBRACE) { @@ -1658,7 +1660,7 @@ fn parse_block(&parser p) -> ast::block { alt (stmt_to_expr(stmt)) { case (some(?e)) { alt (p.peek()) { - case (token::SEMI) { p.bump(); stmts += [stmt]; } + case (token::SEMI) { p.bump(); stmts += ~[stmt]; } case (token::RBRACE) { expr = some(e); } case (?t) { if (stmt_ends_with_semi(*stmt)) { @@ -1668,13 +1670,13 @@ fn parse_block(&parser p) -> ast::block { t)); fail; } - stmts += [stmt]; + stmts += ~[stmt]; } } } case (none) { // Not an expression statement. - stmts += [stmt]; + stmts += ~[stmt]; if (p.get_file_type() == SOURCE_FILE && stmt_ends_with_semi(*stmt)) { @@ -1693,20 +1695,20 @@ fn parse_block(&parser p) -> ast::block { fn parse_ty_param(&parser p) -> ast::ty_param { ret parse_ident(p); } -fn parse_ty_params(&parser p) -> vec[ast::ty_param] { - let vec[ast::ty_param] ty_params = []; +fn parse_ty_params(&parser p) -> ast::ty_param[] { + let ast::ty_param[] ty_params = ~[]; if (p.peek() == token::LBRACKET) { ty_params = - parse_seq(token::LBRACKET, token::RBRACKET, some(token::COMMA), - parse_ty_param, p).node; + parse_seq_ivec(token::LBRACKET, token::RBRACKET, + some(token::COMMA), parse_ty_param, p).node; } ret ty_params; } fn parse_fn_decl(&parser p, ast::purity purity) -> ast::fn_decl { - let ast::spanned[vec[ast::arg]] inputs = - parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), parse_arg, - p); + let ast::spanned[ast::arg[]] inputs = + parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA), + parse_arg, p); let ty_or_bang rslt; auto constrs = parse_constrs(inputs.node, p).node; if (p.peek() == token::RARROW) { @@ -1740,7 +1742,7 @@ fn parse_fn(&parser p, ast::proto proto, ast::purity purity) -> ast::_fn { ret rec(decl=decl, proto=proto, body=body); } -fn parse_fn_header(&parser p) -> tup(ast::ident, vec[ast::ty_param]) { +fn parse_fn_header(&parser p) -> tup(ast::ident, ast::ty_param[]) { auto id = parse_value_ident(p); auto ty_params = parse_ty_params(p); ret tup(id, ty_params); @@ -1791,7 +1793,7 @@ fn parse_method(&parser p) -> @ast::method { fn parse_dtor(&parser p) -> @ast::method { auto lo = p.get_last_lo_pos(); let ast::block b = parse_block(p); - let vec[ast::arg] inputs = []; + let ast::arg[] inputs = ~[]; let @ast::ty output = @spanned(lo, lo, ast::ty_nil); let ast::fn_decl d = rec(inputs=inputs, @@ -1812,16 +1814,16 @@ fn parse_item_obj(&parser p, ast::layer lyr, &ast::attribute[] attrs) -> auto lo = p.get_last_lo_pos(); auto ident = parse_value_ident(p); auto ty_params = parse_ty_params(p); - let ast::spanned[vec[ast::obj_field]] fields = - parse_seq[ast::obj_field](token::LPAREN, token::RPAREN, - some(token::COMMA), parse_obj_field, p); - let vec[@ast::method] meths = []; + let ast::spanned[ast::obj_field[]] fields = + parse_seq_ivec(token::LPAREN, token::RPAREN, some(token::COMMA), + parse_obj_field, p); + let (@ast::method)[] meths = ~[]; let option::t[@ast::method] dtor = none; expect(p, token::LBRACE); while (p.peek() != token::RBRACE) { if (eat_word(p, "drop")) { dtor = some(parse_dtor(p)); - } else { vec::push(meths, parse_method(p)); } + } else { meths += ~[parse_method(p)]; } } auto hi = p.get_hi_pos(); expect(p, token::RBRACE); @@ -1840,8 +1842,8 @@ fn parse_item_res(&parser p, ast::layer lyr, &ast::attribute[] attrs) -> auto arg_ident = parse_value_ident(p); expect(p, token::RPAREN); auto dtor = parse_block(p); - auto decl = rec(inputs=[rec(mode=ast::alias(false), ty=t, ident=arg_ident, - id=p.get_id())], + auto decl = rec(inputs=~[rec(mode=ast::alias(false), ty=t, + ident=arg_ident, id=p.get_id())], output=@spanned(lo, lo, ast::ty_nil), purity=ast::impure_fn, cf=ast::return, @@ -2015,7 +2017,7 @@ fn parse_item_tag(&parser p, &ast::attribute[] attrs) -> @ast::item { auto lo = p.get_last_lo_pos(); auto id = parse_ident(p); auto ty_params = parse_ty_params(p); - let vec[ast::variant] variants = []; + let ast::variant[] variants = ~[]; // Newtype syntax if (p.peek() == token::EQ) { if (p.get_bad_expr_words().contains_key(id)) { @@ -2029,7 +2031,7 @@ fn parse_item_tag(&parser p, &ast::attribute[] attrs) -> @ast::item { args=[rec(ty=ty, id=p.get_id())], id=p.get_id())); ret mk_item(p, lo, ty.span.hi, id, - ast::item_tag([variant], ty_params), attrs); + ast::item_tag(~[variant], ty_params), attrs); } expect(p, token::LBRACE); while (p.peek() != token::RBRACE) { @@ -2058,7 +2060,7 @@ fn parse_item_tag(&parser p, &ast::attribute[] attrs) -> @ast::item { rec(name=p.get_str(name), args=args, id=p.get_id()); - variants += [spanned(vlo, vhi, vr)]; + variants += ~[spanned(vlo, vhi, vr)]; } case (token::RBRACE) {/* empty */ } case (_) { diff --git a/src/comp/syntax/print/pprust.rs b/src/comp/syntax/print/pprust.rs index 6f63a600925f..82d198f307ad 100644 --- a/src/comp/syntax/print/pprust.rs +++ b/src/comp/syntax/print/pprust.rs @@ -103,7 +103,7 @@ fn item_to_str(&@ast::item i) -> str { be to_str(i, print_item); } fn path_to_str(&ast::path p) -> str { be to_str(p, print_path); } -fn fun_to_str(&ast::_fn f, str name, vec[ast::ty_param] params) -> str { +fn fun_to_str(&ast::_fn f, str name, &ast::ty_param[] params) -> str { auto writer = io::string_writer(); auto s = rust_printer(writer.get_writer()); print_fn(s, f.decl, f.proto, name, params); @@ -257,9 +257,9 @@ fn commasep_cmnt_ivec[IN](&ps s, breaks b, &IN[] elts, fn(&ps, &IN) op, end(s); } -fn commasep_exprs(&ps s, breaks b, vec[@ast::expr] exprs) { +fn commasep_exprs(&ps s, breaks b, &(@ast::expr)[] exprs) { fn expr_span(&@ast::expr expr) -> codemap::span { ret expr.span; } - commasep_cmnt(s, b, exprs, print_expr, expr_span); + commasep_cmnt_ivec(s, b, exprs, print_expr, expr_span); } fn print_mod(&ps s, ast::_mod _mod, &ast::attribute[] attrs) { @@ -463,7 +463,7 @@ fn print_item(&ps s, &@ast::item item) { break_offset(s.s, 0u, 0); } case (ast::item_tag(?variants, ?params)) { - auto newtype = vec::len(variants) == 1u && + auto newtype = ivec::len(variants) == 1u && str::eq(item.ident, variants.(0).node.name) && vec::len(variants.(0).node.args) == 1u; if (newtype) { @@ -515,12 +515,13 @@ fn print_item(&ps s, &@ast::item item) { end(s); } fn get_span(&ast::obj_field f) -> codemap::span { ret f.ty.span; } - commasep_cmnt(s, consistent, _obj.fields, print_field, get_span); + commasep_cmnt_ivec(s, consistent, _obj.fields, print_field, + get_span); pclose(s); space(s.s); bopen(s); for (@ast::method meth in _obj.methods) { - let vec[ast::ty_param] typarams = []; + let ast::ty_param[] typarams = ~[]; hardbreak_if_not_bol(s); maybe_print_comment(s, meth.span.lo); print_fn(s, meth.node.meth.decl, meth.node.meth.proto, @@ -687,7 +688,7 @@ fn print_expr(&ps s, &@ast::expr expr) { fn get_span(&ast::elt elt) -> codemap::span { ret elt.expr.span; } word(s.s, "tup"); popen(s); - commasep_cmnt(s, inconsistent, exprs, printElt, get_span); + commasep_cmnt_ivec(s, inconsistent, exprs, printElt, get_span); pclose(s); } case (ast::expr_rec(?fields, ?wth)) { @@ -704,10 +705,10 @@ fn print_expr(&ps s, &@ast::expr expr) { } word(s.s, "rec"); popen(s); - commasep_cmnt(s, consistent, fields, print_field, get_span); + commasep_cmnt_ivec(s, consistent, fields, print_field, get_span); alt (wth) { case (some(?expr)) { - if (vec::len(fields) > 0u) { space(s.s); } + if (ivec::len(fields) > 0u) { space(s.s); } ibox(s, indent_unit); word_space(s, "with"); print_expr(s, expr); @@ -737,7 +738,7 @@ fn print_expr(&ps s, &@ast::expr expr) { word_nbsp(s, "bind"); print_expr(s, func); popen(s); - commasep(s, inconsistent, args, print_opt); + commasep_ivec(s, inconsistent, args, print_opt); pclose(s); } case (ast::expr_spawn(_, _, ?e, ?es)) { @@ -959,7 +960,7 @@ fn print_expr(&ps s, &@ast::expr expr) { case (ast::expr_ext(?path, ?args, ?body, _)) { word(s.s, "#"); print_path(s, path); - if (vec::len(args) > 0u) { + if (ivec::len(args) > 0u) { popen(s); commasep_exprs(s, inconsistent, args); pclose(s); @@ -1062,9 +1063,9 @@ fn print_pat(&ps s, &@ast::pat pat) { case (ast::pat_lit(?lit)) { print_literal(s, lit); } case (ast::pat_tag(?path, ?args)) { print_path(s, path); - if (vec::len(args) > 0u) { + if (ivec::len(args) > 0u) { popen(s); - commasep(s, inconsistent, args, print_pat); + commasep_ivec(s, inconsistent, args, print_pat); pclose(s); } } @@ -1073,7 +1074,7 @@ fn print_pat(&ps s, &@ast::pat pat) { } fn print_fn(&ps s, ast::fn_decl decl, ast::proto proto, str name, - vec[ast::ty_param] typarams) { + &ast::ty_param[] typarams) { alt (decl.purity) { case (ast::impure_fn) { if (proto == ast::proto_iter) { @@ -1097,7 +1098,7 @@ fn print_fn_args_and_ret(&ps s, &ast::fn_decl decl) { word(s.s, x.ident); end(s); } - commasep(s, inconsistent, decl.inputs, print_arg); + commasep_ivec(s, inconsistent, decl.inputs, print_arg); pclose(s); maybe_print_comment(s, decl.output.span.lo); if (decl.output.node != ast::ty_nil) { @@ -1115,11 +1116,11 @@ fn print_alias(&ps s, ast::mode m) { } } -fn print_type_params(&ps s, &vec[ast::ty_param] params) { - if (vec::len(params) > 0u) { +fn print_type_params(&ps s, &ast::ty_param[] params) { + if (ivec::len(params) > 0u) { word(s.s, "["); fn printParam(&ps s, &ast::ty_param param) { word(s.s, param); } - commasep(s, inconsistent, params, printParam); + commasep_ivec(s, inconsistent, params, printParam); word(s.s, "]"); } } diff --git a/src/comp/syntax/visit.rs b/src/comp/syntax/visit.rs index 96dccf28b129..076a81b4260a 100644 --- a/src/comp/syntax/visit.rs +++ b/src/comp/syntax/visit.rs @@ -33,7 +33,7 @@ type visitor[E] = fn(&@expr, &E, &vt[E]) visit_expr, fn(&@ty, &E, &vt[E]) visit_ty, fn(&@constr, &E, &vt[E]) visit_constr, - fn(&_fn, &vec[ty_param], &span, &fn_ident, node_id, &E, &vt[E]) + fn(&_fn, &ty_param[], &span, &fn_ident, node_id, &E, &vt[E]) visit_fn); fn default_visitor[E]() -> visitor[E] { @@ -121,13 +121,13 @@ fn visit_item[E](&@item i, &E e, &vt[E] v) { case (item_obj(?ob, _, _)) { for (obj_field f in ob.fields) { vt(v).visit_ty(f.ty, e, v); } for (@method m in ob.methods) { - vt(v).visit_fn(m.node.meth, [], m.span, some(m.node.ident), + vt(v).visit_fn(m.node.meth, ~[], m.span, some(m.node.ident), m.node.id, e, v); } alt (ob.dtor) { case (none) { } case (some(?m)) { - vt(v).visit_fn(m.node.meth, [], m.span, + vt(v).visit_fn(m.node.meth, ~[], m.span, some(m.node.ident), m.node.id, e, v); } @@ -210,7 +210,7 @@ fn visit_fn_decl[E](&fn_decl fd, &E e, &vt[E] v) { vt(v).visit_ty(fd.output, e, v); } -fn visit_fn[E](&_fn f, &vec[ty_param] tp, &span sp, &fn_ident i, +fn visit_fn[E](&_fn f, &ty_param[] tp, &span sp, &fn_ident i, node_id id, &E e, &vt[E] v) { visit_fn_decl(f.decl, e, v); vt(v).visit_block(f.body, e, v); @@ -245,7 +245,7 @@ fn visit_expr_opt[E](option::t[@expr] eo, &E e, &vt[E] v) { } } -fn visit_exprs[E](vec[@expr] exprs, &E e, &vt[E] v) { +fn visit_exprs[E](&(@expr)[] exprs, &E e, &vt[E] v) { for (@expr ex in exprs) { vt(v).visit_expr(ex, e, v); } } @@ -320,7 +320,7 @@ fn visit_expr[E](&@expr ex, &E e, &vt[E] v) { for (arm a in arms) { vt(v).visit_arm(a, e, v); } } case (expr_fn(?f)) { - vt(v).visit_fn(f, [], ex.span, none, ex.id, e, v); + vt(v).visit_fn(f, ~[], ex.span, none, ex.id, e, v); } case (expr_block(?b)) { vt(v).visit_block(b, e, v); } case (expr_assign(?a, ?b)) { @@ -386,7 +386,7 @@ fn visit_expr[E](&@expr ex, &E e, &vt[E] v) { case (some(?ex)) { vt(v).visit_expr(ex, e, v); } } for (@method m in anon_obj.methods) { - vt(v).visit_fn(m.node.meth, [], m.span, some(m.node.ident), + vt(v).visit_fn(m.node.meth, ~[], m.span, some(m.node.ident), m.node.id, e, v); } } diff --git a/src/comp/syntax/walk.rs b/src/comp/syntax/walk.rs index 2b74f81f9b31..59d7d75a7de7 100644 --- a/src/comp/syntax/walk.rs +++ b/src/comp/syntax/walk.rs @@ -39,9 +39,9 @@ type ast_visitor = fn(&@ast::ty) visit_ty_pre, fn(&@ast::ty) visit_ty_post, fn(&@ast::constr) visit_constr, - fn(&ast::_fn, &vec[ast::ty_param], &span, &ast::fn_ident, + fn(&ast::_fn, &ast::ty_param[], &span, &ast::fn_ident, ast::node_id) visit_fn_pre, - fn(&ast::_fn, &vec[ast::ty_param], &span, &ast::fn_ident, + fn(&ast::_fn, &ast::ty_param[], &span, &ast::fn_ident, ast::node_id) visit_fn_post); fn walk_crate(&ast_visitor v, &ast::crate c) { @@ -117,14 +117,14 @@ fn walk_item(&ast_visitor v, @ast::item i) { for (@ast::method m in ob.methods) { v.visit_method_pre(m); // Methods don't have ty params? - walk_fn(v, m.node.meth, [], m.span, + walk_fn(v, m.node.meth, ~[], m.span, some(m.node.ident), m.node.id); v.visit_method_post(m); } alt (ob.dtor) { case (none) { } case (some(?m)) { - walk_fn(v, m.node.meth, [], m.span, + walk_fn(v, m.node.meth, ~[], m.span, some(m.node.ident), m.node.id); } } @@ -218,7 +218,7 @@ fn walk_fn_decl(&ast_visitor v, &ast::fn_decl fd) { walk_ty(v, fd.output); } -fn walk_fn(&ast_visitor v, &ast::_fn f, &vec[ast::ty_param] tps, +fn walk_fn(&ast_visitor v, &ast::_fn f, &ast::ty_param[] tps, &span sp, &ast::fn_ident i, ast::node_id d) { if (!v.keep_going()) { ret; } v.visit_fn_pre(f, tps, sp, i, d); @@ -262,7 +262,7 @@ fn walk_expr_opt(&ast_visitor v, option::t[@ast::expr] eo) { alt (eo) { case (none) { } case (some(?e)) { walk_expr(v, e); } } } -fn walk_exprs(&ast_visitor v, vec[@ast::expr] exprs) { +fn walk_exprs(&ast_visitor v, &(@ast::expr)[] exprs) { for (@ast::expr e in exprs) { walk_expr(v, e); } } @@ -341,7 +341,7 @@ fn walk_expr(&ast_visitor v, @ast::expr e) { } } case (ast::expr_fn(?f)) { - walk_fn(v, f, [], e.span, none, e.id); + walk_fn(v, f, ~[], e.span, none, e.id); } case (ast::expr_block(?b)) { walk_block(v, b); } case (ast::expr_assign(?a, ?b)) { @@ -402,7 +402,7 @@ fn walk_expr(&ast_visitor v, @ast::expr e) { // Methods for (@ast::method m in anon_obj.methods) { v.visit_method_pre(m); - walk_fn(v, m.node.meth, [], m.span, some(m.node.ident), + walk_fn(v, m.node.meth, ~[], m.span, some(m.node.ident), m.node.id); v.visit_method_post(m); } @@ -445,7 +445,7 @@ fn def_visit_ty(&@ast::ty t) { } fn def_visit_constr(&@ast::constr c) { } -fn def_visit_fn(&ast::_fn f, &vec[ast::ty_param] tps, +fn def_visit_fn(&ast::_fn f, &ast::ty_param[] tps, &span sp, &ast::fn_ident i, ast::node_id d) { } fn default_visitor() -> ast_visitor { diff --git a/src/comp/util/common.rs b/src/comp/util/common.rs index cf50c2fbc733..04243a204c96 100644 --- a/src/comp/util/common.rs +++ b/src/comp/util/common.rs @@ -50,16 +50,18 @@ fn new_def_hash[V]() -> std::map::hashmap[ast::def_id, V] { fn elt_expr(&ast::elt e) -> @ast::expr { ret e.expr; } -fn elt_exprs(&vec[ast::elt] elts) -> vec[@ast::expr] { - auto f = elt_expr; - ret vec::map[ast::elt, @ast::expr](f, elts); +fn elt_exprs(&ast::elt[] elts) -> (@ast::expr)[] { + auto es = ~[]; + for (ast::elt e in elts) { es += ~[e.expr]; } + ret es; } fn field_expr(&ast::field f) -> @ast::expr { ret f.node.expr; } -fn field_exprs(vec[ast::field] fields) -> vec[@ast::expr] { - auto f = field_expr; - ret vec::map[ast::field, @ast::expr](f, fields); +fn field_exprs(&ast::field[] fields) -> (@ast::expr)[] { + auto es = ~[]; + for (ast::field f in fields) { es += ~[f.node.expr]; } + ret es; } fn log_expr(&ast::expr e) { log print::pprust::expr_to_str(@e); } @@ -76,11 +78,11 @@ fn log_block_err(&ast::block b) { log_err print::pprust::block_to_str(b); } fn log_item_err(&@ast::item i) { log_err print::pprust::item_to_str(i); } -fn log_fn(&ast::_fn f, str name, vec[ast::ty_param] params) { +fn log_fn(&ast::_fn f, str name, &ast::ty_param[] params) { log print::pprust::fun_to_str(f, name, params); } -fn log_fn_err(&ast::_fn f, str name, vec[ast::ty_param] params) { +fn log_fn_err(&ast::_fn f, str name, &ast::ty_param[] params) { log_err print::pprust::fun_to_str(f, name, params); }