From 4539f8a03cfa85fae97140687bc8ed2e48d91a65 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Mon, 9 May 2011 17:49:19 -0700 Subject: [PATCH] Alias-ify fold and its users, remove another 85kb. --- src/comp/front/creader.rs | 7 +- src/comp/middle/fold.rs | 576 +++++++++++++++-------------- src/comp/middle/resolve.rs | 30 +- src/comp/middle/typeck.rs | 77 ++-- src/comp/middle/typestate_check.rs | 39 +- src/comp/util/common.rs | 6 +- 6 files changed, 378 insertions(+), 357 deletions(-) diff --git a/src/comp/front/creader.rs b/src/comp/front/creader.rs index 75d837132b5..832ef13182f 100644 --- a/src/comp/front/creader.rs +++ b/src/comp/front/creader.rs @@ -441,9 +441,10 @@ fn load_crate(session.session sess, fail; } -fn fold_view_item_use(&env e, &span sp, ast.ident ident, - vec[@ast.meta_item] meta_items, ast.def_id id, Option.t[int] cnum_opt) - -> @ast.view_item { +fn fold_view_item_use(&env e, &span sp, &ast.ident ident, + &vec[@ast.meta_item] meta_items, + &ast.def_id id, &Option.t[int] cnum_opt) + -> @ast.view_item { auto cnum; if (!e.crate_cache.contains_key(ident)) { cnum = e.next_crate_num; diff --git a/src/comp/middle/fold.rs b/src/comp/middle/fold.rs index ace45c2f9a5..3afa9ef676d 100644 --- a/src/comp/middle/fold.rs +++ b/src/comp/middle/fold.rs @@ -39,7 +39,7 @@ type ast_fold[ENV] = @rec ( // Path fold. - (fn(&ENV e, &span sp, ast.path_ p) -> path) fold_path, + (fn(&ENV e, &span sp, &ast.path_ p) -> path) fold_path, // Type folds. (fn(&ENV e, &span sp) -> @ty) fold_ty_nil, @@ -53,246 +53,252 @@ type ast_fold[ENV] = (fn(&ENV e, &span sp, &mt tm) -> @ty) fold_ty_box, (fn(&ENV e, &span sp, &mt tm) -> @ty) fold_ty_vec, - (fn(&ENV e, &span sp, vec[mt] elts) -> @ty) fold_ty_tup, + (fn(&ENV e, &span sp, &vec[mt] elts) -> @ty) fold_ty_tup, (fn(&ENV e, &span sp, - vec[ast.ty_field] elts) -> @ty) fold_ty_rec, + &vec[ast.ty_field] elts) -> @ty) fold_ty_rec, (fn(&ENV e, &span sp, - vec[ast.ty_method] meths) -> @ty) fold_ty_obj, + &vec[ast.ty_method] meths) -> @ty) fold_ty_obj, (fn(&ENV e, &span sp, ast.proto proto, - vec[rec(ast.mode mode, @ty ty)] inputs, - @ty output) -> @ty) fold_ty_fn, + &vec[rec(ast.mode mode, @ty ty)] inputs, + &@ty output) -> @ty) fold_ty_fn, - (fn(&ENV e, &span sp, ast.path p, + (fn(&ENV e, &span sp, &ast.path p, &Option.t[def] d) -> @ty) fold_ty_path, - (fn(&ENV e, &span sp, @ty t) -> @ty) fold_ty_chan, - (fn(&ENV e, &span sp, @ty t) -> @ty) fold_ty_port, + (fn(&ENV e, &span sp, &@ty t) -> @ty) fold_ty_chan, + (fn(&ENV e, &span sp, &@ty t) -> @ty) fold_ty_port, // Expr folds. (fn(&ENV e, &span sp, - vec[@expr] es, ast.mutability mut, - ann a) -> @expr) fold_expr_vec, + &vec[@expr] es, ast.mutability mut, + &ann a) -> @expr) fold_expr_vec, (fn(&ENV e, &span sp, - vec[ast.elt] es, ann a) -> @expr) fold_expr_tup, + &vec[ast.elt] es, &ann a) -> @expr) fold_expr_tup, (fn(&ENV e, &span sp, - vec[ast.field] fields, - Option.t[@expr] base, ann a) -> @expr) fold_expr_rec, + &vec[ast.field] fields, + &Option.t[@expr] base, &ann a) -> @expr) fold_expr_rec, (fn(&ENV e, &span sp, - @expr f, vec[@expr] args, - ann a) -> @expr) fold_expr_call, + &@expr f, &vec[@expr] args, + &ann a) -> @expr) fold_expr_call, (fn(&ENV e, &span sp, - ident id, ann a) -> @expr) fold_expr_self_method, + &ident id, &ann a) -> @expr) fold_expr_self_method, (fn(&ENV e, &span sp, - @expr f, vec[Option.t[@expr]] args, - ann a) -> @expr) fold_expr_bind, + &@expr f, &vec[Option.t[@expr]] args, + &ann a) -> @expr) fold_expr_bind, (fn(&ENV e, &span sp, - ast.spawn_dom dom, Option.t[str] name, - @expr f, vec[@expr] args, - ann a) -> @expr) fold_expr_spawn, + ast.spawn_dom dom, &Option.t[str] name, + &@expr f, &vec[@expr] args, + &ann a) -> @expr) fold_expr_spawn, (fn(&ENV e, &span sp, ast.binop, - @expr lhs, @expr rhs, - ann a) -> @expr) fold_expr_binary, + &@expr lhs, &@expr rhs, + &ann a) -> @expr) fold_expr_binary, (fn(&ENV e, &span sp, - ast.unop, @expr e, - ann a) -> @expr) fold_expr_unary, + ast.unop, &@expr e, + &ann a) -> @expr) fold_expr_unary, (fn(&ENV e, &span sp, - @ast.lit, ann a) -> @expr) fold_expr_lit, + &@ast.lit, &ann a) -> @expr) fold_expr_lit, (fn(&ENV e, &span sp, - @ast.expr e, @ast.ty ty, - ann a) -> @expr) fold_expr_cast, + &@ast.expr e, &@ast.ty ty, + &ann a) -> @expr) fold_expr_cast, (fn(&ENV e, &span sp, - @expr cond, &block thn, + &@expr cond, &block thn, &Option.t[@expr] els, - ann a) -> @expr) fold_expr_if, + &ann a) -> @expr) fold_expr_if, (fn(&ENV e, &span sp, - @decl decl, @expr seq, &block body, - ann a) -> @expr) fold_expr_for, + &@decl decl, &@expr seq, &block body, + &ann a) -> @expr) fold_expr_for, (fn(&ENV e, &span sp, - @decl decl, @expr seq, &block body, - ann a) -> @expr) fold_expr_for_each, + &@decl decl, &@expr seq, &block body, + &ann a) -> @expr) fold_expr_for_each, (fn(&ENV e, &span sp, - @expr cond, &block body, - ann a) -> @expr) fold_expr_while, + &@expr cond, &block body, + &ann a) -> @expr) fold_expr_while, (fn(&ENV e, &span sp, - &block body, @expr cond, - ann a) -> @expr) fold_expr_do_while, + &block body, &@expr cond, + &ann a) -> @expr) fold_expr_do_while, (fn(&ENV e, &span sp, - @expr e, vec[arm] arms, - ann a) -> @expr) fold_expr_alt, + &@expr e, &vec[arm] arms, + &ann a) -> @expr) fold_expr_alt, (fn(&ENV e, &span sp, - &block blk, ann a) -> @expr) fold_expr_block, + &block blk, &ann a) -> @expr) fold_expr_block, (fn(&ENV e, &span sp, - @expr lhs, @expr rhs, - ann a) -> @expr) fold_expr_assign, + &@expr lhs, &@expr rhs, + &ann a) -> @expr) fold_expr_assign, (fn(&ENV e, &span sp, ast.binop, - @expr lhs, @expr rhs, - ann a) -> @expr) fold_expr_assign_op, + &@expr lhs, &@expr rhs, + &ann a) -> @expr) fold_expr_assign_op, (fn(&ENV e, &span sp, - @expr lhs, @expr rhs, ann a) -> @expr) fold_expr_send, + &@expr lhs, &@expr rhs, + &ann a) -> @expr) fold_expr_send, (fn(&ENV e, &span sp, - @expr lhs, @expr rhs, ann a) -> @expr) fold_expr_recv, + &@expr lhs, &@expr rhs, + &ann a) -> @expr) fold_expr_recv, (fn(&ENV e, &span sp, - @expr e, ident i, - ann a) -> @expr) fold_expr_field, + &@expr e, &ident i, + &ann a) -> @expr) fold_expr_field, (fn(&ENV e, &span sp, - @expr e, @expr ix, - ann a) -> @expr) fold_expr_index, + &@expr e, &@expr ix, + &ann a) -> @expr) fold_expr_index, (fn(&ENV e, &span sp, &path p, &Option.t[def] d, - ann a) -> @expr) fold_expr_path, + &ann a) -> @expr) fold_expr_path, (fn(&ENV e, &span sp, - &path p, vec[@expr] args, - Option.t[str] body, - @expr expanded, - ann a) -> @expr) fold_expr_ext, + &path p, &vec[@expr] args, + &Option.t[str] body, + &@expr expanded, + &ann a) -> @expr) fold_expr_ext, - (fn(&ENV e, &span sp, ann a) -> @expr) fold_expr_fail, + (fn(&ENV e, &span sp, &ann a) -> @expr) fold_expr_fail, - (fn(&ENV e, &span sp, ann a) -> @expr) fold_expr_break, + (fn(&ENV e, &span sp, &ann a) -> @expr) fold_expr_break, - (fn(&ENV e, &span sp, ann a) -> @expr) fold_expr_cont, + (fn(&ENV e, &span sp, &ann a) -> @expr) fold_expr_cont, (fn(&ENV e, &span sp, - &Option.t[@expr] rv, ann a) -> @expr) fold_expr_ret, + &Option.t[@expr] rv, &ann a) -> @expr) fold_expr_ret, (fn(&ENV e, &span sp, - &Option.t[@expr] rv, ann a) -> @expr) fold_expr_put, + &Option.t[@expr] rv, &ann a) -> @expr) fold_expr_put, (fn(&ENV e, &span sp, - @expr e, ann a) -> @expr) fold_expr_be, + &@expr e, &ann a) -> @expr) fold_expr_be, (fn(&ENV e, &span sp, int lvl, - @expr e, ann a) -> @expr) fold_expr_log, + &@expr e, &ann a) -> @expr) fold_expr_log, (fn(&ENV e, &span sp, - @expr e, ann a) -> @expr) fold_expr_check, + &@expr e, &ann a) -> @expr) fold_expr_check, (fn(&ENV e, &span sp, - @expr e, ann a) -> @expr) fold_expr_assert, + &@expr e, &ann a) -> @expr) fold_expr_assert, (fn(&ENV e, &span sp, - ann a) -> @expr) fold_expr_port, + &ann a) -> @expr) fold_expr_port, (fn(&ENV e, &span sp, - @expr e, ann a) -> @expr) fold_expr_chan, + &@expr e, &ann a) -> @expr) fold_expr_chan, // Decl folds. (fn(&ENV e, &span sp, - @ast.local local) -> @decl) fold_decl_local, + &@ast.local local) -> @decl) fold_decl_local, (fn(&ENV e, &span sp, - @item item) -> @decl) fold_decl_item, + &@item item) -> @decl) fold_decl_item, // Pat folds. (fn(&ENV e, &span sp, - ann a) -> @pat) fold_pat_wild, + &ann a) -> @pat) fold_pat_wild, (fn(&ENV e, &span sp, - @ast.lit lit, ann a) -> @pat) fold_pat_lit, + &@ast.lit lit, &ann a) -> @pat) fold_pat_lit, (fn(&ENV e, &span sp, - ident i, def_id did, ann a) -> @pat) fold_pat_bind, + &ident i, &def_id did, &ann a) -> @pat) fold_pat_bind, (fn(&ENV e, &span sp, - path p, vec[@pat] args, - Option.t[ast.variant_def] d, - ann a) -> @pat) fold_pat_tag, + &path p, &vec[@pat] args, + &Option.t[ast.variant_def] d, + &ann a) -> @pat) fold_pat_tag, // Stmt folds. (fn(&ENV e, &span sp, - @decl decl, ann a) + &@decl decl, &ann a) -> @stmt) fold_stmt_decl, (fn(&ENV e, &span sp, - @expr e, ann a) + &@expr e, &ann a) -> @stmt) fold_stmt_expr, // Item folds. - (fn(&ENV e, &span sp, ident ident, - @ty t, @expr e, - def_id id, ann a) -> @item) fold_item_const, + (fn(&ENV e, &span sp, &ident ident, + &@ty t, &@expr e, + &def_id id, &ann a) -> @item) fold_item_const, - (fn(&ENV e, &span sp, ident ident, + (fn(&ENV e, &span sp, &ident ident, &ast._fn f, - vec[ast.ty_param] ty_params, - def_id id, ann a) -> @item) fold_item_fn, + &vec[ast.ty_param] ty_params, + &def_id id, &ann a) -> @item) fold_item_fn, - (fn(&ENV e, &span sp, ident ident, - Option.t[str] link_name, + (fn(&ENV e, &span sp, &ident ident, + &Option.t[str] link_name, &ast.fn_decl decl, - vec[ast.ty_param] ty_params, - def_id id, ann a) -> @native_item) fold_native_item_fn, + &vec[ast.ty_param] ty_params, + &def_id id, &ann a) -> @native_item) fold_native_item_fn, - (fn(&ENV e, &span sp, ident ident, - &ast._mod m, def_id id) -> @item) fold_item_mod, + (fn(&ENV e, &span sp, &ident ident, + &ast._mod m, &def_id id) -> @item) fold_item_mod, - (fn(&ENV e, &span sp, ident ident, - &ast.native_mod m, def_id id) -> @item) fold_item_native_mod, + (fn(&ENV e, &span sp, &ident ident, + &ast.native_mod m, &def_id id) -> @item) fold_item_native_mod, - (fn(&ENV e, &span sp, ident ident, - @ty t, vec[ast.ty_param] ty_params, - def_id id, ann a) -> @item) fold_item_ty, + (fn(&ENV e, &span sp, &ident ident, + &@ty t, &vec[ast.ty_param] ty_params, + &def_id id, &ann a) -> @item) fold_item_ty, - (fn(&ENV e, &span sp, ident ident, - def_id id) -> @native_item) fold_native_item_ty, + (fn(&ENV e, &span sp, &ident ident, + &def_id id) -> @native_item) fold_native_item_ty, - (fn(&ENV e, &span sp, ident ident, - vec[ast.variant] variants, - vec[ast.ty_param] ty_params, - def_id id, ann a) -> @item) fold_item_tag, + (fn(&ENV e, &span sp, &ident ident, + &vec[ast.variant] variants, + &vec[ast.ty_param] ty_params, + &def_id id, &ann a) -> @item) fold_item_tag, - (fn(&ENV e, &span sp, ident ident, + (fn(&ENV e, &span sp, &ident ident, &ast._obj ob, - vec[ast.ty_param] ty_params, - ast.obj_def_ids odid, ann a) -> @item) fold_item_obj, + &vec[ast.ty_param] ty_params, + &ast.obj_def_ids odid, &ann a) -> @item) fold_item_obj, // View Item folds. - (fn(&ENV e, &span sp, ident ident, - vec[@meta_item] meta_items, - def_id id, Option.t[int]) -> @view_item) fold_view_item_use, + (fn(&ENV e, &span sp, &ident ident, + &vec[@meta_item] meta_items, + &def_id id, + &Option.t[int]) -> @view_item) fold_view_item_use, - (fn(&ENV e, &span sp, ident i, vec[ident] idents, - def_id id, Option.t[def]) -> @view_item) fold_view_item_import, + (fn(&ENV e, &span sp, &ident i, + &vec[ident] idents, + &def_id id, + &Option.t[def]) -> @view_item) fold_view_item_import, - (fn(&ENV e, &span sp, ident i) -> @view_item) fold_view_item_export, + (fn(&ENV e, &span sp, + &ident i) -> @view_item) fold_view_item_export, // Annotation folds. - (fn(&ENV e, ann a) -> ann) fold_ann, + (fn(&ENV e, &ann a) -> ann) fold_ann, // Additional nodes. @@ -301,35 +307,36 @@ type ast_fold[ENV] = &block body) -> ast._fn) fold_fn, (fn(&ENV e, - vec[arg] inputs, - @ty output, - purity p) -> ast.fn_decl) fold_fn_decl, + &vec[arg] inputs, + &@ty output, + &purity p) -> ast.fn_decl) fold_fn_decl, (fn(&ENV e, &ast._mod m) -> ast._mod) fold_mod, (fn(&ENV e, &ast.native_mod m) -> ast.native_mod) fold_native_mod, (fn(&ENV e, &span sp, - vec[@ast.crate_directive] cdirs, + &vec[@ast.crate_directive] cdirs, &ast._mod m) -> @ast.crate) fold_crate, (fn(&ENV e, - vec[ast.obj_field] fields, - vec[@ast.method] methods, - Option.t[@ast.method] dtor) -> ast._obj) fold_obj, + &vec[ast.obj_field] fields, + &vec[@ast.method] methods, + &Option.t[@ast.method] dtor) + -> ast._obj) fold_obj, // Env updates. - (fn(&ENV e, @ast.crate c) -> ENV) update_env_for_crate, - (fn(&ENV e, @item i) -> ENV) update_env_for_item, - (fn(&ENV e, @native_item i) -> ENV) update_env_for_native_item, - (fn(&ENV e, @view_item i) -> ENV) update_env_for_view_item, + (fn(&ENV e, &@ast.crate c) -> ENV) update_env_for_crate, + (fn(&ENV e, &@item i) -> ENV) update_env_for_item, + (fn(&ENV e, &@native_item i) -> ENV) update_env_for_native_item, + (fn(&ENV e, &@view_item i) -> ENV) update_env_for_view_item, (fn(&ENV e, &block b) -> ENV) update_env_for_block, - (fn(&ENV e, @stmt s) -> ENV) update_env_for_stmt, - (fn(&ENV e, @decl i) -> ENV) update_env_for_decl, - (fn(&ENV e, @pat p) -> ENV) update_env_for_pat, + (fn(&ENV e, &@stmt s) -> ENV) update_env_for_stmt, + (fn(&ENV e, &@decl i) -> ENV) update_env_for_decl, + (fn(&ENV e, &@pat p) -> ENV) update_env_for_pat, (fn(&ENV e, &arm a) -> ENV) update_env_for_arm, - (fn(&ENV e, @expr x) -> ENV) update_env_for_expr, - (fn(&ENV e, @ty t) -> ENV) update_env_for_ty, + (fn(&ENV e, &@expr x) -> ENV) update_env_for_expr, + (fn(&ENV e, &@ty t) -> ENV) update_env_for_ty, // Traversal control. (fn(&ENV v) -> bool) keep_going @@ -338,7 +345,7 @@ type ast_fold[ENV] = //// Fold drivers. -fn fold_path[ENV](&ENV env, ast_fold[ENV] fld, &path p) -> path { +fn fold_path[ENV](&ENV env, &ast_fold[ENV] fld, &path p) -> path { let vec[@ast.ty] tys_ = vec(); for (@ast.ty t in p.node.types) { Vec.push[@ast.ty](tys_, fold_ty(env, fld, t)); @@ -347,7 +354,7 @@ fn fold_path[ENV](&ENV env, ast_fold[ENV] fld, &path p) -> path { ret fld.fold_path(env, p.span, p_); } -fn fold_ty[ENV](&ENV env, ast_fold[ENV] fld, @ty t) -> @ty { +fn fold_ty[ENV](&ENV env, &ast_fold[ENV] fld, &@ty t) -> @ty { let ENV env_ = fld.update_env_for_ty(env, t); if (!fld.keep_going(env_)) { @@ -434,10 +441,10 @@ fn fold_ty[ENV](&ENV env, ast_fold[ENV] fld, @ty t) -> @ty { } } -fn fold_ty_fn[ENV](&ENV env, ast_fold[ENV] fld, &span sp, +fn fold_ty_fn[ENV](&ENV env, &ast_fold[ENV] fld, &span sp, ast.proto proto, - vec[rec(ast.mode mode, @ty ty)] inputs, - @ty output) -> @ty { + &vec[rec(ast.mode mode, @ty ty)] inputs, + &@ty output) -> @ty { auto output_ = fold_ty(env, fld, output); let vec[rec(ast.mode mode, @ty ty)] inputs_ = vec(); for (rec(ast.mode mode, @ty ty) input in inputs) { @@ -448,7 +455,7 @@ fn fold_ty_fn[ENV](&ENV env, ast_fold[ENV] fld, &span sp, ret fld.fold_ty_fn(env, sp, proto, inputs_, output_); } -fn fold_decl[ENV](&ENV env, ast_fold[ENV] fld, @decl d) -> @decl { +fn fold_decl[ENV](&ENV env, &ast_fold[ENV] fld, &@decl d) -> @decl { let ENV env_ = fld.update_env_for_decl(env, d); if (!fld.keep_going(env_)) { @@ -487,7 +494,7 @@ fn fold_decl[ENV](&ENV env, ast_fold[ENV] fld, @decl d) -> @decl { fail; } -fn fold_pat[ENV](&ENV env, ast_fold[ENV] fld, @ast.pat p) -> @ast.pat { +fn fold_pat[ENV](&ENV env, &ast_fold[ENV] fld, &@ast.pat p) -> @ast.pat { let ENV env_ = fld.update_env_for_pat(env, p); if (!fld.keep_going(env_)) { @@ -515,7 +522,8 @@ fn fold_pat[ENV](&ENV env, ast_fold[ENV] fld, @ast.pat p) -> @ast.pat { } } -fn fold_exprs[ENV](&ENV env, ast_fold[ENV] fld, vec[@expr] es) -> vec[@expr] { +fn fold_exprs[ENV](&ENV env, &ast_fold[ENV] fld, + &vec[@expr] es) -> vec[@expr] { let vec[@expr] exprs = vec(); for (@expr e in es) { Vec.push[@expr](exprs, fold_expr(env, fld, e)); @@ -523,16 +531,16 @@ fn fold_exprs[ENV](&ENV env, ast_fold[ENV] fld, vec[@expr] es) -> vec[@expr] { ret exprs; } -fn fold_tup_elt[ENV](&ENV env, ast_fold[ENV] fld, &ast.elt e) -> ast.elt { +fn fold_tup_elt[ENV](&ENV env, &ast_fold[ENV] fld, &ast.elt e) -> ast.elt { ret rec(expr=fold_expr(env, fld, e.expr) with e); } -fn fold_rec_field[ENV](&ENV env, ast_fold[ENV] fld, &ast.field f) +fn fold_rec_field[ENV](&ENV env, &ast_fold[ENV] fld, &ast.field f) -> ast.field { ret rec(expr=fold_expr(env, fld, f.expr) with f); } -fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr { +fn fold_expr[ENV](&ENV env, &ast_fold[ENV] fld, &@expr e) -> @expr { let ENV env_ = fld.update_env_for_expr(env, e); @@ -829,7 +837,7 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr { } -fn fold_stmt[ENV](&ENV env, ast_fold[ENV] fld, &@stmt s) -> @stmt { +fn fold_stmt[ENV](&ENV env, &ast_fold[ENV] fld, &@stmt s) -> @stmt { let ENV env_ = fld.update_env_for_stmt(env, s); @@ -853,7 +861,7 @@ fn fold_stmt[ENV](&ENV env, ast_fold[ENV] fld, &@stmt s) -> @stmt { fail; } -fn fold_block[ENV](&ENV env, ast_fold[ENV] fld, &block blk) -> block { +fn fold_block[ENV](&ENV env, &ast_fold[ENV] fld, &block blk) -> block { auto index = new_str_hash[ast.block_index_entry](); let ENV env_ = fld.update_env_for_block(env, blk); @@ -879,23 +887,23 @@ fn fold_block[ENV](&ENV env, ast_fold[ENV] fld, &block blk) -> block { } } - auto aa = fld.fold_ann(env, blk.node.a); + auto aa = fld.fold_ann(env, blk.node.a); ret respan(blk.span, rec(stmts=stmts, expr=expr, index=index, a=aa)); } -fn fold_arm[ENV](&ENV env, ast_fold[ENV] fld, &arm a) -> arm { +fn fold_arm[ENV](&ENV env, &ast_fold[ENV] fld, &arm a) -> arm { let ENV env_ = fld.update_env_for_arm(env, a); auto ppat = fold_pat(env_, fld, a.pat); auto bblock = fold_block(env_, fld, a.block); ret rec(pat=ppat, block=bblock, index=a.index); } -fn fold_arg[ENV](&ENV env, ast_fold[ENV] fld, &arg a) -> arg { +fn fold_arg[ENV](&ENV env, &ast_fold[ENV] fld, &arg a) -> arg { auto ty = fold_ty(env, fld, a.ty); ret rec(ty=ty with a); } -fn fold_fn_decl[ENV](&ENV env, ast_fold[ENV] fld, +fn fold_fn_decl[ENV](&ENV env, &ast_fold[ENV] fld, &ast.fn_decl decl) -> ast.fn_decl { let vec[ast.arg] inputs = vec(); for (ast.arg a in decl.inputs) { @@ -905,7 +913,7 @@ fn fold_fn_decl[ENV](&ENV env, ast_fold[ENV] fld, ret fld.fold_fn_decl(env, inputs, output, decl.purity); } -fn fold_fn[ENV](&ENV env, ast_fold[ENV] fld, &ast._fn f) -> ast._fn { +fn fold_fn[ENV](&ENV env, &ast_fold[ENV] fld, &ast._fn f) -> ast._fn { auto decl = fold_fn_decl(env, fld, f.decl); auto body = fold_block[ENV](env, fld, f.body); @@ -914,21 +922,21 @@ fn fold_fn[ENV](&ENV env, ast_fold[ENV] fld, &ast._fn f) -> ast._fn { } -fn fold_obj_field[ENV](&ENV env, ast_fold[ENV] fld, +fn fold_obj_field[ENV](&ENV env, &ast_fold[ENV] fld, &ast.obj_field f) -> ast.obj_field { auto ty = fold_ty(env, fld, f.ty); ret rec(ty=ty with f); } -fn fold_method[ENV](&ENV env, ast_fold[ENV] fld, - @ast.method m) -> @ast.method { +fn fold_method[ENV](&ENV env, &ast_fold[ENV] fld, + &@ast.method m) -> @ast.method { auto meth = fold_fn(env, fld, m.node.meth); ret @rec(node=rec(meth=meth with m.node) with *m); } -fn fold_obj[ENV](&ENV env, ast_fold[ENV] fld, &ast._obj ob) -> ast._obj { +fn fold_obj[ENV](&ENV env, &ast_fold[ENV] fld, &ast._obj ob) -> ast._obj { let vec[ast.obj_field] fields = vec(); let vec[@ast.method] meths = vec(); @@ -959,7 +967,7 @@ fn fold_obj[ENV](&ENV env, ast_fold[ENV] fld, &ast._obj ob) -> ast._obj { ret fld.fold_obj(env, fields, meths, dtor); } -fn fold_view_item[ENV](&ENV env, ast_fold[ENV] fld, @view_item vi) +fn fold_view_item[ENV](&ENV env, &ast_fold[ENV] fld, &@view_item vi) -> @view_item { let ENV env_ = fld.update_env_for_view_item(env, vi); @@ -987,7 +995,7 @@ fn fold_view_item[ENV](&ENV env, ast_fold[ENV] fld, @view_item vi) fail; } -fn fold_item[ENV](&ENV env, ast_fold[ENV] fld, @item i) -> @item { +fn fold_item[ENV](&ENV env, &ast_fold[ENV] fld, &@item i) -> @item { let ENV env_ = fld.update_env_for_item(env, i); @@ -1049,7 +1057,7 @@ fn fold_item[ENV](&ENV env, ast_fold[ENV] fld, @item i) -> @item { fail; } -fn fold_mod[ENV](&ENV e, ast_fold[ENV] fld, &ast._mod m) -> ast._mod { +fn fold_mod[ENV](&ENV e, &ast_fold[ENV] fld, &ast._mod m) -> ast._mod { let vec[@view_item] view_items = vec(); let vec[@item] items = vec(); @@ -1070,8 +1078,8 @@ fn fold_mod[ENV](&ENV e, ast_fold[ENV] fld, &ast._mod m) -> ast._mod { ret fld.fold_mod(e, rec(view_items=view_items, items=items, index=index)); } -fn fold_native_item[ENV](&ENV env, ast_fold[ENV] fld, - @native_item i) -> @native_item { +fn fold_native_item[ENV](&ENV env, &ast_fold[ENV] fld, + &@native_item i) -> @native_item { let ENV env_ = fld.update_env_for_native_item(env, i); if (!fld.keep_going(env_)) { @@ -1090,7 +1098,7 @@ fn fold_native_item[ENV](&ENV env, ast_fold[ENV] fld, } } -fn fold_native_mod[ENV](&ENV e, ast_fold[ENV] fld, +fn fold_native_mod[ENV](&ENV e, &ast_fold[ENV] fld, &ast.native_mod m) -> ast.native_mod { let vec[@view_item] view_items = vec(); let vec[@native_item] items = vec(); @@ -1114,7 +1122,8 @@ fn fold_native_mod[ENV](&ENV e, ast_fold[ENV] fld, index=index)); } -fn fold_crate[ENV](&ENV env, ast_fold[ENV] fld, @ast.crate c) -> @ast.crate { +fn fold_crate[ENV](&ENV env, &ast_fold[ENV] fld, + &@ast.crate c) -> @ast.crate { // FIXME: possibly fold the directives so you process any expressions // within them? Not clear. After front/eval.rs, nothing else should look // at crate directives. @@ -1132,7 +1141,7 @@ fn respan[T](&span sp, &T t) -> spanned[T] { // Path identity. -fn identity_fold_path[ENV](&ENV env, &span sp, ast.path_ p) -> path { +fn identity_fold_path[ENV](&ENV env, &span sp, &ast.path_ p) -> path { ret respan(sp, p); } @@ -1180,359 +1189,368 @@ fn identity_fold_ty_vec[ENV](&ENV env, &span sp, &mt tm) -> @ty { } fn identity_fold_ty_tup[ENV](&ENV env, &span sp, - vec[mt] elts) -> @ty { + &vec[mt] elts) -> @ty { ret @respan(sp, ast.ty_tup(elts)); } fn identity_fold_ty_rec[ENV](&ENV env, &span sp, - vec[ast.ty_field] elts) -> @ty { + &vec[ast.ty_field] elts) -> @ty { ret @respan(sp, ast.ty_rec(elts)); } fn identity_fold_ty_obj[ENV](&ENV env, &span sp, - vec[ast.ty_method] meths) -> @ty { + &vec[ast.ty_method] meths) -> @ty { ret @respan(sp, ast.ty_obj(meths)); } fn identity_fold_ty_fn[ENV](&ENV env, &span sp, ast.proto proto, - vec[rec(ast.mode mode, @ty ty)] inputs, - @ty output) -> @ty { + &vec[rec(ast.mode mode, @ty ty)] inputs, + &@ty output) -> @ty { ret @respan(sp, ast.ty_fn(proto, inputs, output)); } -fn identity_fold_ty_path[ENV](&ENV env, &span sp, ast.path p, - &Option.t[def] d) -> @ty { +fn identity_fold_ty_path[ENV](&ENV env, &span sp, &ast.path p, + &Option.t[def] d) -> @ty { ret @respan(sp, ast.ty_path(p, d)); } -fn identity_fold_ty_chan[ENV](&ENV env, &span sp, @ty t) -> @ty { +fn identity_fold_ty_chan[ENV](&ENV env, &span sp, &@ty t) -> @ty { ret @respan(sp, ast.ty_chan(t)); } -fn identity_fold_ty_port[ENV](&ENV env, &span sp, @ty t) -> @ty { +fn identity_fold_ty_port[ENV](&ENV env, &span sp, &@ty t) -> @ty { ret @respan(sp, ast.ty_port(t)); } // Expr identities. -fn identity_fold_expr_vec[ENV](&ENV env, &span sp, vec[@expr] es, - ast.mutability mut, ann a) -> @expr { +fn identity_fold_expr_vec[ENV](&ENV env, &span sp, &vec[@expr] es, + ast.mutability mut, &ann a) -> @expr { ret @respan(sp, ast.expr_vec(es, mut, a)); } fn identity_fold_expr_tup[ENV](&ENV env, &span sp, - vec[ast.elt] es, ann a) -> @expr { + &vec[ast.elt] es, &ann a) -> @expr { ret @respan(sp, ast.expr_tup(es, a)); } fn identity_fold_expr_rec[ENV](&ENV env, &span sp, - vec[ast.field] fields, - Option.t[@expr] base, ann a) -> @expr { + &vec[ast.field] fields, + &Option.t[@expr] base, &ann a) -> @expr { ret @respan(sp, ast.expr_rec(fields, base, a)); } -fn identity_fold_expr_call[ENV](&ENV env, &span sp, @expr f, - vec[@expr] args, ann a) -> @expr { +fn identity_fold_expr_call[ENV](&ENV env, &span sp, &@expr f, + &vec[@expr] args, &ann a) -> @expr { ret @respan(sp, ast.expr_call(f, args, a)); } -fn identity_fold_expr_self_method[ENV](&ENV env, &span sp, ident id, - ann a) -> @expr { +fn identity_fold_expr_self_method[ENV](&ENV env, &span sp, &ident id, + &ann a) -> @expr { ret @respan(sp, ast.expr_self_method(id, a)); } -fn identity_fold_expr_bind[ENV](&ENV env, &span sp, @expr f, - vec[Option.t[@expr]] args_opt, ann a) +fn identity_fold_expr_bind[ENV](&ENV env, &span sp, &@expr f, + &vec[Option.t[@expr]] args_opt, &ann a) -> @expr { ret @respan(sp, ast.expr_bind(f, args_opt, a)); } fn identity_fold_expr_spawn[ENV](&ENV env, &span sp, - ast.spawn_dom dom, Option.t[str] name, - @expr f, vec[@expr] args, ann a) -> @expr { + ast.spawn_dom dom, &Option.t[str] name, + &@expr f, &vec[@expr] args, + &ann a) -> @expr { ret @respan(sp, ast.expr_spawn(dom, name, f, args, a)); } fn identity_fold_expr_binary[ENV](&ENV env, &span sp, ast.binop b, - @expr lhs, @expr rhs, - ann a) -> @expr { + &@expr lhs, &@expr rhs, + &ann a) -> @expr { ret @respan(sp, ast.expr_binary(b, lhs, rhs, a)); } fn identity_fold_expr_unary[ENV](&ENV env, &span sp, - ast.unop u, @expr e, ann a) + ast.unop u, &@expr e, &ann a) -> @expr { ret @respan(sp, ast.expr_unary(u, e, a)); } -fn identity_fold_expr_lit[ENV](&ENV env, &span sp, @ast.lit lit, - ann a) -> @expr { +fn identity_fold_expr_lit[ENV](&ENV env, &span sp, &@ast.lit lit, + &ann a) -> @expr { ret @respan(sp, ast.expr_lit(lit, a)); } -fn identity_fold_expr_cast[ENV](&ENV env, &span sp, @ast.expr e, - @ast.ty t, ann a) -> @expr { +fn identity_fold_expr_cast[ENV](&ENV env, &span sp, &@ast.expr e, + &@ast.ty t, &ann a) -> @expr { ret @respan(sp, ast.expr_cast(e, t, a)); } fn identity_fold_expr_if[ENV](&ENV env, &span sp, - @expr cond, &block thn, - &Option.t[@expr] els, ann a) -> @expr { + &@expr cond, &block thn, + &Option.t[@expr] els, &ann a) -> @expr { ret @respan(sp, ast.expr_if(cond, thn, els, a)); } fn identity_fold_expr_for[ENV](&ENV env, &span sp, - @decl d, @expr seq, - &block body, ann a) -> @expr { + &@decl d, &@expr seq, + &block body, &ann a) -> @expr { ret @respan(sp, ast.expr_for(d, seq, body, a)); } fn identity_fold_expr_for_each[ENV](&ENV env, &span sp, - @decl d, @expr seq, - &block body, ann a) -> @expr { + &@decl d, &@expr seq, + &block body, &ann a) -> @expr { ret @respan(sp, ast.expr_for_each(d, seq, body, a)); } fn identity_fold_expr_while[ENV](&ENV env, &span sp, - @expr cond, &block body, ann a) -> @expr { + &@expr cond, &block body, &ann a) -> @expr { ret @respan(sp, ast.expr_while(cond, body, a)); } fn identity_fold_expr_do_while[ENV](&ENV env, &span sp, - &block body, @expr cond, ann a) -> @expr { + &block body, &@expr cond, + &ann a) -> @expr { ret @respan(sp, ast.expr_do_while(body, cond, a)); } fn identity_fold_expr_alt[ENV](&ENV env, &span sp, - @expr e, vec[arm] arms, ann a) -> @expr { + &@expr e, &vec[arm] arms, + &ann a) -> @expr { ret @respan(sp, ast.expr_alt(e, arms, a)); } fn identity_fold_expr_block[ENV](&ENV env, &span sp, &block blk, - ann a) -> @expr { + &ann a) -> @expr { ret @respan(sp, ast.expr_block(blk, a)); } fn identity_fold_expr_assign[ENV](&ENV env, &span sp, - @expr lhs, @expr rhs, ann a) + &@expr lhs, &@expr rhs, &ann a) -> @expr { ret @respan(sp, ast.expr_assign(lhs, rhs, a)); } fn identity_fold_expr_assign_op[ENV](&ENV env, &span sp, ast.binop op, - @expr lhs, @expr rhs, ann a) + &@expr lhs, &@expr rhs, &ann a) -> @expr { ret @respan(sp, ast.expr_assign_op(op, lhs, rhs, a)); } fn identity_fold_expr_send[ENV](&ENV e, &span sp, - @expr lhs, @expr rhs, ann a) -> @expr { + &@expr lhs, &@expr rhs, &ann a) -> @expr { ret @respan(sp, ast.expr_send(lhs, rhs, a)); } fn identity_fold_expr_recv[ENV](&ENV e, &span sp, - @expr lhs, @expr rhs, ann a) -> @expr { + &@expr lhs, &@expr rhs, &ann a) -> @expr { ret @respan(sp, ast.expr_recv(lhs, rhs, a)); } fn identity_fold_expr_field[ENV](&ENV env, &span sp, - @expr e, ident i, ann a) -> @expr { + &@expr e, &ident i, &ann a) -> @expr { ret @respan(sp, ast.expr_field(e, i, a)); } fn identity_fold_expr_index[ENV](&ENV env, &span sp, - @expr e, @expr ix, ann a) -> @expr { + &@expr e, &@expr ix, &ann a) -> @expr { ret @respan(sp, ast.expr_index(e, ix, a)); } fn identity_fold_expr_path[ENV](&ENV env, &span sp, &path p, &Option.t[def] d, - ann a) -> @expr { + &ann a) -> @expr { ret @respan(sp, ast.expr_path(p, d, a)); } fn identity_fold_expr_ext[ENV](&ENV env, &span sp, - &path p, vec[@expr] args, - Option.t[str] body, - @expr expanded, - ann a) -> @expr { + &path p, &vec[@expr] args, + &Option.t[str] body, + &@expr expanded, + &ann a) -> @expr { ret @respan(sp, ast.expr_ext(p, args, body, expanded, a)); } -fn identity_fold_expr_fail[ENV](&ENV env, &span sp, ann a) -> @expr { +fn identity_fold_expr_fail[ENV](&ENV env, &span sp, &ann a) -> @expr { ret @respan(sp, ast.expr_fail(a)); } -fn identity_fold_expr_break[ENV](&ENV env, &span sp, ann a) -> @expr { +fn identity_fold_expr_break[ENV](&ENV env, &span sp, &ann a) -> @expr { ret @respan(sp, ast.expr_break(a)); } -fn identity_fold_expr_cont[ENV](&ENV env, &span sp, ann a) -> @expr { +fn identity_fold_expr_cont[ENV](&ENV env, &span sp, &ann a) -> @expr { ret @respan(sp, ast.expr_cont(a)); } fn identity_fold_expr_ret[ENV](&ENV env, &span sp, - &Option.t[@expr] rv, ann a) -> @expr { + &Option.t[@expr] rv, &ann a) -> @expr { ret @respan(sp, ast.expr_ret(rv, a)); } fn identity_fold_expr_put[ENV](&ENV env, &span sp, - &Option.t[@expr] rv, ann a) -> @expr { + &Option.t[@expr] rv, &ann a) -> @expr { ret @respan(sp, ast.expr_put(rv, a)); } -fn identity_fold_expr_be[ENV](&ENV env, &span sp, @expr x, ann a) -> @expr { +fn identity_fold_expr_be[ENV](&ENV env, &span sp, + &@expr x, &ann a) -> @expr { ret @respan(sp, ast.expr_be(x, a)); } -fn identity_fold_expr_log[ENV](&ENV e, &span sp, int lvl, @expr x, - ann a) -> @expr { +fn identity_fold_expr_log[ENV](&ENV e, &span sp, int lvl, &@expr x, + &ann a) -> @expr { ret @respan(sp, ast.expr_log(lvl, x, a)); } -fn identity_fold_expr_check[ENV](&ENV e, &span sp, @expr x, ann a) +fn identity_fold_expr_check[ENV](&ENV e, &span sp, &@expr x, &ann a) -> @expr { ret @respan(sp, ast.expr_check(x, a)); } -fn identity_fold_expr_assert[ENV](&ENV e, &span sp, @expr x, ann a) +fn identity_fold_expr_assert[ENV](&ENV e, &span sp, &@expr x, &ann a) -> @expr { ret @respan(sp, ast.expr_assert(x, a)); } -fn identity_fold_expr_port[ENV](&ENV e, &span sp, ann a) -> @expr { +fn identity_fold_expr_port[ENV](&ENV e, &span sp, &ann a) -> @expr { ret @respan(sp, ast.expr_port(a)); } -fn identity_fold_expr_chan[ENV](&ENV e, &span sp, @expr x, ann a) -> @expr { +fn identity_fold_expr_chan[ENV](&ENV e, &span sp, &@expr x, + &ann a) -> @expr { ret @respan(sp, ast.expr_chan(x, a)); } // Decl identities. fn identity_fold_decl_local[ENV](&ENV e, &span sp, - @ast.local local) -> @decl { + &@ast.local local) -> @decl { ret @respan(sp, ast.decl_local(local)); } -fn identity_fold_decl_item[ENV](&ENV e, &span sp, @item i) -> @decl { +fn identity_fold_decl_item[ENV](&ENV e, &span sp, &@item i) -> @decl { ret @respan(sp, ast.decl_item(i)); } // Pat identities. -fn identity_fold_pat_wild[ENV](&ENV e, &span sp, ann a) -> @pat { +fn identity_fold_pat_wild[ENV](&ENV e, &span sp, &ann a) -> @pat { ret @respan(sp, ast.pat_wild(a)); } -fn identity_fold_pat_lit[ENV](&ENV e, &span sp, @ast.lit lit, ann a) -> @pat { +fn identity_fold_pat_lit[ENV](&ENV e, &span sp, + &@ast.lit lit, &ann a) -> @pat { ret @respan(sp, ast.pat_lit(lit, a)); } -fn identity_fold_pat_bind[ENV](&ENV e, &span sp, ident i, def_id did, ann a) +fn identity_fold_pat_bind[ENV](&ENV e, &span sp, &ident i, + &def_id did, &ann a) -> @pat { ret @respan(sp, ast.pat_bind(i, did, a)); } -fn identity_fold_pat_tag[ENV](&ENV e, &span sp, path p, vec[@pat] args, - Option.t[ast.variant_def] d, ann a) -> @pat { +fn identity_fold_pat_tag[ENV](&ENV e, &span sp, &path p, &vec[@pat] args, + &Option.t[ast.variant_def] d, &ann a) -> @pat { ret @respan(sp, ast.pat_tag(p, args, d, a)); } // Stmt identities. -fn identity_fold_stmt_decl[ENV](&ENV env, &span sp, @decl d, ann a) -> @stmt { +fn identity_fold_stmt_decl[ENV](&ENV env, &span sp, + &@decl d, &ann a) -> @stmt { ret @respan(sp, ast.stmt_decl(d, a)); } -fn identity_fold_stmt_expr[ENV](&ENV e, &span sp, @expr x, ann a) -> @stmt { +fn identity_fold_stmt_expr[ENV](&ENV e, &span sp, + &@expr x, &ann a) -> @stmt { ret @respan(sp, ast.stmt_expr(x, a)); } // Item identities. -fn identity_fold_item_const[ENV](&ENV e, &span sp, ident i, - @ty t, @expr ex, - def_id id, ann a) -> @item { +fn identity_fold_item_const[ENV](&ENV e, &span sp, &ident i, + &@ty t, &@expr ex, + &def_id id, &ann a) -> @item { ret @respan(sp, ast.item_const(i, t, ex, id, a)); } -fn identity_fold_item_fn[ENV](&ENV e, &span sp, ident i, - &ast._fn f, vec[ast.ty_param] ty_params, - def_id id, ann a) -> @item { +fn identity_fold_item_fn[ENV](&ENV e, &span sp, &ident i, + &ast._fn f, &vec[ast.ty_param] ty_params, + &def_id id, &ann a) -> @item { ret @respan(sp, ast.item_fn(i, f, ty_params, id, a)); } -fn identity_fold_native_item_fn[ENV](&ENV e, &span sp, ident i, - Option.t[str] link_name, +fn identity_fold_native_item_fn[ENV](&ENV e, &span sp, &ident i, + &Option.t[str] link_name, &ast.fn_decl decl, - vec[ast.ty_param] ty_params, - def_id id, ann a) -> @native_item { + &vec[ast.ty_param] ty_params, + &def_id id, &ann a) -> @native_item { ret @respan(sp, ast.native_item_fn(i, link_name, decl, ty_params, id, a)); } -fn identity_fold_item_mod[ENV](&ENV e, &span sp, ident i, - &ast._mod m, def_id id) -> @item { +fn identity_fold_item_mod[ENV](&ENV e, &span sp, &ident i, + &ast._mod m, &def_id id) -> @item { ret @respan(sp, ast.item_mod(i, m, id)); } -fn identity_fold_item_native_mod[ENV](&ENV e, &span sp, ident i, - &ast.native_mod m, def_id id) -> @item { +fn identity_fold_item_native_mod[ENV](&ENV e, &span sp, &ident i, + &ast.native_mod m, &def_id id) -> @item { ret @respan(sp, ast.item_native_mod(i, m, id)); } -fn identity_fold_item_ty[ENV](&ENV e, &span sp, ident i, - @ty t, vec[ast.ty_param] ty_params, - def_id id, ann a) -> @item { +fn identity_fold_item_ty[ENV](&ENV e, &span sp, &ident i, + &@ty t, &vec[ast.ty_param] ty_params, + &def_id id, &ann a) -> @item { ret @respan(sp, ast.item_ty(i, t, ty_params, id, a)); } -fn identity_fold_native_item_ty[ENV](&ENV e, &span sp, ident i, - def_id id) -> @native_item { +fn identity_fold_native_item_ty[ENV](&ENV e, &span sp, &ident i, + &def_id id) -> @native_item { ret @respan(sp, ast.native_item_ty(i, id)); } -fn identity_fold_item_tag[ENV](&ENV e, &span sp, ident i, - vec[ast.variant] variants, - vec[ast.ty_param] ty_params, - def_id id, ann a) -> @item { +fn identity_fold_item_tag[ENV](&ENV e, &span sp, &ident i, + &vec[ast.variant] variants, + &vec[ast.ty_param] ty_params, + &def_id id, &ann a) -> @item { ret @respan(sp, ast.item_tag(i, variants, ty_params, id, a)); } -fn identity_fold_item_obj[ENV](&ENV e, &span sp, ident i, - &ast._obj ob, vec[ast.ty_param] ty_params, - ast.obj_def_ids odid, ann a) -> @item { +fn identity_fold_item_obj[ENV](&ENV e, &span sp, &ident i, + &ast._obj ob, &vec[ast.ty_param] ty_params, + &ast.obj_def_ids odid, &ann a) -> @item { ret @respan(sp, ast.item_obj(i, ob, ty_params, odid, a)); } // View Item folds. -fn identity_fold_view_item_use[ENV](&ENV e, &span sp, ident i, - vec[@meta_item] meta_items, - def_id id, Option.t[int] cnum) +fn identity_fold_view_item_use[ENV](&ENV e, &span sp, &ident i, + &vec[@meta_item] meta_items, + &def_id id, &Option.t[int] cnum) -> @view_item { ret @respan(sp, ast.view_item_use(i, meta_items, id, cnum)); } -fn identity_fold_view_item_import[ENV](&ENV e, &span sp, ident i, - vec[ident] is, def_id id, - Option.t[def] target_def) +fn identity_fold_view_item_import[ENV](&ENV e, &span sp, &ident i, + &vec[ident] is, &def_id id, + &Option.t[def] target_def) -> @view_item { ret @respan(sp, ast.view_item_import(i, is, id, target_def)); } -fn identity_fold_view_item_export[ENV](&ENV e, &span sp, ident i) +fn identity_fold_view_item_export[ENV](&ENV e, &span sp, &ident i) -> @view_item { ret @respan(sp, ast.view_item_export(i)); } // Annotation folding. -fn identity_fold_ann[ENV](&ENV e, ann a) -> ann { +fn identity_fold_ann[ENV](&ENV e, &ann a) -> ann { ret a; } @@ -1543,9 +1561,9 @@ fn identity_fold_block[ENV](&ENV e, &span sp, &ast.block_ blk) -> block { } fn identity_fold_fn_decl[ENV](&ENV e, - vec[arg] inputs, - @ty output, - purity p) -> ast.fn_decl { + &vec[arg] inputs, + &@ty output, + &purity p) -> ast.fn_decl { ret rec(inputs=inputs, output=output, purity=p); } @@ -1566,34 +1584,34 @@ fn identity_fold_native_mod[ENV](&ENV e, } fn identity_fold_crate[ENV](&ENV e, &span sp, - vec[@ast.crate_directive] cdirs, + &vec[@ast.crate_directive] cdirs, &ast._mod m) -> @ast.crate { ret @respan(sp, rec(directives=cdirs, module=m)); } fn identity_fold_obj[ENV](&ENV e, - vec[ast.obj_field] fields, - vec[@ast.method] methods, - Option.t[@ast.method] dtor) -> ast._obj { + &vec[ast.obj_field] fields, + &vec[@ast.method] methods, + &Option.t[@ast.method] dtor) -> ast._obj { ret rec(fields=fields, methods=methods, dtor=dtor); } // Env update identities. -fn identity_update_env_for_crate[ENV](&ENV e, @ast.crate c) -> ENV { +fn identity_update_env_for_crate[ENV](&ENV e, &@ast.crate c) -> ENV { ret e; } -fn identity_update_env_for_item[ENV](&ENV e, @item i) -> ENV { +fn identity_update_env_for_item[ENV](&ENV e, &@item i) -> ENV { ret e; } -fn identity_update_env_for_native_item[ENV](&ENV e, @native_item i) -> ENV { +fn identity_update_env_for_native_item[ENV](&ENV e, &@native_item i) -> ENV { ret e; } -fn identity_update_env_for_view_item[ENV](&ENV e, @view_item i) -> ENV { +fn identity_update_env_for_view_item[ENV](&ENV e, &@view_item i) -> ENV { ret e; } @@ -1601,11 +1619,11 @@ fn identity_update_env_for_block[ENV](&ENV e, &block b) -> ENV { ret e; } -fn identity_update_env_for_stmt[ENV](&ENV e, @stmt s) -> ENV { +fn identity_update_env_for_stmt[ENV](&ENV e, &@stmt s) -> ENV { ret e; } -fn identity_update_env_for_decl[ENV](&ENV e, @decl d) -> ENV { +fn identity_update_env_for_decl[ENV](&ENV e, &@decl d) -> ENV { ret e; } @@ -1613,15 +1631,15 @@ fn identity_update_env_for_arm[ENV](&ENV e, &arm a) -> ENV { ret e; } -fn identity_update_env_for_pat[ENV](&ENV e, @pat p) -> ENV { +fn identity_update_env_for_pat[ENV](&ENV e, &@pat p) -> ENV { ret e; } -fn identity_update_env_for_expr[ENV](&ENV e, @expr x) -> ENV { +fn identity_update_env_for_expr[ENV](&ENV e, &@expr x) -> ENV { ret e; } -fn identity_update_env_for_ty[ENV](&ENV e, @ty t) -> ENV { +fn identity_update_env_for_ty[ENV](&ENV e, &@ty t) -> ENV { ret e; } @@ -1697,7 +1715,7 @@ fn new_identity_fold[ENV]() -> ast_fold[ENV] { = bind identity_fold_expr_check[ENV](_,_,_,_), fold_expr_assert = bind identity_fold_expr_assert[ENV](_,_,_,_), - + fold_expr_port = bind identity_fold_expr_port[ENV](_,_,_), fold_expr_chan = bind identity_fold_expr_chan[ENV](_,_,_,_), diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs index 433b4734052..5fb2eb04fa9 100644 --- a/src/comp/middle/resolve.rs +++ b/src/comp/middle/resolve.rs @@ -604,9 +604,9 @@ fn lookup_name_wrapped(&env e, ast.ident i, namespace ns, direction dir) } } -fn fold_pat_tag(&env e, &span sp, ast.path p, vec[@ast.pat] args, - Option.t[ast.variant_def] old_def, - ann a) -> @ast.pat { +fn fold_pat_tag(&env e, &span sp, &ast.path p, &vec[@ast.pat] args, + &Option.t[ast.variant_def] old_def, + &ann a) -> @ast.pat { auto len = Vec.len[ast.ident](p.node.idents); auto last_id = p.node.idents.(len - 1u); auto new_def; @@ -647,7 +647,7 @@ fn fold_pat_tag(&env e, &span sp, ast.path p, vec[@ast.pat] args, // expressions tacked on the end. fn fold_expr_path(&env e, &span sp, &ast.path p, &Option.t[def] d, - ann a) -> @ast.expr { + &ann a) -> @ast.expr { auto n_idents = Vec.len[ast.ident](p.node.idents); assert (n_idents != 0u); @@ -683,9 +683,9 @@ fn fold_expr_path(&env e, &span sp, &ast.path p, &Option.t[def] d, } fn fold_view_item_import(&env e, &span sp, - import_map index, ident i, - vec[ident] is, ast.def_id id, - Option.t[def] target_id) -> @ast.view_item { + &import_map index, &ident i, + &vec[ident] is, &ast.def_id id, + &Option.t[def] target_id) -> @ast.view_item { // Produce errors for invalid imports auto len = Vec.len[ast.ident](is); auto last_id = is.(len - 1u); @@ -703,7 +703,7 @@ fn fold_view_item_import(&env e, &span sp, target_def)); } -fn fold_ty_path(&env e, &span sp, ast.path p, &Option.t[def] d) -> @ast.ty { +fn fold_ty_path(&env e, &span sp, &ast.path p, &Option.t[def] d) -> @ast.ty { auto index = new_def_hash[def_wrap](); auto d = find_final_def(e, index, sp, p.node.idents, ns_type, none[ast.def_id]); @@ -711,22 +711,22 @@ fn fold_ty_path(&env e, &span sp, ast.path p, &Option.t[def] d) -> @ast.ty { ret @fold.respan[ast.ty_](sp, ast.ty_path(p, some(unwrap_def(d)))); } -fn update_env_for_crate(&env e, @ast.crate c) -> env { +fn update_env_for_crate(&env e, &@ast.crate c) -> env { ret rec(scopes = cons[scope](scope_crate(c), @e.scopes) with e); } -fn update_env_for_item(&env e, @ast.item i) -> env { +fn update_env_for_item(&env e, &@ast.item i) -> env { ret rec(scopes = cons[scope](scope_item(i), @e.scopes) with e); } -fn update_env_for_native_item(&env e, @ast.native_item i) -> env { +fn update_env_for_native_item(&env e, &@ast.native_item i) -> env { ret rec(scopes = cons[scope](scope_native_item(i), @e.scopes) with e); } // Not actually called by fold, but here since this is analogous to // update_env_for_item() above and is called by find_final_def(). -fn update_env_for_external_mod(&env e, ast.def_id mod_id, - vec[ast.ident] idents) -> env { +fn update_env_for_external_mod(&env e, &ast.def_id mod_id, + &vec[ast.ident] idents) -> env { ret rec(scopes = cons[scope](scope_external_mod(mod_id, idents), @e.scopes) with e); @@ -736,7 +736,7 @@ fn update_env_for_block(&env e, &ast.block b) -> env { ret rec(scopes = cons[scope](scope_block(b), @e.scopes) with e); } -fn update_env_for_expr(&env e, @ast.expr x) -> env { +fn update_env_for_expr(&env e, &@ast.expr x) -> env { alt (x.node) { case (ast.expr_for(?d, _, _, _)) { ret rec(scopes = cons[scope](scope_loop(d), @e.scopes) with e); @@ -753,7 +753,7 @@ fn update_env_for_arm(&env e, &ast.arm p) -> env { ret rec(scopes = cons[scope](scope_arm(p), @e.scopes) with e); } -fn resolve_imports(session.session sess, @ast.crate crate) -> @ast.crate { +fn resolve_imports(session.session sess, &@ast.crate crate) -> @ast.crate { let fold.ast_fold[env] fld = fold.new_identity_fold[env](); auto import_index = new_def_hash[def_wrap](); diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs index 1d888949463..cdccb82870d 100644 --- a/src/comp/middle/typeck.rs +++ b/src/comp/middle/typeck.rs @@ -631,7 +631,7 @@ mod Collect { ret result; } - fn collect(&@ty_item_table id_to_ty_item, @ast.item i) -> @ty_item_table { + fn collect(&@ty_item_table id_to_ty_item, &@ast.item i) -> @ty_item_table { alt (i.node) { case (ast.item_ty(_, _, _, ?def_id, _)) { id_to_ty_item.insert(def_id, any_item_rust(i)); @@ -647,7 +647,7 @@ mod Collect { ret id_to_ty_item; } - fn collect_native(&@ty_item_table id_to_ty_item, @ast.native_item i) + fn collect_native(&@ty_item_table id_to_ty_item, &@ast.native_item i) -> @ty_item_table { alt (i.node) { case (ast.native_item_ty(_, ?def_id)) { @@ -662,7 +662,7 @@ mod Collect { ret id_to_ty_item; } - fn convert(&@env e, @ast.item i) -> @env { + fn convert(&@env e, &@ast.item i) -> @env { auto abi = e.abi; alt (i.node) { case (ast.item_mod(_, _, _)) { @@ -681,32 +681,32 @@ mod Collect { ret @rec(abi=abi with *e); } - fn convert_native(&@env e, @ast.native_item i) -> @env { + fn convert_native(&@env e, &@ast.native_item i) -> @env { ty_of_native_item(e.cx, i, e.abi); ret e; } - fn fold_item_const(&@env e, &span sp, ast.ident i, - @ast.ty t, @ast.expr ex, - ast.def_id id, ast.ann a) -> @ast.item { + fn fold_item_const(&@env e, &span sp, &ast.ident i, + &@ast.ty t, &@ast.expr ex, + &ast.def_id id, &ast.ann a) -> @ast.item { // assert (e.cx.type_cache.contains_key(id)); auto typ = e.cx.type_cache.get(id)._1; auto item = ast.item_const(i, t, ex, id, triv_ann(typ)); ret @fold.respan[ast.item_](sp, item); } - fn fold_item_fn(&@env e, &span sp, ast.ident i, - &ast._fn f, vec[ast.ty_param] ty_params, - ast.def_id id, ast.ann a) -> @ast.item { + fn fold_item_fn(&@env e, &span sp, &ast.ident i, + &ast._fn f, &vec[ast.ty_param] ty_params, + &ast.def_id id, &ast.ann a) -> @ast.item { // assert (e.cx.type_cache.contains_key(id)); auto typ = e.cx.type_cache.get(id)._1; auto item = ast.item_fn(i, f, ty_params, id, triv_ann(typ)); ret @fold.respan[ast.item_](sp, item); } - fn fold_native_item_fn(&@env e, &span sp, ast.ident i, Option.t[str] ln, - &ast.fn_decl d, vec[ast.ty_param] ty_params, - ast.def_id id, ast.ann a) -> @ast.native_item { + fn fold_native_item_fn(&@env e, &span sp, &ast.ident i, &Option.t[str] ln, + &ast.fn_decl d, &vec[ast.ty_param] ty_params, + &ast.def_id id, &ast.ann a) -> @ast.native_item { // assert (e.cx.type_cache.contains_key(id)); auto typ = e.cx.type_cache.get(id)._1; auto item = ast.native_item_fn(i, ln, d, ty_params, id, @@ -714,7 +714,7 @@ mod Collect { ret @fold.respan[ast.native_item_](sp, item); } - fn get_ctor_obj_methods(&@env e, ty.t t) -> vec[method] { + fn get_ctor_obj_methods(&@env e, &ty.t t) -> vec[method] { alt (struct(e.cx.tcx, t)) { case (ty.ty_fn(_,_,?tobj)) { alt (struct(e.cx.tcx, tobj)) { @@ -735,9 +735,9 @@ mod Collect { } - fn fold_item_obj(&@env e, &span sp, ast.ident i, - &ast._obj ob, vec[ast.ty_param] ty_params, - ast.obj_def_ids odid, ast.ann a) -> @ast.item { + fn fold_item_obj(&@env e, &span sp, &ast.ident i, + &ast._obj ob, &vec[ast.ty_param] ty_params, + &ast.obj_def_ids odid, &ast.ann a) -> @ast.item { // assert (e.cx.type_cache.contains_key(odid.ctor)); auto t = e.cx.type_cache.get(odid.ctor)._1; let vec[method] meth_tys = get_ctor_obj_methods(e, t); @@ -791,19 +791,19 @@ mod Collect { ret @fold.respan[ast.item_](sp, item); } - fn fold_item_ty(&@env e, &span sp, ast.ident i, - @ast.ty t, vec[ast.ty_param] ty_params, - ast.def_id id, ast.ann a) -> @ast.item { + fn fold_item_ty(&@env e, &span sp, &ast.ident i, + &@ast.ty t, &vec[ast.ty_param] ty_params, + &ast.def_id id, &ast.ann a) -> @ast.item { // assert (e.cx.type_cache.contains_key(id)); auto typ = e.cx.type_cache.get(id)._1; auto item = ast.item_ty(i, t, ty_params, id, triv_ann(typ)); ret @fold.respan[ast.item_](sp, item); } - fn fold_item_tag(&@env e, &span sp, ast.ident i, - vec[ast.variant] variants, - vec[ast.ty_param] ty_params, - ast.def_id id, ast.ann a) -> @ast.item { + fn fold_item_tag(&@env e, &span sp, &ast.ident i, + &vec[ast.variant] variants, + &vec[ast.ty_param] ty_params, + &ast.def_id id, &ast.ann a) -> @ast.item { auto variants_t = get_tag_variant_types(e.cx, id, variants, ty_params); auto typ = e.cx.type_cache.get(id)._1; @@ -813,7 +813,8 @@ mod Collect { ret @fold.respan[ast.item_](sp, item); } - fn collect_item_types(session.session sess, ty.ctxt tcx, @ast.crate crate) + fn collect_item_types(&session.session sess, &ty.ctxt tcx, + &@ast.crate crate) -> tup(@ast.crate, ty.type_cache, @ty_item_table) { // First pass: collect all type item IDs. auto module = crate.node.module; @@ -1523,7 +1524,7 @@ mod Pushdown { // Local variable resolution: the phase that finds all the types in the AST // and replaces opaque "ty_local" types with the resolved local types. -fn writeback_local(&Option.t[@fn_ctxt] env, &span sp, @ast.local local) +fn writeback_local(&Option.t[@fn_ctxt] env, &span sp, &@ast.local local) -> @ast.decl { auto fcx = Option.get[@fn_ctxt](env); @@ -1545,7 +1546,7 @@ fn writeback_local(&Option.t[@fn_ctxt] env, &span sp, @ast.local local) ret @fold.respan[ast.decl_](sp, ast.decl_local(local_wb)); } -fn resolve_local_types_in_annotation(&Option.t[@fn_ctxt] env, ast.ann ann) +fn resolve_local_types_in_annotation(&Option.t[@fn_ctxt] env, &ast.ann ann) -> ast.ann { fn resolver(@fn_ctxt fcx, ty.t typ) -> ty.t { alt (struct(fcx.ccx.tcx, typ)) { @@ -1574,7 +1575,7 @@ fn resolve_local_types_in_annotation(&Option.t[@fn_ctxt] env, ast.ann ann) fn resolve_local_types_in_block(&@fn_ctxt fcx, &ast.block block) -> ast.block { - fn update_env_for_item(&Option.t[@fn_ctxt] env, @ast.item i) + fn update_env_for_item(&Option.t[@fn_ctxt] env, &@ast.item i) -> Option.t[@fn_ctxt] { ret none[@fn_ctxt]; } @@ -1588,13 +1589,11 @@ fn resolve_local_types_in_block(&@fn_ctxt fcx, &ast.block block) auto rltia = bind resolve_local_types_in_annotation(_,_); auto uefi = update_env_for_item; auto kg = keep_going; - fld = @rec( - fold_decl_local = wbl, - fold_ann = rltia, - update_env_for_item = uefi, - keep_going = kg - with *fld - ); + fld = @rec(fold_decl_local = wbl, + fold_ann = rltia, + update_env_for_item = uefi, + keep_going = kg + with *fld); ret fold.fold_block[Option.t[@fn_ctxt]](some[@fn_ctxt](fcx), fld, block); } @@ -2872,9 +2871,9 @@ fn check_fn(&@crate_ctxt ccx, &ast.fn_decl decl, ast.proto proto, ret fn_t; } -fn check_item_fn(&@crate_ctxt ccx, &span sp, ast.ident ident, &ast._fn f, - vec[ast.ty_param] ty_params, ast.def_id id, - ast.ann ann) -> @ast.item { +fn check_item_fn(&@crate_ctxt ccx, &span sp, &ast.ident ident, &ast._fn f, + &vec[ast.ty_param] ty_params, &ast.def_id id, + &ast.ann ann) -> @ast.item { // FIXME: duplicate work: the item annotation already has the arg types // and return type translated to typeck.ty values. We don't need do to it @@ -2893,7 +2892,7 @@ fn check_item_fn(&@crate_ctxt ccx, &span sp, ast.ident ident, &ast._fn f, ret @fold.respan[ast.item_](sp, item); } -fn update_obj_fields(&@crate_ctxt ccx, @ast.item i) -> @crate_ctxt { +fn update_obj_fields(&@crate_ctxt ccx, &@ast.item i) -> @crate_ctxt { alt (i.node) { case (ast.item_obj(_, ?ob, _, ?obj_def_ids, _)) { let ast.def_id di = obj_def_ids.ty; diff --git a/src/comp/middle/typestate_check.rs b/src/comp/middle/typestate_check.rs index e571fa21ee5..7a9f9da7686 100644 --- a/src/comp/middle/typestate_check.rs +++ b/src/comp/middle/typestate_check.rs @@ -309,7 +309,7 @@ fn num_locals(fn_info m) -> uint { ret m.size(); } -fn collect_local(&@vec[tup(ident, def_id)] vars, &span sp, @ast.local loc) +fn collect_local(&@vec[tup(ident, def_id)] vars, &span sp, &@ast.local loc) -> @decl { log("collect_local: pushing " + loc.ident); Vec.push[tup(ident, def_id)](*vars, tup(loc.ident, loc.id)); @@ -351,19 +351,20 @@ fn mk_fn_info(_fn f) -> fn_info { ret res; } -/* extends mk_fn_info to a function item, side-effecting the map fi from +/* extends mk_fn_info to a function item, side-effecting the map fi from function IDs to fn_info maps */ -fn mk_fn_info_item_fn(&fn_info_map fi, &span sp, ident i, &ast._fn f, - vec[ast.ty_param] ty_params, def_id id, ann a) -> @item { +fn mk_fn_info_item_fn(&fn_info_map fi, &span sp, &ident i, &ast._fn f, + &vec[ast.ty_param] ty_params, &def_id id, &ann a) -> @item { fi.insert(id, mk_fn_info(f)); log(i + " has " + uistr(num_locals(mk_fn_info(f))) + " local vars"); ret @respan(sp, item_fn(i, f, ty_params, id, a)); } -/* extends mk_fn_info to an obj item, side-effecting the map fi from +/* extends mk_fn_info to an obj item, side-effecting the map fi from function IDs to fn_info maps */ -fn mk_fn_info_item_obj(&fn_info_map fi, &span sp, ident i, &ast._obj o, - vec[ast.ty_param] ty_params, ast.obj_def_ids odid, ann a) -> @item { +fn mk_fn_info_item_obj(&fn_info_map fi, &span sp, &ident i, &ast._obj o, + &vec[ast.ty_param] ty_params, + &ast.obj_def_ids odid, &ann a) -> @item { auto all_methods = Vec.clone[@method](o.methods); plus_option[@method](all_methods, o.dtor); for (@method m in all_methods) { @@ -1251,14 +1252,15 @@ fn find_pre_post_fn(&fn_info_map fm, &fn_info fi, &_fn f) -> () { find_pre_post_block(fm, fi, f.body); } -fn check_item_fn(&fn_info_map fm, &span sp, ident i, &ast._fn f, - vec[ast.ty_param] ty_params, def_id id, ann a) -> @item { +fn check_item_fn(&fn_info_map fm, &span sp, &ident i, &ast._fn f, + &vec[ast.ty_param] ty_params, + &def_id id, &ann a) -> @item { log("check_item_fn:"); log_fn(f, i, ty_params); assert (fm.contains_key(id)); - find_pre_post_fn(fm, fm.get(id), f); + find_pre_post_fn(fm, fm.get(id), f); ret @respan(sp, ast.item_fn(i, f, ty_params, id, a)); } @@ -2006,9 +2008,9 @@ fn check_fn_states(&fn_info_map f_info_map, &fn_info f_info, &ast._fn f) check_states_against_conditions(f_info, f); } -fn check_item_fn_state(&fn_info_map f_info_map, &span sp, ident i, - &ast._fn f, vec[ast.ty_param] ty_params, def_id id, - ann a) -> @item { +fn check_item_fn_state(&fn_info_map f_info_map, &span sp, &ident i, + &ast._fn f, &vec[ast.ty_param] ty_params, + &def_id id, &ann a) -> @item { /* Look up the var-to-bit-num map for this function */ assert (f_info_map.contains_key(id)); @@ -2026,8 +2028,9 @@ fn check_method_states(&fn_info_map f_info_map, @method m) -> () { check_fn_states(f_info_map, f_info, m.node.meth); } -fn check_obj_state(&fn_info_map f_info_map, vec[obj_field] fields, - vec[@method] methods, Option.t[@method] dtor) -> ast._obj { +fn check_obj_state(&fn_info_map f_info_map, &vec[obj_field] fields, + &vec[@method] methods, + &Option.t[@method] dtor) -> ast._obj { fn one(fn_info_map fm, &@method m) -> () { ret check_method_states(fm, m); } @@ -2037,7 +2040,7 @@ fn check_obj_state(&fn_info_map f_info_map, vec[obj_field] fields, ret rec(fields=fields, methods=methods, dtor=dtor); } -fn init_ann(&fn_info fi, ann a) -> ann { +fn init_ann(&fn_info fi, &ann a) -> ann { alt (a) { case (ann_none) { // log("init_ann: shouldn't see ann_none"); @@ -2053,7 +2056,7 @@ fn init_ann(&fn_info fi, ann a) -> ann { } } -fn init_blank_ann(&() ignore, ann a) -> ann { +fn init_blank_ann(&() ignore, &ann a) -> ann { alt (a) { case (ann_none) { // log("init_blank_ann: shouldn't see ann_none"); @@ -2492,7 +2495,7 @@ fn annotate_crate(&fn_info_map fm, &@ast.crate crate) -> @ast.crate { fn check_crate(@ast.crate crate) -> @ast.crate { /* Build the global map from function id to var-to-bit-num-map */ auto fm = mk_f_to_fn_info(crate); - + /* Add a blank ts_ann to every statement (and expression) */ auto with_anns = annotate_crate(fm, crate); diff --git a/src/comp/util/common.rs b/src/comp/util/common.rs index b1a39893986..2c4dcd26ee5 100644 --- a/src/comp/util/common.rs +++ b/src/comp/util/common.rs @@ -252,12 +252,12 @@ fn has_nonlocal_exits(&ast.block b) -> bool { /* overkill, but just passing around a mutable bool doesn't seem to work in rustboot */ auto has_exits = new_str_hash[()](); - - fn set_break(&flag f, &span sp, ast.ann a) -> @ast.expr { + + fn set_break(&flag f, &span sp, &ast.ann a) -> @ast.expr { f.insert("foo", ()); ret @respan(sp, ast.expr_break(a)); } - fn set_cont(&flag f, &span sp, ast.ann a) -> @ast.expr { + fn set_cont(&flag f, &span sp, &ast.ann a) -> @ast.expr { f.insert("foo", ()); ret @respan(sp, ast.expr_cont(a)); }