From 476442e48ce0dad5dfbb09a7ef874e09339224fc Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Mon, 9 May 2011 16:09:00 -0700 Subject: [PATCH] Alias-ify walk, typeck, metadata. Cuts another 80kb off rustc. --- src/comp/middle/capture.rs | 6 +- src/comp/middle/metadata.rs | 75 +++++++++---------- src/comp/middle/trans.rs | 18 ++--- src/comp/middle/ty.rs | 2 +- src/comp/middle/typeck.rs | 142 ++++++++++++++++++------------------ src/comp/middle/walk.rs | 60 +++++++-------- 6 files changed, 153 insertions(+), 150 deletions(-) diff --git a/src/comp/middle/capture.rs b/src/comp/middle/capture.rs index 003c38972f8..d61edacad5a 100644 --- a/src/comp/middle/capture.rs +++ b/src/comp/middle/capture.rs @@ -17,7 +17,7 @@ fn current_context(&env e) -> ast.def_id { ret e.current_context.(Vec.len(e.current_context) - 1u); } -fn enter_item(@env e, @ast.item i) { +fn enter_item(@env e, &@ast.item i) { alt (i.node) { case (ast.item_fn(?name, _, _, ?id, _)) { Vec.push(e.current_context, id); @@ -29,7 +29,7 @@ fn enter_item(@env e, @ast.item i) { } } -fn leave_item(@env e, @ast.item i) { +fn leave_item(@env e, &@ast.item i) { alt (i.node) { case (ast.item_fn(?name, _, _, ?id, _)) { Vec.pop(e.current_context); @@ -41,7 +41,7 @@ fn leave_item(@env e, @ast.item i) { } } -fn walk_expr(@env e, @ast.expr x) { +fn walk_expr(@env e, &@ast.expr x) { alt (x.node) { case (ast.expr_for(?d, _, _, _)) { alt (d.node) { diff --git a/src/comp/middle/metadata.rs b/src/comp/middle/metadata.rs index c4563cf2b19..dee9046d77f 100644 --- a/src/comp/middle/metadata.rs +++ b/src/comp/middle/metadata.rs @@ -61,26 +61,26 @@ tag abbrev_ctxt { mod Encode { type ctxt = rec( - fn(ast.def_id) -> str ds, // Def -> str Callback. + fn(&ast.def_id) -> str ds, // Def -> str Callback. ty.ctxt tcx, // The type context. abbrev_ctxt abbrevs ); - fn cx_uses_abbrevs(@ctxt cx) -> bool { + fn cx_uses_abbrevs(&@ctxt cx) -> bool { alt (cx.abbrevs) { case (ac_no_abbrevs) { ret false; } case (ac_use_abbrevs(_)) { ret true; } } } - fn ty_str(@ctxt cx, ty.t t) -> str { + fn ty_str(&@ctxt cx, &ty.t t) -> str { assert (!cx_uses_abbrevs(cx)); auto sw = IO.string_writer(); enc_ty(sw.get_writer(), cx, t); ret sw.get_str(); } - fn enc_ty(IO.writer w, @ctxt cx, ty.t t) { + fn enc_ty(&IO.writer w, &@ctxt cx, &ty.t t) { alt (cx.abbrevs) { case (ac_no_abbrevs) { enc_sty(w, cx, ty.struct(cx.tcx, t)); } case (ac_use_abbrevs(?abbrevs)) { @@ -121,7 +121,7 @@ mod Encode { } } - fn enc_mt(IO.writer w, @ctxt cx, &ty.mt mt) { + fn enc_mt(&IO.writer w, &@ctxt cx, &ty.mt mt) { alt (mt.mut) { case (ast.imm) { } case (ast.mut) { w.write_char('m'); } @@ -130,7 +130,7 @@ mod Encode { enc_ty(w, cx, mt.ty); } - fn enc_sty(IO.writer w, @ctxt cx, ty.sty st) { + fn enc_sty(&IO.writer w, &@ctxt cx, &ty.sty st) { alt (st) { case (ty.ty_nil) { w.write_char('n'); } case (ty.ty_bool) { w.write_char('b'); } @@ -231,14 +231,14 @@ mod Encode { } } - fn enc_proto(IO.writer w, ast.proto proto) { + fn enc_proto(&IO.writer w, ast.proto proto) { alt (proto) { case (ast.proto_iter) { w.write_char('W'); } case (ast.proto_fn) { w.write_char('F'); } } } - fn enc_ty_fn(IO.writer w, @ctxt cx, vec[ty.arg] args, ty.t out) { + fn enc_ty_fn(&IO.writer w, &@ctxt cx, &vec[ty.arg] args, &ty.t out) { w.write_char('['); for (ty.arg arg in args) { if (arg.mode == ty.mo_alias) { w.write_char('&'); } @@ -252,14 +252,14 @@ mod Encode { // Returns a Plain Old LLVM String. -fn C_postr(str s) -> ValueRef { +fn C_postr(&str s) -> ValueRef { ret llvm.LLVMConstString(Str.buf(s), Str.byte_len(s), False); } // Path table encoding -fn encode_name(&EBML.writer ebml_w, str name) { +fn encode_name(&EBML.writer ebml_w, &str name) { EBML.start_tag(ebml_w, tag_paths_data_name); ebml_w.writer.write(Str.bytes(name)); EBML.end_tag(ebml_w); @@ -272,8 +272,8 @@ fn encode_def_id(&EBML.writer ebml_w, &ast.def_id id) { } fn encode_tag_variant_paths(&EBML.writer ebml_w, - vec[ast.variant] variants, - vec[str] path, + &vec[ast.variant] variants, + &vec[str] path, &mutable vec[tup(str, uint)] index) { for (ast.variant variant in variants) { add_to_index(ebml_w, path, index, variant.node.name); @@ -285,16 +285,16 @@ fn encode_tag_variant_paths(&EBML.writer ebml_w, } fn add_to_index(&EBML.writer ebml_w, - vec[str] path, + &vec[str] path, &mutable vec[tup(str, uint)] index, - str name) { + &str name) { auto full_path = path + vec(name); index += vec(tup(Str.connect(full_path, "."), ebml_w.writer.tell())); } fn encode_native_module_item_paths(&EBML.writer ebml_w, &ast.native_mod nmod, - vec[str] path, + &vec[str] path, &mutable vec[tup(str, uint)] index) { for (@ast.native_item nitem in nmod.items) { alt (nitem.node) { @@ -318,7 +318,7 @@ fn encode_native_module_item_paths(&EBML.writer ebml_w, fn encode_module_item_paths(&EBML.writer ebml_w, &ast._mod module, - vec[str] path, + &vec[str] path, &mutable vec[tup(str, uint)] index) { // TODO: only encode exported items for (@ast.item it in module.items) { @@ -382,7 +382,7 @@ fn encode_module_item_paths(&EBML.writer ebml_w, } } -fn encode_item_paths(&EBML.writer ebml_w, @ast.crate crate) +fn encode_item_paths(&EBML.writer ebml_w, &@ast.crate crate) -> vec[tup(str, uint)] { let vec[tup(str, uint)] index = vec(); let vec[str] path = vec(); @@ -401,23 +401,23 @@ fn encode_kind(&EBML.writer ebml_w, u8 c) { EBML.end_tag(ebml_w); } -fn def_to_str(ast.def_id did) -> str { +fn def_to_str(&ast.def_id did) -> str { ret #fmt("%d:%d", did._0, did._1); } -fn encode_type_param_count(&EBML.writer ebml_w, vec[ast.ty_param] tps) { +fn encode_type_param_count(&EBML.writer ebml_w, &vec[ast.ty_param] tps) { EBML.start_tag(ebml_w, tag_items_data_item_ty_param_count); EBML.write_vint(ebml_w.writer, Vec.len[ast.ty_param](tps)); EBML.end_tag(ebml_w); } -fn encode_variant_id(&EBML.writer ebml_w, ast.def_id vid) { +fn encode_variant_id(&EBML.writer ebml_w, &ast.def_id vid) { EBML.start_tag(ebml_w, tag_items_data_item_variant); ebml_w.writer.write(Str.bytes(def_to_str(vid))); EBML.end_tag(ebml_w); } -fn encode_type(@trans.crate_ctxt cx, &EBML.writer ebml_w, ty.t typ) { +fn encode_type(&@trans.crate_ctxt cx, &EBML.writer ebml_w, &ty.t typ) { EBML.start_tag(ebml_w, tag_items_data_item_type); auto f = def_to_str; @@ -427,14 +427,15 @@ fn encode_type(@trans.crate_ctxt cx, &EBML.writer ebml_w, ty.t typ) { EBML.end_tag(ebml_w); } -fn encode_symbol(@trans.crate_ctxt cx, &EBML.writer ebml_w, ast.def_id did) { +fn encode_symbol(&@trans.crate_ctxt cx, &EBML.writer ebml_w, + &ast.def_id did) { EBML.start_tag(ebml_w, tag_items_data_item_symbol); ebml_w.writer.write(Str.bytes(cx.item_symbols.get(did))); EBML.end_tag(ebml_w); } -fn encode_discriminant(@trans.crate_ctxt cx, &EBML.writer ebml_w, - ast.def_id did) { +fn encode_discriminant(&@trans.crate_ctxt cx, &EBML.writer ebml_w, + &ast.def_id did) { EBML.start_tag(ebml_w, tag_items_data_item_symbol); ebml_w.writer.write(Str.bytes(cx.discrim_symbols.get(did))); EBML.end_tag(ebml_w); @@ -453,10 +454,10 @@ fn encode_obj_type_id(&EBML.writer ebml_w, &ast.def_id id) { } -fn encode_tag_variant_info(@trans.crate_ctxt cx, &EBML.writer ebml_w, - ast.def_id did, vec[ast.variant] variants, +fn encode_tag_variant_info(&@trans.crate_ctxt cx, &EBML.writer ebml_w, + &ast.def_id did, &vec[ast.variant] variants, &mutable vec[tup(int, uint)] index, - vec[ast.ty_param] ty_params) { + &vec[ast.ty_param] ty_params) { for (ast.variant variant in variants) { index += vec(tup(variant.node.id._1, ebml_w.writer.tell())); @@ -547,8 +548,8 @@ fn encode_info_for_item(@trans.crate_ctxt cx, &EBML.writer ebml_w, } } -fn encode_info_for_native_item(@trans.crate_ctxt cx, &EBML.writer ebml_w, - @ast.native_item nitem) { +fn encode_info_for_native_item(&@trans.crate_ctxt cx, &EBML.writer ebml_w, + &@ast.native_item nitem) { EBML.start_tag(ebml_w, tag_items_data_item); alt (nitem.node) { case (ast.native_item_ty(_, ?did)) { @@ -567,7 +568,7 @@ fn encode_info_for_native_item(@trans.crate_ctxt cx, &EBML.writer ebml_w, EBML.end_tag(ebml_w); } -fn encode_info_for_items(@trans.crate_ctxt cx, &EBML.writer ebml_w) +fn encode_info_for_items(&@trans.crate_ctxt cx, &EBML.writer ebml_w) -> vec[tup(int, uint)] { let vec[tup(int, uint)] index = vec(); @@ -603,7 +604,7 @@ fn hash_path(&str s) -> uint { ret h; } -fn create_index[T](vec[tup(T, uint)] index, fn(&T) -> uint hash_fn) +fn create_index[T](&vec[tup(T, uint)] index, fn(&T) -> uint hash_fn) -> vec[vec[tup(T, uint)]] { let vec[vec[tup(T, uint)]] buckets = vec(); for each (uint i in UInt.range(0u, 256u)) { @@ -619,8 +620,8 @@ fn create_index[T](vec[tup(T, uint)] index, fn(&T) -> uint hash_fn) ret buckets; } -fn encode_index[T](&EBML.writer ebml_w, vec[vec[tup(T, uint)]] buckets, - fn(IO.writer, &T) write_fn) { +fn encode_index[T](&EBML.writer ebml_w, &vec[vec[tup(T, uint)]] buckets, + fn(&IO.writer, &T) write_fn) { auto writer = IO.new_writer_(ebml_w.writer); EBML.start_tag(ebml_w, tag_index); @@ -650,16 +651,16 @@ fn encode_index[T](&EBML.writer ebml_w, vec[vec[tup(T, uint)]] buckets, EBML.end_tag(ebml_w); } -fn write_str(IO.writer writer, &str s) { +fn write_str(&IO.writer writer, &str s) { writer.write_str(s); } -fn write_int(IO.writer writer, &int n) { +fn write_int(&IO.writer writer, &int n) { writer.write_be_uint(n as uint, 4u); } -fn encode_metadata(@trans.crate_ctxt cx, @ast.crate crate) +fn encode_metadata(&@trans.crate_ctxt cx, &@ast.crate crate) -> ValueRef { auto string_w = IO.string_writer(); auto buf_w = string_w.get_writer().get_buf_writer(); @@ -690,7 +691,7 @@ fn encode_metadata(@trans.crate_ctxt cx, @ast.crate crate) ret C_postr(string_w.get_str()); } -fn write_metadata(@trans.crate_ctxt cx, @ast.crate crate) { +fn write_metadata(&@trans.crate_ctxt cx, &@ast.crate crate) { auto llmeta = C_postr(""); if (cx.sess.get_opts().shared) { llmeta = encode_metadata(cx, crate); diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs index cb537b38a1a..7840a129102 100644 --- a/src/comp/middle/trans.rs +++ b/src/comp/middle/trans.rs @@ -3569,7 +3569,7 @@ fn collect_upvars(@block_ctxt cx, &ast.block bloc, &ast.def_id initial_decl) hashmap[ast.def_id,()] decls ); - fn walk_expr(env e, @ast.expr expr) { + fn walk_expr(env e, &@ast.expr expr) { alt (expr.node) { case (ast.expr_path(?path, ?d, _)) { alt (Option.get[ast.def](d)) { @@ -3589,7 +3589,7 @@ fn collect_upvars(@block_ctxt cx, &ast.block bloc, &ast.def_id initial_decl) } } - fn walk_decl(env e, @ast.decl decl) { + fn walk_decl(env e, &@ast.decl decl) { alt (decl.node) { case (ast.decl_local(?local)) { e.decls.insert(local.id, ()); @@ -6949,7 +6949,7 @@ fn new_walk_ctxt() -> @walk_ctxt { ret @rec(mutable path=path); } -fn enter_item(@walk_ctxt cx, @ast.item item) { +fn enter_item(@walk_ctxt cx, &@ast.item item) { alt (item.node) { case (ast.item_fn(?name, _, _, _, _)) { Vec.push[str](cx.path, name); @@ -6964,7 +6964,7 @@ fn enter_item(@walk_ctxt cx, @ast.item item) { } } -fn leave_item(@walk_ctxt cx, @ast.item item) { +fn leave_item(@walk_ctxt cx, &@ast.item item) { alt (item.node) { case (ast.item_fn(_, _, _, _, _)) { Vec.pop[str](cx.path); @@ -6979,7 +6979,7 @@ fn leave_item(@walk_ctxt cx, @ast.item item) { } } -fn collect_native_item(@crate_ctxt ccx, @walk_ctxt wcx, @ast.native_item i) { +fn collect_native_item(@crate_ctxt ccx, @walk_ctxt wcx, &@ast.native_item i) { alt (i.node) { case (ast.native_item_fn(?name, _, _, _, ?fid, ?ann)) { ccx.native_items.insert(fid, i); @@ -6993,7 +6993,7 @@ fn collect_native_item(@crate_ctxt ccx, @walk_ctxt wcx, @ast.native_item i) { } } -fn collect_item_1(@crate_ctxt ccx, @walk_ctxt wcx, @ast.item i) { +fn collect_item_1(@crate_ctxt ccx, @walk_ctxt wcx, &@ast.item i) { enter_item(wcx, i); alt (i.node) { @@ -7019,7 +7019,7 @@ fn collect_item_1(@crate_ctxt ccx, @walk_ctxt wcx, @ast.item i) { } } -fn collect_item_2(@crate_ctxt ccx, @walk_ctxt wcx, @ast.item i) { +fn collect_item_2(@crate_ctxt ccx, @walk_ctxt wcx, &@ast.item i) { enter_item(wcx, i); alt (i.node) { @@ -7055,7 +7055,7 @@ fn collect_items(@crate_ctxt ccx, @ast.crate crate) { walk.walk_crate(visitor2, *crate); } -fn collect_tag_ctor(@crate_ctxt ccx, @walk_ctxt wcx, @ast.item i) { +fn collect_tag_ctor(@crate_ctxt ccx, @walk_ctxt wcx, &@ast.item i) { enter_item(wcx, i); alt (i.node) { @@ -7083,7 +7083,7 @@ fn collect_tag_ctors(@crate_ctxt ccx, @ast.crate crate) { // The constant translation pass. -fn trans_constant(@crate_ctxt ccx, @walk_ctxt wcx, @ast.item it) { +fn trans_constant(@crate_ctxt ccx, @walk_ctxt wcx, &@ast.item it) { enter_item(wcx, it); alt (it.node) { diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs index 4a630af1b5b..dfdf07d9c2f 100644 --- a/src/comp/middle/ty.rs +++ b/src/comp/middle/ty.rs @@ -1046,7 +1046,7 @@ fn type_param(&ctxt cx, &t ty) -> Option.t[uint] { ret none[uint]; } -fn def_to_str(ast.def_id did) -> str { +fn def_to_str(&ast.def_id did) -> str { ret #fmt("%d:%d", did._0, did._1); } diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs index cdee187d0f5..1d888949463 100644 --- a/src/comp/middle/typeck.rs +++ b/src/comp/middle/typeck.rs @@ -77,14 +77,14 @@ type fn_ctxt = rec(ty.t ret_ty, @crate_ctxt ccx); // Used for ast_ty_to_ty() below. -type ty_getter = fn(ast.def_id) -> ty.ty_param_count_and_ty; +type ty_getter = fn(&ast.def_id) -> ty.ty_param_count_and_ty; // Substitutes the user's explicit types for the parameters in a path // expression. fn substitute_ty_params(&@crate_ctxt ccx, - ty.t typ, + &ty.t typ, uint ty_param_count, - vec[ty.t] supplied, + &vec[ty.t] supplied, &span sp) -> ty.t { fn substituter(@crate_ctxt ccx, vec[ty.t] supplied, ty.t typ) -> ty.t { alt (struct(ccx.tcx, typ)) { @@ -112,7 +112,7 @@ fn substitute_ty_params(&@crate_ctxt ccx, // Returns the type parameter count and the type for the given definition. -fn ty_param_count_and_ty_for_def(@fn_ctxt fcx, &ast.span sp, &ast.def defn) +fn ty_param_count_and_ty_for_def(&@fn_ctxt fcx, &ast.span sp, &ast.def defn) -> ty_param_count_and_ty { alt (defn) { case (ast.def_arg(?id)) { @@ -177,8 +177,8 @@ fn ty_param_count_and_ty_for_def(@fn_ctxt fcx, &ast.span sp, &ast.def defn) // Instantiates the given path, which must refer to an item with the given // number of type parameters and type. -fn instantiate_path(@fn_ctxt fcx, &ast.path pth, &ty_param_count_and_ty tpt, - &span sp) -> ast.ann { +fn instantiate_path(&@fn_ctxt fcx, &ast.path pth, &ty_param_count_and_ty tpt, + &span sp) -> ast.ann { auto ty_param_count = tpt._0; auto t = bind_params_in_type(fcx.ccx.tcx, tpt._1); @@ -224,25 +224,25 @@ fn ast_mode_to_mode(ast.mode mode) -> ty.mode { // Parses the programmer's textual representation of a type into our internal // notion of a type. `getter` is a function that returns the type // corresponding to a definition ID. -fn ast_ty_to_ty(ty.ctxt tcx, ty_getter getter, &@ast.ty ast_ty) -> ty.t { - fn ast_arg_to_arg(ty.ctxt tcx, - ty_getter getter, +fn ast_ty_to_ty(&ty.ctxt tcx, &ty_getter getter, &@ast.ty ast_ty) -> ty.t { + fn ast_arg_to_arg(&ty.ctxt tcx, + &ty_getter getter, &rec(ast.mode mode, @ast.ty ty) arg) -> rec(ty.mode mode, ty.t ty) { auto ty_mode = ast_mode_to_mode(arg.mode); ret rec(mode=ty_mode, ty=ast_ty_to_ty(tcx, getter, arg.ty)); } - fn ast_mt_to_mt(ty.ctxt tcx, - ty_getter getter, + fn ast_mt_to_mt(&ty.ctxt tcx, + &ty_getter getter, &ast.mt mt) -> ty.mt { ret rec(ty=ast_ty_to_ty(tcx, getter, mt.ty), mut=mt.mut); } - fn instantiate(ty.ctxt tcx, - ty_getter getter, - ast.def_id id, - vec[@ast.ty] args) -> ty.t { + fn instantiate(&ty.ctxt tcx, + &ty_getter getter, + &ast.def_id id, + &vec[@ast.ty] args) -> ty.t { // TODO: maybe record cname chains so we can do // "foo = int" like OCaml? auto params_opt_and_ty = getter(id); @@ -324,7 +324,7 @@ fn ast_ty_to_ty(ty.ctxt tcx, ty_getter getter, &@ast.ty ast_ty) -> ty.t { typ = instantiate(tcx, getter, id, path.node.types); } case (ast.def_ty_arg(?id)) { typ = ty.mk_param(tcx, id); } - case (_) { + case (_) { tcx.sess.span_err(ast_ty.span, "found type name used as a variable"); fail; } @@ -362,7 +362,7 @@ fn ast_ty_to_ty(ty.ctxt tcx, ty_getter getter, &@ast.ty ast_ty) -> ty.t { // A convenience function to use a crate_ctxt to resolve names for // ast_ty_to_ty. fn ast_ty_to_ty_crate(@crate_ctxt ccx, &@ast.ty ast_ty) -> ty.t { - fn getter(@crate_ctxt ccx, ast.def_id id) -> ty.ty_param_count_and_ty { + fn getter(@crate_ctxt ccx, &ast.def_id id) -> ty.ty_param_count_and_ty { ret ty.lookup_item_type(ccx.sess, ccx.tcx, ccx.type_cache, id); } auto f = bind getter(ccx, _); @@ -388,13 +388,13 @@ mod Collect { ty.ctxt tcx); type env = rec(@ctxt cx, ast.native_abi abi); - fn ty_of_fn_decl(@ctxt cx, - fn(&@ast.ty ast_ty) -> ty.t convert, - fn(&ast.arg a) -> arg ty_of_arg, + fn ty_of_fn_decl(&@ctxt cx, + &fn(&@ast.ty ast_ty) -> ty.t convert, + &fn(&ast.arg a) -> arg ty_of_arg, &ast.fn_decl decl, ast.proto proto, - vec[ast.ty_param] ty_params, - ast.def_id def_id) -> ty.ty_param_count_and_ty { + &vec[ast.ty_param] ty_params, + &ast.def_id def_id) -> ty.ty_param_count_and_ty { auto input_tys = Vec.map[ast.arg,arg](ty_of_arg, decl.inputs); auto output_ty = convert(decl.output); auto t_fn = ty.mk_fn(cx.tcx, proto, input_tys, output_ty); @@ -404,13 +404,13 @@ mod Collect { ret tpt; } - fn ty_of_native_fn_decl(@ctxt cx, - fn(&@ast.ty ast_ty) -> ty.t convert, - fn(&ast.arg a) -> arg ty_of_arg, + fn ty_of_native_fn_decl(&@ctxt cx, + &fn(&@ast.ty ast_ty) -> ty.t convert, + &fn(&ast.arg a) -> arg ty_of_arg, &ast.fn_decl decl, ast.native_abi abi, - vec[ast.ty_param] ty_params, - ast.def_id def_id) -> ty.ty_param_count_and_ty { + &vec[ast.ty_param] ty_params, + &ast.def_id def_id) -> ty.ty_param_count_and_ty { auto input_tys = Vec.map[ast.arg,arg](ty_of_arg, decl.inputs); auto output_ty = convert(decl.output); auto t_fn = ty.mk_native_fn(cx.tcx, abi, input_tys, output_ty); @@ -420,7 +420,7 @@ mod Collect { ret tpt; } - fn getter(@ctxt cx, ast.def_id id) -> ty.ty_param_count_and_ty { + fn getter(@ctxt cx, &ast.def_id id) -> ty.ty_param_count_and_ty { if (id._0 != cx.sess.get_targ_crate_num()) { // This is a type we need to load in from the crate reader. @@ -458,9 +458,9 @@ mod Collect { } fn ty_of_obj(@ctxt cx, - ast.ident id, + &ast.ident id, &ast._obj obj_info, - vec[ast.ty_param] ty_params) -> ty.ty_param_count_and_ty { + &vec[ast.ty_param] ty_params) -> ty.ty_param_count_and_ty { auto f = bind ty_of_method(cx, _); auto methods = Vec.map[@ast.method,method](f, obj_info.methods); @@ -473,8 +473,8 @@ mod Collect { fn ty_of_obj_ctor(@ctxt cx, &ast.ident id, &ast._obj obj_info, - ast.def_id obj_ty_id, - vec[ast.ty_param] ty_params) + &ast.def_id obj_ty_id, + &vec[ast.ty_param] ty_params) -> ty.ty_param_count_and_ty { auto t_obj = ty_of_obj(cx, id, obj_info, ty_params); let vec[arg] t_inputs = vec(); @@ -490,7 +490,7 @@ mod Collect { ret tup(t_obj._0, t_fn); } - fn ty_of_item(@ctxt cx, @ast.item it) -> ty.ty_param_count_and_ty { + fn ty_of_item(&@ctxt cx, &@ast.item it) -> ty.ty_param_count_and_ty { auto get = bind getter(cx, _); auto convert = bind ast_ty_to_ty(cx.tcx, get, _); @@ -557,7 +557,7 @@ mod Collect { } } - fn ty_of_native_item(@ctxt cx, @ast.native_item it, ast.native_abi abi) + fn ty_of_native_item(&@ctxt cx, &@ast.native_item it, ast.native_abi abi) -> ty.ty_param_count_and_ty { alt (it.node) { case (ast.native_item_fn(?ident, ?lname, ?fn_decl, @@ -584,7 +584,7 @@ mod Collect { } } - fn get_tag_variant_types(@ctxt cx, &ast.def_id tag_id, + fn get_tag_variant_types(&@ctxt cx, &ast.def_id tag_id, &vec[ast.variant] variants, &vec[ast.ty_param] ty_params) -> vec[ast.variant] { @@ -856,7 +856,8 @@ mod Collect { // Type unification mod Unify { - fn simple(@fn_ctxt fcx, ty.t expected, ty.t actual) -> ty.Unify.result { + fn simple(&@fn_ctxt fcx, &ty.t expected, + &ty.t actual) -> ty.Unify.result { // FIXME: horrid botch let vec[mutable ty.t] param_substs = vec(mutable ty.mk_nil(fcx.ccx.tcx)); @@ -864,8 +865,8 @@ mod Unify { ret with_params(fcx, expected, actual, param_substs); } - fn with_params(@fn_ctxt fcx, ty.t expected, ty.t actual, - vec[mutable ty.t] param_substs) -> ty.Unify.result { + fn with_params(&@fn_ctxt fcx, &ty.t expected, &ty.t actual, + &vec[mutable ty.t] param_substs) -> ty.Unify.result { auto cache_key = tup(expected, actual, param_substs); alt (fcx.ccx.unify_cache.find(cache_key)) { case (some[ty.Unify.result](?r)) { @@ -947,7 +948,7 @@ tag autoderef_kind { NO_AUTODEREF; } -fn strip_boxes(ty.ctxt tcx, ty.t t) -> ty.t { +fn strip_boxes(&ty.ctxt tcx, &ty.t t) -> ty.t { auto t1 = t; while (true) { alt (struct(tcx, t1)) { @@ -958,7 +959,7 @@ fn strip_boxes(ty.ctxt tcx, ty.t t) -> ty.t { fail; } -fn add_boxes(@crate_ctxt ccx, uint n, ty.t t) -> ty.t { +fn add_boxes(&@crate_ctxt ccx, uint n, &ty.t t) -> ty.t { auto t1 = t; while (n != 0u) { t1 = ty.mk_imm_box(ccx.tcx, t1); @@ -968,7 +969,7 @@ fn add_boxes(@crate_ctxt ccx, uint n, ty.t t) -> ty.t { } -fn count_boxes(ty.ctxt tcx, ty.t t) -> uint { +fn count_boxes(&ty.ctxt tcx, &ty.t t) -> uint { auto n = 0u; auto t1 = t; while (true) { @@ -987,12 +988,12 @@ fn count_boxes(ty.ctxt tcx, ty.t t) -> uint { type ty_param_substs_and_ty = tup(vec[ty.t], ty.t); mod Demand { - fn simple(@fn_ctxt fcx, &span sp, ty.t expected, ty.t actual) -> ty.t { + fn simple(&@fn_ctxt fcx, &span sp, &ty.t expected, &ty.t actual) -> ty.t { let vec[ty.t] tps = vec(); ret full(fcx, sp, expected, actual, tps, NO_AUTODEREF)._1; } - fn autoderef(@fn_ctxt fcx, &span sp, ty.t expected, ty.t actual, + fn autoderef(&@fn_ctxt fcx, &span sp, &ty.t expected, &ty.t actual, autoderef_kind adk) -> ty.t { let vec[ty.t] tps = vec(); ret full(fcx, sp, expected, actual, tps, adk)._1; @@ -1001,8 +1002,8 @@ mod Demand { // Requires that the two types unify, and prints an error message if they // don't. Returns the unified type and the type parameter substitutions. - fn full(@fn_ctxt fcx, &span sp, ty.t expected, ty.t actual, - vec[ty.t] ty_param_substs_0, autoderef_kind adk) + fn full(&@fn_ctxt fcx, &span sp, &ty.t expected, &ty.t actual, + &vec[ty.t] ty_param_substs_0, autoderef_kind adk) -> ty_param_substs_and_ty { auto expected_1 = expected; @@ -1050,7 +1051,7 @@ mod Demand { // Returns true if the two types unify and false if they don't. -fn are_compatible(&@fn_ctxt fcx, ty.t expected, ty.t actual) -> bool { +fn are_compatible(&@fn_ctxt fcx, &ty.t expected, &ty.t actual) -> bool { alt (Unify.simple(fcx, expected, actual)) { case (ures_ok(_)) { ret true; } case (ures_err(_, _, _)) { ret false; } @@ -1058,8 +1059,8 @@ fn are_compatible(&@fn_ctxt fcx, ty.t expected, ty.t actual) -> bool { } // Returns the types of the arguments to a tag variant. -fn variant_arg_types(@crate_ctxt ccx, &span sp, ast.def_id vid, - vec[ty.t] tag_ty_params) -> vec[ty.t] { +fn variant_arg_types(&@crate_ctxt ccx, &span sp, &ast.def_id vid, + &vec[ty.t] tag_ty_params) -> vec[ty.t] { auto ty_param_count = Vec.len[ty.t](tag_ty_params); let vec[ty.t] result = vec(); @@ -1106,7 +1107,8 @@ mod Pushdown { // // TODO: enforce this via a predicate. - fn pushdown_pat(&@fn_ctxt fcx, ty.t expected, @ast.pat pat) -> @ast.pat { + fn pushdown_pat(&@fn_ctxt fcx, &ty.t expected, + &@ast.pat pat) -> @ast.pat { auto p_1; alt (pat.node) { @@ -1168,12 +1170,12 @@ mod Pushdown { // TODO: enforce this via a predicate. // TODO: This function is incomplete. - fn pushdown_expr(&@fn_ctxt fcx, ty.t expected, @ast.expr e) + fn pushdown_expr(&@fn_ctxt fcx, &ty.t expected, &@ast.expr e) -> @ast.expr { be pushdown_expr_full(fcx, expected, e, NO_AUTODEREF); } - fn pushdown_expr_full(&@fn_ctxt fcx, ty.t expected, @ast.expr e, + fn pushdown_expr_full(&@fn_ctxt fcx, &ty.t expected, &@ast.expr e, autoderef_kind adk) -> @ast.expr { auto e_1; @@ -1496,7 +1498,7 @@ mod Pushdown { } // Push-down over typed blocks. - fn pushdown_block(&@fn_ctxt fcx, ty.t expected, &ast.block bloc) + fn pushdown_block(&@fn_ctxt fcx, &ty.t expected, &ast.block bloc) -> ast.block { alt (bloc.node.expr) { case (some[@ast.expr](?e_0)) { @@ -1598,7 +1600,7 @@ fn resolve_local_types_in_block(&@fn_ctxt fcx, &ast.block block) // AST fragment checking -fn check_lit(@crate_ctxt ccx, @ast.lit lit) -> ty.t { +fn check_lit(@crate_ctxt ccx, &@ast.lit lit) -> ty.t { alt (lit.node) { case (ast.lit_str(_)) { ret ty.mk_str(ccx.tcx); } case (ast.lit_char(_)) { ret ty.mk_char(ccx.tcx); } @@ -1615,7 +1617,7 @@ fn check_lit(@crate_ctxt ccx, @ast.lit lit) -> ty.t { fail; // not reached } -fn check_pat(&@fn_ctxt fcx, @ast.pat pat) -> @ast.pat { +fn check_pat(&@fn_ctxt fcx, &@ast.pat pat) -> @ast.pat { auto new_pat; alt (pat.node) { case (ast.pat_wild(_)) { @@ -1689,7 +1691,7 @@ fn check_pat(&@fn_ctxt fcx, @ast.pat pat) -> @ast.pat { } fn require_impure(&session.session sess, - &ast.purity f_purity, &span sp) -> () { + &ast.purity f_purity, &span sp) -> () { alt (f_purity) { case (ast.impure_fn) { ret; @@ -1707,7 +1709,8 @@ fn get_function_purity(@crate_ctxt ccx, &ast.def_id d_id) -> ast.purity { } fn require_pure_call(@crate_ctxt ccx, - &ast.purity caller_purity, @ast.expr callee, &span sp) -> () { + &ast.purity caller_purity, + &@ast.expr callee, &span sp) -> () { alt (caller_purity) { case (ast.impure_fn) { ret; @@ -1744,7 +1747,7 @@ fn require_pure_function(@crate_ctxt ccx, &ast.def_id d_id, &span sp) -> () { } } -fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr { +fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr { //fcx.ccx.sess.span_warn(expr.span, "typechecking expr " + // util.common.expr_to_str(expr)); @@ -1804,7 +1807,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr { } // A generic function for checking assignment expressions - fn check_assignment(&@fn_ctxt fcx, @ast.expr lhs, @ast.expr rhs) + fn check_assignment(&@fn_ctxt fcx, &@ast.expr lhs, &@ast.expr rhs) -> tup(@ast.expr, @ast.expr, ast.ann) { auto lhs_0 = check_expr(fcx, lhs); auto rhs_0 = check_expr(fcx, rhs); @@ -1820,7 +1823,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr { } // A generic function for checking call expressions - fn check_call(&@fn_ctxt fcx, @ast.expr f, vec[@ast.expr] args) + fn check_call(&@fn_ctxt fcx, &@ast.expr f, &vec[@ast.expr] args) -> tup(@ast.expr, vec[@ast.expr]) { let vec[Option.t[@ast.expr]] args_opt_0 = vec(); @@ -2686,7 +2689,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr { } } -fn next_ty_var(@crate_ctxt ccx) -> ty.t { +fn next_ty_var(&@crate_ctxt ccx) -> ty.t { auto t = ty.mk_var(ccx.tcx, ccx.next_var_id); ccx.next_var_id += 1; ret t; @@ -2699,7 +2702,7 @@ fn check_decl_local(&@fn_ctxt fcx, &@ast.decl decl) -> @ast.decl { auto t; t = ty.mk_nil(fcx.ccx.tcx); - + alt (local.ty) { case (none[@ast.ty]) { // Auto slot. Do nothing for now. @@ -2712,7 +2715,7 @@ fn check_decl_local(&@fn_ctxt fcx, &@ast.decl decl) -> @ast.decl { } } - auto a_res = local.ann; + auto a_res = local.ann; alt (a_res) { case (ann_none) { a_res = triv_ann(t); @@ -2807,8 +2810,8 @@ fn check_block(&@fn_ctxt fcx, &ast.block block) -> ast.block { a=plain_ann(fcx.ccx.tcx))); } -fn check_const(&@crate_ctxt ccx, &span sp, ast.ident ident, @ast.ty t, - @ast.expr e, ast.def_id id, ast.ann ann) -> @ast.item { +fn check_const(&@crate_ctxt ccx, &span sp, &ast.ident ident, &@ast.ty t, + &@ast.expr e, &ast.def_id id, &ast.ann ann) -> @ast.item { // FIXME: this is kinda a kludge; we manufacture a fake "function context" // for checking the initializer expression. auto rty = ann_to_type(ann); @@ -2858,7 +2861,7 @@ fn check_fn(&@crate_ctxt ccx, &ast.fn_decl decl, ast.proto proto, ccx.sess.span_err(body.span, "Non-boolean return type in pred"); } } - case (_) {} + case (_) {} } auto block_wb = resolve_local_types_in_block(fcx, block_t); @@ -2894,7 +2897,7 @@ 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; - ret @rec(obj_fields = ob.fields, + ret @rec(obj_fields = ob.fields, this_obj = some[ast.def_id](di) with *ccx); } case (_) { @@ -2935,10 +2938,10 @@ fn eq_unify_cache_entry(&unify_cache_entry a, &unify_cache_entry b) -> bool { ret true; } -fn mk_fn_purity_table(@ast.crate crate) -> @fn_purity_table { +fn mk_fn_purity_table(&@ast.crate crate) -> @fn_purity_table { auto res = @new_def_hash[ast.purity](); - fn do_one(@fn_purity_table t, @ast.item i) -> () { + fn do_one(@fn_purity_table t, &@ast.item i) -> () { alt (i.node) { case (ast.item_fn(_, ?f, _, ?d_id, _)) { t.insert(d_id, f.decl.purity); @@ -2958,8 +2961,7 @@ fn mk_fn_purity_table(@ast.crate crate) -> @fn_purity_table { type typecheck_result = tup(@ast.crate, ty.type_cache); -fn check_crate(ty.ctxt tcx, @ast.crate crate) - -> typecheck_result { +fn check_crate(&ty.ctxt tcx, &@ast.crate crate) -> typecheck_result { auto sess = tcx.sess; auto result = Collect.collect_item_types(sess, tcx, crate); diff --git a/src/comp/middle/walk.rs b/src/comp/middle/walk.rs index 2df69261f38..c8f5f43236e 100644 --- a/src/comp/middle/walk.rs +++ b/src/comp/middle/walk.rs @@ -5,28 +5,28 @@ import std.Option.some; import std.Option.none; type ast_visitor = - rec(fn () -> bool keep_going, - fn () -> bool want_crate_directives, - fn (&ast.crate c) visit_crate_pre, - fn (&ast.crate c) visit_crate_post, - fn (@ast.crate_directive cd) visit_crate_directive_pre, - fn (@ast.crate_directive cd) visit_crate_directive_post, - fn (@ast.view_item i) visit_view_item_pre, - fn (@ast.view_item i) visit_view_item_post, - fn (@ast.native_item i) visit_native_item_pre, - fn (@ast.native_item i) visit_native_item_post, - fn (@ast.item i) visit_item_pre, - fn (@ast.item i) visit_item_post, - fn (&ast.block b) visit_block_pre, - fn (&ast.block b) visit_block_post, - fn (@ast.stmt s) visit_stmt_pre, - fn (@ast.stmt s) visit_stmt_post, - fn (@ast.decl d) visit_decl_pre, - fn (@ast.decl d) visit_decl_post, - fn (@ast.expr e) visit_expr_pre, - fn (@ast.expr e) visit_expr_post, - fn (@ast.ty t) visit_ty_pre, - fn (@ast.ty t) visit_ty_post); + rec(fn () -> bool keep_going, + fn () -> bool want_crate_directives, + fn (&ast.crate c) visit_crate_pre, + fn (&ast.crate c) visit_crate_post, + fn (&@ast.crate_directive cd) visit_crate_directive_pre, + fn (&@ast.crate_directive cd) visit_crate_directive_post, + fn (&@ast.view_item i) visit_view_item_pre, + fn (&@ast.view_item i) visit_view_item_post, + fn (&@ast.native_item i) visit_native_item_pre, + fn (&@ast.native_item i) visit_native_item_post, + fn (&@ast.item i) visit_item_pre, + fn (&@ast.item i) visit_item_post, + fn (&ast.block b) visit_block_pre, + fn (&ast.block b) visit_block_post, + fn (&@ast.stmt s) visit_stmt_pre, + fn (&@ast.stmt s) visit_stmt_post, + fn (&@ast.decl d) visit_decl_pre, + fn (&@ast.decl d) visit_decl_post, + fn (&@ast.expr e) visit_expr_pre, + fn (&@ast.expr e) visit_expr_post, + fn (&@ast.ty t) visit_ty_pre, + fn (&@ast.ty t) visit_ty_post); fn walk_crate(&ast_visitor v, &ast.crate c) { if (!v.keep_going()) { ret; } @@ -409,15 +409,15 @@ fn walk_expr(&ast_visitor v, @ast.expr e) { fn def_keep_going() -> bool { ret true; } fn def_want_crate_directives() -> bool { ret false; } fn def_visit_crate(&ast.crate c) { } -fn def_visit_crate_directive(@ast.crate_directive c) { } -fn def_visit_view_item(@ast.view_item vi) { } -fn def_visit_native_item(@ast.native_item ni) { } -fn def_visit_item(@ast.item i) { } +fn def_visit_crate_directive(&@ast.crate_directive c) { } +fn def_visit_view_item(&@ast.view_item vi) { } +fn def_visit_native_item(&@ast.native_item ni) { } +fn def_visit_item(&@ast.item i) { } fn def_visit_block(&ast.block b) { } -fn def_visit_stmt(@ast.stmt s) { } -fn def_visit_decl(@ast.decl d) { } -fn def_visit_expr(@ast.expr e) { } -fn def_visit_ty(@ast.ty t) { } +fn def_visit_stmt(&@ast.stmt s) { } +fn def_visit_decl(&@ast.decl d) { } +fn def_visit_expr(&@ast.expr e) { } +fn def_visit_ty(&@ast.ty t) { } fn default_visitor() -> ast_visitor {