diff options
Diffstat (limited to 'src/comp/middle')
| -rw-r--r-- | src/comp/middle/capture.rs | 30 | ||||
| -rw-r--r-- | src/comp/middle/fold.rs | 98 | ||||
| -rw-r--r-- | src/comp/middle/metadata.rs | 274 | ||||
| -rw-r--r-- | src/comp/middle/resolve.rs | 94 | ||||
| -rw-r--r-- | src/comp/middle/trans.rs | 402 | ||||
| -rw-r--r-- | src/comp/middle/ty.rs | 192 | ||||
| -rw-r--r-- | src/comp/middle/typeck.rs | 176 | ||||
| -rw-r--r-- | src/comp/middle/typestate_check.rs | 212 | ||||
| -rw-r--r-- | src/comp/middle/walk.rs | 10 |
9 files changed, 744 insertions, 744 deletions
diff --git a/src/comp/middle/capture.rs b/src/comp/middle/capture.rs index 02431580..003c3897 100644 --- a/src/comp/middle/capture.rs +++ b/src/comp/middle/capture.rs @@ -1,29 +1,29 @@ import driver.session; import front.ast; -import std.map.hashmap; -import std.option; -import std.option.some; -import std.option.none; -import std._int; -import std._vec; +import std.Map.hashmap; +import std.Option; +import std.Option.some; +import std.Option.none; +import std.Int; +import std.Vec; import util.common; -type fn_id_of_local = std.map.hashmap[ast.def_id, ast.def_id]; +type fn_id_of_local = std.Map.hashmap[ast.def_id, ast.def_id]; type env = rec(mutable vec[ast.def_id] current_context, // fn or obj fn_id_of_local idmap, session.session sess); fn current_context(&env e) -> ast.def_id { - ret e.current_context.(_vec.len(e.current_context) - 1u); + ret e.current_context.(Vec.len(e.current_context) - 1u); } fn enter_item(@env e, @ast.item i) { alt (i.node) { case (ast.item_fn(?name, _, _, ?id, _)) { - _vec.push(e.current_context, id); + Vec.push(e.current_context, id); } case (ast.item_obj(_, _, _, ?ids, _)) { - _vec.push(e.current_context, ids.ty); + Vec.push(e.current_context, ids.ty); } case (_) {} } @@ -32,10 +32,10 @@ fn enter_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); + Vec.pop(e.current_context); } case (ast.item_obj(_, _, _, ?ids, _)) { - _vec.pop(e.current_context); + Vec.pop(e.current_context); } case (_) {} } @@ -61,13 +61,13 @@ fn walk_expr(@env e, @ast.expr x) { } case (ast.expr_path(_, ?def, _)) { auto local_id; - alt (option.get(def)) { + alt (Option.get(def)) { case (ast.def_local(?id)) { local_id = id; } case (_) { ret; } } - auto df = ast.def_id_of_def(option.get(def)); - auto def_context = option.get(e.idmap.find(df)); + auto df = ast.def_id_of_def(Option.get(def)); + auto def_context = Option.get(e.idmap.find(df)); if (current_context(*e) != def_context) { e.sess.span_err(x.span, diff --git a/src/comp/middle/fold.rs b/src/comp/middle/fold.rs index b37f7be8..ace45c2f 100644 --- a/src/comp/middle/fold.rs +++ b/src/comp/middle/fold.rs @@ -1,7 +1,7 @@ -import std.map.hashmap; -import std.option; -import std.option.some; -import std.option.none; +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; @@ -32,8 +32,8 @@ import front.ast.ann; import front.ast.mt; import front.ast.purity; -import std._uint; -import std._vec; +import std.UInt; +import std.Vec; type ast_fold[ENV] = @rec @@ -67,7 +67,7 @@ type ast_fold[ENV] = @ty output) -> @ty) fold_ty_fn, (fn(&ENV e, &span sp, ast.path p, - &option.t[def] d) -> @ty) fold_ty_path, + &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, @@ -82,7 +82,7 @@ type ast_fold[ENV] = (fn(&ENV e, &span sp, vec[ast.field] fields, - option.t[@expr] base, ann a) -> @expr) fold_expr_rec, + Option.t[@expr] base, ann a) -> @expr) fold_expr_rec, (fn(&ENV e, &span sp, @expr f, vec[@expr] args, @@ -92,11 +92,11 @@ 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, @@ -118,7 +118,7 @@ type ast_fold[ENV] = (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, @@ -169,12 +169,12 @@ type ast_fold[ENV] = (fn(&ENV e, &span sp, &path p, - &option.t[def] d, + &Option.t[def] d, ann a) -> @expr) fold_expr_path, (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, @@ -185,10 +185,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, @@ -229,7 +229,7 @@ type ast_fold[ENV] = (fn(&ENV e, &span sp, path p, vec[@pat] args, - option.t[ast.variant_def] d, + Option.t[ast.variant_def] d, ann a) -> @pat) fold_pat_tag, @@ -253,7 +253,7 @@ type ast_fold[ENV] = def_id id, ann a) -> @item) fold_item_fn, (fn(&ENV e, &span sp, ident ident, - option.t[str] link_name, + 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, @@ -284,10 +284,10 @@ type ast_fold[ENV] = // 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, + 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, + 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, @@ -316,7 +316,7 @@ type ast_fold[ENV] = (fn(&ENV e, vec[ast.obj_field] fields, vec[@ast.method] methods, - option.t[@ast.method] dtor) -> ast._obj) fold_obj, + Option.t[@ast.method] dtor) -> ast._obj) fold_obj, // Env updates. (fn(&ENV e, @ast.crate c) -> ENV) update_env_for_crate, @@ -341,7 +341,7 @@ type ast_fold[ENV] = 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)); + Vec.push[@ast.ty](tys_, fold_ty(env, fld, t)); } let ast.path_ p_ = rec(idents=p.node.idents, types=tys_); ret fld.fold_path(env, p.span, p_); @@ -382,7 +382,7 @@ fn fold_ty[ENV](&ENV env, ast_fold[ENV] fld, @ty t) -> @ty { 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_); } @@ -391,7 +391,7 @@ fn fold_ty[ENV](&ENV env, ast_fold[ENV] fld, @ty t) -> @ty { 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_); @@ -404,7 +404,7 @@ fn fold_ty[ENV](&ENV env, ast_fold[ENV] fld, @ty t) -> @ty { m.inputs, m.output); alt (tfn.node) { case (ast.ty_fn(?p, ?ins, ?out)) { - _vec.push[ast.ty_method] + Vec.push[ast.ty_method] (meths_, rec(proto=p, inputs=ins, output=out with m)); } @@ -518,7 +518,7 @@ 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] { 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; } @@ -558,7 +558,7 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr { case (ast.expr_rec(?fs, ?base, ?t)) { let vec[ast.field] fields = vec(); - let option.t[@expr] b = none[@expr]; + let Option.t[@expr] b = none[@expr]; for (ast.field f in fs) { fields += vec(fold_rec_field(env, fld, f)); } @@ -586,8 +586,8 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr { 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]); @@ -865,7 +865,7 @@ fn fold_block[ENV](&ENV env, ast_fold[ENV] fld, &block blk) -> block { 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); ast.index_stmt(index, new_stmt); } @@ -935,7 +935,7 @@ fn fold_obj[ENV](&ENV env, ast_fold[ENV] fld, &ast._obj ob) -> ast._obj { 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)) { @@ -954,7 +954,7 @@ fn fold_obj[ENV](&ENV env, ast_fold[ENV] fld, &ast._obj ob) -> ast._obj { 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); } @@ -1057,13 +1057,13 @@ fn fold_mod[ENV](&ENV e, ast_fold[ENV] fld, &ast._mod m) -> ast._mod { 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); ast.index_view_item(index, 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); ast.index_item(index, new_item); } @@ -1098,12 +1098,12 @@ fn fold_native_mod[ENV](&ENV e, ast_fold[ENV] fld, 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); ast.index_native_item(index, new_item); } @@ -1202,7 +1202,7 @@ fn identity_fold_ty_fn[ENV](&ENV env, &span sp, } fn identity_fold_ty_path[ENV](&ENV env, &span sp, ast.path p, - &option.t[def] d) -> @ty { + &Option.t[def] d) -> @ty { ret @respan(sp, ast.ty_path(p, d)); } @@ -1228,7 +1228,7 @@ fn identity_fold_expr_tup[ENV](&ENV env, &span sp, fn identity_fold_expr_rec[ENV](&ENV env, &span sp, vec[ast.field] fields, - option.t[@expr] base, ann a) -> @expr { + Option.t[@expr] base, ann a) -> @expr { ret @respan(sp, ast.expr_rec(fields, base, a)); } @@ -1243,13 +1243,13 @@ fn identity_fold_expr_self_method[ENV](&ENV env, &span sp, ident id, } 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)); } 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)); } @@ -1278,7 +1278,7 @@ fn identity_fold_expr_cast[ENV](&ENV env, &span sp, @ast.expr e, fn identity_fold_expr_if[ENV](&ENV env, &span sp, @expr cond, &block thn, - &option.t[@expr] els, ann a) -> @expr { + &Option.t[@expr] els, ann a) -> @expr { ret @respan(sp, ast.expr_if(cond, thn, els, a)); } @@ -1347,14 +1347,14 @@ fn identity_fold_expr_index[ENV](&ENV env, &span sp, } fn identity_fold_expr_path[ENV](&ENV env, &span sp, - &path p, &option.t[def] d, + &path p, &Option.t[def] d, 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, + Option.t[str] body, @expr expanded, ann a) -> @expr { ret @respan(sp, ast.expr_ext(p, args, body, expanded, a)); @@ -1373,12 +1373,12 @@ fn identity_fold_expr_cont[ENV](&ENV env, &span sp, ann a) -> @expr { } 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)); } @@ -1437,7 +1437,7 @@ fn identity_fold_pat_bind[ENV](&ENV e, &span sp, ident i, def_id did, ann 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 { + Option.t[ast.variant_def] d, ann a) -> @pat { ret @respan(sp, ast.pat_tag(p, args, d, a)); } @@ -1468,7 +1468,7 @@ fn identity_fold_item_fn[ENV](&ENV e, &span sp, ident i, } fn identity_fold_native_item_fn[ENV](&ENV e, &span sp, ident i, - option.t[str] link_name, + Option.t[str] link_name, &ast.fn_decl decl, vec[ast.ty_param] ty_params, def_id id, ann a) -> @native_item { @@ -1513,14 +1513,14 @@ fn identity_fold_item_obj[ENV](&ENV e, &span sp, ident i, 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)); } fn identity_fold_view_item_import[ENV](&ENV e, &span sp, ident i, vec[ident] is, def_id id, - option.t[def] target_def) + Option.t[def] target_def) -> @view_item { ret @respan(sp, ast.view_item_import(i, is, id, target_def)); } @@ -1574,7 +1574,7 @@ fn identity_fold_crate[ENV](&ENV e, &span sp, fn identity_fold_obj[ENV](&ENV e, vec[ast.obj_field] fields, vec[@ast.method] methods, - option.t[@ast.method] dtor) -> ast._obj { + Option.t[@ast.method] dtor) -> ast._obj { ret rec(fields=fields, methods=methods, dtor=dtor); } diff --git a/src/comp/middle/metadata.rs b/src/comp/middle/metadata.rs index ce37822d..f8e7a96e 100644 --- a/src/comp/middle/metadata.rs +++ b/src/comp/middle/metadata.rs @@ -1,12 +1,12 @@ -import std._str; -import std._uint; -import std._vec; -import std.map.hashmap; -import std.ebml; -import std.io; -import std.option; -import std.option.some; -import std.option.none; +import std.Str; +import std.UInt; +import std.Vec; +import std.Map.hashmap; +import std.EBML; +import std.IO; +import std.Option; +import std.Option.some; +import std.Option.none; import front.ast; import middle.fold; @@ -75,12 +75,12 @@ mod Encode { fn ty_str(@ctxt cx, ty.t t) -> str { assert (!cx_uses_abbrevs(cx)); - auto sw = io.string_writer(); + 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)) { @@ -109,8 +109,8 @@ mod Encode { if (abbrev_len < len) { // I.e. it's actually an abbreviation. auto s = ("#" - + _uint.to_str(pos, 16u) + ":" - + _uint.to_str(len, 16u) + "#"); + + UInt.to_str(pos, 16u) + ":" + + UInt.to_str(len, 16u) + "#"); auto a = rec(pos=pos, len=len, s=s); abbrevs.insert(t, a); } @@ -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 == ast.alias) { w.write_char('&'); } @@ -253,46 +253,46 @@ mod Encode { // Returns a Plain Old LLVM String. fn C_postr(str s) -> ValueRef { - ret llvm.LLVMConstString(_str.buf(s), _str.byte_len(s), False); + ret llvm.LLVMConstString(Str.buf(s), Str.byte_len(s), False); } // Path table encoding -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); +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); } -fn encode_def_id(&ebml.writer ebml_w, &ast.def_id id) { - ebml.start_tag(ebml_w, tag_def_id); - ebml_w.writer.write(_str.bytes(def_to_str(id))); - ebml.end_tag(ebml_w); +fn encode_def_id(&EBML.writer ebml_w, &ast.def_id id) { + EBML.start_tag(ebml_w, tag_def_id); + ebml_w.writer.write(Str.bytes(def_to_str(id))); + EBML.end_tag(ebml_w); } -fn encode_tag_variant_paths(&ebml.writer ebml_w, +fn encode_tag_variant_paths(&EBML.writer ebml_w, 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); - ebml.start_tag(ebml_w, tag_paths_data_item); + EBML.start_tag(ebml_w, tag_paths_data_item); encode_name(ebml_w, variant.node.name); encode_def_id(ebml_w, variant.node.id); - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); } } -fn add_to_index(&ebml.writer ebml_w, +fn add_to_index(&EBML.writer ebml_w, vec[str] path, &mutable vec[tup(str, uint)] index, str name) { auto full_path = path + vec(name); - index += vec(tup(_str.connect(full_path, "."), ebml_w.writer.tell())); + index += vec(tup(Str.connect(full_path, "."), ebml_w.writer.tell())); } -fn encode_native_module_item_paths(&ebml.writer ebml_w, +fn encode_native_module_item_paths(&EBML.writer ebml_w, &ast.native_mod nmod, vec[str] path, &mutable vec[tup(str, uint)] index) { @@ -300,23 +300,23 @@ fn encode_native_module_item_paths(&ebml.writer ebml_w, alt (nitem.node) { case (ast.native_item_ty(?id, ?did)) { add_to_index(ebml_w, path, index, id); - ebml.start_tag(ebml_w, tag_paths_data_item); + EBML.start_tag(ebml_w, tag_paths_data_item); encode_name(ebml_w, id); encode_def_id(ebml_w, did); - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); } case (ast.native_item_fn(?id, _, _, _, ?did, _)) { add_to_index(ebml_w, path, index, id); - ebml.start_tag(ebml_w, tag_paths_data_item); + EBML.start_tag(ebml_w, tag_paths_data_item); encode_name(ebml_w, id); encode_def_id(ebml_w, did); - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); } } } } -fn encode_module_item_paths(&ebml.writer ebml_w, +fn encode_module_item_paths(&EBML.writer ebml_w, &ast._mod module, vec[str] path, &mutable vec[tup(str, uint)] index) { @@ -325,197 +325,197 @@ fn encode_module_item_paths(&ebml.writer ebml_w, alt (it.node) { case (ast.item_const(?id, _, ?tps, ?did, ?ann)) { add_to_index(ebml_w, path, index, id); - ebml.start_tag(ebml_w, tag_paths_data_item); + EBML.start_tag(ebml_w, tag_paths_data_item); encode_name(ebml_w, id); encode_def_id(ebml_w, did); - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); } case (ast.item_fn(?id, _, ?tps, ?did, ?ann)) { add_to_index(ebml_w, path, index, id); - ebml.start_tag(ebml_w, tag_paths_data_item); + EBML.start_tag(ebml_w, tag_paths_data_item); encode_name(ebml_w, id); encode_def_id(ebml_w, did); - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); } case (ast.item_mod(?id, ?_mod, ?did)) { add_to_index(ebml_w, path, index, id); - ebml.start_tag(ebml_w, tag_paths_data_mod); + EBML.start_tag(ebml_w, tag_paths_data_mod); encode_name(ebml_w, id); encode_def_id(ebml_w, did); encode_module_item_paths(ebml_w, _mod, path + vec(id), index); - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); } case (ast.item_native_mod(?id, ?nmod, ?did)) { add_to_index(ebml_w, path, index, id); - ebml.start_tag(ebml_w, tag_paths_data_mod); + EBML.start_tag(ebml_w, tag_paths_data_mod); encode_name(ebml_w, id); encode_def_id(ebml_w, did); encode_native_module_item_paths(ebml_w, nmod, path + vec(id), index); - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); } case (ast.item_ty(?id, _, ?tps, ?did, ?ann)) { add_to_index(ebml_w, path, index, id); - ebml.start_tag(ebml_w, tag_paths_data_item); + EBML.start_tag(ebml_w, tag_paths_data_item); encode_name(ebml_w, id); encode_def_id(ebml_w, did); - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); } case (ast.item_tag(?id, ?variants, ?tps, ?did, _)) { add_to_index(ebml_w, path, index, id); - ebml.start_tag(ebml_w, tag_paths_data_item); + EBML.start_tag(ebml_w, tag_paths_data_item); encode_name(ebml_w, id); encode_def_id(ebml_w, did); - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); encode_tag_variant_paths(ebml_w, variants, path, index); } case (ast.item_obj(?id, _, ?tps, ?odid, ?ann)) { add_to_index(ebml_w, path, index, id); - ebml.start_tag(ebml_w, tag_paths_data_item); + EBML.start_tag(ebml_w, tag_paths_data_item); encode_name(ebml_w, id); encode_def_id(ebml_w, odid.ctor); encode_obj_type_id(ebml_w, odid.ty); - ebml.end_tag(ebml_w); + EBML.end_tag(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(); - ebml.start_tag(ebml_w, tag_paths); + EBML.start_tag(ebml_w, tag_paths); encode_module_item_paths(ebml_w, crate.node.module, path, index); - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); ret index; } // Item info table encoding -fn encode_kind(&ebml.writer ebml_w, u8 c) { - ebml.start_tag(ebml_w, tag_items_data_item_kind); +fn encode_kind(&EBML.writer ebml_w, u8 c) { + EBML.start_tag(ebml_w, tag_items_data_item_kind); ebml_w.writer.write(vec(c)); - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); } 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) { - 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_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) { - 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_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) { - ebml.start_tag(ebml_w, tag_items_data_item_type); +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; auto ty_str_ctxt = @rec(ds=f, tcx=cx.tcx, abbrevs=ac_use_abbrevs(cx.type_abbrevs)); - Encode.enc_ty(io.new_writer_(ebml_w.writer), ty_str_ctxt, typ); - ebml.end_tag(ebml_w); + Encode.enc_ty(IO.new_writer_(ebml_w.writer), ty_str_ctxt, typ); + EBML.end_tag(ebml_w); } -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_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, +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); + 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); } -fn encode_tag_id(&ebml.writer ebml_w, &ast.def_id id) { - ebml.start_tag(ebml_w, tag_items_data_item_tag_id); - ebml_w.writer.write(_str.bytes(def_to_str(id))); - ebml.end_tag(ebml_w); +fn encode_tag_id(&EBML.writer ebml_w, &ast.def_id id) { + EBML.start_tag(ebml_w, tag_items_data_item_tag_id); + ebml_w.writer.write(Str.bytes(def_to_str(id))); + EBML.end_tag(ebml_w); } -fn encode_obj_type_id(&ebml.writer ebml_w, &ast.def_id id) { - ebml.start_tag(ebml_w, tag_items_data_item_obj_type_id); - ebml_w.writer.write(_str.bytes(def_to_str(id))); - ebml.end_tag(ebml_w); +fn encode_obj_type_id(&EBML.writer ebml_w, &ast.def_id id) { + EBML.start_tag(ebml_w, tag_items_data_item_obj_type_id); + ebml_w.writer.write(Str.bytes(def_to_str(id))); + EBML.end_tag(ebml_w); } -fn encode_tag_variant_info(@trans.crate_ctxt cx, &ebml.writer ebml_w, +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) { for (ast.variant variant in variants) { index += vec(tup(variant.node.id._1, ebml_w.writer.tell())); - ebml.start_tag(ebml_w, tag_items_data_item); + EBML.start_tag(ebml_w, tag_items_data_item); encode_def_id(ebml_w, variant.node.id); encode_kind(ebml_w, 'v' as u8); encode_tag_id(ebml_w, did); encode_type(cx, ebml_w, trans.node_ann_type(cx, variant.node.ann)); - if (_vec.len[ast.variant_arg](variant.node.args) > 0u) { + if (Vec.len[ast.variant_arg](variant.node.args) > 0u) { encode_symbol(cx, ebml_w, variant.node.id); } encode_discriminant(cx, ebml_w, variant.node.id); encode_type_param_count(ebml_w, ty_params); - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); } } -fn encode_info_for_item(@trans.crate_ctxt cx, &ebml.writer ebml_w, +fn encode_info_for_item(@trans.crate_ctxt cx, &EBML.writer ebml_w, @ast.item item, &mutable vec[tup(int, uint)] index) { alt (item.node) { case (ast.item_const(_, _, _, ?did, ?ann)) { - ebml.start_tag(ebml_w, tag_items_data_item); + EBML.start_tag(ebml_w, tag_items_data_item); encode_def_id(ebml_w, did); encode_kind(ebml_w, 'c' as u8); encode_type(cx, ebml_w, trans.node_ann_type(cx, ann)); encode_symbol(cx, ebml_w, did); - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); } case (ast.item_fn(_, _, ?tps, ?did, ?ann)) { - ebml.start_tag(ebml_w, tag_items_data_item); + EBML.start_tag(ebml_w, tag_items_data_item); encode_def_id(ebml_w, did); encode_kind(ebml_w, 'f' as u8); encode_type_param_count(ebml_w, tps); encode_type(cx, ebml_w, trans.node_ann_type(cx, ann)); encode_symbol(cx, ebml_w, did); - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); } case (ast.item_mod(_, _, ?did)) { - ebml.start_tag(ebml_w, tag_items_data_item); + EBML.start_tag(ebml_w, tag_items_data_item); encode_def_id(ebml_w, did); encode_kind(ebml_w, 'm' as u8); - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); } case (ast.item_native_mod(_, _, ?did)) { - ebml.start_tag(ebml_w, tag_items_data_item); + EBML.start_tag(ebml_w, tag_items_data_item); encode_def_id(ebml_w, did); encode_kind(ebml_w, 'n' as u8); - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); } case (ast.item_ty(?id, _, ?tps, ?did, ?ann)) { - ebml.start_tag(ebml_w, tag_items_data_item); + EBML.start_tag(ebml_w, tag_items_data_item); encode_def_id(ebml_w, did); encode_kind(ebml_w, 'y' as u8); encode_type_param_count(ebml_w, tps); encode_type(cx, ebml_w, trans.node_ann_type(cx, ann)); - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); } case (ast.item_tag(?id, ?variants, ?tps, ?did, ?ann)) { - ebml.start_tag(ebml_w, tag_items_data_item); + EBML.start_tag(ebml_w, tag_items_data_item); encode_def_id(ebml_w, did); encode_kind(ebml_w, 't' as u8); encode_type_param_count(ebml_w, tps); @@ -523,33 +523,33 @@ fn encode_info_for_item(@trans.crate_ctxt cx, &ebml.writer ebml_w, for (ast.variant v in variants) { encode_variant_id(ebml_w, v.node.id); } - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); encode_tag_variant_info(cx, ebml_w, did, variants, index, tps); } case (ast.item_obj(?id, _, ?tps, ?odid, ?ann)) { - ebml.start_tag(ebml_w, tag_items_data_item); + EBML.start_tag(ebml_w, tag_items_data_item); encode_def_id(ebml_w, odid.ctor); encode_kind(ebml_w, 'o' as u8); encode_type_param_count(ebml_w, tps); auto fn_ty = trans.node_ann_type(cx, ann); encode_type(cx, ebml_w, fn_ty); encode_symbol(cx, ebml_w, odid.ctor); - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); - ebml.start_tag(ebml_w, tag_items_data_item); + EBML.start_tag(ebml_w, tag_items_data_item); encode_def_id(ebml_w, odid.ty); encode_kind(ebml_w, 'y' as u8); encode_type_param_count(ebml_w, tps); encode_type(cx, ebml_w, ty.ty_fn_ret(cx.tcx, fn_ty)); - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); } } } -fn encode_info_for_native_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) { - ebml.start_tag(ebml_w, tag_items_data_item); + EBML.start_tag(ebml_w, tag_items_data_item); alt (nitem.node) { case (ast.native_item_ty(_, ?did)) { encode_def_id(ebml_w, did); @@ -564,14 +564,14 @@ fn encode_info_for_native_item(@trans.crate_ctxt cx, &ebml.writer ebml_w, encode_symbol(cx, ebml_w, did); } } - ebml.end_tag(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(); - ebml.start_tag(ebml_w, tag_items_data); + EBML.start_tag(ebml_w, tag_items_data); for each (@tup(ast.def_id, @ast.item) kvp in cx.items.items()) { index += vec(tup(kvp._0._1, ebml_w.writer.tell())); encode_info_for_item(cx, ebml_w, kvp._1, index); @@ -581,7 +581,7 @@ fn encode_info_for_items(@trans.crate_ctxt cx, &ebml.writer ebml_w) index += vec(tup(kvp._0._1, ebml_w.writer.tell())); encode_info_for_native_item(cx, ebml_w, kvp._1); } - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); ret index; } @@ -597,7 +597,7 @@ fn hash_def_num(&int def_num) -> uint { fn hash_path(&str s) -> uint { auto h = 5381u; - for (u8 ch in _str.bytes(s)) { + for (u8 ch in Str.bytes(s)) { h = ((h << 5u) + h) ^ (ch as uint); } ret h; @@ -606,7 +606,7 @@ fn hash_path(&str s) -> uint { 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)) { + for each (uint i in UInt.range(0u, 256u)) { let vec[tup(T, uint)] bucket = vec(); buckets += vec(bucket); } @@ -619,69 +619,69 @@ 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) { - auto writer = io.new_writer_(ebml_w.writer); +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); + EBML.start_tag(ebml_w, tag_index); let vec[uint] bucket_locs = vec(); - ebml.start_tag(ebml_w, tag_index_buckets); + EBML.start_tag(ebml_w, tag_index_buckets); for (vec[tup(T, uint)] bucket in buckets) { bucket_locs += vec(ebml_w.writer.tell()); - ebml.start_tag(ebml_w, tag_index_buckets_bucket); + EBML.start_tag(ebml_w, tag_index_buckets_bucket); for (tup(T, uint) elt in bucket) { - ebml.start_tag(ebml_w, tag_index_buckets_bucket_elt); + EBML.start_tag(ebml_w, tag_index_buckets_bucket_elt); writer.write_be_uint(elt._1, 4u); write_fn(writer, elt._0); - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); } - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); } - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); - ebml.start_tag(ebml_w, tag_index_table); + EBML.start_tag(ebml_w, tag_index_table); for (uint pos in bucket_locs) { writer.write_be_uint(pos, 4u); } - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); - ebml.end_tag(ebml_w); + 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) -> ValueRef { - auto string_w = io.string_writer(); + auto string_w = IO.string_writer(); auto buf_w = string_w.get_writer().get_buf_writer(); - auto ebml_w = ebml.create_writer(buf_w); + auto ebml_w = EBML.create_writer(buf_w); // Encode and index the paths. - ebml.start_tag(ebml_w, tag_paths); + EBML.start_tag(ebml_w, tag_paths); auto paths_index = encode_item_paths(ebml_w, crate); auto str_writer = write_str; auto path_hasher = hash_path; auto paths_buckets = create_index[str](paths_index, path_hasher); encode_index[str](ebml_w, paths_buckets, str_writer); - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); // Encode and index the items. - ebml.start_tag(ebml_w, tag_items); + EBML.start_tag(ebml_w, tag_items); auto items_index = encode_info_for_items(cx, ebml_w); auto int_writer = write_int; auto item_hasher = hash_def_num; auto items_buckets = create_index[int](items_index, item_hasher); encode_index[int](ebml_w, items_buckets, int_writer); - ebml.end_tag(ebml_w); + EBML.end_tag(ebml_w); // Pad this, since something (LLVM, presumably) is cutting off the // remaining % 4 bytes. @@ -698,9 +698,9 @@ fn write_metadata(@trans.crate_ctxt cx, @ast.crate crate) { auto llconst = trans.C_struct(vec(llmeta)); auto llglobal = llvm.LLVMAddGlobal(cx.llmod, trans.val_ty(llconst), - _str.buf("rust_metadata")); + Str.buf("rust_metadata")); llvm.LLVMSetInitializer(llglobal, llconst); - llvm.LLVMSetSection(llglobal, _str.buf(x86.get_meta_sect_name())); + llvm.LLVMSetSection(llglobal, Str.buf(x86.get_meta_sect_name())); } // diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs index 8b92cabd..433b4734 100644 --- a/src/comp/middle/resolve.rs +++ b/src/comp/middle/resolve.rs @@ -7,15 +7,15 @@ import driver.session; import util.common.new_def_hash; import util.common.span; import util.typestate_ann.ts_ann; -import std.map.hashmap; -import std.list.list; -import std.list.nil; -import std.list.cons; -import std.option; -import std.option.some; -import std.option.none; -import std._str; -import std._vec; +import std.Map.hashmap; +import std.List.list; +import std.List.nil; +import std.List.cons; +import std.Option; +import std.Option.some; +import std.Option.none; +import std.Str; +import std.Vec; tag scope { scope_crate(@ast.crate); @@ -43,7 +43,7 @@ tag direction { down; } -type import_map = std.map.hashmap[ast.def_id,def_wrap]; +type import_map = std.Map.hashmap[ast.def_id,def_wrap]; // A simple wrapper over defs that stores a bit more information about modules // and uses so that we can use the regular lookup_name when resolving imports. @@ -112,7 +112,7 @@ fn unwrap_def(def_wrap d) -> def { } fn lookup_external_def(session.session sess, int cnum, vec[ident] idents) - -> option.t[def_wrap] { + -> Option.t[def_wrap] { alt (creader.lookup_def(sess, cnum, idents)) { case (none[ast.def]) { ret none[def_wrap]; @@ -141,7 +141,7 @@ fn lookup_external_def(session.session sess, int cnum, vec[ident] idents) fn find_final_def(&env e, import_map index, &span sp, vec[ident] idents, namespace ns, - option.t[ast.def_id] import_id) -> def_wrap { + Option.t[ast.def_id] import_id) -> def_wrap { // We are given a series of identifiers (p.q.r) and we know that // in the environment 'e' the identifier 'p' was resolved to 'd'. We @@ -153,8 +153,8 @@ fn find_final_def(&env e, import_map index, fn found_mod(&env e, &import_map index, &span sp, vec[ident] idents, namespace ns, @ast.item i) -> def_wrap { - auto len = _vec.len[ident](idents); - auto rest_idents = _vec.slice[ident](idents, 1u, len); + auto len = Vec.len[ident](idents); + auto rest_idents = Vec.slice[ident](idents, 1u, len); auto empty_e = rec(scopes = nil[scope], sess = e.sess); auto tmp_e = update_env_for_item(empty_e, i); @@ -178,8 +178,8 @@ fn find_final_def(&env e, import_map index, vec[ident] idents, namespace ns, ast.def_id mod_id) -> def_wrap { - auto len = _vec.len[ident](idents); - auto rest_idents = _vec.slice[ident](idents, 1u, len); + auto len = Vec.len[ident](idents); + auto rest_idents = Vec.slice[ident](idents, 1u, len); auto empty_e = rec(scopes = nil[scope], sess = e.sess); auto tmp_e = update_env_for_external_mod(empty_e, mod_id, idents); @@ -202,12 +202,12 @@ fn find_final_def(&env e, import_map index, fn found_crate(&env e, &import_map index, &span sp, vec[ident] idents, int cnum) -> def_wrap { - auto len = _vec.len[ident](idents); - auto rest_idents = _vec.slice[ident](idents, 1u, len); + auto len = Vec.len[ident](idents); + auto rest_idents = Vec.slice[ident](idents, 1u, len); alt (lookup_external_def(e.sess, cnum, rest_idents)) { case (none[def_wrap]) { e.sess.span_err(sp, #fmt("unbound name '%s'", - _str.connect(idents, "."))); + Str.connect(idents, "."))); fail; } case (some[def_wrap](?dw)) { ret dw; } @@ -227,7 +227,7 @@ fn find_final_def(&env e, import_map index, case (_) { } } - auto len = _vec.len[ident](idents); + auto len = Vec.len[ident](idents); if (len == 1u) { ret d; } @@ -247,13 +247,13 @@ fn find_final_def(&env e, import_map index, case (def_wrap_use(?vi)) { alt (vi.node) { case (ast.view_item_use(_, _, _, ?cnum_opt)) { - auto cnum = option.get[int](cnum_opt); + auto cnum = Option.get[int](cnum_opt); ret found_crate(e, index, sp, idents, cnum); } } } case (def_wrap_other(?d)) { - let uint l = _vec.len[ident](idents); + let uint l = Vec.len[ident](idents); ret def_wrap_expr_field(l, d); } } @@ -261,7 +261,7 @@ fn find_final_def(&env e, import_map index, } if (import_id != none[ast.def_id]) { - alt (index.find(option.get[ast.def_id](import_id))) { + alt (index.find(Option.get[ast.def_id](import_id))) { case (some[def_wrap](?x)) { alt (x) { case (def_wrap_resolving) { @@ -276,7 +276,7 @@ fn find_final_def(&env e, import_map index, case (none[def_wrap]) { } } - index.insert(option.get[ast.def_id](import_id), def_wrap_resolving); + index.insert(Option.get[ast.def_id](import_id), def_wrap_resolving); } auto first = idents.(0); auto d_ = lookup_name_wrapped(e, first, ns, up); @@ -288,7 +288,7 @@ fn find_final_def(&env e, import_map index, case (some[tup(@env, def_wrap)](?d)) { auto x = found_something(*d._0, index, sp, idents, ns, d._1); if (import_id != none[ast.def_id]) { - index.insert(option.get[ast.def_id](import_id), x); + index.insert(Option.get[ast.def_id](import_id), x); } ret x; } @@ -296,7 +296,7 @@ fn find_final_def(&env e, import_map index, } fn lookup_name_wrapped(&env e, ast.ident i, namespace ns, direction dir) - -> option.t[tup(@env, def_wrap)] { + -> Option.t[tup(@env, def_wrap)] { // log "resolving name " + i; @@ -357,7 +357,7 @@ fn lookup_name_wrapped(&env e, ast.ident i, namespace ns, direction dir) } fn check_mod(ast.ident i, ast._mod m, namespace ns, - direction dir) -> option.t[def_wrap] { + direction dir) -> Option.t[def_wrap] { fn visible(ast.ident i, ast._mod m, direction dir) -> bool { @@ -411,7 +411,7 @@ fn lookup_name_wrapped(&env e, ast.ident i, namespace ns, direction dir) } } - fn check_native_mod(ast.ident i, ast.native_mod m) -> option.t[def_wrap] { + fn check_native_mod(ast.ident i, ast.native_mod m) -> Option.t[def_wrap] { alt (m.index.find(i)) { case (some[ast.native_mod_index_entry](?ent)) { @@ -431,9 +431,9 @@ fn lookup_name_wrapped(&env e, ast.ident i, namespace ns, direction dir) } fn handle_fn_decl(ast.ident identifier, &ast.fn_decl decl, - &vec[ast.ty_param] ty_params) -> option.t[def_wrap] { + &vec[ast.ty_param] ty_params) -> Option.t[def_wrap] { for (ast.arg a in decl.inputs) { - if (_str.eq(a.ident, identifier)) { + if (Str.eq(a.ident, identifier)) { auto t = ast.def_arg(a.id); ret some(def_wrap_other(t)); } @@ -441,7 +441,7 @@ fn lookup_name_wrapped(&env e, ast.ident i, namespace ns, direction dir) auto i = 0u; for (ast.ty_param tp in ty_params) { - if (_str.eq(tp, identifier)) { + if (Str.eq(tp, identifier)) { auto t = ast.def_ty_arg(i); ret some(def_wrap_other(t)); } @@ -465,7 +465,7 @@ fn lookup_name_wrapped(&env e, ast.ident i, namespace ns, direction dir) } fn check_block(ast.ident i, &ast.block_ b, namespace ns) - -> option.t[def_wrap] { + -> Option.t[def_wrap] { alt (b.index.find(i)) { case (some[ast.block_index_entry](?ix)) { alt(ix) { @@ -486,7 +486,7 @@ fn lookup_name_wrapped(&env e, ast.ident i, namespace ns, direction dir) } fn in_scope(&session.session sess, ast.ident identifier, &scope s, - namespace ns, direction dir) -> option.t[def_wrap] { + namespace ns, direction dir) -> Option.t[def_wrap] { alt (s) { case (scope_crate(?c)) { @@ -500,7 +500,7 @@ fn lookup_name_wrapped(&env e, ast.ident i, namespace ns, direction dir) } case (ast.item_obj(_, ?ob, ?ty_params, _, _)) { for (ast.obj_field f in ob.fields) { - if (_str.eq(f.ident, identifier)) { + if (Str.eq(f.ident, identifier)) { auto t = ast.def_obj_field(f.id); ret some(def_wrap_other(t)); } @@ -508,7 +508,7 @@ fn lookup_name_wrapped(&env e, ast.ident i, namespace ns, direction dir) auto i = 0u; for (ast.ty_param tp in ty_params) { - if (_str.eq(tp, identifier)) { + if (Str.eq(tp, identifier)) { auto t = ast.def_ty_arg(i); ret some(def_wrap_other(t)); } @@ -518,7 +518,7 @@ fn lookup_name_wrapped(&env e, ast.ident i, namespace ns, direction dir) case (ast.item_tag(_,?variants,?ty_params,?tag_id,_)) { auto i = 0u; for (ast.ty_param tp in ty_params) { - if (_str.eq(tp, identifier)) { + if (Str.eq(tp, identifier)) { auto t = ast.def_ty_arg(i); ret some(def_wrap_other(t)); } @@ -534,7 +534,7 @@ fn lookup_name_wrapped(&env e, ast.ident i, namespace ns, direction dir) case (ast.item_ty(_, _, ?ty_params, _, _)) { auto i = 0u; for (ast.ty_param tp in ty_params) { - if (_str.eq(tp, identifier)) { + if (Str.eq(tp, identifier)) { auto t = ast.def_ty_arg(i); ret some(def_wrap_other(t)); } @@ -560,7 +560,7 @@ fn lookup_name_wrapped(&env e, ast.ident i, namespace ns, direction dir) case (scope_loop(?d)) { alt (d.node) { case (ast.decl_local(?local)) { - if (_str.eq(local.ident, identifier)) { + if (Str.eq(local.ident, identifier)) { auto lc = ast.def_local(local.id); ret some(def_wrap_other(lc)); } @@ -605,9 +605,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, + Option.t[ast.variant_def] old_def, ann a) -> @ast.pat { - auto len = _vec.len[ast.ident](p.node.idents); + auto len = Vec.len[ast.ident](p.node.idents); auto last_id = p.node.idents.(len - 1u); auto new_def; auto index = new_def_hash[def_wrap](); @@ -646,9 +646,9 @@ fn fold_pat_tag(&env e, &span sp, ast.path p, vec[@ast.pat] args, // and split that off as the 'primary' expr_path, with secondary expr_field // expressions tacked on the end. -fn fold_expr_path(&env e, &span sp, &ast.path p, &option.t[def] d, +fn fold_expr_path(&env e, &span sp, &ast.path p, &Option.t[def] d, ann a) -> @ast.expr { - auto n_idents = _vec.len[ast.ident](p.node.idents); + auto n_idents = Vec.len[ast.ident](p.node.idents); assert (n_idents != 0u); auto index = new_def_hash[def_wrap](); @@ -669,7 +669,7 @@ fn fold_expr_path(&env e, &span sp, &ast.path p, &option.t[def] d, } } auto path_elems = - _vec.slice[ident](p.node.idents, 0u, path_len); + Vec.slice[ident](p.node.idents, 0u, path_len); auto p_ = rec(node=rec(idents = path_elems with p.node) with p); auto d_ = some(unwrap_def(d)); auto ex = @fold.respan[ast.expr_](sp, ast.expr_path(p_, d_, a)); @@ -685,9 +685,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 { + Option.t[def] target_id) -> @ast.view_item { // Produce errors for invalid imports - auto len = _vec.len[ast.ident](is); + auto len = Vec.len[ast.ident](is); auto last_id = is.(len - 1u); auto d = find_final_def(e, index, sp, is, ns_value, some(id)); alt (d) { @@ -698,12 +698,12 @@ fn fold_view_item_import(&env e, &span sp, case (_) { } } - let option.t[def] target_def = some(unwrap_def(d)); + let Option.t[def] target_def = some(unwrap_def(d)); ret @fold.respan[ast.view_item_](sp, ast.view_item_import(i, is, id, 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]); diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs index 86ddcddf..9f10097d 100644 --- a/src/comp/middle/trans.rs +++ b/src/comp/middle/trans.rs @@ -1,14 +1,14 @@ -import std._int; -import std._str; -import std._uint; -import std._vec; -import std._str.rustrt.sbuf; -import std._vec.rustrt.vbuf; -import std.map; -import std.map.hashmap; -import std.option; -import std.option.some; -import std.option.none; +import std.Int; +import std.Str; +import std.UInt; +import std.Vec; +import std.Str.rustrt.sbuf; +import std.Vec.rustrt.vbuf; +import std.Map; +import std.Map.hashmap; +import std.Option; +import std.Option.some; +import std.Option.none; import front.ast; import front.creader; @@ -110,7 +110,7 @@ state type crate_ctxt = rec(session.session sess, hashmap[ty.t, TypeRef] lltypes, @glue_fns glues, namegen names, - std.sha1.sha1 sha, + std.SHA1.sha1 sha, hashmap[ty.t, str] type_sha1s, hashmap[ty.t, metadata.ty_abbrev] type_abbrevs, ty.ctxt tcx); @@ -129,8 +129,8 @@ state type fn_ctxt = rec(ValueRef llfn, ValueRef llenv, ValueRef llretptr, mutable BasicBlockRef llallocas, - mutable option.t[self_vt] llself, - mutable option.t[ValueRef] lliterbody, + mutable Option.t[self_vt] llself, + mutable Option.t[ValueRef] lliterbody, hashmap[ast.def_id, ValueRef] llargs, hashmap[ast.def_id, ValueRef] llobjfields, hashmap[ast.def_id, ValueRef] lllocals, @@ -145,7 +145,7 @@ tag cleanup { tag block_kind { SCOPE_BLOCK; - LOOP_SCOPE_BLOCK(option.t[@block_ctxt], @block_ctxt); + LOOP_SCOPE_BLOCK(Option.t[@block_ctxt], @block_ctxt); NON_SCOPE_BLOCK; } @@ -156,7 +156,7 @@ state type block_ctxt = rec(BasicBlockRef llbb, mutable vec[cleanup] cleanups, @fn_ctxt fcx); -// FIXME: we should be able to use option.t[@block_parent] here but +// FIXME: we should be able to use Option.t[@block_parent] here but // the infinite-tag check in rustboot gets upset. tag block_parent { @@ -177,7 +177,7 @@ fn extend_path(@local_ctxt cx, str name) -> @local_ctxt { } fn path_name(vec[str] path) -> str { - ret _str.connect(path, sep()); + ret Str.connect(path, sep()); } @@ -192,7 +192,7 @@ fn get_type_sha1(@crate_ctxt ccx, ty.t t) -> str { // to be independent of one another in the crate. auto cx = @rec(ds=f, tcx=ccx.tcx, abbrevs=metadata.ac_no_abbrevs); ccx.sha.input_str(metadata.Encode.ty_str(cx, t)); - hash = _str.substr(ccx.sha.result_str(), 0u, 16u); + hash = Str.substr(ccx.sha.result_str(), 0u, 16u); ccx.type_sha1s.insert(t, hash); } } @@ -306,8 +306,8 @@ fn T_char() -> TypeRef { fn T_fn(vec[TypeRef] inputs, TypeRef output) -> TypeRef { ret llvm.LLVMFunctionType(output, - _vec.buf[TypeRef](inputs), - _vec.len[TypeRef](inputs), + Vec.buf[TypeRef](inputs), + Vec.len[TypeRef](inputs), False); } @@ -321,8 +321,8 @@ fn T_ptr(TypeRef t) -> TypeRef { } fn T_struct(vec[TypeRef] elts) -> TypeRef { - ret llvm.LLVMStructType(_vec.buf[TypeRef](elts), - _vec.len[TypeRef](elts), + ret llvm.LLVMStructType(Vec.buf[TypeRef](elts), + Vec.len[TypeRef](elts), False); } @@ -352,9 +352,9 @@ fn T_task(type_names tn) -> TypeRef { fn T_tydesc_field(type_names tn, int field) -> TypeRef { // Bit of a kludge: pick the fn typeref out of the tydesc.. let vec[TypeRef] tydesc_elts = - _vec.init_elt[TypeRef](T_nil(), abi.n_tydesc_fields as uint); + Vec.init_elt[TypeRef](T_nil(), abi.n_tydesc_fields as uint); llvm.LLVMGetStructElementTypes(T_tydesc(tn), - _vec.buf[TypeRef](tydesc_elts)); + Vec.buf[TypeRef](tydesc_elts)); auto t = llvm.LLVMGetElementType(tydesc_elts.(field)); ret t; } @@ -372,7 +372,7 @@ fn T_glue_fn(type_names tn) -> TypeRef { fn T_dtor(@crate_ctxt ccx, TypeRef llself_ty) -> TypeRef { ret type_of_fn_full(ccx, ast.proto_fn, some[TypeRef](llself_ty), - _vec.empty[ty.arg](), ty.mk_nil(ccx.tcx), 0u); + Vec.empty[ty.arg](), ty.mk_nil(ccx.tcx), 0u); } fn T_cmp_glue_fn(type_names tn) -> TypeRef { @@ -535,7 +535,7 @@ fn T_opaque_closure_ptr(type_names tn) -> TypeRef { } fn T_tag(type_names tn, uint size) -> TypeRef { - auto s = "tag_" + _uint.to_str(size, 10u); + auto s = "tag_" + UInt.to_str(size, 10u); if (tn.name_has_type(s)) { ret tn.get_type(s); } @@ -559,7 +559,7 @@ fn T_opaque_tag_ptr(type_names tn) -> TypeRef { } fn T_captured_tydescs(type_names tn, uint n) -> TypeRef { - ret T_struct(_vec.init_elt[TypeRef](T_ptr(T_tydesc(tn)), n)); + ret T_struct(Vec.init_elt[TypeRef](T_ptr(T_tydesc(tn)), n)); } fn T_obj_ptr(type_names tn, uint n_captured_tydescs) -> TypeRef { @@ -623,7 +623,7 @@ fn type_of_explicit_args(@crate_ctxt cx, vec[ty.arg] inputs) -> vec[TypeRef] { fn type_of_fn_full(@crate_ctxt cx, ast.proto proto, - option.t[TypeRef] obj_self, + Option.t[TypeRef] obj_self, vec[ty.arg] inputs, ty.t output, uint ty_param_count) -> TypeRef { @@ -811,7 +811,7 @@ fn type_of_inner(@crate_ctxt cx, ty.t t) -> TypeRef { } assert (llty as int != 0); - llvm.LLVMAddTypeName(cx.llmod, _str.buf(ty.ty_to_short_str(cx.tcx, t)), + llvm.LLVMAddTypeName(cx.llmod, Str.buf(ty.ty_to_short_str(cx.tcx, t)), llty); cx.lltypes.insert(t, llty); ret llty; @@ -872,7 +872,7 @@ fn sanitize(str s) -> str { c != (' ' as u8) && c != ('\t' as u8) && c != (';' as u8)) { auto v = vec(c); - result += _str.from_bytes(v); + result += Str.from_bytes(v); } } } @@ -894,15 +894,15 @@ fn C_integral(int i, TypeRef t) -> ValueRef { // // ret llvm.LLVMConstInt(T_int(), t as LLVM.ULongLong, False); // - ret llvm.LLVMConstIntOfString(t, _str.buf(istr(i)), 10); + ret llvm.LLVMConstIntOfString(t, Str.buf(istr(i)), 10); } fn C_float(str s) -> ValueRef { - ret llvm.LLVMConstRealOfString(T_float(), _str.buf(s)); + ret llvm.LLVMConstRealOfString(T_float(), Str.buf(s)); } fn C_floating(str s, TypeRef t) -> ValueRef { - ret llvm.LLVMConstRealOfString(t, _str.buf(s)); + ret llvm.LLVMConstRealOfString(t, Str.buf(s)); } fn C_nil() -> ValueRef { @@ -929,9 +929,9 @@ fn C_i8(uint i) -> ValueRef { // This is a 'c-like' raw string, which differs from // our boxed-and-length-annotated strings. fn C_cstr(@crate_ctxt cx, str s) -> ValueRef { - auto sc = llvm.LLVMConstString(_str.buf(s), _str.byte_len(s), False); + auto sc = llvm.LLVMConstString(Str.buf(s), Str.byte_len(s), False); auto g = llvm.LLVMAddGlobal(cx.llmod, val_ty(sc), - _str.buf(cx.names.next("str"))); + Str.buf(cx.names.next("str"))); llvm.LLVMSetInitializer(g, sc); llvm.LLVMSetGlobalConstant(g, True); llvm.LLVMSetLinkage(g, lib.llvm.LLVMInternalLinkage @@ -941,15 +941,15 @@ fn C_cstr(@crate_ctxt cx, str s) -> ValueRef { // A rust boxed-and-length-annotated string. fn C_str(@crate_ctxt cx, str s) -> ValueRef { - auto len = _str.byte_len(s); + auto len = Str.byte_len(s); auto box = C_struct(vec(C_int(abi.const_refcount as int), C_int(len + 1u as int), // 'alloc' C_int(len + 1u as int), // 'fill' C_int(0), // 'pad' - llvm.LLVMConstString(_str.buf(s), + llvm.LLVMConstString(Str.buf(s), len, False))); auto g = llvm.LLVMAddGlobal(cx.llmod, val_ty(box), - _str.buf(cx.names.next("str"))); + Str.buf(cx.names.next("str"))); llvm.LLVMSetInitializer(g, box); llvm.LLVMSetGlobalConstant(g, True); llvm.LLVMSetLinkage(g, lib.llvm.LLVMInternalLinkage @@ -964,24 +964,24 @@ fn C_zero_byte_arr(uint size) -> ValueRef { elts += vec(C_integral(0, T_i8())); i += 1u; } - ret llvm.LLVMConstArray(T_i8(), _vec.buf[ValueRef](elts), - _vec.len[ValueRef](elts)); + ret llvm.LLVMConstArray(T_i8(), Vec.buf[ValueRef](elts), + Vec.len[ValueRef](elts)); } fn C_struct(vec[ValueRef] elts) -> ValueRef { - ret llvm.LLVMConstStruct(_vec.buf[ValueRef](elts), - _vec.len[ValueRef](elts), + ret llvm.LLVMConstStruct(Vec.buf[ValueRef](elts), + Vec.len[ValueRef](elts), False); } fn C_array(TypeRef ty, vec[ValueRef] elts) -> ValueRef { - ret llvm.LLVMConstArray(ty, _vec.buf[ValueRef](elts), - _vec.len[ValueRef](elts)); + ret llvm.LLVMConstArray(ty, Vec.buf[ValueRef](elts), + Vec.len[ValueRef](elts)); } fn decl_fn(ModuleRef llmod, str name, uint cc, TypeRef llty) -> ValueRef { let ValueRef llfn = - llvm.LLVMAddFunction(llmod, _str.buf(name), llty); + llvm.LLVMAddFunction(llmod, Str.buf(name), llty); llvm.LLVMSetFunctionCallConv(llfn, cc); ret llfn; } @@ -1026,7 +1026,7 @@ fn decl_native_glue(ModuleRef llmod, type_names tn, args += vec(T_int()); // taskptr, will not be passed } - args += _vec.init_elt[TypeRef](T_int(), n as uint); + args += Vec.init_elt[TypeRef](T_int(), n as uint); ret decl_fastcall_fn(llmod, s, T_fn(args, T_int())); } @@ -1047,14 +1047,14 @@ fn get_extern_const(&hashmap[str, ValueRef] externs, if (externs.contains_key(name)) { ret externs.get(name); } - auto c = llvm.LLVMAddGlobal(llmod, ty, _str.buf(name)); + auto c = llvm.LLVMAddGlobal(llmod, ty, Str.buf(name)); externs.insert(name, c); ret c; } fn get_simple_extern_fn(&hashmap[str, ValueRef] externs, ModuleRef llmod, str name, int n_args) -> ValueRef { - auto inputs = _vec.init_elt[TypeRef](T_int(), n_args as uint); + auto inputs = Vec.init_elt[TypeRef](T_int(), n_args as uint); auto output = T_int(); auto t = T_fn(inputs, output); ret get_extern_fn(externs, llmod, name, lib.llvm.LLVMCCallConv, t); @@ -1075,7 +1075,7 @@ fn trans_native_call(builder b, @glue_fns glues, ValueRef lltaskptr, &hashmap[str, ValueRef] externs, type_names tn, ModuleRef llmod, str name, bool pass_task, vec[ValueRef] args) -> ValueRef { - let int n = (_vec.len[ValueRef](args) as int); + let int n = (Vec.len[ValueRef](args) as int); let ValueRef llnative = get_simple_extern_fn(externs, llmod, name, n); llnative = llvm.LLVMConstPointerCast(llnative, T_int()); @@ -1395,7 +1395,7 @@ fn GEP_tup_like(@block_ctxt cx, ty.t t, fn split_type(@crate_ctxt ccx, ty.t t, vec[int] ixs, uint n) -> rec(vec[ty.t] prefix, ty.t target) { - let uint len = _vec.len[int](ixs); + let uint len = Vec.len[int](ixs); // We don't support 0-index or 1-index GEPs. The former is nonsense // and the latter would only be meaningful if we supported non-0 @@ -1417,7 +1417,7 @@ fn GEP_tup_like(@block_ctxt cx, ty.t t, let vec[ty.t] prefix = vec(); let int i = 0; while (i < ix) { - _vec.push[ty.t](prefix, + Vec.push[ty.t](prefix, ty.get_element_type(ccx.tcx, t, i as uint)); i += 1 ; } @@ -1617,8 +1617,8 @@ fn mk_derived_tydesc(@block_ctxt cx, ty.t t, bool escapes) -> result { let uint n_params = ty.count_ty_params(cx.fcx.lcx.ccx.tcx, t); auto tys = linearize_ty_params(cx, t); - assert (n_params == _vec.len[uint](tys._0)); - assert (n_params == _vec.len[ValueRef](tys._1)); + assert (n_params == Vec.len[uint](tys._0)); + assert (n_params == Vec.len[ValueRef](tys._1)); auto root = get_static_tydesc(cx, t, tys._0).tydesc; @@ -1746,7 +1746,7 @@ fn declare_tydesc(@local_ctxt cx, ty.t t) -> @tydesc_info { auto name = mangle_name_by_type_only(ccx, t, "tydesc"); auto gvar = llvm.LLVMAddGlobal(ccx.llmod, T_tydesc(ccx.tn), - _str.buf(name)); + Str.buf(name)); auto tydesc = C_struct(vec(C_null(T_ptr(T_ptr(T_tydesc(ccx.tn)))), llsize, llalign, @@ -1827,20 +1827,20 @@ fn make_generic_glue(@local_ctxt cx, llty = T_ptr(type_of(cx.ccx, t)); } - auto ty_param_count = _vec.len[uint](ty_params); + auto ty_param_count = Vec.len[uint](ty_params); auto lltyparams = llvm.LLVMGetParam(llfn, 3u); - auto lltydescs = _vec.empty_mut[ValueRef](); + auto lltydescs = Vec.empty_mut[ValueRef](); auto p = 0u; while (p < ty_param_count) { auto llparam = bcx.build.GEP(lltyparams, vec(C_int(p as int))); llparam = bcx.build.Load(llparam); - _vec.grow_set[ValueRef](lltydescs, ty_params.(p), 0 as ValueRef, + Vec.grow_set[ValueRef](lltydescs, ty_params.(p), 0 as ValueRef, llparam); p += 1u; } - bcx.fcx.lltydescs = _vec.freeze[ValueRef](lltydescs); + bcx.fcx.lltydescs = Vec.freeze[ValueRef](lltydescs); auto llrawptr0 = llvm.LLVMGetParam(llfn, 4u); auto llval0 = bcx.build.BitCast(llrawptr0, llty); @@ -2157,7 +2157,7 @@ fn make_cmp_glue(@block_ctxt cx, */ auto flag = alloca(scx, T_i1()); - llvm.LLVMSetValueName(flag, _str.buf("flag")); + llvm.LLVMSetValueName(flag, Str.buf("flag")); auto r; if (ty.type_is_sequence(cx.fcx.lcx.ccx.tcx, t)) { @@ -2378,7 +2378,7 @@ fn tag_variants(@crate_ctxt cx, ast.def_id id) -> vec[variant_info] { for (ast.variant variant in variants) { auto ctor_ty = node_ann_type(cx, variant.node.ann); let vec[ty.t] arg_tys = vec(); - if (_vec.len[ast.variant_arg](variant.node.args) > 0u) { + if (Vec.len[ast.variant_arg](variant.node.args) > 0u) { for (ty.arg a in ty.ty_fn_args(cx.tcx, ctor_ty)) { arg_tys += vec(a.ty); } @@ -2399,7 +2399,7 @@ fn tag_variant_with_id(@crate_ctxt cx, auto variants = tag_variants(cx, tag_id); auto i = 0u; - while (i < _vec.len[variant_info](variants)) { + while (i < Vec.len[variant_info](variants)) { auto variant = variants.(i); if (common.def_eq(variant.id, variant_id)) { ret variant; @@ -2495,7 +2495,7 @@ fn iter_structural_ty_full(@block_ctxt cx, } case (ty.ty_tag(?tid, ?tps)) { auto variants = tag_variants(cx.fcx.lcx.ccx, tid); - auto n_variants = _vec.len[variant_info](variants); + auto n_variants = Vec.len[variant_info](variants); // Cast the tags to types we can GEP into. auto lltagty = T_opaque_tag_ptr(cx.fcx.lcx.ccx.tn); @@ -2532,10 +2532,10 @@ fn iter_structural_ty_full(@block_ctxt cx, for (variant_info variant in variants) { auto variant_cx = new_sub_block_ctxt(bcx, "tag-iter-variant-" + - _uint.to_str(i, 10u)); + UInt.to_str(i, 10u)); llvm.LLVMAddCase(llswitch, C_int(i as int), variant_cx.llbb); - if (_vec.len[ty.t](variant.args) > 0u) { + if (Vec.len[ty.t](variant.args) > 0u) { // N-ary variant. auto fn_ty = variant.ctor_ty; alt (ty.struct(bcx.fcx.lcx.ccx.tcx, fn_ty)) { @@ -3386,12 +3386,12 @@ fn join_results(@block_ctxt parent_cx, } } - alt (_vec.len[result](live)) { + alt (Vec.len[result](live)) { case (0u) { // No incoming edges are live, so we're in dead-code-land. // Arbitrarily pick the first dead edge, since the caller // is just going to propagate it outward. - assert (_vec.len[result](ins) >= 1u); + assert (Vec.len[result](ins) >= 1u); ret ins.(0); } @@ -3408,7 +3408,7 @@ fn join_results(@block_ctxt parent_cx, } fn trans_if(@block_ctxt cx, @ast.expr cond, - &ast.block thn, &option.t[@ast.expr] els) -> result { + &ast.block thn, &Option.t[@ast.expr] els) -> result { auto cond_res = trans_expr(cx, cond); @@ -3472,7 +3472,7 @@ fn trans_for(@block_ctxt cx, auto next_cx = new_sub_block_ctxt(cx, "next"); auto scope_cx = - new_loop_scope_block_ctxt(cx, option.some[@block_ctxt](next_cx), + new_loop_scope_block_ctxt(cx, Option.some[@block_ctxt](next_cx), outer_next_cx, "for loop scope"); cx.build.Br(scope_cx.llbb); @@ -3517,15 +3517,15 @@ fn collect_upvars(@block_ctxt cx, &ast.block bloc, &ast.def_id initial_decl) fn walk_expr(env e, @ast.expr expr) { alt (expr.node) { case (ast.expr_path(?path, ?d, _)) { - alt (option.get[ast.def](d)) { + alt (Option.get[ast.def](d)) { case (ast.def_arg(?did)) { - _vec.push[ast.def_id](e.refs, did); + Vec.push[ast.def_id](e.refs, did); } case (ast.def_local(?did)) { - _vec.push[ast.def_id](e.refs, did); + Vec.push[ast.def_id](e.refs, did); } case (ast.def_upvar(?did)) { - _vec.push[ast.def_id](e.refs, did); + Vec.push[ast.def_id](e.refs, did); } case (_) {} } @@ -3606,7 +3606,7 @@ fn trans_for_each(@block_ctxt cx, } auto upvars = collect_upvars(cx, body, decl_id); - auto upvar_count = _vec.len[ast.def_id](upvars); + auto upvar_count = Vec.len[ast.def_id](upvars); auto llbindingsptr; if (upvar_count > 0u) { @@ -3645,7 +3645,7 @@ fn trans_for_each(@block_ctxt cx, } // Create an environment and populate it with the bindings. - auto tydesc_count = _vec.len[ValueRef](cx.fcx.lltydescs); + auto tydesc_count = Vec.len[ValueRef](cx.fcx.lltydescs); auto llenvptrty = T_closure_ptr(lcx.ccx.tn, T_ptr(T_nil()), val_ty(llbindingsptr), tydesc_count); auto llenvptr = alloca(cx, llvm.LLVMGetElementType(llenvptrty)); @@ -3776,7 +3776,7 @@ fn trans_while(@block_ctxt cx, @ast.expr cond, auto cond_cx = new_scope_block_ctxt(cx, "while cond"); auto next_cx = new_sub_block_ctxt(cx, "next"); - auto body_cx = new_loop_scope_block_ctxt(cx, option.none[@block_ctxt], + auto body_cx = new_loop_scope_block_ctxt(cx, Option.none[@block_ctxt], next_cx, "while loop body"); auto body_res = trans_block(body_cx, body); @@ -3795,7 +3795,7 @@ fn trans_do_while(@block_ctxt cx, &ast.block body, @ast.expr cond) -> result { auto next_cx = new_sub_block_ctxt(cx, "next"); - auto body_cx = new_loop_scope_block_ctxt(cx, option.none[@block_ctxt], + auto body_cx = new_loop_scope_block_ctxt(cx, Option.none[@block_ctxt], next_cx, "do-while loop body"); auto body_res = trans_block(body_cx, body); @@ -3834,7 +3834,7 @@ fn trans_pat_match(@block_ctxt cx, @ast.pat pat, ValueRef llval, vec(C_int(0), C_int(0))); auto lldiscrim = cx.build.Load(lldiscrimptr); - auto vdef = option.get[ast.variant_def](vdef_opt); + auto vdef = Option.get[ast.variant_def](vdef_opt); auto variant_id = vdef._1; auto variant_tag = 0; @@ -3857,7 +3857,7 @@ fn trans_pat_match(@block_ctxt cx, @ast.pat pat, ValueRef llval, auto ty_params = node_ann_ty_params(ann); - if (_vec.len[@ast.pat](subpats) > 0u) { + if (Vec.len[@ast.pat](subpats) > 0u) { auto llblobptr = matched_cx.build.GEP(lltagptr, vec(C_int(0), C_int(1))); auto i = 0; @@ -3899,7 +3899,7 @@ fn trans_pat_binding(@block_ctxt cx, @ast.pat pat, auto rslt = alloc_ty(cx, t); auto dst = rslt.val; auto bcx = rslt.bcx; - llvm.LLVMSetValueName(dst, _str.buf(id)); + llvm.LLVMSetValueName(dst, Str.buf(id)); bcx.fcx.lllocals.insert(def_id, dst); bcx.cleanups += vec(clean(bind drop_slot(_, dst, t))); @@ -3907,10 +3907,10 @@ fn trans_pat_binding(@block_ctxt cx, @ast.pat pat, } } case (ast.pat_tag(_, ?subpats, ?vdef_opt, ?ann)) { - if (_vec.len[@ast.pat](subpats) == 0u) { ret res(cx, llval); } + if (Vec.len[@ast.pat](subpats) == 0u) { ret res(cx, llval); } // Get the appropriate variant for this tag. - auto vdef = option.get[ast.variant_def](vdef_opt); + auto vdef = Option.get[ast.variant_def](vdef_opt); auto lltagptr = cx.build.PointerCast(llval, T_opaque_tag_ptr(cx.fcx.lcx.ccx.tn)); @@ -3982,9 +3982,9 @@ type generic_info = rec(ty.t item_type, type lval_result = rec(result res, bool is_mem, - option.t[generic_info] generic, - option.t[ValueRef] llobj, - option.t[ty.t] method_ty); + Option.t[generic_info] generic, + Option.t[ValueRef] llobj, + Option.t[ty.t] method_ty); fn lval_mem(@block_ctxt cx, ValueRef val) -> lval_result { ret rec(res=res(cx, val), @@ -4035,18 +4035,18 @@ fn lval_generic_fn(@block_ctxt cx, } case (ast.ann_type(?monoty_, ?tps, _)) { monoty = monoty_; - tys = option.get[vec[ty.t]](tps); + tys = Option.get[vec[ty.t]](tps); } } - if (_vec.len[ty.t](tys) != 0u) { + if (Vec.len[ty.t](tys) != 0u) { auto bcx = lv.res.bcx; let vec[ValueRef] tydescs = vec(); for (ty.t t in tys) { // TODO: Doesn't always escape. auto td = get_tydesc(bcx, t, true); bcx = td.bcx; - _vec.push[ValueRef](tydescs, td.val); + Vec.push[ValueRef](tydescs, td.val); } auto gen = rec( item_type = tpt._1, tydescs = tydescs ); @@ -4065,7 +4065,7 @@ fn lookup_discriminant(@local_ctxt lcx, ast.def_id tid, ast.def_id vid) assert (lcx.ccx.sess.get_targ_crate_num() != vid._0); auto sym = creader.get_symbol(lcx.ccx.sess, vid); auto gvar = llvm.LLVMAddGlobal(lcx.ccx.llmod, T_int(), - _str.buf(sym)); + Str.buf(sym)); llvm.LLVMSetLinkage(gvar, lib.llvm.LLVMExternalLinkage as llvm.Linkage); llvm.LLVMSetGlobalConstant(gvar, True); @@ -4076,7 +4076,7 @@ fn lookup_discriminant(@local_ctxt lcx, ast.def_id tid, ast.def_id vid) } } -fn trans_path(@block_ctxt cx, &ast.path p, &option.t[ast.def] dopt, +fn trans_path(@block_ctxt cx, &ast.path p, &Option.t[ast.def] dopt, &ast.ann ann) -> lval_result { alt (dopt) { case (some[ast.def](?def)) { @@ -4246,10 +4246,10 @@ fn trans_index(@block_ctxt cx, &ast.span sp, @ast.expr base, auto unit_ty = node_ann_type(cx.fcx.lcx.ccx, ann); auto unit_sz = size_of(bcx, unit_ty); bcx = unit_sz.bcx; - llvm.LLVMSetValueName(unit_sz.val, _str.buf("unit_sz")); + llvm.LLVMSetValueName(unit_sz.val, Str.buf("unit_sz")); auto scaled_ix = bcx.build.Mul(ix_val, unit_sz.val); - llvm.LLVMSetValueName(scaled_ix, _str.buf("scaled_ix")); + llvm.LLVMSetValueName(scaled_ix, Str.buf("scaled_ix")); auto lim = bcx.build.GEP(v, vec(C_int(0), C_int(abi.vec_elt_fill))); lim = bcx.build.Load(lim); @@ -4369,7 +4369,7 @@ fn trans_cast(@block_ctxt cx, @ast.expr e, &ast.ann ann) -> result { fn trans_bind_thunk(@local_ctxt cx, ty.t incoming_fty, ty.t outgoing_fty, - vec[option.t[@ast.expr]] args, + vec[Option.t[@ast.expr]] args, ty.t closure_ty, vec[ty.t] bound_tys, uint ty_param_count) -> ValueRef { @@ -4433,7 +4433,7 @@ fn trans_bind_thunk(@local_ctxt cx, let vec[TypeRef] llout_arg_tys = type_of_explicit_args(cx.ccx, outgoing_args); - for (option.t[@ast.expr] arg in args) { + for (Option.t[@ast.expr] arg in args) { auto out_arg = outgoing_args.(outgoing_arg_index); auto llout_arg_ty = llout_arg_tys.(outgoing_arg_index); @@ -4516,7 +4516,7 @@ fn trans_bind_thunk(@local_ctxt cx, } fn trans_bind(@block_ctxt cx, @ast.expr f, - vec[option.t[@ast.expr]] args, + vec[Option.t[@ast.expr]] args, &ast.ann ann) -> result { auto f_res = trans_lval(cx, f); if (f_res.is_mem) { @@ -4524,12 +4524,12 @@ fn trans_bind(@block_ctxt cx, @ast.expr f, } else { let vec[@ast.expr] bound = vec(); - for (option.t[@ast.expr] argopt in args) { + for (Option.t[@ast.expr] argopt in args) { alt (argopt) { case (none[@ast.expr]) { } case (some[@ast.expr](?e)) { - _vec.push[@ast.expr](bound, e); + Vec.push[@ast.expr](bound, e); } } } @@ -4547,9 +4547,9 @@ fn trans_bind(@block_ctxt cx, @ast.expr f, lltydescs = ginfo.tydescs; } } - auto ty_param_count = _vec.len[ValueRef](lltydescs); + auto ty_param_count = Vec.len[ValueRef](lltydescs); - if (_vec.len[@ast.expr](bound) == 0u && ty_param_count == 0u) { + if (Vec.len[@ast.expr](bound) == 0u && ty_param_count == 0u) { // Trivial 'binding': just return the static pair-ptr. ret f_res.res; } else { @@ -4565,8 +4565,8 @@ fn trans_bind(@block_ctxt cx, @ast.expr f, auto arg = trans_expr(bcx, e); bcx = arg.bcx; - _vec.push[ValueRef](bound_vals, arg.val); - _vec.push[ty.t](bound_tys, + Vec.push[ValueRef](bound_vals, arg.val); + Vec.push[ty.t](bound_tys, ty.expr_ty(cx.fcx.lcx.ccx.tcx, e)); i += 1u; @@ -4582,7 +4582,7 @@ fn trans_bind(@block_ctxt cx, @ast.expr f, let ty.t tydesc_ty = ty.mk_type(cx.fcx.lcx.ccx.tcx); let vec[ty.t] captured_tys = - _vec.init_elt[ty.t](tydesc_ty, ty_param_count); + Vec.init_elt[ty.t](tydesc_ty, ty_param_count); let vec[ty.t] closure_tys = vec(tydesc_ty, @@ -4778,9 +4778,9 @@ fn trans_arg_expr(@block_ctxt cx, fn trans_args(@block_ctxt cx, ValueRef llenv, - option.t[ValueRef] llobj, - option.t[generic_info] gen, - option.t[ValueRef] lliterbody, + Option.t[ValueRef] llobj, + Option.t[generic_info] gen, + Option.t[ValueRef] lliterbody, &vec[@ast.expr] es, ty.t fn_ty) -> tup(@block_ctxt, vec[ValueRef], ValueRef) { @@ -4869,7 +4869,7 @@ fn trans_args(@block_ctxt cx, } fn trans_call(@block_ctxt cx, @ast.expr f, - option.t[ValueRef] lliterbody, + Option.t[ValueRef] lliterbody, vec[@ast.expr] args, &ast.ann ann) -> result { @@ -4997,7 +4997,7 @@ fn trans_vec(@block_ctxt cx, vec[@ast.expr] args, auto bcx = cx; auto unit_sz = size_of(bcx, unit_ty); bcx = unit_sz.bcx; - auto data_sz = bcx.build.Mul(C_int(_vec.len[@ast.expr](args) as int), + auto data_sz = bcx.build.Mul(C_int(Vec.len[@ast.expr](args) as int), unit_sz.val); // FIXME: pass tydesc properly. @@ -5015,8 +5015,8 @@ fn trans_vec(@block_ctxt cx, vec[@ast.expr] args, auto pseudo_tup_ty = ty.mk_imm_tup(cx.fcx.lcx.ccx.tcx, - _vec.init_elt[ty.t](unit_ty, - _vec.len[@ast.expr](args))); + Vec.init_elt[ty.t](unit_ty, + Vec.len[@ast.expr](args))); let int i = 0; for (@ast.expr e in args) { @@ -5056,7 +5056,7 @@ fn trans_vec(@block_ctxt cx, vec[@ast.expr] args, } fn trans_rec(@block_ctxt cx, vec[ast.field] fields, - option.t[@ast.expr] base, &ast.ann ann) -> result { + Option.t[@ast.expr] base, &ast.ann ann) -> result { auto bcx = cx; auto t = node_ann_type(bcx.fcx.lcx.ccx, ann); @@ -5093,7 +5093,7 @@ fn trans_rec(@block_ctxt cx, vec[ast.field] fields, auto src_res = res(bcx, C_nil()); for (ast.field f in fields) { - if (_str.eq(f.ident, tf.ident)) { + if (Str.eq(f.ident, tf.ident)) { expr_provided = true; src_res = trans_expr(bcx, f.expr); } @@ -5326,13 +5326,13 @@ fn load_if_immediate(@block_ctxt cx, ValueRef v, ty.t t) -> ValueRef { fn trans_log(int lvl, @block_ctxt cx, @ast.expr e) -> result { auto lcx = cx.fcx.lcx; - auto modname = _str.connect(lcx.module_path, "."); + auto modname = Str.connect(lcx.module_path, "."); auto global; if (lcx.ccx.module_data.contains_key(modname)) { global = lcx.ccx.module_data.get(modname); } else { global = llvm.LLVMAddGlobal(lcx.ccx.llmod, T_int(), - _str.buf("_rust_mod_log_" + modname)); + Str.buf("_rust_mod_log_" + modname)); llvm.LLVMSetGlobalConstant(global, False); llvm.LLVMSetInitializer(global, C_null(T_int())); llvm.LLVMSetLinkage(global, lib.llvm.LLVMInternalLinkage @@ -5418,7 +5418,7 @@ fn trans_check_expr(@block_ctxt cx, @ast.expr e) -> result { ret res(next_cx, C_nil()); } -fn trans_fail(@block_ctxt cx, option.t[common.span] sp_opt, str fail_str) +fn trans_fail(@block_ctxt cx, Option.t[common.span] sp_opt, str fail_str) -> result { auto V_fail_str = p2i(C_cstr(cx.fcx.lcx.ccx, fail_str)); @@ -5442,7 +5442,7 @@ fn trans_fail(@block_ctxt cx, option.t[common.span] sp_opt, str fail_str) ret res(sub.bcx, C_nil()); } -fn trans_put(@block_ctxt cx, &option.t[@ast.expr] e) -> result { +fn trans_put(@block_ctxt cx, &Option.t[@ast.expr] e) -> result { auto llcallee = C_nil(); auto llenv = C_nil(); @@ -5490,7 +5490,7 @@ fn trans_break_cont(@block_ctxt cx, bool to_end) -> result { bcx.build.Br(_break.llbb); } else { alt (_cont) { - case (option.some[@block_ctxt](?_cont)) { + case (Option.some[@block_ctxt](?_cont)) { bcx.build.Br(_cont.llbb); } case (_) { @@ -5519,7 +5519,7 @@ fn trans_cont(@block_ctxt cx) -> result { } -fn trans_ret(@block_ctxt cx, &option.t[@ast.expr] e) -> result { +fn trans_ret(@block_ctxt cx, &Option.t[@ast.expr] e) -> result { auto bcx = cx; auto val = C_nil(); @@ -5765,7 +5765,7 @@ fn new_block_ctxt(@fn_ctxt cx, block_parent parent, let vec[cleanup] cleanups = vec(); let BasicBlockRef llbb = llvm.LLVMAppendBasicBlock(cx.llfn, - _str.buf(cx.lcx.ccx.names.next(name))); + Str.buf(cx.lcx.ccx.names.next(name))); ret @rec(llbb=llbb, build=new_builder(llbb), @@ -5786,7 +5786,7 @@ fn new_scope_block_ctxt(@block_ctxt bcx, str n) -> @block_ctxt { ret new_block_ctxt(bcx.fcx, parent_some(bcx), SCOPE_BLOCK, n); } -fn new_loop_scope_block_ctxt(@block_ctxt bcx, option.t[@block_ctxt] _cont, +fn new_loop_scope_block_ctxt(@block_ctxt bcx, Option.t[@block_ctxt] _cont, @block_ctxt _break, str n) -> @block_ctxt { ret new_block_ctxt(bcx.fcx, parent_some(bcx), LOOP_SCOPE_BLOCK(_cont, _break), n); @@ -5803,10 +5803,10 @@ fn trans_block_cleanups(@block_ctxt cx, auto bcx = cx; if (cleanup_cx.kind == NON_SCOPE_BLOCK) { - assert (_vec.len[cleanup](cleanup_cx.cleanups) == 0u); + assert (Vec.len[cleanup](cleanup_cx.cleanups) == 0u); } - auto i = _vec.len[cleanup](cleanup_cx.cleanups); + auto i = Vec.len[cleanup](cleanup_cx.cleanups); while (i > 0u) { i -= 1u; auto c = cleanup_cx.cleanups.(i); @@ -5983,7 +5983,7 @@ fn new_fn_ctxt(@local_ctxt cx, let hashmap[ast.def_id, ValueRef] llupvars = new_def_hash[ValueRef](); let BasicBlockRef llallocas = - llvm.LLVMAppendBasicBlock(llfndecl, _str.buf("allocas")); + llvm.LLVMAppendBasicBlock(llfndecl, Str.buf("allocas")); ret @rec(llfn=llfndecl, lltaskptr=lltaskptr, @@ -5996,7 +5996,7 @@ fn new_fn_ctxt(@local_ctxt cx, llobjfields=llobjfields, lllocals=lllocals, llupvars=llupvars, - mutable lltydescs=_vec.empty[ValueRef](), + mutable lltydescs=Vec.empty[ValueRef](), lcx=cx); } @@ -6009,7 +6009,7 @@ fn new_fn_ctxt(@local_ctxt cx, fn create_llargs_for_fn_args(&@fn_ctxt cx, ast.proto proto, - option.t[tup(TypeRef, ty.t)] ty_self, + Option.t[tup(TypeRef, ty.t)] ty_self, ty.t ret_ty, &vec[ast.arg] args, &vec[ast.ty_param] ty_params) { @@ -6052,7 +6052,7 @@ fn create_llargs_for_fn_args(&@fn_ctxt cx, // were passed and whatnot. Apparently mem2reg will mop up. fn copy_any_self_to_alloca(@fn_ctxt fcx, - option.t[tup(TypeRef, ty.t)] ty_self) { + Option.t[tup(TypeRef, ty.t)] ty_self) { auto bcx = llallocas_block_ctxt(fcx); @@ -6152,7 +6152,7 @@ fn populate_fn_ctxt_from_llself(@fn_ctxt fcx, self_vt llself) { // its magic. auto fields_tup_ty = ty.mk_imm_tup(fcx.lcx.ccx.tcx, field_tys); - auto n_typarams = _vec.len[ast.ty_param](bcx.fcx.lcx.obj_typarams); + auto n_typarams = Vec.len[ast.ty_param](bcx.fcx.lcx.obj_typarams); let TypeRef llobj_box_ty = T_obj_ptr(bcx.fcx.lcx.ccx.tn, n_typarams); auto box_cell = @@ -6209,7 +6209,7 @@ fn populate_fn_ctxt_from_llself(@fn_ctxt fcx, self_vt llself) { } fn trans_fn(@local_ctxt cx, &ast._fn f, ast.def_id fid, - option.t[tup(TypeRef, ty.t)] ty_self, + Option.t[tup(TypeRef, ty.t)] ty_self, &vec[ast.ty_param] ty_params, &ast.ann ann) { auto llfndecl = cx.ccx.item_ids.get(fid); @@ -6264,10 +6264,10 @@ fn trans_vtbl(@local_ctxt cx, let vec[ValueRef] methods = vec(dtor); fn meth_lteq(&@ast.method a, &@ast.method b) -> bool { - ret _str.lteq(a.node.ident, b.node.ident); + ret Str.lteq(a.node.ident, b.node.ident); } - auto meths = std.sort.merge_sort[@ast.method](bind meth_lteq(_,_), + auto meths = std.Sort.merge_sort[@ast.method](bind meth_lteq(_,_), ob.methods); for (@ast.method m in meths) { @@ -6278,7 +6278,7 @@ fn trans_vtbl(@local_ctxt cx, llfnty = type_of_fn_full(cx.ccx, proto, some[TypeRef](llself_ty), inputs, output, - _vec.len[ast.ty_param](ty_params)); + Vec.len[ast.ty_param](ty_params)); } } @@ -6297,7 +6297,7 @@ fn trans_vtbl(@local_ctxt cx, auto vtbl = C_struct(methods); auto vtbl_name = mangle_name_by_seq(cx.ccx, cx.path, "vtbl"); auto gvar = llvm.LLVMAddGlobal(cx.ccx.llmod, val_ty(vtbl), - _str.buf(vtbl_name)); + Str.buf(vtbl_name)); llvm.LLVMSetInitializer(gvar, vtbl); llvm.LLVMSetGlobalConstant(gvar, True); llvm.LLVMSetLinkage(gvar, lib.llvm.LLVMInternalLinkage @@ -6368,22 +6368,22 @@ fn trans_obj(@local_ctxt cx, &ast._obj ob, ast.def_id oid, // FIXME we should probably also allocate a box for empty objs that have a // dtor, since otherwise they are never dropped, and the dtor never runs - if (_vec.len[ast.ty_param](ty_params) == 0u && - _vec.len[ty.arg](arg_tys) == 0u) { + if (Vec.len[ast.ty_param](ty_params) == 0u && + Vec.len[ty.arg](arg_tys) == 0u) { // Store null into pair, if no args or typarams. bcx.build.Store(C_null(llbox_ty), pair_box); } else { // Malloc a box for the body and copy args in. let vec[ty.t] obj_fields = vec(); for (ty.arg a in arg_tys) { - _vec.push[ty.t](obj_fields, a.ty); + Vec.push[ty.t](obj_fields, a.ty); } // Synthesize an obj body type. auto tydesc_ty = ty.mk_type(ccx.tcx); let vec[ty.t] tps = vec(); for (ast.ty_param tp in ty_params) { - _vec.push[ty.t](tps, tydesc_ty); + Vec.push[ty.t](tps, tydesc_ty); } let ty.t typarams_ty = ty.mk_imm_tup(ccx.tcx, tps); @@ -6467,7 +6467,7 @@ fn trans_obj(@local_ctxt cx, &ast._obj ob, ast.def_id oid, fn trans_tag_variant(@local_ctxt cx, ast.def_id tag_id, &ast.variant variant, int index, &vec[ast.ty_param] ty_params) { - if (_vec.len[ast.variant_arg](variant.node.args) == 0u) { + if (Vec.len[ast.variant_arg](variant.node.args) == 0u) { ret; // nullary constructors are just constants } @@ -6477,7 +6477,7 @@ fn trans_tag_variant(@local_ctxt cx, ast.def_id tag_id, for (ast.variant_arg varg in variant.node.args) { fn_args += vec(rec(mode=ast.alias, ty=varg.ty, - ident="arg" + _uint.to_str(i, 10u), + ident="arg" + UInt.to_str(i, 10u), id=varg.id)); } @@ -6617,7 +6617,7 @@ fn get_pair_fn_ty(TypeRef llpairty) -> TypeRef { // Bit of a kludge: pick the fn typeref out of the pair. let vec[TypeRef] pair_tys = vec(T_nil(), T_nil()); llvm.LLVMGetStructElementTypes(llpairty, - _vec.buf[TypeRef](pair_tys)); + Vec.buf[TypeRef](pair_tys)); ret llvm.LLVMGetElementType(pair_tys.(0)); } @@ -6633,7 +6633,7 @@ fn decl_fn_and_pair(@crate_ctxt ccx, alt (ty.struct(ccx.tcx, node_ann_type(ccx, ann))) { case (ty.ty_fn(?proto, ?inputs, ?output)) { llfty = type_of_fn(ccx, proto, inputs, output, - _vec.len[ast.ty_param](ty_params)); + Vec.len[ast.ty_param](ty_params)); llpairty = T_fn_pair(ccx.tn, llfty); } case (_) { @@ -6655,7 +6655,7 @@ fn decl_fn_and_pair(@crate_ctxt ccx, fn register_fn_pair(@crate_ctxt cx, str ps, TypeRef llpairty, ValueRef llfn, ast.def_id id) { let ValueRef gvar = llvm.LLVMAddGlobal(cx.llmod, llpairty, - _str.buf(ps)); + Str.buf(ps)); auto pair = C_struct(vec(llfn, C_null(T_opaque_closure_ptr(cx.tn)))); @@ -6681,7 +6681,7 @@ fn native_fn_ty_param_count(@crate_ctxt cx, &ast.def_id id) -> uint { fail; } case (ast.native_item_fn(_, _, _, ?tps, _, _)) { - count = _vec.len[ast.ty_param](tps); + count = Vec.len[ast.ty_param](tps); } } ret count; @@ -6768,7 +6768,7 @@ fn decl_native_fn_and_pair(@crate_ctxt ccx, if (pass_task) { call_args += vec(lltaskptr); } auto arg_n = 3u; - for each (uint i in _uint.range(0u, num_ty_param)) { + for each (uint i in UInt.range(0u, num_ty_param)) { auto llarg = llvm.LLVMGetParam(fcx.llfn, arg_n); fcx.lltydescs += vec(llarg); assert (llarg as int != 0); @@ -6900,13 +6900,13 @@ fn new_walk_ctxt() -> @walk_ctxt { fn enter_item(@walk_ctxt cx, @ast.item item) { alt (item.node) { case (ast.item_fn(?name, _, _, _, _)) { - _vec.push[str](cx.path, name); + Vec.push[str](cx.path, name); } case (ast.item_obj(?name, _, _, _, _)) { - _vec.push[str](cx.path, name); + Vec.push[str](cx.path, name); } case (ast.item_mod(?name, _, _)) { - _vec.push[str](cx.path, name); + Vec.push[str](cx.path, name); } case (_) { } } @@ -6915,13 +6915,13 @@ fn enter_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); + Vec.pop[str](cx.path); } case (ast.item_obj(_, _, _, _, _)) { - _vec.pop[str](cx.path); + Vec.pop[str](cx.path); } case (ast.item_mod(_, _, _)) { - _vec.pop[str](cx.path); + Vec.pop[str](cx.path); } case (_) { } } @@ -6948,7 +6948,7 @@ fn collect_item_1(@crate_ctxt ccx, @walk_ctxt wcx, @ast.item i) { case (ast.item_const(?name, _, _, ?cid, ?ann)) { auto typ = node_ann_type(ccx, ann); auto g = llvm.LLVMAddGlobal(ccx.llmod, type_of(ccx, typ), - _str.buf(ccx.names.next(name))); + Str.buf(ccx.names.next(name))); llvm.LLVMSetLinkage(g, lib.llvm.LLVMInternalLinkage as llvm.Linkage); ccx.items.insert(cid, i); @@ -7009,7 +7009,7 @@ fn collect_tag_ctor(@crate_ctxt ccx, @walk_ctxt wcx, @ast.item i) { alt (i.node) { case (ast.item_tag(_, ?variants, ?tps, _, _)) { for (ast.variant variant in variants) { - if (_vec.len[ast.variant_arg](variant.node.args) != 0u) { + if (Vec.len[ast.variant_arg](variant.node.args) != 0u) { decl_fn_and_pair(ccx, wcx.path + vec(variant.node.name), "tag", tps, variant.node.ann, variant.node.id); @@ -7037,7 +7037,7 @@ fn trans_constant(@crate_ctxt ccx, @walk_ctxt wcx, @ast.item it) { alt (it.node) { case (ast.item_tag(?ident, ?variants, _, ?tag_id, _)) { auto i = 0u; - auto n_variants = _vec.len[ast.variant](variants); + auto n_variants = Vec.len[ast.variant](variants); while (i < n_variants) { auto variant = variants.(i); @@ -7047,7 +7047,7 @@ fn trans_constant(@crate_ctxt ccx, @walk_ctxt wcx, @ast.item it) { #fmt("_rust_tag_discrim_%s_%u", ident, i)); auto discrim_gvar = llvm.LLVMAddGlobal(ccx.llmod, T_int(), - _str.buf(s)); + Str.buf(s)); llvm.LLVMSetInitializer(discrim_gvar, discrim_val); llvm.LLVMSetGlobalConstant(discrim_gvar, True); @@ -7107,7 +7107,7 @@ fn trans_exit_task_glue(@glue_fns glues, auto llfn = glues.exit_task_glue; - auto entrybb = llvm.LLVMAppendBasicBlock(llfn, _str.buf("entry")); + auto entrybb = llvm.LLVMAppendBasicBlock(llfn, Str.buf("entry")); auto build = new_builder(entrybb); let ValueRef arg1 = llvm.LLVMGetParam(llfn, 0u); @@ -7129,9 +7129,9 @@ fn trans_exit_task_glue(@glue_fns glues, } fn create_typedefs(@crate_ctxt cx) { - llvm.LLVMAddTypeName(cx.llmod, _str.buf("crate"), T_crate(cx.tn)); - llvm.LLVMAddTypeName(cx.llmod, _str.buf("task"), T_task(cx.tn)); - llvm.LLVMAddTypeName(cx.llmod, _str.buf("tydesc"), T_tydesc(cx.tn)); + llvm.LLVMAddTypeName(cx.llmod, Str.buf("crate"), T_crate(cx.tn)); + llvm.LLVMAddTypeName(cx.llmod, Str.buf("task"), T_task(cx.tn)); + llvm.LLVMAddTypeName(cx.llmod, Str.buf("tydesc"), T_tydesc(cx.tn)); } fn create_crate_constant(ValueRef crate_ptr, @glue_fns glues) { @@ -7173,7 +7173,7 @@ fn find_main_fn(@crate_ctxt cx) -> ValueRef { let ValueRef v = C_nil(); let uint n = 0u; for each (@tup(ast.def_id, str) i in cx.item_symbols.items()) { - if (_str.ends_with(i._1, e)) { + if (Str.ends_with(i._1, e)) { n += 1u; v = cx.item_ids.get(i._0); } @@ -7197,7 +7197,7 @@ fn trans_main_fn(@local_ctxt cx, ValueRef llcrate, ValueRef crate_map) { auto T_rust_start_args = vec(T_int(), T_int(), T_int(), T_int(), T_int()); auto main_name; - if (_str.eq(std.os.target_os(), "win32")) { + if (Str.eq(std.OS.target_os(), "win32")) { main_name = "WinMain@16"; } else { main_name = "main"; @@ -7222,7 +7222,7 @@ fn trans_main_fn(@local_ctxt cx, ValueRef llcrate, ValueRef crate_map) { // let BasicBlockRef llbb = - llvm.LLVMAppendBasicBlock(llmain, _str.buf("")); + llvm.LLVMAppendBasicBlock(llmain, Str.buf("")); auto b = new_builder(llbb); auto start_args = vec(p2i(llrust_main), p2i(llcrate), llargc, llargv, @@ -7267,7 +7267,7 @@ fn decl_no_op_type_glue(ModuleRef llmod, type_names tn) -> ValueRef { } fn make_no_op_type_glue(ValueRef fun) { - auto bb_name = _str.buf("_rust_no_op_type_glue_bb"); + auto bb_name = Str.buf("_rust_no_op_type_glue_bb"); auto llbb = llvm.LLVMAppendBasicBlock(fun, bb_name); new_builder(llbb).RetVoid(); } @@ -7283,10 +7283,10 @@ fn make_memcpy_glue(ValueRef fun) { // We're not using the LLVM memcpy intrinsic. It appears to call through // to the platform memcpy in some cases, which is not terribly safe to run // on a rust stack. - auto initbb = llvm.LLVMAppendBasicBlock(fun, _str.buf("init")); - auto hdrbb = llvm.LLVMAppendBasicBlock(fun, _str.buf("hdr")); - auto loopbb = llvm.LLVMAppendBasicBlock(fun, _str.buf("loop")); - auto endbb = llvm.LLVMAppendBasicBlock(fun, _str.buf("end")); + auto initbb = llvm.LLVMAppendBasicBlock(fun, Str.buf("init")); + auto hdrbb = llvm.LLVMAppendBasicBlock(fun, Str.buf("hdr")); + auto loopbb = llvm.LLVMAppendBasicBlock(fun, Str.buf("loop")); + auto endbb = llvm.LLVMAppendBasicBlock(fun, Str.buf("end")); auto dst = llvm.LLVMGetParam(fun, 0u); auto src = llvm.LLVMGetParam(fun, 1u); @@ -7325,10 +7325,10 @@ fn decl_bzero_glue(ModuleRef llmod) -> ValueRef { fn make_bzero_glue(ValueRef fun) -> ValueRef { // We're not using the LLVM memset intrinsic. Same as with memcpy. - auto initbb = llvm.LLVMAppendBasicBlock(fun, _str.buf("init")); - auto hdrbb = llvm.LLVMAppendBasicBlock(fun, _str.buf("hdr")); - auto loopbb = llvm.LLVMAppendBasicBlock(fun, _str.buf("loop")); - auto endbb = llvm.LLVMAppendBasicBlock(fun, _str.buf("end")); + auto initbb = llvm.LLVMAppendBasicBlock(fun, Str.buf("init")); + auto hdrbb = llvm.LLVMAppendBasicBlock(fun, Str.buf("hdr")); + auto loopbb = llvm.LLVMAppendBasicBlock(fun, Str.buf("loop")); + auto endbb = llvm.LLVMAppendBasicBlock(fun, Str.buf("end")); auto dst = llvm.LLVMGetParam(fun, 0u); auto count = llvm.LLVMGetParam(fun, 1u); @@ -7440,7 +7440,7 @@ fn trans_vec_append_glue(@local_ctxt cx) { let ValueRef llskipnull = llvm.LLVMGetParam(llfn, 5u); let BasicBlockRef llallocas = - llvm.LLVMAppendBasicBlock(llfn, _str.buf("allocas")); + llvm.LLVMAppendBasicBlock(llfn, Str.buf("allocas")); auto fcx = @rec(llfn=llfn, lltaskptr=lltaskptr, @@ -7453,7 +7453,7 @@ fn trans_vec_append_glue(@local_ctxt cx) { llobjfields=new_def_hash[ValueRef](), lllocals=new_def_hash[ValueRef](), llupvars=new_def_hash[ValueRef](), - mutable lltydescs=_vec.empty[ValueRef](), + mutable lltydescs=Vec.empty[ValueRef](), lcx=cx); auto bcx = new_top_block_ctxt(fcx); @@ -7476,14 +7476,14 @@ fn trans_vec_append_glue(@local_ctxt cx) { bcx = llnew_vec_res.bcx; auto llnew_vec = vi2p(bcx, llnew_vec_res.val, T_opaque_vec_ptr()); - llvm.LLVMSetValueName(llnew_vec, _str.buf("llnew_vec")); + llvm.LLVMSetValueName(llnew_vec, Str.buf("llnew_vec")); auto copy_dst_cx = new_sub_block_ctxt(bcx, "copy new <- dst"); auto copy_src_cx = new_sub_block_ctxt(bcx, "copy new <- src"); auto pp0 = alloca(bcx, T_ptr(T_i8())); bcx.build.Store(vec_p1_adjusted(bcx, llnew_vec, llskipnull), pp0); - llvm.LLVMSetValueName(pp0, _str.buf("pp0")); + llvm.LLVMSetValueName(pp0, Str.buf("pp0")); bcx.build.CondBr(bcx.build.TruncOrBitCast (bcx.build.Load(llcopy_dst_ptr), @@ -7499,13 +7499,13 @@ fn trans_vec_append_glue(@local_ctxt cx) { ValueRef n_bytes) -> result { auto src_lim = cx.build.GEP(src, vec(n_bytes)); - llvm.LLVMSetValueName(src_lim, _str.buf("src_lim")); + llvm.LLVMSetValueName(src_lim, Str.buf("src_lim")); auto elt_llsz = cx.build.Load(cx.build.GEP(elt_tydesc, vec(C_int(0), C_int(abi.tydesc_field_size)))); - llvm.LLVMSetValueName(elt_llsz, _str.buf("elt_llsz")); + llvm.LLVMSetValueName(elt_llsz, Str.buf("elt_llsz")); fn take_one(ValueRef elt_tydesc, @block_ctxt cx, @@ -7526,7 +7526,7 @@ fn trans_vec_append_glue(@local_ctxt cx) { // Copy any dst elements in, omitting null if doing str. auto n_bytes = vec_fill_adjusted(copy_dst_cx, lldst_vec, llskipnull); - llvm.LLVMSetValueName(n_bytes, _str.buf("n_bytes")); + llvm.LLVMSetValueName(n_bytes, Str.buf("n_bytes")); copy_dst_cx = copy_elts(copy_dst_cx, llelt_tydesc, @@ -7576,13 +7576,13 @@ fn make_glues(ModuleRef llmod, type_names tn) -> @glue_fns { T_void())), native_glues_rust = - _vec.init_fn[ValueRef](bind decl_native_glue(llmod, tn, + Vec.init_fn[ValueRef](bind decl_native_glue(llmod, tn, abi.ngt_rust, _), abi.n_native_glues + 1 as uint), native_glues_pure_rust = - _vec.init_fn[ValueRef](bind decl_native_glue(llmod, tn, + Vec.init_fn[ValueRef](bind decl_native_glue(llmod, tn, abi.ngt_pure_rust, _), abi.n_native_glues + 1 as uint), native_glues_cdecl = - _vec.init_fn[ValueRef](bind decl_native_glue(llmod, tn, + Vec.init_fn[ValueRef](bind decl_native_glue(llmod, tn, abi.ngt_cdecl, _), abi.n_native_glues + 1 as uint), no_op_type_glue = decl_no_op_type_glue(llmod, tn), memcpy_glue = decl_memcpy_glue(llmod), @@ -7595,19 +7595,19 @@ fn make_common_glue(session.session sess, str output) { // to autogen it, but things like the memcpy implementation are not // and it might be better to just check in a .ll file. auto llmod = - llvm.LLVMModuleCreateWithNameInContext(_str.buf("rust_out"), + llvm.LLVMModuleCreateWithNameInContext(Str.buf("rust_out"), llvm.LLVMGetGlobalContext()); - llvm.LLVMSetDataLayout(llmod, _str.buf(x86.get_data_layout())); - llvm.LLVMSetTarget(llmod, _str.buf(x86.get_target_triple())); + llvm.LLVMSetDataLayout(llmod, Str.buf(x86.get_data_layout())); + llvm.LLVMSetTarget(llmod, Str.buf(x86.get_target_triple())); auto td = mk_target_data(x86.get_data_layout()); auto tn = mk_type_names(); let ValueRef crate_ptr = - llvm.LLVMAddGlobal(llmod, T_crate(tn), _str.buf("rust_crate")); + llvm.LLVMAddGlobal(llmod, T_crate(tn), Str.buf("rust_crate")); auto intrinsics = declare_intrinsics(llmod); - llvm.LLVMSetModuleInlineAsm(llmod, _str.buf(x86.get_module_asm())); + llvm.LLVMSetModuleInlineAsm(llmod, Str.buf(x86.get_module_asm())); auto glues = make_glues(llmod, tn); create_crate_constant(crate_ptr, glues); @@ -7624,22 +7624,22 @@ fn create_module_map(@crate_ctxt ccx) -> ValueRef { auto elttype = T_struct(vec(T_int(), T_int())); auto maptype = T_array(elttype, ccx.module_data.size() + 1u); auto map = llvm.LLVMAddGlobal(ccx.llmod, maptype, - _str.buf("_rust_mod_map")); + Str.buf("_rust_mod_map")); llvm.LLVMSetLinkage(map, lib.llvm.LLVMInternalLinkage as llvm.Linkage); let vec[ValueRef] elts = vec(); for each (@tup(str, ValueRef) item in ccx.module_data.items()) { auto elt = C_struct(vec(p2i(C_cstr(ccx, item._0)), p2i(item._1))); - _vec.push[ValueRef](elts, elt); + Vec.push[ValueRef](elts, elt); } auto term = C_struct(vec(C_int(0), C_int(0))); - _vec.push[ValueRef](elts, term); + Vec.push[ValueRef](elts, term); llvm.LLVMSetInitializer(map, C_array(elttype, elts)); ret map; } fn crate_name(@crate_ctxt ccx, str deflt) -> str { for (@ast.meta_item item in ccx.sess.get_metadata()) { - if (_str.eq(item.node.name, "name")) { + if (Str.eq(item.node.name, "name")) { ret item.node.value; } } @@ -7653,15 +7653,15 @@ fn create_crate_map(@crate_ctxt ccx) -> ValueRef { while (ccx.sess.has_external_crate(i)) { auto name = ccx.sess.get_external_crate(i).name; auto cr = llvm.LLVMAddGlobal(ccx.llmod, T_int(), - _str.buf("_rust_crate_map_" + name)); - _vec.push[ValueRef](subcrates, p2i(cr)); + Str.buf("_rust_crate_map_" + name)); + Vec.push[ValueRef](subcrates, p2i(cr)); i += 1; } - _vec.push[ValueRef](subcrates, C_int(0)); + Vec.push[ValueRef](subcrates, C_int(0)); auto sym_name = "_rust_crate_map_" + crate_name(ccx, "__none__"); - auto arrtype = T_array(T_int(), _vec.len[ValueRef](subcrates)); + auto arrtype = T_array(T_int(), Vec.len[ValueRef](subcrates)); auto maptype = T_struct(vec(T_int(), arrtype)); - auto map = llvm.LLVMAddGlobal(ccx.llmod, maptype, _str.buf(sym_name)); + auto map = llvm.LLVMAddGlobal(ccx.llmod, maptype, Str.buf(sym_name)); llvm.LLVMSetLinkage(map, lib.llvm.LLVMExternalLinkage as llvm.Linkage); llvm.LLVMSetInitializer(map, C_struct(vec(p2i(create_module_map(ccx)), C_array(T_int(), subcrates)))); @@ -7672,26 +7672,26 @@ fn trans_crate(session.session sess, @ast.crate crate, ty.ctxt tcx, ty.type_cache type_cache, str output) -> ModuleRef { auto llmod = - llvm.LLVMModuleCreateWithNameInContext(_str.buf("rust_out"), + llvm.LLVMModuleCreateWithNameInContext(Str.buf("rust_out"), llvm.LLVMGetGlobalContext()); - llvm.LLVMSetDataLayout(llmod, _str.buf(x86.get_data_layout())); - llvm.LLVMSetTarget(llmod, _str.buf(x86.get_target_triple())); + llvm.LLVMSetDataLayout(llmod, Str.buf(x86.get_data_layout())); + llvm.LLVMSetTarget(llmod, Str.buf(x86.get_target_triple())); auto td = mk_target_data(x86.get_data_layout()); auto tn = mk_type_names(); let ValueRef crate_ptr = - llvm.LLVMAddGlobal(llmod, T_crate(tn), _str.buf("rust_crate")); + llvm.LLVMAddGlobal(llmod, T_crate(tn), Str.buf("rust_crate")); auto intrinsics = declare_intrinsics(llmod); auto glues = make_glues(llmod, tn); auto hasher = ty.hash_ty; auto eqer = ty.eq_ty; - auto tag_sizes = map.mk_hashmap[ty.t,uint](hasher, eqer); - auto tydescs = map.mk_hashmap[ty.t,@tydesc_info](hasher, eqer); - auto lltypes = map.mk_hashmap[ty.t,TypeRef](hasher, eqer); - auto sha1s = map.mk_hashmap[ty.t,str](hasher, eqer); - auto abbrevs = map.mk_hashmap[ty.t,metadata.ty_abbrev](hasher, eqer); + auto tag_sizes = Map.mk_hashmap[ty.t,uint](hasher, eqer); + auto tydescs = Map.mk_hashmap[ty.t,@tydesc_info](hasher, eqer); + auto lltypes = Map.mk_hashmap[ty.t,TypeRef](hasher, eqer); + auto sha1s = Map.mk_hashmap[ty.t,str](hasher, eqer); + auto abbrevs = Map.mk_hashmap[ty.t,metadata.ty_abbrev](hasher, eqer); auto ccx = @rec(sess = sess, llmod = llmod, @@ -7716,7 +7716,7 @@ fn trans_crate(session.session sess, @ast.crate crate, ty.ctxt tcx, lltypes = lltypes, glues = glues, names = namegen(0), - sha = std.sha1.mk_sha1(), + sha = std.SHA1.mk_sha1(), type_sha1s = sha1s, type_abbrevs = abbrevs, tcx = tcx); diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs index 5baa6b7a..44fc5486 100644 --- a/src/comp/middle/ty.rs +++ b/src/comp/middle/ty.rs @@ -1,13 +1,13 @@ -import std._str; -import std._uint; -import std._vec; +import std.Str; +import std.UInt; +import std.Vec; import std.Box; import std.UFind; -import std.map; -import std.map.hashmap; -import std.option; -import std.option.none; -import std.option.some; +import std.Map; +import std.Map.hashmap; +import std.Option; +import std.Option.none; +import std.Option.some; import driver.session; import front.ast; @@ -65,7 +65,7 @@ fn method_ty_to_fn_ty(ctxt cx, method m) -> t { // TODO: It'd be really nice to be able to hide this definition from the // outside world, to enforce the above invariants. type raw_t = rec(sty struct, - option.t[str] cname, + Option.t[str] cname, uint magic, uint hash, bool has_params, @@ -108,7 +108,7 @@ tag sty { // Data structures used in type unification type unify_handler = obj { - fn resolve_local(ast.def_id id) -> option.t[t]; + fn resolve_local(ast.def_id id) -> Option.t[t]; fn record_local(ast.def_id id, t ty); // TODO: -> Unify.result fn record_param(uint index, t binding) -> Unify.result; }; @@ -168,8 +168,8 @@ fn mk_type_store() -> @type_store { auto hasher = hash_ty; auto eqer = eq_ty_full; - ret @rec(empty_vec_ty = _vec.empty[ty.t](), - empty_vec_mutable_ty = _vec.empty_mut[ty.t](), + ret @rec(empty_vec_ty = Vec.empty[ty.t](), + empty_vec_mutable_ty = Vec.empty_mut[ty.t](), t_nil = mk_ty_full(ty_nil, none[str]), t_bool = mk_ty_full(ty_bool, none[str]), t_int = mk_ty_full(ty_int, none[str]), @@ -196,11 +196,11 @@ fn mk_type_store() -> @type_store { t_native = mk_ty_full(ty_native, none[str]), t_type = mk_ty_full(ty_type, none[str]), - mutable t_params = _vec.empty[ty.t](), - mutable t_bound_params = _vec.empty[ty.t](), - mutable t_vars = _vec.empty[ty.t](), + mutable t_params = Vec.empty[ty.t](), + mutable t_bound_params = Vec.empty[ty.t](), + mutable t_vars = Vec.empty[ty.t](), - others=map.mk_hashmap[t,t](hasher, eqer)); + others=Map.mk_hashmap[t,t](hasher, eqer)); } fn mk_rcache() -> creader_cache { @@ -215,7 +215,7 @@ fn mk_rcache() -> creader_cache { } auto h = hash_cache_entry; auto e = eq_cache_entries; - ret map.mk_hashmap[tup(int,uint,uint),t](h, e); + ret Map.mk_hashmap[tup(int,uint,uint),t](h, e); } fn mk_ctxt(session.session s) -> ctxt { @@ -225,7 +225,7 @@ fn mk_ctxt(session.session s) -> ctxt { } // Type constructors -fn mk_ty_full(&sty st, option.t[str] cname) -> t { +fn mk_ty_full(&sty st, Option.t[str] cname) -> t { auto h = hash_type_info(st, cname); auto magic = mk_magic(st); @@ -350,7 +350,7 @@ fn mk_ty_full(&sty st, option.t[str] cname) -> t { has_locals = has_locals); } -fn gen_ty_full(ctxt cx, &sty st, option.t[str] cname) -> t { +fn gen_ty_full(ctxt cx, &sty st, Option.t[str] cname) -> t { auto new_type = mk_ty_full(st, cname); // Do not intern anything with locals or vars; it'll be nearly @@ -457,7 +457,7 @@ fn mk_local(ctxt cx, ast.def_id did) -> t { } fn mk_param(ctxt cx, uint n) -> t { - let uint i = _vec.len[t](cx.ts.t_params); + let uint i = Vec.len[t](cx.ts.t_params); while (i <= n) { cx.ts.t_params += vec(mk_ty_full(ty_param(i), none[str])); i += 1u; @@ -466,7 +466,7 @@ fn mk_param(ctxt cx, uint n) -> t { } fn mk_bound_param(ctxt cx, uint n) -> t { - let uint i = _vec.len[t](cx.ts.t_bound_params); + let uint i = Vec.len[t](cx.ts.t_bound_params); while (i <= n) { cx.ts.t_bound_params += vec(mk_ty_full(ty_bound_param(i), none[str])); i += 1u; @@ -482,17 +482,17 @@ fn mk_native(ctxt cx) -> t { ret cx.ts.t_native; } fn struct(ctxt cx, t typ) -> sty { ret typ.struct; } // Returns the canonical name of the given type. -fn cname(ctxt cx, t typ) -> option.t[str] { ret typ.cname; } +fn cname(ctxt cx, t typ) -> Option.t[str] { ret typ.cname; } // Stringification fn path_to_str(&ast.path pth) -> str { - auto result = _str.connect(pth.node.idents, "."); - if (_vec.len[@ast.ty](pth.node.types) > 0u) { + auto result = Str.connect(pth.node.idents, "."); + if (Vec.len[@ast.ty](pth.node.types) > 0u) { auto f = pretty.pprust.ty_to_str; result += "["; - result += _str.connect(_vec.map[@ast.ty,str](f, pth.node.types), ","); + result += Str.connect(Vec.map[@ast.ty,str](f, pth.node.types), ","); result += "]"; } ret result; @@ -513,7 +513,7 @@ fn ty_to_str(ctxt cx, &t typ) -> str { fn fn_to_str(ctxt cx, ast.proto proto, - option.t[ast.ident] ident, + Option.t[ast.ident] ident, vec[arg] inputs, t output) -> str { auto f = bind fn_input_to_str(cx, _); @@ -536,7 +536,7 @@ fn ty_to_str(ctxt cx, &t typ) -> str { } s += "("; - s += _str.connect(_vec.map[arg,str](f, inputs), ", "); + s += Str.connect(Vec.map[arg,str](f, inputs), ", "); s += ")"; if (struct(cx, output) != ty_nil) { @@ -592,24 +592,24 @@ fn ty_to_str(ctxt cx, &t typ) -> str { case (ty_tup(?elems)) { auto f = bind mt_to_str(cx, _); - auto strs = _vec.map[mt,str](f, elems); - s += "tup(" + _str.connect(strs, ",") + ")"; + auto strs = Vec.map[mt,str](f, elems); + s += "tup(" + Str.connect(strs, ",") + ")"; } case (ty_rec(?elems)) { auto f = bind field_to_str(cx, _); - auto strs = _vec.map[field,str](f, elems); - s += "rec(" + _str.connect(strs, ",") + ")"; + auto strs = Vec.map[field,str](f, elems); + s += "rec(" + Str.connect(strs, ",") + ")"; } case (ty_tag(?id, ?tps)) { // The user should never see this if the cname is set properly! s += "<tag#" + util.common.istr(id._0) + ":" + util.common.istr(id._1) + ">"; - if (_vec.len[t](tps) > 0u) { + if (Vec.len[t](tps) > 0u) { auto f = bind ty_to_str(cx, _); - auto strs = _vec.map[t,str](f, tps); - s += "[" + _str.connect(strs, ",") + "]"; + auto strs = Vec.map[t,str](f, tps); + s += "[" + Str.connect(strs, ",") + "]"; } } @@ -623,8 +623,8 @@ fn ty_to_str(ctxt cx, &t typ) -> str { case (ty_obj(?meths)) { auto f = bind method_to_str(cx, _); - auto m = _vec.map[method,str](f, meths); - s += "obj {\n\t" + _str.connect(m, "\n\t") + "\n}"; + auto m = Vec.map[method,str](f, meths); + s += "obj {\n\t" + Str.connect(m, "\n\t") + "\n}"; } case (ty_var(?v)) { @@ -637,11 +637,11 @@ fn ty_to_str(ctxt cx, &t typ) -> str { } case (ty_param(?id)) { - s += "'" + _str.unsafe_from_bytes(vec(('a' as u8) + (id as u8))); + s += "'" + Str.unsafe_from_bytes(vec(('a' as u8) + (id as u8))); } case (ty_bound_param(?id)) { - s += "''" + _str.unsafe_from_bytes(vec(('a' as u8) + (id as u8))); + s += "''" + Str.unsafe_from_bytes(vec(('a' as u8) + (id as u8))); } } @@ -652,7 +652,7 @@ fn ty_to_short_str(ctxt cx, t typ) -> str { auto f = def_to_str; auto ecx = @rec(ds=f, tcx=cx, abbrevs=metadata.ac_no_abbrevs); auto s = metadata.Encode.ty_str(ecx, typ); - if (_str.byte_len(s) >= 64u) { s = _str.substr(s, 0u, 64u); } + if (Str.byte_len(s) >= 64u) { s = Str.substr(s, 0u, 64u); } ret s; } @@ -956,14 +956,14 @@ fn type_has_dynamic_size(ctxt cx, t ty) -> bool { alt (struct(cx, ty)) { case (ty_tup(?mts)) { auto i = 0u; - while (i < _vec.len[mt](mts)) { + while (i < Vec.len[mt](mts)) { if (type_has_dynamic_size(cx, mts.(i).ty)) { ret true; } i += 1u; } } case (ty_rec(?fields)) { auto i = 0u; - while (i < _vec.len[field](fields)) { + while (i < Vec.len[field](fields)) { if (type_has_dynamic_size(cx, fields.(i).mt.ty)) { ret true; } @@ -972,7 +972,7 @@ fn type_has_dynamic_size(ctxt cx, t ty) -> bool { } case (ty_tag(_, ?subtys)) { auto i = 0u; - while (i < _vec.len[t](subtys)) { + while (i < Vec.len[t](subtys)) { if (type_has_dynamic_size(cx, subtys.(i))) { ret true; } i += 1u; } @@ -1041,7 +1041,7 @@ fn type_is_signed(ctxt cx, t ty) -> bool { fail; } -fn type_param(ctxt cx, t ty) -> option.t[uint] { +fn type_param(ctxt cx, t ty) -> Option.t[uint] { alt (struct(cx, ty)) { case (ty_param(?id)) { ret some[uint](id); } case (_) { /* fall through */ } @@ -1174,7 +1174,7 @@ fn hash_type_structure(&sty st) -> uint { case (ty_obj(?methods)) { auto h = 27u; for (method m in methods) { - h += h << 5u + _str.hash(m.ident); + h += h << 5u + Str.hash(m.ident); } ret h; } @@ -1187,11 +1187,11 @@ fn hash_type_structure(&sty st) -> uint { } } -fn hash_type_info(&sty st, option.t[str] cname_opt) -> uint { +fn hash_type_info(&sty st, Option.t[str] cname_opt) -> uint { auto h = hash_type_structure(st); alt (cname_opt) { case (none[str]) { /* no-op */ } - case (some[str](?s)) { h += h << 5u + _str.hash(s); } + case (some[str](?s)) { h += h << 5u + Str.hash(s); } } ret h; } @@ -1297,8 +1297,8 @@ fn equal_type_structures(&sty a, &sty b) -> bool { vec[arg] args_b, t rty_b) -> bool { if (!eq_ty(rty_a, rty_b)) { ret false; } - auto len = _vec.len[arg](args_a); - if (len != _vec.len[arg](args_b)) { ret false; } + auto len = Vec.len[arg](args_a); + if (len != Vec.len[arg](args_b)) { ret false; } auto i = 0u; while (i < len) { @@ -1370,8 +1370,8 @@ fn equal_type_structures(&sty a, &sty b) -> bool { case (ty_tag(?id_b, ?tys_b)) { if (!equal_def(id_a, id_b)) { ret false; } - auto len = _vec.len[t](tys_a); - if (len != _vec.len[t](tys_b)) { ret false; } + auto len = Vec.len[t](tys_a); + if (len != Vec.len[t](tys_b)) { ret false; } auto i = 0u; while (i < len) { if (!eq_ty(tys_a.(i), tys_b.(i))) { ret false; } @@ -1415,8 +1415,8 @@ fn equal_type_structures(&sty a, &sty b) -> bool { case (ty_tup(?mts_a)) { alt (b) { case (ty_tup(?mts_b)) { - auto len = _vec.len[mt](mts_a); - if (len != _vec.len[mt](mts_b)) { ret false; } + auto len = Vec.len[mt](mts_a); + if (len != Vec.len[mt](mts_b)) { ret false; } auto i = 0u; while (i < len) { if (!equal_mt(mts_a.(i), mts_b.(i))) { ret false; } @@ -1430,12 +1430,12 @@ fn equal_type_structures(&sty a, &sty b) -> bool { case (ty_rec(?flds_a)) { alt (b) { case (ty_rec(?flds_b)) { - auto len = _vec.len[field](flds_a); - if (len != _vec.len[field](flds_b)) { ret false; } + auto len = Vec.len[field](flds_a); + if (len != Vec.len[field](flds_b)) { ret false; } auto i = 0u; while (i < len) { auto fld_a = flds_a.(i); auto fld_b = flds_b.(i); - if (!_str.eq(fld_a.ident, fld_b.ident) || + if (!Str.eq(fld_a.ident, fld_b.ident) || !equal_mt(fld_a.mt, fld_b.mt)) { ret false; } @@ -1467,13 +1467,13 @@ fn equal_type_structures(&sty a, &sty b) -> bool { case (ty_obj(?methods_a)) { alt (b) { case (ty_obj(?methods_b)) { - auto len = _vec.len[method](methods_a); - if (len != _vec.len[method](methods_b)) { ret false; } + auto len = Vec.len[method](methods_a); + if (len != Vec.len[method](methods_b)) { ret false; } auto i = 0u; while (i < len) { auto m_a = methods_a.(i); auto m_b = methods_b.(i); if (!equal_proto(m_a.proto, m_b.proto) || - !_str.eq(m_a.ident, m_b.ident) || + !Str.eq(m_a.ident, m_b.ident) || !equal_fn(m_a.inputs, m_a.output, m_b.inputs, m_b.output)) { ret false; @@ -1546,7 +1546,7 @@ fn eq_ty_full(&t a, &t b) -> bool { case (some[str](?s_a)) { alt (b.cname) { case (some[str](?s_b)) { - if (!_str.eq(s_a, s_b)) { ret false; } + if (!Str.eq(s_a, s_b)) { ret false; } } case (_) { ret false; } } @@ -1651,7 +1651,7 @@ fn count_ty_params(ctxt cx, t ty) -> uint { let @mutable vec[uint] param_indices = @mutable v; auto f = bind counter(cx, param_indices, _); walk_ty(cx, f, ty); - ret _vec.len[uint](*param_indices); + ret Vec.len[uint](*param_indices); } fn type_contains_vars(ctxt cx, t typ) -> bool { @@ -1721,7 +1721,7 @@ fn native_item_ty(@ast.native_item it) -> ty_param_count_and_ty { auto result_ty; alt (it.node) { case (ast.native_item_fn(_, _, _, ?tps, _, ?ann)) { - ty_param_count = _vec.len[ast.ty_param](tps); + ty_param_count = Vec.len[ast.ty_param](tps); result_ty = ann_to_type(ann); } } @@ -1737,22 +1737,22 @@ fn item_ty(@ast.item it) -> ty_param_count_and_ty { result_ty = ann_to_type(ann); } case (ast.item_fn(_, _, ?tps, _, ?ann)) { - ty_param_count = _vec.len[ast.ty_param](tps); + ty_param_count = Vec.len[ast.ty_param](tps); result_ty = ann_to_type(ann); } case (ast.item_mod(_, _, _)) { fail; // modules are typeless } case (ast.item_ty(_, _, ?tps, _, ?ann)) { - ty_param_count = _vec.len[ast.ty_param](tps); + ty_param_count = Vec.len[ast.ty_param](tps); result_ty = ann_to_type(ann); } case (ast.item_tag(_, _, ?tps, ?did, ?ann)) { - ty_param_count = _vec.len[ast.ty_param](tps); + ty_param_count = Vec.len[ast.ty_param](tps); result_ty = ann_to_type(ann); } case (ast.item_obj(_, _, ?tps, _, ?ann)) { - ty_param_count = _vec.len[ast.ty_param](tps); + ty_param_count = Vec.len[ast.ty_param](tps); result_ty = ann_to_type(ann); } } @@ -1924,7 +1924,7 @@ fn expr_has_ty_params(@ast.expr expr) -> bool { alt (expr_ann(expr)) { case (ast.ann_none) { fail; } case (ast.ann_type(_, ?tps_opt, _)) { - ret !option.is_none[vec[t]](tps_opt); + ret !Option.is_none[vec[t]](tps_opt); } } } @@ -1987,7 +1987,7 @@ fn field_num(session.session sess, &span sp, &ast.ident id) -> uint { accum += (c as uint) - ('0' as uint); } else { auto s = ""; - s += _str.unsafe_from_byte(c); + s += Str.unsafe_from_byte(c); sess.span_err(sp, "bad numeric field on tuple: " + " non-digit character: " @@ -2003,7 +2003,7 @@ fn field_idx(session.session sess, &span sp, &ast.ident id, vec[field] fields) -> uint { let uint i = 0u; for (field f in fields) { - if (_str.eq(f.ident, id)) { + if (Str.eq(f.ident, id)) { ret i; } i += 1u; @@ -2016,7 +2016,7 @@ fn method_idx(session.session sess, &span sp, &ast.ident id, vec[method] meths) -> uint { let uint i = 0u; for (method m in meths) { - if (_str.eq(m.ident, id)) { + if (Str.eq(m.ident, id)) { ret i; } i += 1u; @@ -2027,10 +2027,10 @@ fn method_idx(session.session sess, &span sp, fn sort_methods(vec[method] meths) -> vec[method] { fn method_lteq(&method a, &method b) -> bool { - ret _str.lteq(a.ident, b.ident); + ret Str.lteq(a.ident, b.ident); } - ret std.sort.merge_sort[method](bind method_lteq(_,_), meths); + ret std.Sort.merge_sort[method](bind method_lteq(_,_), meths); } fn is_lval(@ast.expr expr) -> bool { @@ -2078,7 +2078,7 @@ mod Unify { // Unifies two mutability flags. fn unify_mut(ast.mutability expected, ast.mutability actual) - -> option.t[ast.mutability] { + -> Option.t[ast.mutability] { if (expected == actual) { ret some[ast.mutability](expected); } @@ -2102,8 +2102,8 @@ mod Unify { vec[arg] expected_inputs, t expected_output, vec[arg] actual_inputs, t actual_output) -> fn_common_res { - auto expected_len = _vec.len[arg](expected_inputs); - auto actual_len = _vec.len[arg](actual_inputs); + auto expected_len = Vec.len[arg](expected_inputs); + auto actual_len = Vec.len[arg](actual_inputs); if (expected_len != actual_len) { ret fn_common_res_err(ures_err(terr_arg_count, expected, actual)); @@ -2213,8 +2213,8 @@ mod Unify { vec[method] actual_meths) -> result { let vec[method] result_meths = vec(); let uint i = 0u; - let uint expected_len = _vec.len[method](expected_meths); - let uint actual_len = _vec.len[method](actual_meths); + let uint expected_len = Vec.len[method](expected_meths); + let uint actual_len = Vec.len[method](actual_meths); if (expected_len != actual_len) { ret ures_err(terr_meth_count, expected, actual); @@ -2223,7 +2223,7 @@ mod Unify { while (i < expected_len) { auto e_meth = expected_meths.(i); auto a_meth = actual_meths.(i); - if (! _str.eq(e_meth.ident, a_meth.ident)) { + if (! Str.eq(e_meth.ident, a_meth.ident)) { ret ures_err(terr_obj_meths(e_meth.ident, a_meth.ident), expected, actual); } @@ -2287,7 +2287,7 @@ mod Unify { case (_) { // Just bind the type variable to the expected type. - auto vlen = _vec.len[vec[t]](cx.types); + auto vlen = Vec.len[vec[t]](cx.types); if (actual_n < vlen) { cx.types.(actual_n) += vec(expected); } else { @@ -2354,7 +2354,7 @@ mod Unify { // ty.ty_tup case let vec[t] result_tps = vec(); auto i = 0u; - auto expected_len = _vec.len[t](expected_tps); + auto expected_len = Vec.len[t](expected_tps); while (i < expected_len) { auto expected_tp = expected_tps.(i); auto actual_tp = actual_tps.(i); @@ -2365,7 +2365,7 @@ mod Unify { alt (result) { case (ures_ok(?rty)) { - _vec.push[t](result_tps, rty); + Vec.push[t](result_tps, rty); } case (_) { ret result; @@ -2494,8 +2494,8 @@ mod Unify { case (ty.ty_tup(?expected_elems)) { alt (struct(cx.tcx, actual)) { case (ty.ty_tup(?actual_elems)) { - auto expected_len = _vec.len[ty.mt](expected_elems); - auto actual_len = _vec.len[ty.mt](actual_elems); + auto expected_len = Vec.len[ty.mt](expected_elems); + auto actual_len = Vec.len[ty.mt](actual_elems); if (expected_len != actual_len) { auto err = terr_tuple_size(expected_len, actual_len); @@ -2548,8 +2548,8 @@ mod Unify { case (ty.ty_rec(?expected_fields)) { alt (struct(cx.tcx, actual)) { case (ty.ty_rec(?actual_fields)) { - auto expected_len = _vec.len[field](expected_fields); - auto actual_len = _vec.len[field](actual_fields); + auto expected_len = Vec.len[field](expected_fields); + auto actual_len = Vec.len[field](actual_fields); if (expected_len != actual_len) { auto err = terr_record_size(expected_len, actual_len); @@ -2574,7 +2574,7 @@ mod Unify { case (some[ast.mutability](?m)) { mut = m; } } - if (!_str.eq(expected_field.ident, + if (!Str.eq(expected_field.ident, actual_field.ident)) { auto err = terr_record_fields(expected_field.ident, @@ -2588,7 +2588,7 @@ mod Unify { alt (result) { case (ures_ok(?rty)) { auto mt = rec(ty=rty, mut=mut); - _vec.push[field] + Vec.push[field] (result_fields, rec(mt=mt with expected_field)); } @@ -2655,7 +2655,7 @@ mod Unify { case (ty.ty_var(?expected_id)) { // Add a binding. auto expected_n = get_or_create_set(cx, expected_id); - auto vlen = _vec.len[vec[t]](cx.types); + auto vlen = Vec.len[vec[t]](cx.types); if (expected_n < vlen) { cx.types.(expected_n) += vec(actual); } else { @@ -2719,7 +2719,7 @@ mod Unify { fn unify_sets(@ctxt cx) -> vec[t] { let vec[t] throwaway = vec(); let vec[mutable vec[t]] set_types = vec(mutable throwaway); - _vec.pop[vec[t]](set_types); // FIXME: botch + Vec.pop[vec[t]](set_types); // FIXME: botch for (UFind.node node in cx.sets.nodes) { let vec[t] v = vec(); @@ -2727,7 +2727,7 @@ mod Unify { } auto i = 0u; - while (i < _vec.len[vec[t]](set_types)) { + while (i < Vec.len[vec[t]](set_types)) { auto root = UFind.find(cx.sets, i); set_types.(root) += cx.types.(i); i += 1u; @@ -2735,7 +2735,7 @@ mod Unify { let vec[t] result = vec(); for (vec[t] types in set_types) { - if (_vec.len[t](types) > 1u) { + if (Vec.len[t](types) > 1u) { log_err "unification of > 1 types in a type set is " + "unimplemented"; fail; @@ -2752,7 +2752,7 @@ mod Unify { ty_ctxt tcx) -> result { let vec[t] throwaway = vec(); let vec[mutable vec[t]] types = vec(mutable throwaway); - _vec.pop[vec[t]](types); // FIXME: botch + Vec.pop[vec[t]](types); // FIXME: botch auto cx = @rec(sets=UFind.make(), var_ids=common.new_int_hash[uint](), @@ -2765,7 +2765,7 @@ mod Unify { case (ures_ok(?typ)) { // Fast path: if there are no local variables, don't perform // substitutions. - if (_vec.len(cx.sets.nodes) == 0u) { + if (Vec.len(cx.sets.nodes) == 0u) { ret ures_ok(typ); } @@ -2791,16 +2791,16 @@ fn type_err_to_str(&ty.type_err err) -> str { ret "vectors differ in mutability"; } case (terr_tuple_size(?e_sz, ?a_sz)) { - ret "expected a tuple with " + _uint.to_str(e_sz, 10u) + - " elements but found one with " + _uint.to_str(a_sz, 10u) + + ret "expected a tuple with " + UInt.to_str(e_sz, 10u) + + " elements but found one with " + UInt.to_str(a_sz, 10u) + " elements"; } case (terr_tuple_mutability) { ret "tuple elements differ in mutability"; } case (terr_record_size(?e_sz, ?a_sz)) { - ret "expected a record with " + _uint.to_str(e_sz, 10u) + - " fields but found one with " + _uint.to_str(a_sz, 10u) + + ret "expected a record with " + UInt.to_str(e_sz, 10u) + + " fields but found one with " + UInt.to_str(a_sz, 10u) + " fields"; } case (terr_record_mutability) { diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs index 65e443df..091616fc 100644 --- a/src/comp/middle/typeck.rs +++ b/src/comp/middle/typeck.rs @@ -32,15 +32,15 @@ import middle.ty.ty_nil; import middle.ty.Unify.ures_ok; import middle.ty.Unify.ures_err; -import std._str; -import std._uint; -import std._vec; -import std.map; -import std.map.hashmap; -import std.option; -import std.option.none; -import std.option.some; -import std.option.from_maybe; +import std.Str; +import std.UInt; +import std.Vec; +import std.Map; +import std.Map.hashmap; +import std.Option; +import std.Option.none; +import std.Option.some; +import std.Option.from_maybe; import util.typestate_ann.ts_ann; @@ -61,7 +61,7 @@ type crate_ctxt = rec(session.session sess, ty.type_cache type_cache, @ty_item_table item_items, vec[ast.obj_field] obj_fields, - option.t[ast.def_id] this_obj, + Option.t[ast.def_id] this_obj, @fn_purity_table fn_purity_table, mutable int next_var_id, unify_cache unify_cache, @@ -91,12 +91,12 @@ fn substitute_ty_params(&@crate_ctxt ccx, } } - auto supplied_len = _vec.len[ty.t](supplied); + auto supplied_len = Vec.len[ty.t](supplied); if (ty_param_count != supplied_len) { ccx.sess.span_err(sp, "expected " + - _uint.to_str(ty_param_count, 10u) + + UInt.to_str(ty_param_count, 10u) + " type parameter(s) but found " + - _uint.to_str(supplied_len, 10u) + " parameter(s)"); + UInt.to_str(supplied_len, 10u) + " parameter(s)"); fail; } @@ -181,7 +181,7 @@ fn instantiate_path(@fn_ctxt fcx, &ast.path pth, &ty_param_count_and_ty tpt, auto t = bind_params_in_type(fcx.ccx.tcx, tpt._1); auto ty_substs_opt; - auto ty_substs_len = _vec.len[@ast.ty](pth.node.types); + auto ty_substs_len = Vec.len[@ast.ty](pth.node.types); if (ty_substs_len > 0u) { let vec[ty.t] ty_substs = vec(); auto i = 0u; @@ -281,7 +281,7 @@ fn ast_ty_to_ty(ty.ctxt tcx, ty_getter getter, &@ast.ty ast_ty) -> ty.t { case (ast.ty_tup(?fields)) { let vec[ty.mt] flds = vec(); for (ast.mt field in fields) { - _vec.push[ty.mt](flds, ast_mt_to_mt(tcx, getter, field)); + Vec.push[ty.mt](flds, ast_mt_to_mt(tcx, getter, field)); } typ = ty.mk_tup(tcx, flds); } @@ -289,21 +289,21 @@ fn ast_ty_to_ty(ty.ctxt tcx, ty_getter getter, &@ast.ty ast_ty) -> ty.t { let vec[field] flds = vec(); for (ast.ty_field f in fields) { auto tm = ast_mt_to_mt(tcx, getter, f.mt); - _vec.push[field](flds, rec(ident=f.ident, mt=tm)); + Vec.push[field](flds, rec(ident=f.ident, mt=tm)); } typ = ty.mk_rec(tcx, flds); } case (ast.ty_fn(?proto, ?inputs, ?output)) { auto f = bind ast_arg_to_arg(tcx, getter, _); - auto i = _vec.map[ast.ty_arg, arg](f, inputs); + auto i = Vec.map[ast.ty_arg, arg](f, inputs); auto out_ty = ast_ty_to_ty(tcx, getter, output); typ = ty.mk_fn(tcx, proto, i, out_ty); } case (ast.ty_path(?path, ?def)) { assert (def != none[ast.def]); - alt (option.get[ast.def](def)) { + alt (Option.get[ast.def](def)) { case (ast.def_ty(?id)) { typ = instantiate(tcx, getter, id, path.node.types); } @@ -325,9 +325,9 @@ fn ast_ty_to_ty(ty.ctxt tcx, ty_getter getter, &@ast.ty ast_ty) -> ty.t { let vec[ty.method] tmeths = vec(); auto f = bind ast_arg_to_arg(tcx, getter, _); for (ast.ty_method m in meths) { - auto ins = _vec.map[ast.ty_arg, arg](f, m.inputs); + auto ins = Vec.map[ast.ty_arg, arg](f, m.inputs); auto out = ast_ty_to_ty(tcx, getter, m.output); - _vec.push[ty.method](tmeths, + Vec.push[ty.method](tmeths, rec(proto=m.proto, ident=m.ident, inputs=ins, @@ -383,10 +383,10 @@ mod Collect { ast.proto proto, 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 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); - auto ty_param_count = _vec.len[ast.ty_param](ty_params); + auto ty_param_count = Vec.len[ast.ty_param](ty_params); auto tpt = tup(ty_param_count, t_fn); cx.type_cache.insert(def_id, tpt); ret tpt; @@ -399,10 +399,10 @@ mod Collect { ast.native_abi abi, 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 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); - auto ty_param_count = _vec.len[ast.ty_param](ty_params); + auto ty_param_count = Vec.len[ast.ty_param](ty_params); auto tpt = tup(ty_param_count, t_fn); cx.type_cache.insert(def_id, tpt); ret tpt; @@ -438,7 +438,7 @@ mod Collect { auto get = bind getter(cx, _); auto convert = bind ast_ty_to_ty(cx.tcx, get, _); auto f = bind ty_of_arg(cx, _); - auto inputs = _vec.map[ast.arg,arg](f, m.node.meth.decl.inputs); + auto inputs = Vec.map[ast.arg,arg](f, m.node.meth.decl.inputs); auto output = convert(m.node.meth.decl.output); ret rec(proto=m.node.meth.proto, ident=m.node.ident, inputs=inputs, output=output); @@ -449,11 +449,11 @@ mod Collect { &ast._obj obj_info, 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); + auto methods = Vec.map[@ast.method,method](f, obj_info.methods); auto t_obj = ty.mk_obj(cx.tcx, ty.sort_methods(methods)); t_obj = ty.rename(cx.tcx, t_obj, id); - auto ty_param_count = _vec.len[ast.ty_param](ty_params); + auto ty_param_count = Vec.len[ast.ty_param](ty_params); ret tup(ty_param_count, t_obj); } @@ -468,7 +468,7 @@ mod Collect { for (ast.obj_field f in obj_info.fields) { auto g = bind getter(cx, _); auto t_field = ast_ty_to_ty(cx.tcx, g, f.ty); - _vec.push[arg](t_inputs, rec(mode=ast.alias, ty=t_field)); + Vec.push[arg](t_inputs, rec(mode=ast.alias, ty=t_field)); } cx.type_cache.insert(obj_ty_id, t_obj); @@ -515,7 +515,7 @@ mod Collect { // Tell ast_ty_to_ty() that we want to perform a recursive // call to resolve any named types. auto typ = convert(t); - auto ty_param_count = _vec.len[ast.ty_param](tps); + auto ty_param_count = Vec.len[ast.ty_param](tps); auto tpt = tup(ty_param_count, typ); cx.type_cache.insert(def_id, tpt); ret tpt; @@ -533,7 +533,7 @@ mod Collect { auto t = ty.mk_tag(cx.tcx, def_id, subtys); - auto ty_param_count = _vec.len[ast.ty_param](tps); + auto ty_param_count = Vec.len[ast.ty_param](tps); auto tpt = tup(ty_param_count, t); cx.type_cache.insert(def_id, tpt); ret tpt; @@ -585,13 +585,13 @@ mod Collect { i += 1u; } - auto ty_param_count = _vec.len[ast.ty_param](ty_params); + auto ty_param_count = Vec.len[ast.ty_param](ty_params); for (ast.variant variant in variants) { // Nullary tag constructors get turned into constants; n-ary tag // constructors get turned into functions. auto result_ty; - if (_vec.len[ast.variant_arg](variant.node.args) == 0u) { + if (Vec.len[ast.variant_arg](variant.node.args) == 0u) { result_ty = ty.mk_tag(cx.tcx, tag_id, ty_param_tys); } else { // As above, tell ast_ty_to_ty() that trans_ty_item_to_ty() @@ -691,7 +691,7 @@ mod Collect { ret @fold.respan[ast.item_](sp, item); } - fn fold_native_item_fn(&@env e, &span sp, ast.ident i, option.t[str] ln, + 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)); @@ -746,7 +746,7 @@ mod Collect { with meth.node ); m = @rec(node=m_ with *meth); - _vec.push[@ast.method](methods, m); + Vec.push[@ast.method](methods, m); } auto g = bind getter(e.cx, _); for (ast.obj_field fld in ob.fields) { @@ -754,7 +754,7 @@ mod Collect { let ast.obj_field f = rec(ann=triv_ann(fty) with fld ); - _vec.push[ast.obj_field](fields, f); + Vec.push[ast.obj_field](fields, f); } auto dtor = none[@ast.method]; @@ -847,7 +847,7 @@ mod Unify { // FIXME: horrid botch let vec[mutable ty.t] param_substs = vec(mutable ty.mk_nil(fcx.ccx.tcx)); - _vec.pop(param_substs); + Vec.pop(param_substs); ret with_params(fcx, expected, actual, param_substs); } @@ -865,7 +865,7 @@ mod Unify { } obj unify_handler(@fn_ctxt fcx, vec[mutable ty.t] param_substs) { - fn resolve_local(ast.def_id id) -> option.t[ty.t] { + fn resolve_local(ast.def_id id) -> Option.t[ty.t] { alt (fcx.locals.find(id)) { case (none[ty.t]) { ret none[ty.t]; } case (some[ty.t](?existing_type)) { @@ -905,7 +905,7 @@ mod Unify { } fn record_param(uint index, ty.t binding) -> ty.Unify.result { // Unify with the appropriate type in the parameter - // substitution list. + // substitution List. auto old_subst = param_substs.(index); auto result = with_params(fcx, old_subst, binding, @@ -1004,7 +1004,7 @@ mod Demand { let vec[mutable ty.t] ty_param_substs = vec(mutable ty.mk_nil(fcx.ccx.tcx)); - _vec.pop(ty_param_substs); // FIXME: horrid botch + Vec.pop(ty_param_substs); // FIXME: horrid botch for (ty.t ty_param_subst in ty_param_substs_0) { ty_param_substs += vec(mutable ty_param_subst); } @@ -1047,7 +1047,7 @@ 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] { - auto ty_param_count = _vec.len[ty.t](tag_ty_params); + auto ty_param_count = Vec.len[ty.t](tag_ty_params); let vec[ty.t] result = vec(); @@ -1130,7 +1130,7 @@ mod Pushdown { } // Get the types of the arguments of the variant. - auto vdef = option.get[ast.variant_def](vdef_opt); + auto vdef = Option.get[ast.variant_def](vdef_opt); auto arg_tys = variant_arg_types(fcx.ccx, pat.span, vdef._1, tag_tps); @@ -1218,7 +1218,7 @@ mod Pushdown { case (none[@ast.expr]) { auto i = 0u; for (ast.field field_0 in fields_0) { - assert (_str.eq(field_0.ident, + assert (Str.eq(field_0.ident, field_mts.(i).ident)); auto e_1 = pushdown_expr(fcx, @@ -1240,7 +1240,7 @@ mod Pushdown { for (ast.field field_0 in fields_0) { for (ty.field ft in field_mts) { - if (_str.eq(field_0.ident, + if (Str.eq(field_0.ident, ft.ident)) { auto e_1 = pushdown_expr(fcx, ft.mt.ty, @@ -1508,9 +1508,9 @@ 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); + auto fcx = Option.get[@fn_ctxt](env); auto local_ty; alt (fcx.locals.find(local.id)) { @@ -1530,7 +1530,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)) { @@ -1539,7 +1539,7 @@ fn resolve_local_types_in_annotation(&option.t[@fn_ctxt] env, ast.ann ann) } } - auto fcx = option.get[@fn_ctxt](env); + auto fcx = Option.get[@fn_ctxt](env); alt (ann) { case (ast.ann_none) { log "warning: no type for expression"; @@ -1559,16 +1559,16 @@ 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) - -> option.t[@fn_ctxt] { + fn update_env_for_item(&Option.t[@fn_ctxt] env, @ast.item i) + -> Option.t[@fn_ctxt] { ret none[@fn_ctxt]; } - fn keep_going(&option.t[@fn_ctxt] env) -> bool { - ret !option.is_none[@fn_ctxt](env); + fn keep_going(&Option.t[@fn_ctxt] env) -> bool { + ret !Option.is_none[@fn_ctxt](env); } // FIXME: rustboot bug prevents us from using these functions directly - auto fld = fold.new_identity_fold[option.t[@fn_ctxt]](); + auto fld = fold.new_identity_fold[Option.t[@fn_ctxt]](); auto wbl = writeback_local; auto rltia = bind resolve_local_types_in_annotation(_,_); auto uefi = update_env_for_item; @@ -1580,7 +1580,7 @@ fn resolve_local_types_in_block(&@fn_ctxt fcx, &ast.block block) keep_going = kg with *fld ); - ret fold.fold_block[option.t[@fn_ctxt]](some[@fn_ctxt](fcx), fld, block); + ret fold.fold_block[Option.t[@fn_ctxt]](some[@fn_ctxt](fcx), fld, block); } // AST fragment checking @@ -1616,10 +1616,10 @@ fn check_pat(&@fn_ctxt fcx, @ast.pat pat) -> @ast.pat { new_pat = ast.pat_bind(id, def_id, ann); } case (ast.pat_tag(?p, ?subpats, ?vdef_opt, _)) { - auto vdef = option.get[ast.variant_def](vdef_opt); + auto vdef = Option.get[ast.variant_def](vdef_opt); auto t = ty.lookup_item_type(fcx.ccx.sess, fcx.ccx.tcx, fcx.ccx.type_cache, vdef._1)._1; - auto len = _vec.len[ast.ident](p.node.idents); + auto len = Vec.len[ast.ident](p.node.idents); auto last_id = p.node.idents.(len - 1u); auto tpt = ty.lookup_item_type(fcx.ccx.sess, fcx.ccx.tcx, @@ -1629,14 +1629,14 @@ fn check_pat(&@fn_ctxt fcx, @ast.pat pat) -> @ast.pat { alt (struct(fcx.ccx.tcx, t)) { // N-ary variants have function types. case (ty.ty_fn(_, ?args, ?tag_ty)) { - auto arg_len = _vec.len[arg](args); - auto subpats_len = _vec.len[@ast.pat](subpats); + auto arg_len = Vec.len[arg](args); + auto subpats_len = Vec.len[@ast.pat](subpats); if (arg_len != subpats_len) { // TODO: pluralize properly auto err_msg = "tag type " + last_id + " has " + - _uint.to_str(subpats_len, 10u) + + UInt.to_str(subpats_len, 10u) + " field(s), but this pattern has " + - _uint.to_str(arg_len, 10u) + + UInt.to_str(arg_len, 10u) + " field(s)"; fcx.ccx.sess.span_err(pat.span, err_msg); @@ -1653,13 +1653,13 @@ fn check_pat(&@fn_ctxt fcx, @ast.pat pat) -> @ast.pat { // Nullary variants have tag types. case (ty.ty_tag(?tid, _)) { - auto subpats_len = _vec.len[@ast.pat](subpats); + auto subpats_len = Vec.len[@ast.pat](subpats); if (subpats_len > 0u) { // TODO: pluralize properly auto err_msg = "tag type " + last_id + " has no field(s)," + " but this pattern has " + - _uint.to_str(subpats_len, 10u) + + UInt.to_str(subpats_len, 10u) + " field(s)"; fcx.ccx.sess.span_err(pat.span, err_msg); @@ -1689,7 +1689,7 @@ fn require_impure(&session.session sess, } fn get_function_purity(@crate_ctxt ccx, &ast.def_id d_id) -> ast.purity { - let option.t[ast.purity] o = ccx.fn_purity_table.find(d_id); + let Option.t[ast.purity] o = ccx.fn_purity_table.find(d_id); ret from_maybe[ast.purity](ast.impure_fn, o); } @@ -1738,16 +1738,16 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr { // A generic function to factor out common logic from call and bind // expressions. fn check_call_or_bind(&@fn_ctxt fcx, &@ast.expr f, - &vec[option.t[@ast.expr]] args) - -> tup(@ast.expr, vec[option.t[@ast.expr]]) { + &vec[Option.t[@ast.expr]] args) + -> tup(@ast.expr, vec[Option.t[@ast.expr]]) { // Check the function. auto f_0 = check_expr(fcx, f); // Check the arguments and generate the argument signature. - let vec[option.t[@ast.expr]] args_0 = vec(); + let vec[Option.t[@ast.expr]] args_0 = vec(); let vec[arg] arg_tys_0 = vec(); - for (option.t[@ast.expr] a_opt in args) { + for (Option.t[@ast.expr] a_opt in args) { alt (a_opt) { case (some[@ast.expr](?a)) { auto a_0 = check_expr(fcx, a); @@ -1756,14 +1756,14 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr { // FIXME: this breaks aliases. We need a ty_fn_arg. auto arg_ty = rec(mode=ast.val, ty=expr_ty(fcx.ccx.tcx, a_0)); - _vec.push[arg](arg_tys_0, arg_ty); + Vec.push[arg](arg_tys_0, arg_ty); } case (none[@ast.expr]) { args_0 += vec(none[@ast.expr]); // FIXME: breaks aliases too? auto typ = next_ty_var(fcx.ccx); - _vec.push[arg](arg_tys_0, rec(mode=ast.val, ty=typ)); + Vec.push[arg](arg_tys_0, rec(mode=ast.val, ty=typ)); } } } @@ -1812,7 +1812,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr { 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(); + let vec[Option.t[@ast.expr]] args_opt_0 = vec(); for (@ast.expr arg in args) { args_opt_0 += vec(some[@ast.expr](arg)); } @@ -1822,8 +1822,8 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr { // Pull out the arguments. let vec[@ast.expr] args_1 = vec(); - for (option.t[@ast.expr] arg in result._1) { - args_1 += vec(option.get[@ast.expr](arg)); + for (Option.t[@ast.expr] arg in result._1) { + args_1 += vec(Option.get[@ast.expr](arg)); } ret tup(result._0, args_1); @@ -1901,7 +1901,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr { case (ast.expr_path(?pth, ?defopt, _)) { auto t = ty.mk_nil(fcx.ccx.tcx); assert (defopt != none[ast.def]); - auto defn = option.get[ast.def](defopt); + auto defn = Option.get[ast.def](defopt); auto tpt = ty_param_count_and_ty_for_def(fcx, expr.span, defn); @@ -1913,7 +1913,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr { // The definition doesn't take type parameters. If the programmer // supplied some, that's an error. - if (_vec.len[@ast.ty](pth.node.types) > 0u) { + if (Vec.len[@ast.ty](pth.node.types) > 0u) { fcx.ccx.sess.span_err(expr.span, "this kind of value does " + "not take type parameters"); fail; @@ -2295,7 +2295,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr { // For each blank argument, add the type of that argument // to the resulting function type. auto i = 0u; - while (i < _vec.len[option.t[@ast.expr]](args)) { + while (i < Vec.len[Option.t[@ast.expr]](args)) { alt (args.(i)) { case (some[@ast.expr](_)) { /* no-op */ } case (none[@ast.expr]) { @@ -2434,7 +2434,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr { let vec[@ast.expr] args_1 = vec(); let ty.t t; - if (_vec.len[@ast.expr](args) == 0u) { + if (Vec.len[@ast.expr](args) == 0u) { t = next_ty_var(fcx.ccx); } else { auto expr_1 = check_expr(fcx, args.(0)); @@ -2445,7 +2445,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr { auto expr_1 = check_expr(fcx, e); auto expr_t = expr_ty(fcx.ccx.tcx, expr_1); Demand.simple(fcx, expr.span, t, expr_t); - _vec.push[@ast.expr](args_1,expr_1); + Vec.push[@ast.expr](args_1,expr_1); } auto ann = triv_ann(ty.mk_vec(fcx.ccx.tcx, @@ -2461,7 +2461,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr { for (ast.elt e in elts) { auto expr_1 = check_expr(fcx, e.expr); auto expr_t = expr_ty(fcx.ccx.tcx, expr_1); - _vec.push[ast.elt](elts_1, rec(expr=expr_1 with e)); + Vec.push[ast.elt](elts_1, rec(expr=expr_1 with e)); elts_mt += vec(rec(ty=expr_t, mut=e.mut)); } @@ -2486,10 +2486,10 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr { for (ast.field f in fields) { auto expr_1 = check_expr(fcx, f.expr); auto expr_t = expr_ty(fcx.ccx.tcx, expr_1); - _vec.push[ast.field](fields_1, rec(expr=expr_1 with f)); + Vec.push[ast.field](fields_1, rec(expr=expr_1 with f)); auto expr_mt = rec(ty=expr_t, mut=f.mut); - _vec.push[field](fields_t, rec(ident=f.ident, mt=expr_mt)); + Vec.push[field](fields_t, rec(ident=f.ident, mt=expr_mt)); } auto ann = ast.ann_none; @@ -2521,7 +2521,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr { for (ty.field f in fields_t) { auto found = false; for (ty.field bf in base_fields) { - if (_str.eq(f.ident, bf.ident)) { + if (Str.eq(f.ident, bf.ident)) { Demand.simple(fcx, expr.span, f.mt.ty, bf.mt.ty); found = true; @@ -2549,7 +2549,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr { case (ty.ty_tup(?args)) { let uint ix = ty.field_num(fcx.ccx.sess, expr.span, field); - if (ix >= _vec.len[ty.mt](args)) { + if (ix >= Vec.len[ty.mt](args)) { fcx.ccx.sess.span_err(expr.span, "bad index on tuple"); } @@ -2563,7 +2563,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr { case (ty.ty_rec(?fields)) { let uint ix = ty.field_idx(fcx.ccx.sess, expr.span, field, fields); - if (ix >= _vec.len[typeck.field](fields)) { + if (ix >= Vec.len[typeck.field](fields)) { fcx.ccx.sess.span_err(expr.span, "bad index on record"); } @@ -2577,7 +2577,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr { case (ty.ty_obj(?methods)) { let uint ix = ty.method_idx(fcx.ccx.sess, expr.span, field, methods); - if (ix >= _vec.len[typeck.method](methods)) { + if (ix >= Vec.len[typeck.method](methods)) { fcx.ccx.sess.span_err(expr.span, "bad index on obj"); } @@ -2775,7 +2775,7 @@ fn check_stmt(&@fn_ctxt fcx, &@ast.stmt stmt) -> @ast.stmt { fn check_block(&@fn_ctxt fcx, &ast.block block) -> ast.block { let vec[@ast.stmt] stmts = vec(); for (@ast.stmt s in block.node.stmts) { - _vec.push[@ast.stmt](stmts, check_stmt(fcx, s)); + Vec.push[@ast.stmt](stmts, check_stmt(fcx, s)); } auto expr = none[@ast.expr]; @@ -2900,7 +2900,7 @@ fn hash_unify_cache_entry(&unify_cache_entry uce) -> uint { h += h << 5u + ty.hash_ty(uce._1); auto i = 0u; - auto tys_len = _vec.len(uce._2); + auto tys_len = Vec.len(uce._2); while (i < tys_len) { h += h << 5u + ty.hash_ty(uce._2.(i)); i += 1u; @@ -2913,8 +2913,8 @@ fn eq_unify_cache_entry(&unify_cache_entry a, &unify_cache_entry b) -> bool { if (!ty.eq_ty(a._0, b._0) || !ty.eq_ty(a._1, b._1)) { ret false; } auto i = 0u; - auto tys_len = _vec.len(a._2); - if (_vec.len(b._2) != tys_len) { ret false; } + auto tys_len = Vec.len(a._2); + if (Vec.len(b._2) != tys_len) { ret false; } while (i < tys_len) { if (!ty.eq_ty(a._2.(i), b._2.(i))) { ret false; } @@ -2957,7 +2957,7 @@ fn check_crate(ty.ctxt tcx, @ast.crate crate) auto hasher = hash_unify_cache_entry; auto eqer = eq_unify_cache_entry; auto unify_cache = - map.mk_hashmap[unify_cache_entry,ty.Unify.result](hasher, eqer); + Map.mk_hashmap[unify_cache_entry,ty.Unify.result](hasher, eqer); auto fpt = mk_fn_purity_table(crate); // use a variation on Collect diff --git a/src/comp/middle/typestate_check.rs b/src/comp/middle/typestate_check.rs index e15c720a..e571fa21 100644 --- a/src/comp/middle/typestate_check.rs +++ b/src/comp/middle/typestate_check.rs @@ -155,37 +155,37 @@ import pretty.pprust.print_block; import pretty.pprust.print_expr; import pretty.pprust.print_decl; import pretty.pp.mkstate; -import std.io.stdout; -import std.io.str_writer; -import std.io.string_writer; -import std._vec.map; -import std._vec; -import std._vec.len; -import std._vec.pop; -import std._vec.push; -import std._vec.slice; -import std._vec.unzip; -import std._vec.plus_option; -import std._vec.cat_options; -import std.option; -import std.option.t; -import std.option.some; -import std.option.none; -import std.option.from_maybe; -import std.option.maybe; -import std.option.is_none; -import std.option.get; -import std.map.hashmap; -import std.list; -import std.list.list; -import std.list.cons; -import std.list.nil; -import std.list.foldl; -import std.list.find; -import std._uint; -import std.bitv; -import std.util.fst; -import std.util.snd; +import std.IO.stdout; +import std.IO.str_writer; +import std.IO.string_writer; +import std.Vec.map; +import std.Vec; +import std.Vec.len; +import std.Vec.pop; +import std.Vec.push; +import std.Vec.slice; +import std.Vec.unzip; +import std.Vec.plus_option; +import std.Vec.cat_options; +import std.Option; +import std.Option.t; +import std.Option.some; +import std.Option.none; +import std.Option.from_maybe; +import std.Option.maybe; +import std.Option.is_none; +import std.Option.get; +import std.Map.hashmap; +import std.List; +import std.List.list; +import std.List.cons; +import std.List.nil; +import std.List.foldl; +import std.List.find; +import std.UInt; +import std.BitV; +import std.Util.fst; +import std.Util.snd; import util.typestate_ann; import util.typestate_ann.difference; @@ -195,22 +195,22 @@ import util.typestate_ann.require_and_preserve; /**** debugging junk ****/ -fn bitv_to_str(fn_info enclosing, bitv.t v) -> str { +fn bitv_to_str(fn_info enclosing, BitV.t v) -> str { auto s = ""; for each (@tup(def_id, tup(uint, ident)) p in enclosing.items()) { - if (bitv.get(v, p._1._0)) { + if (BitV.get(v, p._1._0)) { s += " " + p._1._1 + " "; } } ret s; } -fn log_bitv(fn_info enclosing, bitv.t v) { +fn log_bitv(fn_info enclosing, BitV.t v) { log(bitv_to_str(enclosing, v)); } -fn log_bitv_err(fn_info enclosing, bitv.t v) { +fn log_bitv_err(fn_info enclosing, BitV.t v) { log_err(bitv_to_str(enclosing, v)); } @@ -235,8 +235,8 @@ fn log_cond_err(vec[uint] v) -> () { } fn log_pp(&pre_and_post pp) -> () { - auto p1 = bitv.to_vec(pp.precondition); - auto p2 = bitv.to_vec(pp.postcondition); + auto p1 = BitV.to_vec(pp.precondition); + auto p2 = BitV.to_vec(pp.postcondition); log("pre:"); log_cond(p1); log("post:"); @@ -244,8 +244,8 @@ fn log_pp(&pre_and_post pp) -> () { } fn log_pp_err(&pre_and_post pp) -> () { - auto p1 = bitv.to_vec(pp.precondition); - auto p2 = bitv.to_vec(pp.postcondition); + auto p1 = BitV.to_vec(pp.precondition); + auto p2 = BitV.to_vec(pp.postcondition); log_err("pre:"); log_cond_err(p1); log_err("post:"); @@ -253,8 +253,8 @@ fn log_pp_err(&pre_and_post pp) -> () { } fn log_states(&pre_and_post_state pp) -> () { - auto p1 = bitv.to_vec(pp.prestate); - auto p2 = bitv.to_vec(pp.poststate); + auto p1 = BitV.to_vec(pp.prestate); + auto p2 = BitV.to_vec(pp.poststate); log("prestate:"); log_cond(p1); log("poststate:"); @@ -262,8 +262,8 @@ fn log_states(&pre_and_post_state pp) -> () { } fn log_states_err(&pre_and_post_state pp) -> () { - auto p1 = bitv.to_vec(pp.prestate); - auto p2 = bitv.to_vec(pp.poststate); + auto p1 = BitV.to_vec(pp.prestate); + auto p2 = BitV.to_vec(pp.poststate); log_err("prestate:"); log_cond_err(p1); log_err("poststate:"); @@ -288,9 +288,9 @@ fn print_idents(vec[ident] idents) -> () { variable in a given function) to bit number (also remembers the ident for error-logging purposes) */ type var_info = tup(uint, ident); -type fn_info = std.map.hashmap[def_id, var_info]; +type fn_info = std.Map.hashmap[def_id, var_info]; /* mapping from function name to fn_info map */ -type fn_info_map = std.map.hashmap[def_id, fn_info]; +type fn_info_map = std.Map.hashmap[def_id, fn_info]; fn bit_num(def_id v, fn_info m) -> uint { assert (m.contains_key(v)); @@ -312,12 +312,12 @@ fn num_locals(fn_info m) -> uint { 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)); + Vec.push[tup(ident, def_id)](*vars, tup(loc.ident, loc.id)); ret @respan(sp, decl_local(loc)); } fn find_locals(_fn f) -> @vec[tup(ident,def_id)] { - auto res = @_vec.alloc[tup(ident,def_id)](0u); + auto res = @Vec.alloc[tup(ident,def_id)](0u); auto fld = fold.new_identity_fold[@vec[tup(ident, def_id)]](); fld = @rec(fold_decl_local = bind collect_local(_,_,_) with *fld); @@ -343,7 +343,7 @@ fn mk_fn_info(_fn f) -> fn_info { just collect locally declared vars */ let @vec[tup(ident,def_id)] locals = find_locals(f); - log(uistr(_vec.len[tup(ident, def_id)](*locals)) + " locals"); + log(uistr(Vec.len[tup(ident, def_id)](*locals)) + " locals"); for (tup(ident,def_id) p in *locals) { next = add_var(p._1, p._0, next, res); } @@ -364,7 +364,7 @@ fn mk_fn_info_item_fn(&fn_info_map fi, &span sp, ident i, &ast._fn f, 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 { - auto all_methods = _vec.clone[@method](o.methods); + auto all_methods = Vec.clone[@method](o.methods); plus_option[@method](all_methods, o.dtor); for (@method m in all_methods) { fi.insert(m.node.id, mk_fn_info(m.node.meth)); @@ -403,7 +403,7 @@ fn ann_to_ts_ann(ann a, uint nv) -> ts_ann { } } -fn ann_to_ts_ann_fail(ann a) -> option.t[@ts_ann] { +fn ann_to_ts_ann_fail(ann a) -> Option.t[@ts_ann] { alt (a) { case (ann_none) { log("ann_to_ts_ann_fail: didn't expect ann_none here"); @@ -432,7 +432,7 @@ fn ann_to_poststate(ann a) -> poststate { ret (ann_to_ts_ann_fail_more(a)).states.poststate; } -fn stmt_to_ann(&stmt s) -> option.t[@ts_ann] { +fn stmt_to_ann(&stmt s) -> Option.t[@ts_ann] { alt (s.node) { case (stmt_decl(_,?a)) { ret ann_to_ts_ann_fail(a); @@ -652,7 +652,7 @@ fn seq_preconds(fn_info enclosing, vec[pre_and_post] pps) -> precond { /* works on either postconds or preconds should probably rethink the whole type synonym situation */ fn union_postconds_go(&postcond first, &vec[postcond] rest) -> postcond { - auto sz = _vec.len[postcond](rest); + auto sz = Vec.len[postcond](rest); if (sz > 0u) { auto other = rest.(0); @@ -665,7 +665,7 @@ fn union_postconds_go(&postcond first, &vec[postcond] rest) -> postcond { fn union_postconds(uint nv, &vec[postcond] pcs) -> postcond { if (len[postcond](pcs) > 0u) { - ret union_postconds_go(bitv.clone(pcs.(0)), pcs); + ret union_postconds_go(BitV.clone(pcs.(0)), pcs); } else { ret empty_prestate(nv); @@ -674,7 +674,7 @@ fn union_postconds(uint nv, &vec[postcond] pcs) -> postcond { /* Gee, maybe we could use foldl or something */ fn intersect_postconds_go(&postcond first, &vec[postcond] rest) -> postcond { - auto sz = _vec.len[postcond](rest); + auto sz = Vec.len[postcond](rest); if (sz > 0u) { auto other = rest.(0); @@ -689,7 +689,7 @@ fn intersect_postconds_go(&postcond first, &vec[postcond] rest) -> postcond { fn intersect_postconds(&vec[postcond] pcs) -> postcond { assert (len[postcond](pcs) > 0u); - ret intersect_postconds_go(bitv.clone(pcs.(0)), pcs); + ret intersect_postconds_go(BitV.clone(pcs.(0)), pcs); } /******* AST-traversing code ********/ @@ -720,8 +720,8 @@ fn find_pre_post_obj(&fn_info_map fm, _obj o) -> () { find_pre_post_fn(fm, fm.get(m.node.id), m.node.meth); } auto f = bind do_a_method(fm,_); - _vec.map[@method, ()](f, o.methods); - option.map[@method, ()](f, o.dtor); + Vec.map[@method, ()](f, o.methods); + Option.map[@method, ()](f, o.dtor); } fn find_pre_post_state_obj(fn_info_map fm, _obj o) -> bool { @@ -730,8 +730,8 @@ fn find_pre_post_state_obj(fn_info_map fm, _obj o) -> bool { ret find_pre_post_state_fn(fm, fm.get(m.node.id), m.node.meth); } auto f = bind do_a_method(fm,_); - auto flags = _vec.map[@method, bool](f, o.methods); - auto changed = _vec.or(flags); + auto flags = Vec.map[@method, bool](f, o.methods); + auto changed = Vec.or(flags); changed = changed || maybe[@method, bool](false, f, o.dtor); ret changed; } @@ -777,19 +777,19 @@ fn find_pre_post_exprs(&fn_info_map fm, &fn_info enclosing, } auto f = bind do_one(fm, enclosing, _); - _vec.map[@expr, ()](f, args); + Vec.map[@expr, ()](f, args); fn get_pp(&@expr e) -> pre_and_post { ret expr_pp(e); } auto g = get_pp; - auto pps = _vec.map[@expr, pre_and_post](g, args); + auto pps = Vec.map[@expr, pre_and_post](g, args); auto h = get_post; set_pre_and_post(a, rec(precondition=seq_preconds(enclosing, pps), postcondition=union_postconds - (nv, (_vec.map[pre_and_post, postcond](h, pps))))); + (nv, (Vec.map[pre_and_post, postcond](h, pps))))); } fn find_pre_post_loop(&fn_info_map fm, &fn_info enclosing, &@decl d, @@ -822,13 +822,13 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () { alt (e.node) { case (expr_call(?operator, ?operands, ?a)) { - auto args = _vec.clone[@expr](operands); - _vec.push[@expr](args, operator); + auto args = Vec.clone[@expr](operands); + Vec.push[@expr](args, operator); find_pre_post_exprs(fm, enclosing, args, a); } case (expr_spawn(_, _, ?operator, ?operands, ?a)) { - auto args = _vec.clone[@expr](operands); - _vec.push[@expr](args, operator); + auto args = Vec.clone[@expr](operands); + Vec.push[@expr](args, operator); find_pre_post_exprs(fm, enclosing, args, a); } case (expr_vec(?args, _, ?a)) { @@ -888,7 +888,7 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () { } case (expr_rec(?fields,?maybe_base,?a)) { auto es = field_exprs(fields); - _vec.plus_option[@expr](es, maybe_base); + Vec.plus_option[@expr](es, maybe_base); find_pre_post_exprs(fm, enclosing, es, a); } case (expr_assign(?lhs, ?rhs, ?a)) { @@ -1051,7 +1051,7 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () { ret block_pp(an_alt.block); } auto f = bind do_an_alt(fm, enclosing, _); - auto alt_pps = _vec.map[arm, pre_and_post](f, alts); + auto alt_pps = Vec.map[arm, pre_and_post](f, alts); fn combine_pp(pre_and_post antec, fn_info enclosing, &pre_and_post pp, &pre_and_post next) -> pre_and_post { @@ -1065,7 +1065,7 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () { postcondition=false_postcond(num_local_vars)); auto g = bind combine_pp(antec_pp, enclosing, _, _); - auto alts_overall_pp = _vec.foldl[pre_and_post, pre_and_post] + auto alts_overall_pp = Vec.foldl[pre_and_post, pre_and_post] (g, e_pp, alt_pps); set_pre_and_post(a, alts_overall_pp); @@ -1091,8 +1091,8 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () { set_pre_and_post(a, expr_pp(p)); } case(expr_bind(?operator, ?maybe_args, ?a)) { - auto args = _vec.cat_options[@expr](maybe_args); - _vec.push[@expr](args, operator); /* ??? order of eval? */ + auto args = Vec.cat_options[@expr](maybe_args); + Vec.push[@expr](args, operator); /* ??? order of eval? */ find_pre_post_exprs(fm, enclosing, args, a); } case (expr_break(?a)) { @@ -1210,12 +1210,12 @@ fn find_pre_post_block(&fn_info_map fm, &fn_info enclosing, block b) } auto do_one = bind do_one_(fm, enclosing, _); - _vec.map[@stmt, ()](do_one, b.node.stmts); + Vec.map[@stmt, ()](do_one, b.node.stmts); fn do_inner_(fn_info_map fm, fn_info i, &@expr e) -> () { find_pre_post_expr(fm, i, e); } auto do_inner = bind do_inner_(fm, enclosing, _); - option.map[@expr, ()](do_inner, b.node.expr); + Option.map[@expr, ()](do_inner, b.node.expr); let vec[pre_and_post] pps = vec(); @@ -1223,20 +1223,20 @@ fn find_pre_post_block(&fn_info_map fm, &fn_info enclosing, block b) ret stmt_pp(*s); } auto f = get_pp_stmt; - pps += _vec.map[@stmt, pre_and_post](f, b.node.stmts); + pps += Vec.map[@stmt, pre_and_post](f, b.node.stmts); fn get_pp_expr(&@expr e) -> pre_and_post { ret expr_pp(e); } auto g = get_pp_expr; plus_option[pre_and_post](pps, - option.map[@expr, pre_and_post](g, b.node.expr)); + Option.map[@expr, pre_and_post](g, b.node.expr)); auto block_precond = seq_preconds(enclosing, pps); auto h = get_post; - auto postconds = _vec.map[pre_and_post, postcond](h, pps); + auto postconds = Vec.map[pre_and_post, postcond](h, pps); /* A block may be empty, so this next line ensures that the postconds vector is non-empty. */ - _vec.push[postcond](postconds, block_precond); + Vec.push[postcond](postconds, block_precond); auto block_postcond = empty_poststate(nv); /* conservative approximation */ if (! has_nonlocal_exits(b)) { @@ -1696,7 +1696,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing, changed = find_pre_post_state_expr(fm, enclosing, pres, e) || changed; auto e_post = expr_poststate(e); auto a_post; - if (_vec.len[arm](alts) > 0u) { + if (Vec.len[arm](alts) > 0u) { a_post = false_postcond(num_local_vars); for (arm an_alt in alts) { changed = find_pre_post_state_block(fm, enclosing, e_post, @@ -1775,9 +1775,9 @@ fn find_pre_post_state_stmt(&fn_info_map fm, &fn_info enclosing, log("*At beginning: stmt = "); log_stmt(*s); log("*prestate = "); - log(bitv.to_str(stmt_ann.states.prestate)); + log(BitV.to_str(stmt_ann.states.prestate)); log("*poststate ="); - log(bitv.to_str(stmt_ann.states.poststate)); + log(BitV.to_str(stmt_ann.states.poststate)); log("*changed ="); log(changed); @@ -1798,7 +1798,7 @@ fn find_pre_post_state_stmt(&fn_info_map fm, &fn_info enclosing, log("Summary: stmt = "); log_stmt(*s); log("prestate = "); - log(bitv.to_str(stmt_ann.states.prestate)); + log(BitV.to_str(stmt_ann.states.prestate)); log_bitv(enclosing, stmt_ann.states.prestate); log("poststate ="); log_bitv(enclosing, stmt_ann.states.poststate); @@ -1835,10 +1835,10 @@ fn find_pre_post_state_stmt(&fn_info_map fm, &fn_info enclosing, log("Summary: stmt = "); log_stmt(*s); log("prestate = "); - log(bitv.to_str(stmt_ann.states.prestate)); + log(BitV.to_str(stmt_ann.states.prestate)); log_bitv(enclosing, stmt_ann.states.prestate); log("poststate ="); - log(bitv.to_str(stmt_ann.states.poststate)); + log(BitV.to_str(stmt_ann.states.poststate)); log_bitv(enclosing, stmt_ann.states.poststate); log("changed ="); log(changed); @@ -1986,12 +1986,12 @@ fn check_states_against_conditions(fn_info enclosing, &ast._fn f) -> () { } auto do_one = bind do_one_(enclosing, _); - _vec.map[@stmt, ()](do_one, f.body.node.stmts); + Vec.map[@stmt, ()](do_one, f.body.node.stmts); fn do_inner_(fn_info i, &@expr e) -> () { check_states_expr(i, e); } auto do_inner = bind do_inner_(enclosing, _); - option.map[@expr, ()](do_inner, f.body.node.expr); + Option.map[@expr, ()](do_inner, f.body.node.expr); } @@ -2027,13 +2027,13 @@ fn check_method_states(&fn_info_map f_info_map, @method m) -> () { } fn check_obj_state(&fn_info_map f_info_map, vec[obj_field] fields, - vec[@method] methods, option.t[@method] dtor) -> ast._obj { + vec[@method] methods, Option.t[@method] dtor) -> ast._obj { fn one(fn_info_map fm, &@method m) -> () { ret check_method_states(fm, m); } auto f = bind one(f_info_map,_); - _vec.map[@method, ()](f, methods); - option.map[@method, ()](f, dtor); + Vec.map[@method, ()](f, methods); + Option.map[@method, ()](f, dtor); ret rec(fields=fields, methods=methods, dtor=dtor); } @@ -2122,7 +2122,7 @@ fn annotate_exprs(&fn_info_map fm, &vec[@expr] es) -> vec[@expr] { ret annotate_expr(fm, e); } auto f = bind one(fm,_); - ret _vec.map[@expr, @expr](f, es); + ret Vec.map[@expr, @expr](f, es); } fn annotate_elts(&fn_info_map fm, &vec[elt] es) -> vec[elt] { fn one(fn_info_map fm, &elt e) -> elt { @@ -2130,7 +2130,7 @@ fn annotate_elts(&fn_info_map fm, &vec[elt] es) -> vec[elt] { expr=annotate_expr(fm, e.expr)); } auto f = bind one(fm,_); - ret _vec.map[elt, elt](f, es); + ret Vec.map[elt, elt](f, es); } fn annotate_fields(&fn_info_map fm, &vec[field] fs) -> vec[field] { fn one(fn_info_map fm, &field f) -> field { @@ -2139,23 +2139,23 @@ fn annotate_fields(&fn_info_map fm, &vec[field] fs) -> vec[field] { expr=annotate_expr(fm, f.expr)); } auto f = bind one(fm,_); - ret _vec.map[field, field](f, fs); + ret Vec.map[field, field](f, fs); } -fn annotate_option_exp(&fn_info_map fm, &option.t[@expr] o) - -> option.t[@expr] { +fn annotate_option_exp(&fn_info_map fm, &Option.t[@expr] o) + -> Option.t[@expr] { fn one(fn_info_map fm, &@expr e) -> @expr { ret annotate_expr(fm, e); } auto f = bind one(fm,_); - ret option.map[@expr, @expr](f, o); + ret Option.map[@expr, @expr](f, o); } -fn annotate_option_exprs(&fn_info_map fm, &vec[option.t[@expr]] es) - -> vec[option.t[@expr]] { - fn one(fn_info_map fm, &option.t[@expr] o) -> option.t[@expr] { +fn annotate_option_exprs(&fn_info_map fm, &vec[Option.t[@expr]] es) + -> vec[Option.t[@expr]] { + fn one(fn_info_map fm, &Option.t[@expr] o) -> Option.t[@expr] { ret annotate_option_exp(fm, o); } auto f = bind one(fm,_); - ret _vec.map[option.t[@expr], option.t[@expr]](f, es); + ret Vec.map[Option.t[@expr], Option.t[@expr]](f, es); } fn annotate_decl(&fn_info_map fm, &@decl d) -> @decl { auto d1 = d.node; @@ -2163,7 +2163,7 @@ fn annotate_decl(&fn_info_map fm, &@decl d) -> @decl { case (decl_local(?l)) { alt(l.init) { case (some[initializer](?init)) { - let option.t[initializer] an_i = + let Option.t[initializer] an_i = some[initializer] (rec(expr=annotate_expr(fm, init.expr) with init)); @@ -2186,7 +2186,7 @@ fn annotate_alts(&fn_info_map fm, &vec[arm] alts) -> vec[arm] { index=a.index); } auto f = bind one(fm,_); - ret _vec.map[arm, arm](f, alts); + ret Vec.map[arm, arm](f, alts); } fn annotate_expr(&fn_info_map fm, &@expr e) -> @expr { @@ -2338,7 +2338,7 @@ fn annotate_block(&fn_info_map fm, &block b) -> block { for (@stmt s in b.node.stmts) { auto new_s = annotate_stmt(fm, s); - _vec.push[@stmt](new_stmts, new_s); + Vec.push[@stmt](new_stmts, new_s); ast.index_stmt(new_index, new_s); } fn ann_e(fn_info_map fm, &@expr e) -> @expr { @@ -2346,7 +2346,7 @@ fn annotate_block(&fn_info_map fm, &block b) -> block { } auto f = bind ann_e(fm,_); - auto new_e = option.map[@expr, @expr](f, b.node.expr); + auto new_e = Option.map[@expr, @expr](f, b.node.expr); ret respan(b.span, rec(stmts=new_stmts, expr=new_e, index=new_index with b.node)); @@ -2362,7 +2362,7 @@ fn annotate_mod(&fn_info_map fm, &ast._mod m) -> ast._mod { for (@item i in m.items) { auto new_i = annotate_item(fm, i); - _vec.push[@item](new_items, new_i); + Vec.push[@item](new_items, new_i); ast.index_item(new_index, new_i); } ret rec(items=new_items, index=new_index with m); @@ -2383,8 +2383,8 @@ fn annotate_obj(&fn_info_map fm, &ast._obj o) -> ast._obj { ret annotate_method(fm, m); } auto f = bind one(fm,_); - auto new_methods = _vec.map[@method, @method](f, o.methods); - auto new_dtor = option.map[@method, @method](f, o.dtor); + auto new_methods = Vec.map[@method, @method](f, o.methods); + auto new_dtor = Option.map[@method, @method](f, o.dtor); ret rec(methods=new_methods, dtor=new_dtor with o); } @@ -2476,7 +2476,7 @@ fn annotate_module(&fn_info_map fm, &ast._mod module) -> ast._mod { for (@item i in module.items) { auto new_item = annotate_item(fm, i); - _vec.push[@item](new_items, new_item); + Vec.push[@item](new_items, new_item); ast.index_item(new_index, new_item); } diff --git a/src/comp/middle/walk.rs b/src/comp/middle/walk.rs index 8a5d40dc..2df69261 100644 --- a/src/comp/middle/walk.rs +++ b/src/comp/middle/walk.rs @@ -1,8 +1,8 @@ import front.ast; -import std.option; -import std.option.some; -import std.option.none; +import std.Option; +import std.Option.some; +import std.Option.none; type ast_visitor = rec(fn () -> bool keep_going, @@ -257,7 +257,7 @@ fn walk_decl(&ast_visitor v, @ast.decl d) { v.visit_decl_post(d); } -fn walk_expr_opt(&ast_visitor v, option.t[@ast.expr] eo) { +fn walk_expr_opt(&ast_visitor v, Option.t[@ast.expr] eo) { alt (eo) { case (none[@ast.expr]) {} case (some[@ast.expr](?e)) { @@ -297,7 +297,7 @@ fn walk_expr(&ast_visitor v, @ast.expr e) { case (ast.expr_self_method(_, _)) { } case (ast.expr_bind(?callee, ?args, _)) { walk_expr(v, callee); - for (option.t[@ast.expr] eo in args) { + for (Option.t[@ast.expr] eo in args) { walk_expr_opt(v, eo); } } |