diff options
Diffstat (limited to 'src/comp/middle/fold.rs')
| -rw-r--r-- | src/comp/middle/fold.rs | 749 |
1 files changed, 375 insertions, 374 deletions
diff --git a/src/comp/middle/fold.rs b/src/comp/middle/fold.rs index d3426684..5af85f14 100644 --- a/src/comp/middle/fold.rs +++ b/src/comp/middle/fold.rs @@ -1,45 +1,45 @@ -import std.Map.hashmap; -import std.Option; -import std.Option.some; -import std.Option.none; - -import util.common.new_str_hash; -import util.common.spanned; -import util.common.span; -import util.common.ty_mach; -import util.typestate_ann.ts_ann; - -import front.ast; -import front.ast.fn_decl; -import front.ast.ident; -import front.ast.path; -import front.ast.mutability; -import front.ast.ty; -import front.ast.expr; -import front.ast.stmt; -import front.ast.block; -import front.ast.item; -import front.ast.view_item; -import front.ast.meta_item; -import front.ast.native_item; -import front.ast.arg; -import front.ast.pat; -import front.ast.decl; -import front.ast.arm; -import front.ast.def; -import front.ast.def_id; -import front.ast.ann; -import front.ast.mt; -import front.ast.purity; - -import std.UInt; -import std.Vec; +import std::map::hashmap; +import std::option; +import std::option::some; +import std::option::none; + +import util::common::new_str_hash; +import util::common::spanned; +import util::common::span; +import util::common::ty_mach; +import util::typestate_ann::ts_ann; + +import front::ast; +import front::ast::fn_decl; +import front::ast::ident; +import front::ast::path; +import front::ast::mutability; +import front::ast::ty; +import front::ast::expr; +import front::ast::stmt; +import front::ast::block; +import front::ast::item; +import front::ast::view_item; +import front::ast::meta_item; +import front::ast::native_item; +import front::ast::arg; +import front::ast::pat; +import front::ast::decl; +import front::ast::arm; +import front::ast::def; +import front::ast::def_id; +import front::ast::ann; +import front::ast::mt; +import front::ast::purity; + +import std::_uint; +import std::_vec; type ast_fold[ENV] = @rec ( - // Path fold. - (fn(&ENV e, &span sp, &ast.path_ p) -> path) fold_path, + // Path fold: + (fn(&ENV e, &span sp, &ast::path_ p) -> path) fold_path, // Type folds. (fn(&ENV e, &span sp) -> @ty) fold_ty_nil, @@ -56,17 +56,17 @@ type ast_fold[ENV] = (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, + ast::proto proto, + &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, &ann a) -> @ty) fold_ty_path, (fn(&ENV e, &span sp, &@ty t) -> @ty) fold_ty_chan, @@ -74,15 +74,15 @@ type ast_fold[ENV] = // Expr folds. (fn(&ENV e, &span sp, - &vec[@expr] es, ast.mutability mut, + &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, @@ -92,33 +92,33 @@ type ast_fold[ENV] = &ident id, &ann a) -> @expr) fold_expr_self_method, (fn(&ENV e, &span sp, - &@expr f, &vec[Option.t[@expr]] args, + &@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, + 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, + ast::binop, &@expr lhs, &@expr rhs, &ann a) -> @expr) fold_expr_binary, (fn(&ENV e, &span sp, - ast.unop, &@expr e, + 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, + &@ast::expr e, &@ast::ty ty, &ann a) -> @expr) fold_expr_cast, (fn(&ENV e, &span sp, &@expr cond, &block thn, - &Option.t[@expr] els, + &option::t[@expr] els, &ann a) -> @expr) fold_expr_if, (fn(&ENV e, &span sp, @@ -149,7 +149,7 @@ type ast_fold[ENV] = &ann a) -> @expr) fold_expr_assign, (fn(&ENV e, &span sp, - ast.binop, + ast::binop, &@expr lhs, &@expr rhs, &ann a) -> @expr) fold_expr_assign_op, @@ -175,7 +175,7 @@ type ast_fold[ENV] = (fn(&ENV e, &span sp, &path p, &vec[@expr] args, - &Option.t[str] body, + &option::t[str] body, &@expr expanded, &ann a) -> @expr) fold_expr_ext, @@ -186,10 +186,10 @@ type ast_fold[ENV] = (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, @@ -212,7 +212,7 @@ type ast_fold[ENV] = // 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, @@ -223,7 +223,7 @@ type ast_fold[ENV] = &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, @@ -248,44 +248,44 @@ type ast_fold[ENV] = &def_id id, &ann a) -> @item) fold_item_const, (fn(&ENV e, &span sp, &ident ident, - &ast._fn f, - &vec[ast.ty_param] ty_params, + &ast::_fn f, + &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, - &ast.fn_decl decl, - &vec[ast.ty_param] ty_params, + &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, (fn(&ENV e, &span sp, &ident ident, - &ast._mod m, &def_id id) -> @item) fold_item_mod, + &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, + &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, + &@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, - &vec[ast.variant] variants, - &vec[ast.ty_param] ty_params, + &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, - &ast._obj ob, - &vec[ast.ty_param] ty_params, - &ast.obj_def_ids odid, &ann a) -> @item) fold_item_obj, + &ast::_obj ob, + &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, + &option::t[int]) -> @view_item) fold_view_item_use, (fn(&ENV e, &span sp, &ident i, &vec[ident] idents, @@ -300,30 +300,30 @@ type ast_fold[ENV] = // Additional nodes. (fn(&ENV e, &fn_decl decl, - ast.proto proto, - &block body) -> ast._fn) fold_fn, + ast::proto proto, + &block body) -> ast::_fn) fold_fn, (fn(&ENV e, &vec[arg] inputs, &@ty output, - &purity p) -> ast.fn_decl) fold_fn_decl, + &purity p) -> ast::fn_decl) fold_fn_decl, - (fn(&ENV e, &ast._mod m) -> ast._mod) fold_mod, + (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, &ast::native_mod m) -> ast::native_mod) fold_native_mod, (fn(&ENV e, &span sp, - &vec[@ast.crate_directive] cdirs, - &ast._mod m) -> @ast.crate) fold_crate, + &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, &@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, @@ -343,11 +343,11 @@ type ast_fold[ENV] = //// Fold drivers. 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)); + let vec[@ast::ty] tys_ = vec(); + for (@ast::ty t in p.node.types) { + _vec::push[@ast::ty](tys_, fold_ty(env, fld, t)); } - let ast.path_ p_ = rec(idents=p.node.idents, types=tys_); + let ast::path_ p_ = rec(idents=p.node.idents, types=tys_); ret fld.fold_path(env, p.span, p_); } @@ -359,56 +359,56 @@ fn fold_ty[ENV](&ENV env, &ast_fold[ENV] fld, &@ty t) -> @ty { } alt (t.node) { - case (ast.ty_nil) { ret fld.fold_ty_nil(env_, t.span); } - case (ast.ty_bool) { ret fld.fold_ty_bool(env_, t.span); } - case (ast.ty_int) { ret fld.fold_ty_int(env_, t.span); } - case (ast.ty_uint) { ret fld.fold_ty_uint(env_, t.span); } - case (ast.ty_float) { ret fld.fold_ty_float(env_, t.span); } + case (ast::ty_nil) { ret fld.fold_ty_nil(env_, t.span); } + case (ast::ty_bool) { ret fld.fold_ty_bool(env_, t.span); } + case (ast::ty_int) { ret fld.fold_ty_int(env_, t.span); } + case (ast::ty_uint) { ret fld.fold_ty_uint(env_, t.span); } + case (ast::ty_float) { ret fld.fold_ty_float(env_, t.span); } - case (ast.ty_machine(?m)) { + case (ast::ty_machine(?m)) { ret fld.fold_ty_machine(env_, t.span, m); } - case (ast.ty_char) { ret fld.fold_ty_char(env_, t.span); } - case (ast.ty_str) { ret fld.fold_ty_str(env_, t.span); } + case (ast::ty_char) { ret fld.fold_ty_char(env_, t.span); } + case (ast::ty_str) { ret fld.fold_ty_str(env_, t.span); } - case (ast.ty_box(?tm)) { + case (ast::ty_box(?tm)) { auto ty_ = fold_ty(env, fld, tm.ty); ret fld.fold_ty_box(env_, t.span, rec(ty=ty_, mut=tm.mut)); } - case (ast.ty_vec(?tm)) { + case (ast::ty_vec(?tm)) { auto ty_ = fold_ty(env, fld, tm.ty); ret fld.fold_ty_vec(env_, t.span, rec(ty=ty_, mut=tm.mut)); } - case (ast.ty_tup(?elts)) { + case (ast::ty_tup(?elts)) { let vec[mt] elts_ = vec(); for (mt elt in elts) { auto ty_ = fold_ty(env, fld, elt.ty); - Vec.push[mt](elts_, rec(ty=ty_, mut=elt.mut)); + _vec::push[mt](elts_, rec(ty=ty_, mut=elt.mut)); } ret fld.fold_ty_tup(env_, t.span, elts_); } - case (ast.ty_rec(?flds)) { - let vec[ast.ty_field] flds_ = vec(); - for (ast.ty_field f in flds) { + case (ast::ty_rec(?flds)) { + let vec[ast::ty_field] flds_ = vec(); + for (ast::ty_field f in flds) { auto ty_ = fold_ty(env, fld, f.mt.ty); - Vec.push[ast.ty_field] + _vec::push[ast::ty_field] (flds_, rec(mt=rec(ty=ty_, mut=f.mt.mut) with f)); } ret fld.fold_ty_rec(env_, t.span, flds_); } - case (ast.ty_obj(?meths)) { - let vec[ast.ty_method] meths_ = vec(); - for (ast.ty_method m in meths) { + case (ast::ty_obj(?meths)) { + let vec[ast::ty_method] meths_ = vec(); + for (ast::ty_method m in meths) { auto tfn = fold_ty_fn(env_, fld, t.span, m.proto, m.inputs, m.output); alt (tfn.node) { - case (ast.ty_fn(?p, ?ins, ?out)) { - Vec.push[ast.ty_method] + case (ast::ty_fn(?p, ?ins, ?out)) { + _vec::push[ast::ty_method] (meths_, rec(proto=p, inputs=ins, output=out with m)); } @@ -417,21 +417,21 @@ fn fold_ty[ENV](&ENV env, &ast_fold[ENV] fld, &@ty t) -> @ty { ret fld.fold_ty_obj(env_, t.span, meths_); } - case (ast.ty_path(?pth, ?ann)) { + case (ast::ty_path(?pth, ?ann)) { auto pth_ = fold_path(env, fld, pth); ret fld.fold_ty_path(env_, t.span, pth_, ann); } - case (ast.ty_fn(?proto, ?inputs, ?output)) { + case (ast::ty_fn(?proto, ?inputs, ?output)) { ret fold_ty_fn(env_, fld, t.span, proto, inputs, output); } - case (ast.ty_chan(?ty)) { + case (ast::ty_chan(?ty)) { auto ty_ = fold_ty(env, fld, ty); ret fld.fold_ty_chan(env_, t.span, ty_); } - case (ast.ty_port(?ty)) { + case (ast::ty_port(?ty)) { auto ty_ = fold_ty(env, fld, ty); ret fld.fold_ty_port(env_, t.span, ty_); } @@ -439,12 +439,12 @@ 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, - ast.proto proto, - &vec[rec(ast.mode mode, @ty ty)] inputs, + ast::proto proto, + &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) { + let vec[rec(ast::mode mode, @ty ty)] inputs_ = vec(); + for (rec(ast::mode mode, @ty ty) input in inputs) { auto ty_ = fold_ty(env, fld, input.ty); auto input_ = rec(ty=ty_ with input); inputs_ += vec(input_); @@ -460,29 +460,29 @@ fn fold_decl[ENV](&ENV env, &ast_fold[ENV] fld, &@decl d) -> @decl { } alt (d.node) { - case (ast.decl_local(?local)) { - auto ty_ = none[@ast.ty]; - auto init_ = none[ast.initializer]; + case (ast::decl_local(?local)) { + auto ty_ = none[@ast::ty]; + auto init_ = none[ast::initializer]; alt (local.ty) { - case (some[@ast.ty](?t)) { - ty_ = some[@ast.ty](fold_ty(env, fld, t)); + case (some[@ast::ty](?t)) { + ty_ = some[@ast::ty](fold_ty(env, fld, t)); } case (_) { /* fall through */ } } alt (local.init) { - case (some[ast.initializer](?init)) { + case (some[ast::initializer](?init)) { auto e = fold_expr(env, fld, init.expr); - init_ = some[ast.initializer](rec(expr = e with init)); + init_ = some[ast::initializer](rec(expr = e with init)); } case (_) { /* fall through */ } } auto ann_ = fld.fold_ann(env_, local.ann); - let @ast.local local_ = + let @ast::local local_ = @rec(ty=ty_, init=init_, ann=ann_ with *local); ret fld.fold_decl_local(env_, d.span, local_); } - case (ast.decl_item(?item)) { + case (ast::decl_item(?item)) { auto item_ = fold_item(env_, fld, item); ret fld.fold_decl_item(env_, d.span, item_); } @@ -491,7 +491,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_)) { @@ -499,18 +499,18 @@ fn fold_pat[ENV](&ENV env, &ast_fold[ENV] fld, &@ast.pat p) -> @ast.pat { } alt (p.node) { - case (ast.pat_wild(?t)) { ret fld.fold_pat_wild(env_, p.span, t); } - case (ast.pat_lit(?lt, ?t)) { + case (ast::pat_wild(?t)) { ret fld.fold_pat_wild(env_, p.span, t); } + case (ast::pat_lit(?lt, ?t)) { ret fld.fold_pat_lit(env_, p.span, lt, t); } - case (ast.pat_bind(?id, ?did, ?t)) { + case (ast::pat_bind(?id, ?did, ?t)) { ret fld.fold_pat_bind(env_, p.span, id, did, t); } - case (ast.pat_tag(?path, ?pats, ?t)) { + case (ast::pat_tag(?path, ?pats, ?t)) { auto ppath = fold_path(env, fld, path); - let vec[@ast.pat] ppats = vec(); - for (@ast.pat pat in pats) { + let vec[@ast::pat] ppats = vec(); + for (@ast::pat pat in pats) { ppats += vec(fold_pat(env_, fld, pat)); } @@ -523,17 +523,17 @@ 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)); + _vec::push[@expr](exprs, fold_expr(env, fld, e)); } 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) - -> ast.field { +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); } @@ -546,30 +546,30 @@ fn fold_expr[ENV](&ENV env, &ast_fold[ENV] fld, &@expr e) -> @expr { } alt (e.node) { - case (ast.expr_vec(?es, ?mut, ?t)) { + case (ast::expr_vec(?es, ?mut, ?t)) { auto ees = fold_exprs(env_, fld, es); auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_vec(env_, e.span, ees, mut, t2); } - case (ast.expr_tup(?es, ?t)) { - let vec[ast.elt] elts = vec(); - for (ast.elt e in es) { + case (ast::expr_tup(?es, ?t)) { + let vec[ast::elt] elts = vec(); + for (ast::elt e in es) { elts += vec(fold_tup_elt[ENV](env, fld, e)); } auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_tup(env_, e.span, elts, t2); } - case (ast.expr_rec(?fs, ?base, ?t)) { - let vec[ast.field] fields = vec(); - let Option.t[@expr] b = none[@expr]; - for (ast.field f in fs) { + case (ast::expr_rec(?fs, ?base, ?t)) { + let vec[ast::field] fields = vec(); + let option::t[@expr] b = none[@expr]; + for (ast::field f in fs) { fields += vec(fold_rec_field(env, fld, f)); } alt (base) { - case (none[@ast.expr]) { } - case (some[@ast.expr](?eb)) { + case (none[@ast::expr]) { } + case (some[@ast::expr](?eb)) { b = some[@expr](fold_expr(env_, fld, eb)); } } @@ -577,69 +577,69 @@ fn fold_expr[ENV](&ENV env, &ast_fold[ENV] fld, &@expr e) -> @expr { ret fld.fold_expr_rec(env_, e.span, fields, b, t2); } - case (ast.expr_call(?f, ?args, ?t)) { + case (ast::expr_call(?f, ?args, ?t)) { auto ff = fold_expr(env_, fld, f); auto aargs = fold_exprs(env_, fld, args); auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_call(env_, e.span, ff, aargs, t2); } - case (ast.expr_self_method(?ident, ?t)) { + case (ast::expr_self_method(?ident, ?t)) { auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_self_method(env_, e.span, ident, t2); } - case (ast.expr_bind(?f, ?args_opt, ?t)) { + case (ast::expr_bind(?f, ?args_opt, ?t)) { auto ff = fold_expr(env_, fld, f); - let vec[Option.t[@ast.expr]] aargs_opt = vec(); - for (Option.t[@ast.expr] t_opt in args_opt) { + let vec[option::t[@ast::expr]] aargs_opt = vec(); + for (option::t[@ast::expr] t_opt in args_opt) { alt (t_opt) { - case (none[@ast.expr]) { - aargs_opt += vec(none[@ast.expr]); + case (none[@ast::expr]) { + aargs_opt += vec(none[@ast::expr]); } - case (some[@ast.expr](?e)) { + case (some[@ast::expr](?e)) { aargs_opt += vec(some(fold_expr(env_, fld, e))); } - case (none[@ast.expr]) { /* empty */ } + case (none[@ast::expr]) { /* empty */ } } } auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_bind(env_, e.span, ff, aargs_opt, t2); } - case (ast.expr_spawn(?dom, ?name, ?f, ?args, ?t)) { + case (ast::expr_spawn(?dom, ?name, ?f, ?args, ?t)) { auto ff = fold_expr(env_, fld, f); auto aargs = fold_exprs(env_, fld, args); auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_spawn(env_, e.span, dom, name, ff, aargs, t2); } - case (ast.expr_binary(?op, ?a, ?b, ?t)) { + case (ast::expr_binary(?op, ?a, ?b, ?t)) { auto aa = fold_expr(env_, fld, a); auto bb = fold_expr(env_, fld, b); auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_binary(env_, e.span, op, aa, bb, t2); } - case (ast.expr_unary(?op, ?a, ?t)) { + case (ast::expr_unary(?op, ?a, ?t)) { auto aa = fold_expr(env_, fld, a); auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_unary(env_, e.span, op, aa, t2); } - case (ast.expr_lit(?lit, ?t)) { + case (ast::expr_lit(?lit, ?t)) { auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_lit(env_, e.span, lit, t2); } - case (ast.expr_cast(?e, ?t, ?at)) { + case (ast::expr_cast(?e, ?t, ?at)) { auto ee = fold_expr(env_, fld, e); auto tt = fold_ty(env, fld, t); auto at2 = fld.fold_ann(env_, at); ret fld.fold_expr_cast(env_, e.span, ee, tt, at2); } - case (ast.expr_if(?cnd, ?thn, ?els, ?t)) { + case (ast::expr_if(?cnd, ?thn, ?els, ?t)) { auto ccnd = fold_expr(env_, fld, cnd); auto tthn = fold_block(env_, fld, thn); auto eels = none[@expr]; @@ -653,7 +653,7 @@ fn fold_expr[ENV](&ENV env, &ast_fold[ENV] fld, &@expr e) -> @expr { ret fld.fold_expr_if(env_, e.span, ccnd, tthn, eels, t2); } - case (ast.expr_for(?decl, ?seq, ?body, ?t)) { + case (ast::expr_for(?decl, ?seq, ?body, ?t)) { auto ddecl = fold_decl(env_, fld, decl); auto sseq = fold_expr(env_, fld, seq); auto bbody = fold_block(env_, fld, body); @@ -661,7 +661,7 @@ fn fold_expr[ENV](&ENV env, &ast_fold[ENV] fld, &@expr e) -> @expr { ret fld.fold_expr_for(env_, e.span, ddecl, sseq, bbody, t2); } - case (ast.expr_for_each(?decl, ?seq, ?body, ?t)) { + case (ast::expr_for_each(?decl, ?seq, ?body, ?t)) { auto ddecl = fold_decl(env_, fld, decl); auto sseq = fold_expr(env_, fld, seq); auto bbody = fold_block(env_, fld, body); @@ -669,84 +669,84 @@ fn fold_expr[ENV](&ENV env, &ast_fold[ENV] fld, &@expr e) -> @expr { ret fld.fold_expr_for_each(env_, e.span, ddecl, sseq, bbody, t2); } - case (ast.expr_while(?cnd, ?body, ?t)) { + case (ast::expr_while(?cnd, ?body, ?t)) { auto ccnd = fold_expr(env_, fld, cnd); auto bbody = fold_block(env_, fld, body); auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_while(env_, e.span, ccnd, bbody, t2); } - case (ast.expr_do_while(?body, ?cnd, ?t)) { + case (ast::expr_do_while(?body, ?cnd, ?t)) { auto bbody = fold_block(env_, fld, body); auto ccnd = fold_expr(env_, fld, cnd); auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_do_while(env_, e.span, bbody, ccnd, t2); } - case (ast.expr_alt(?expr, ?arms, ?t)) { + case (ast::expr_alt(?expr, ?arms, ?t)) { auto eexpr = fold_expr(env_, fld, expr); - let vec[ast.arm] aarms = vec(); - for (ast.arm a in arms) { + let vec[ast::arm] aarms = vec(); + for (ast::arm a in arms) { aarms += vec(fold_arm(env_, fld, a)); } auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_alt(env_, e.span, eexpr, aarms, t2); } - case (ast.expr_block(?b, ?t)) { + case (ast::expr_block(?b, ?t)) { auto bb = fold_block(env_, fld, b); auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_block(env_, e.span, bb, t2); } - case (ast.expr_assign(?lhs, ?rhs, ?t)) { + case (ast::expr_assign(?lhs, ?rhs, ?t)) { auto llhs = fold_expr(env_, fld, lhs); auto rrhs = fold_expr(env_, fld, rhs); auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_assign(env_, e.span, llhs, rrhs, t2); } - case (ast.expr_assign_op(?op, ?lhs, ?rhs, ?t)) { + case (ast::expr_assign_op(?op, ?lhs, ?rhs, ?t)) { auto llhs = fold_expr(env_, fld, lhs); auto rrhs = fold_expr(env_, fld, rhs); auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_assign_op(env_, e.span, op, llhs, rrhs, t2); } - case (ast.expr_send(?lhs, ?rhs, ?t)) { + case (ast::expr_send(?lhs, ?rhs, ?t)) { auto llhs = fold_expr(env_, fld, lhs); auto rrhs = fold_expr(env_, fld, rhs); auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_send(env_, e.span, llhs, rrhs, t2); } - case (ast.expr_recv(?lhs, ?rhs, ?t)) { + case (ast::expr_recv(?lhs, ?rhs, ?t)) { auto llhs = fold_expr(env_, fld, lhs); auto rrhs = fold_expr(env_, fld, rhs); auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_recv(env_, e.span, llhs, rrhs, t2); } - case (ast.expr_field(?e, ?i, ?t)) { + case (ast::expr_field(?e, ?i, ?t)) { auto ee = fold_expr(env_, fld, e); auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_field(env_, e.span, ee, i, t2); } - case (ast.expr_index(?e, ?ix, ?t)) { + case (ast::expr_index(?e, ?ix, ?t)) { auto ee = fold_expr(env_, fld, e); auto iix = fold_expr(env_, fld, ix); auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_index(env_, e.span, ee, iix, t2); } - case (ast.expr_path(?p, ?t)) { + case (ast::expr_path(?p, ?t)) { auto p_ = fold_path(env_, fld, p); auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_path(env_, e.span, p_, t2); } - case (ast.expr_ext(?p, ?args, ?body, ?expanded, ?t)) { + case (ast::expr_ext(?p, ?args, ?body, ?expanded, ?t)) { // Only fold the expanded expression, not the // expressions involved in syntax extension auto exp = fold_expr(env_, fld, expanded); @@ -755,22 +755,22 @@ fn fold_expr[ENV](&ENV env, &ast_fold[ENV] fld, &@expr e) -> @expr { exp, t2); } - case (ast.expr_fail(?t)) { + case (ast::expr_fail(?t)) { auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_fail(env_, e.span, t2); } - case (ast.expr_break(?t)) { + case (ast::expr_break(?t)) { auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_break(env_, e.span, t2); } - case (ast.expr_cont(?t)) { + case (ast::expr_cont(?t)) { auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_cont(env_, e.span, t2); } - case (ast.expr_ret(?oe, ?t)) { + case (ast::expr_ret(?oe, ?t)) { auto oee = none[@expr]; alt (oe) { case (some[@expr](?x)) { @@ -782,7 +782,7 @@ fn fold_expr[ENV](&ENV env, &ast_fold[ENV] fld, &@expr e) -> @expr { ret fld.fold_expr_ret(env_, e.span, oee, t2); } - case (ast.expr_put(?oe, ?t)) { + case (ast::expr_put(?oe, ?t)) { auto oee = none[@expr]; alt (oe) { case (some[@expr](?x)) { @@ -794,36 +794,36 @@ fn fold_expr[ENV](&ENV env, &ast_fold[ENV] fld, &@expr e) -> @expr { ret fld.fold_expr_put(env_, e.span, oee, t2); } - case (ast.expr_be(?x, ?t)) { + case (ast::expr_be(?x, ?t)) { auto ee = fold_expr(env_, fld, x); auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_be(env_, e.span, ee, t2); } - case (ast.expr_log(?l, ?x, ?t)) { + case (ast::expr_log(?l, ?x, ?t)) { auto ee = fold_expr(env_, fld, x); auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_log(env_, e.span, l, ee, t2); } - case (ast.expr_check(?x, ?t)) { + case (ast::expr_check(?x, ?t)) { auto ee = fold_expr(env_, fld, x); auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_check(env_, e.span, ee, t2); } - case (ast.expr_assert(?x, ?t)) { + case (ast::expr_assert(?x, ?t)) { auto ee = fold_expr(env_, fld, x); auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_assert(env_, e.span, ee, t2); } - case (ast.expr_port(?t)) { + case (ast::expr_port(?t)) { auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_port(env_, e.span, t2); } - case (ast.expr_chan(?x, ?t)) { + case (ast::expr_chan(?x, ?t)) { auto ee = fold_expr(env_, fld, x); auto t2 = fld.fold_ann(env_, t); ret fld.fold_expr_chan(env_, e.span, ee, t2); @@ -843,13 +843,13 @@ fn fold_stmt[ENV](&ENV env, &ast_fold[ENV] fld, &@stmt s) -> @stmt { } alt (s.node) { - case (ast.stmt_decl(?d, ?a)) { + case (ast::stmt_decl(?d, ?a)) { auto dd = fold_decl(env_, fld, d); auto aa = fld.fold_ann(env_, a); ret fld.fold_stmt_decl(env_, s.span, dd, aa); } - case (ast.stmt_expr(?e, ?a)) { + case (ast::stmt_expr(?e, ?a)) { auto ee = fold_expr(env_, fld, e); auto aa = fld.fold_ann(env_, a); ret fld.fold_stmt_expr(env_, s.span, ee, aa); @@ -866,18 +866,18 @@ fn fold_block[ENV](&ENV env, &ast_fold[ENV] fld, &block blk) -> block { ret blk; } - let vec[@ast.stmt] stmts = vec(); - for (@ast.stmt s in blk.node.stmts) { + let vec[@ast::stmt] stmts = vec(); + for (@ast::stmt s in blk.node.stmts) { auto new_stmt = fold_stmt[ENV](env_, fld, s); - Vec.push[@ast.stmt](stmts, new_stmt); + _vec::push[@ast::stmt](stmts, new_stmt); } - auto expr = none[@ast.expr]; + auto expr = none[@ast::expr]; alt (blk.node.expr) { - case (some[@ast.expr](?e)) { - expr = some[@ast.expr](fold_expr[ENV](env_, fld, e)); + case (some[@ast::expr](?e)) { + expr = some[@ast::expr](fold_expr[ENV](env_, fld, e)); } - case (none[@ast.expr]) { + case (none[@ast::expr]) { // empty } } @@ -899,16 +899,16 @@ fn fold_arg[ENV](&ENV env, &ast_fold[ENV] fld, &arg a) -> arg { } 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) { + &ast::fn_decl decl) -> ast::fn_decl { + let vec[ast::arg] inputs = vec(); + for (ast::arg a in decl.inputs) { inputs += vec(fold_arg(env, fld, a)); } auto output = fold_ty[ENV](env, fld, decl.output); 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); @@ -918,46 +918,46 @@ 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, - &ast.obj_field f) -> ast.obj_field { + &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 { + &@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(); - for (ast.obj_field f in ob.fields) { + let vec[ast::obj_field] fields = vec(); + let vec[@ast::method] meths = vec(); + for (ast::obj_field f in ob.fields) { fields += vec(fold_obj_field(env, fld, f)); } - let Option.t[@ast.method] dtor = none[@ast.method]; + let option::t[@ast::method] dtor = none[@ast::method]; alt (ob.dtor) { - case (none[@ast.method]) { } - case (some[@ast.method](?m)) { - dtor = some[@ast.method](fold_method[ENV](env, fld, m)); + case (none[@ast::method]) { } + case (some[@ast::method](?m)) { + dtor = some[@ast::method](fold_method[ENV](env, fld, m)); } } - let vec[ast.ty_param] tp = vec(); - for (@ast.method m in ob.methods) { - // Fake-up an ast.item for this method. + let vec[ast::ty_param] tp = vec(); + for (@ast::method m in ob.methods) { + // Fake-up an ast::item for this method. // FIXME: this is kinda awful. Maybe we should reformulate // the way we store methods in the AST? - let @ast.item i = @rec(node=ast.item_fn(m.node.ident, + let @ast::item i = @rec(node=ast::item_fn(m.node.ident, m.node.meth, tp, m.node.id, m.node.ann), span=m.span); let ENV _env = fld.update_env_for_item(env, i); - Vec.push[@ast.method](meths, fold_method(_env, fld, m)); + _vec::push[@ast::method](meths, fold_method(_env, fld, m)); } ret fld.fold_obj(env, fields, meths, dtor); } @@ -972,16 +972,16 @@ fn fold_view_item[ENV](&ENV env, &ast_fold[ENV] fld, &@view_item vi) } alt (vi.node) { - case (ast.view_item_use(?ident, ?meta_items, ?def_id, ?cnum)) { + case (ast::view_item_use(?ident, ?meta_items, ?def_id, ?cnum)) { ret fld.fold_view_item_use(env_, vi.span, ident, meta_items, def_id, cnum); } - case (ast.view_item_import(?def_ident, ?idents, ?def_id)) { + case (ast::view_item_import(?def_ident, ?idents, ?def_id)) { ret fld.fold_view_item_import(env_, vi.span, def_ident, idents, def_id); } - case (ast.view_item_export(?def_ident)) { + case (ast::view_item_export(?def_ident)) { ret fld.fold_view_item_export(env_, vi.span, def_ident); } } @@ -999,50 +999,50 @@ fn fold_item[ENV](&ENV env, &ast_fold[ENV] fld, &@item i) -> @item { alt (i.node) { - case (ast.item_const(?ident, ?t, ?e, ?id, ?ann)) { - let @ast.ty t_ = fold_ty[ENV](env_, fld, t); - let @ast.expr e_ = fold_expr(env_, fld, e); + case (ast::item_const(?ident, ?t, ?e, ?id, ?ann)) { + let @ast::ty t_ = fold_ty[ENV](env_, fld, t); + let @ast::expr e_ = fold_expr(env_, fld, e); ret fld.fold_item_const(env_, i.span, ident, t_, e_, id, ann); } - case (ast.item_fn(?ident, ?ff, ?tps, ?id, ?ann)) { - let ast._fn ff_ = fold_fn[ENV](env_, fld, ff); + case (ast::item_fn(?ident, ?ff, ?tps, ?id, ?ann)) { + let ast::_fn ff_ = fold_fn[ENV](env_, fld, ff); ret fld.fold_item_fn(env_, i.span, ident, ff_, tps, id, ann); } - case (ast.item_mod(?ident, ?mm, ?id)) { - let ast._mod mm_ = fold_mod[ENV](env_, fld, mm); + case (ast::item_mod(?ident, ?mm, ?id)) { + let ast::_mod mm_ = fold_mod[ENV](env_, fld, mm); ret fld.fold_item_mod(env_, i.span, ident, mm_, id); } - case (ast.item_native_mod(?ident, ?mm, ?id)) { - let ast.native_mod mm_ = fold_native_mod[ENV](env_, fld, mm); + case (ast::item_native_mod(?ident, ?mm, ?id)) { + let ast::native_mod mm_ = fold_native_mod[ENV](env_, fld, mm); ret fld.fold_item_native_mod(env_, i.span, ident, mm_, id); } - case (ast.item_ty(?ident, ?ty, ?params, ?id, ?ann)) { - let @ast.ty ty_ = fold_ty[ENV](env_, fld, ty); + case (ast::item_ty(?ident, ?ty, ?params, ?id, ?ann)) { + let @ast::ty ty_ = fold_ty[ENV](env_, fld, ty); ret fld.fold_item_ty(env_, i.span, ident, ty_, params, id, ann); } - case (ast.item_tag(?ident, ?variants, ?ty_params, ?id, ?ann)) { - let vec[ast.variant] new_variants = vec(); - for (ast.variant v in variants) { - let vec[ast.variant_arg] new_args = vec(); - for (ast.variant_arg va in v.node.args) { + case (ast::item_tag(?ident, ?variants, ?ty_params, ?id, ?ann)) { + let vec[ast::variant] new_variants = vec(); + for (ast::variant v in variants) { + let vec[ast::variant_arg] new_args = vec(); + for (ast::variant_arg va in v.node.args) { auto new_ty = fold_ty[ENV](env_, fld, va.ty); new_args += vec(rec(ty=new_ty, id=va.id)); } auto new_v = rec(name=v.node.name, args=new_args, id=v.node.id, ann=v.node.ann); - new_variants += vec(respan[ast.variant_](v.span, new_v)); + new_variants += vec(respan[ast::variant_](v.span, new_v)); } ret fld.fold_item_tag(env_, i.span, ident, new_variants, ty_params, id, ann); } - case (ast.item_obj(?ident, ?ob, ?tps, ?odid, ?ann)) { - let ast._obj ob_ = fold_obj[ENV](env_, fld, ob); + case (ast::item_obj(?ident, ?ob, ?tps, ?odid, ?ann)) { + let ast::_obj ob_ = fold_obj[ENV](env_, fld, ob); ret fld.fold_item_obj(env_, i.span, ident, ob_, tps, odid, ann); } @@ -1051,19 +1051,19 @@ 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(); for (@view_item vi in m.view_items) { auto new_vi = fold_view_item[ENV](e, fld, vi); - Vec.push[@view_item](view_items, new_vi); + _vec::push[@view_item](view_items, new_vi); } for (@item i in m.items) { auto new_item = fold_item[ENV](e, fld, i); - Vec.push[@item](items, new_item); + _vec::push[@item](items, new_item); } ret fld.fold_mod(e, rec(view_items=view_items, items=items)); @@ -1077,10 +1077,10 @@ fn fold_native_item[ENV](&ENV env, &ast_fold[ENV] fld, ret i; } alt (i.node) { - case (ast.native_item_ty(?ident, ?id)) { + case (ast::native_item_ty(?ident, ?id)) { ret fld.fold_native_item_ty(env_, i.span, ident, id); } - case (ast.native_item_fn(?ident, ?lname, ?fn_decl, + case (ast::native_item_fn(?ident, ?lname, ?fn_decl, ?ty_params, ?id, ?ann)) { auto d = fold_fn_decl[ENV](env_, fld, fn_decl); ret fld.fold_native_item_fn(env_, i.span, ident, lname, d, @@ -1090,18 +1090,18 @@ fn fold_native_item[ENV](&ENV env, &ast_fold[ENV] fld, } fn fold_native_mod[ENV](&ENV e, &ast_fold[ENV] fld, - &ast.native_mod m) -> ast.native_mod { + &ast::native_mod m) -> ast::native_mod { let vec[@view_item] view_items = vec(); let vec[@native_item] items = vec(); for (@view_item vi in m.view_items) { auto new_vi = fold_view_item[ENV](e, fld, vi); - Vec.push[@view_item](view_items, new_vi); + _vec::push[@view_item](view_items, new_vi); } for (@native_item i in m.items) { auto new_item = fold_native_item[ENV](e, fld, i); - Vec.push[@native_item](items, new_item); + _vec::push[@native_item](items, new_item); } ret fld.fold_native_mod(e, rec(native_name=m.native_name, @@ -1111,12 +1111,12 @@ fn fold_native_mod[ENV](&ENV e, &ast_fold[ENV] fld, } fn fold_crate[ENV](&ENV env, &ast_fold[ENV] fld, - &@ast.crate c) -> @ast.crate { + &@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 + // within them? Not clear. After front/eval::rs, nothing else should look // at crate directives. let ENV env_ = fld.update_env_for_crate(env, c); - let ast._mod m = fold_mod[ENV](env_, fld, c.node.module); + let ast::_mod m = fold_mod[ENV](env_, fld, c.node.module); ret fld.fold_crate(env_, c.span, c.node.directives, m); } @@ -1129,319 +1129,319 @@ 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); } // Type identities. fn identity_fold_ty_nil[ENV](&ENV env, &span sp) -> @ty { - ret @respan(sp, ast.ty_nil); + ret @respan(sp, ast::ty_nil); } fn identity_fold_ty_bool[ENV](&ENV env, &span sp) -> @ty { - ret @respan(sp, ast.ty_bool); + ret @respan(sp, ast::ty_bool); } fn identity_fold_ty_int[ENV](&ENV env, &span sp) -> @ty { - ret @respan(sp, ast.ty_int); + ret @respan(sp, ast::ty_int); } fn identity_fold_ty_uint[ENV](&ENV env, &span sp) -> @ty { - ret @respan(sp, ast.ty_uint); + ret @respan(sp, ast::ty_uint); } fn identity_fold_ty_float[ENV](&ENV env, &span sp) -> @ty { - ret @respan(sp, ast.ty_float); + ret @respan(sp, ast::ty_float); } fn identity_fold_ty_machine[ENV](&ENV env, &span sp, ty_mach tm) -> @ty { - ret @respan(sp, ast.ty_machine(tm)); + ret @respan(sp, ast::ty_machine(tm)); } fn identity_fold_ty_char[ENV](&ENV env, &span sp) -> @ty { - ret @respan(sp, ast.ty_char); + ret @respan(sp, ast::ty_char); } fn identity_fold_ty_str[ENV](&ENV env, &span sp) -> @ty { - ret @respan(sp, ast.ty_str); + ret @respan(sp, ast::ty_str); } fn identity_fold_ty_box[ENV](&ENV env, &span sp, &mt tm) -> @ty { - ret @respan(sp, ast.ty_box(tm)); + ret @respan(sp, ast::ty_box(tm)); } fn identity_fold_ty_vec[ENV](&ENV env, &span sp, &mt tm) -> @ty { - ret @respan(sp, ast.ty_vec(tm)); + ret @respan(sp, ast::ty_vec(tm)); } fn identity_fold_ty_tup[ENV](&ENV env, &span sp, &vec[mt] elts) -> @ty { - ret @respan(sp, ast.ty_tup(elts)); + ret @respan(sp, ast::ty_tup(elts)); } fn identity_fold_ty_rec[ENV](&ENV env, &span sp, - &vec[ast.ty_field] elts) -> @ty { - ret @respan(sp, ast.ty_rec(elts)); + &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 { - ret @respan(sp, ast.ty_obj(meths)); + &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, + ast::proto proto, + &vec[rec(ast::mode mode, @ty ty)] inputs, &@ty output) -> @ty { - ret @respan(sp, ast.ty_fn(proto, inputs, output)); + ret @respan(sp, ast::ty_fn(proto, inputs, output)); } -fn identity_fold_ty_path[ENV](&ENV env, &span sp, &ast.path p, +fn identity_fold_ty_path[ENV](&ENV env, &span sp, &ast::path p, &ann a) -> @ty { - ret @respan(sp, ast.ty_path(p, a)); + ret @respan(sp, ast::ty_path(p, a)); } fn identity_fold_ty_chan[ENV](&ENV env, &span sp, &@ty t) -> @ty { - ret @respan(sp, ast.ty_chan(t)); + ret @respan(sp, ast::ty_chan(t)); } fn identity_fold_ty_port[ENV](&ENV env, &span sp, &@ty t) -> @ty { - ret @respan(sp, ast.ty_port(t)); + 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 { - ret @respan(sp, ast.expr_vec(es, mut, a)); + 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 { - ret @respan(sp, ast.expr_tup(es, a)); + &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 { - ret @respan(sp, ast.expr_rec(fields, base, a)); + &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 { - ret @respan(sp, ast.expr_call(f, args, a)); + 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 { - ret @respan(sp, ast.expr_self_method(id, a)); + 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) + &vec[option::t[@expr]] args_opt, &ann a) -> @expr { - ret @respan(sp, ast.expr_bind(f, args_opt, a)); + 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, + 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)); + ret @respan(sp, ast::expr_spawn(dom, name, f, args, a)); } -fn identity_fold_expr_binary[ENV](&ENV env, &span sp, ast.binop b, +fn identity_fold_expr_binary[ENV](&ENV env, &span sp, ast::binop b, &@expr lhs, &@expr rhs, &ann a) -> @expr { - ret @respan(sp, ast.expr_binary(b, lhs, rhs, a)); + 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)); + ret @respan(sp, ast::expr_unary(u, e, a)); } -fn identity_fold_expr_lit[ENV](&ENV env, &span sp, &@ast.lit lit, +fn identity_fold_expr_lit[ENV](&ENV env, &span sp, &@ast::lit lit, &ann a) -> @expr { - ret @respan(sp, ast.expr_lit(lit, a)); + 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 { - ret @respan(sp, ast.expr_cast(e, t, a)); +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 { - ret @respan(sp, ast.expr_if(cond, thn, els, a)); + &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 { - ret @respan(sp, ast.expr_for(d, seq, body, a)); + 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 { - ret @respan(sp, ast.expr_for_each(d, seq, body, a)); + 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 { - ret @respan(sp, ast.expr_while(cond, body, a)); + 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 { - ret @respan(sp, ast.expr_do_while(body, cond, a)); + 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 { - ret @respan(sp, ast.expr_alt(e, arms, a)); + ret @respan(sp, ast::expr_alt(e, arms, a)); } fn identity_fold_expr_block[ENV](&ENV env, &span sp, &block blk, &ann a) -> @expr { - ret @respan(sp, ast.expr_block(blk, a)); + 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 { - ret @respan(sp, ast.expr_assign(lhs, rhs, a)); + ret @respan(sp, ast::expr_assign(lhs, rhs, a)); } -fn identity_fold_expr_assign_op[ENV](&ENV env, &span sp, ast.binop op, +fn identity_fold_expr_assign_op[ENV](&ENV env, &span sp, ast::binop op, &@expr lhs, &@expr rhs, &ann a) -> @expr { - ret @respan(sp, ast.expr_assign_op(op, lhs, rhs, a)); + 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 { - ret @respan(sp, ast.expr_send(lhs, rhs, a)); + 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 { - ret @respan(sp, ast.expr_recv(lhs, rhs, a)); + 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 { - ret @respan(sp, ast.expr_field(e, i, a)); + 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 { - ret @respan(sp, ast.expr_index(e, ix, a)); + ret @respan(sp, ast::expr_index(e, ix, a)); } fn identity_fold_expr_path[ENV](&ENV env, &span sp, &path p, &ann a) -> @expr { - ret @respan(sp, ast.expr_path(p, a)); + ret @respan(sp, ast::expr_path(p, a)); } fn identity_fold_expr_ext[ENV](&ENV env, &span sp, &path p, &vec[@expr] args, - &Option.t[str] body, + &option::t[str] body, &@expr expanded, &ann a) -> @expr { - ret @respan(sp, ast.expr_ext(p, args, body, expanded, a)); + ret @respan(sp, ast::expr_ext(p, args, body, expanded, a)); } fn identity_fold_expr_fail[ENV](&ENV env, &span sp, &ann a) -> @expr { - ret @respan(sp, ast.expr_fail(a)); + ret @respan(sp, ast::expr_fail(a)); } fn identity_fold_expr_break[ENV](&ENV env, &span sp, &ann a) -> @expr { - ret @respan(sp, ast.expr_break(a)); + ret @respan(sp, ast::expr_break(a)); } fn identity_fold_expr_cont[ENV](&ENV env, &span sp, &ann a) -> @expr { - ret @respan(sp, ast.expr_cont(a)); + ret @respan(sp, ast::expr_cont(a)); } fn identity_fold_expr_ret[ENV](&ENV env, &span sp, - &Option.t[@expr] rv, &ann a) -> @expr { - ret @respan(sp, ast.expr_ret(rv, a)); + &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 { - ret @respan(sp, ast.expr_put(rv, a)); + &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 { - ret @respan(sp, ast.expr_be(x, a)); + 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 { - ret @respan(sp, ast.expr_log(lvl, x, a)); + ret @respan(sp, ast::expr_log(lvl, x, a)); } fn identity_fold_expr_check[ENV](&ENV e, &span sp, &@expr x, &ann a) -> @expr { - ret @respan(sp, ast.expr_check(x, a)); + ret @respan(sp, ast::expr_check(x, a)); } fn identity_fold_expr_assert[ENV](&ENV e, &span sp, &@expr x, &ann a) -> @expr { - ret @respan(sp, ast.expr_assert(x, a)); + ret @respan(sp, ast::expr_assert(x, a)); } fn identity_fold_expr_port[ENV](&ENV e, &span sp, &ann a) -> @expr { - ret @respan(sp, ast.expr_port(a)); + ret @respan(sp, ast::expr_port(a)); } fn identity_fold_expr_chan[ENV](&ENV e, &span sp, &@expr x, &ann a) -> @expr { - ret @respan(sp, ast.expr_chan(x, a)); + ret @respan(sp, ast::expr_chan(x, a)); } // Decl identities. fn identity_fold_decl_local[ENV](&ENV e, &span sp, - &@ast.local local) -> @decl { - ret @respan(sp, ast.decl_local(local)); + &@ast::local local) -> @decl { + ret @respan(sp, ast::decl_local(local)); } fn identity_fold_decl_item[ENV](&ENV e, &span sp, &@item i) -> @decl { - ret @respan(sp, ast.decl_item(i)); + ret @respan(sp, ast::decl_item(i)); } // Pat identities. fn identity_fold_pat_wild[ENV](&ENV e, &span sp, &ann a) -> @pat { - ret @respan(sp, ast.pat_wild(a)); + ret @respan(sp, ast::pat_wild(a)); } fn identity_fold_pat_lit[ENV](&ENV e, &span sp, - &@ast.lit lit, &ann a) -> @pat { - ret @respan(sp, ast.pat_lit(lit, a)); + &@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) -> @pat { - ret @respan(sp, ast.pat_bind(i, did, a)); + ret @respan(sp, ast::pat_bind(i, did, a)); } fn identity_fold_pat_tag[ENV](&ENV e, &span sp, &path p, &vec[@pat] args, &ann a) -> @pat { - ret @respan(sp, ast.pat_tag(p, args, a)); + ret @respan(sp, ast::pat_tag(p, args, a)); } @@ -1449,12 +1449,12 @@ fn identity_fold_pat_tag[ENV](&ENV e, &span sp, &path p, &vec[@pat] args, fn identity_fold_stmt_decl[ENV](&ENV env, &span sp, &@decl d, &ann a) -> @stmt { - ret @respan(sp, ast.stmt_decl(d, a)); + ret @respan(sp, ast::stmt_decl(d, a)); } fn identity_fold_stmt_expr[ENV](&ENV e, &span sp, &@expr x, &ann a) -> @stmt { - ret @respan(sp, ast.stmt_expr(x, a)); + ret @respan(sp, ast::stmt_expr(x, a)); } @@ -1463,76 +1463,77 @@ fn identity_fold_stmt_expr[ENV](&ENV e, &span sp, 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)); + 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, + &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)); + 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, - &ast.fn_decl decl, - &vec[ast.ty_param] ty_params, + &option::t[str] link_name, + &ast::fn_decl decl, + &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)); + 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 { - ret @respan(sp, ast.item_mod(i, m, id)); + &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, + &ast::native_mod m, &def_id id) -> @item { - ret @respan(sp, ast.item_native_mod(i, m, id)); + 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, + &@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)); + 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 { - ret @respan(sp, ast.native_item_ty(i, id)); + 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, + &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)); + 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 { - ret @respan(sp, ast.item_obj(i, ob, ty_params, odid, a)); + &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) + &def_id id, &option::t[int] cnum) -> @view_item { - ret @respan(sp, ast.view_item_use(i, meta_items, id, cnum)); + 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) -> @view_item { - ret @respan(sp, ast.view_item_import(i, is, id)); + ret @respan(sp, ast::view_item_import(i, is, id)); } fn identity_fold_view_item_export[ENV](&ENV e, &span sp, &ident i) -> @view_item { - ret @respan(sp, ast.view_item_export(i)); + ret @respan(sp, ast::view_item_export(i)); } // Annotation folding. @@ -1543,50 +1544,50 @@ fn identity_fold_ann[ENV](&ENV e, &ann a) -> ann { // Additional identities. -fn identity_fold_block[ENV](&ENV e, &span sp, &ast.block_ blk) -> block { +fn identity_fold_block[ENV](&ENV e, &span sp, &ast::block_ blk) -> block { ret respan(sp, blk); } fn identity_fold_fn_decl[ENV](&ENV e, &vec[arg] inputs, &@ty output, - &purity p) -> ast.fn_decl { + &purity p) -> ast::fn_decl { ret rec(inputs=inputs, output=output, purity=p); } fn identity_fold_fn[ENV](&ENV e, &fn_decl decl, - ast.proto proto, - &block body) -> ast._fn { + ast::proto proto, + &block body) -> ast::_fn { ret rec(decl=decl, proto=proto, body=body); } -fn identity_fold_mod[ENV](&ENV e, &ast._mod m) -> ast._mod { +fn identity_fold_mod[ENV](&ENV e, &ast::_mod m) -> ast::_mod { ret m; } fn identity_fold_native_mod[ENV](&ENV e, - &ast.native_mod m) -> ast.native_mod { + &ast::native_mod m) -> ast::native_mod { ret m; } fn identity_fold_crate[ENV](&ENV e, &span sp, - &vec[@ast.crate_directive] cdirs, - &ast._mod m) -> @ast.crate { + &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; } |