From 14f1fe0e29d5f4d832ef622b7a1a49e5c591e1c0 Mon Sep 17 00:00:00 2001 From: Marijn Haverbeke Date: Wed, 11 May 2011 16:30:48 +0200 Subject: [PATCH] Remove mod indices from the AST They are now created by the resolve pass, which is the only pass that needs them, and kept internal to that pass. --- src/comp/front/ast.rs | 91 +-------------- src/comp/front/eval.rs | 46 +++----- src/comp/front/parser.rs | 38 ++----- src/comp/middle/fold.rs | 10 +- src/comp/middle/resolve.rs | 171 ++++++++++++++++++++++------- src/comp/middle/typestate_check.rs | 11 +- 6 files changed, 165 insertions(+), 202 deletions(-) diff --git a/src/comp/front/ast.rs b/src/comp/front/ast.rs index 3d8090b0a36..8cfffc3948e 100644 --- a/src/comp/front/ast.rs +++ b/src/comp/front/ast.rs @@ -360,21 +360,8 @@ fn unop_to_str(unop op) -> str { vec[@method] methods, Option.t[@method] dtor); -tag mod_index_entry { - mie_view_item(@view_item); - mie_item(@item); - mie_tag_variant(@item /* tag item */, uint /* variant index */); -} - -tag native_mod_index_entry { - nmie_view_item(@view_item); - nmie_item(@native_item); -} - -type mod_index = hashmap[ident,mod_index_entry]; type _mod = rec(vec[@view_item] view_items, - vec[@item] items, - mod_index index); + vec[@item] items); tag native_abi { native_abi_rust; @@ -386,9 +373,7 @@ fn unop_to_str(unop op) -> str { type native_mod = rec(str native_name, native_abi abi, vec[@view_item] view_items, - vec[@native_item] items, - native_mod_index index); -type native_mod_index = hashmap[ident,native_mod_index_entry]; + vec[@native_item] items); type variant_arg = rec(@ty ty, def_id id); type variant_ = rec(str name, vec[variant_arg] args, def_id id, ann ann); @@ -433,78 +418,6 @@ fn item_ident(@item it) -> ident { fn_decl, vec[ty_param], def_id, ann); } -fn index_view_item(mod_index index, @view_item it) { - alt (it.node) { - case(ast.view_item_use(?id, _, _, _)) { - index.insert(id, ast.mie_view_item(it)); - } - case(ast.view_item_import(?def_ident,_,_)) { - index.insert(def_ident, ast.mie_view_item(it)); - } - case(ast.view_item_export(_)) { - // NB: don't index these, they might collide with - // the import or use that they're exporting. Have - // to do linear search for exports. - } - } -} - -fn index_item(mod_index index, @item it) { - alt (it.node) { - case (ast.item_const(?id, _, _, _, _)) { - index.insert(id, ast.mie_item(it)); - } - case (ast.item_fn(?id, _, _, _, _)) { - index.insert(id, ast.mie_item(it)); - } - case (ast.item_mod(?id, _, _)) { - index.insert(id, ast.mie_item(it)); - } - case (ast.item_native_mod(?id, _, _)) { - index.insert(id, ast.mie_item(it)); - } - case (ast.item_ty(?id, _, _, _, _)) { - index.insert(id, ast.mie_item(it)); - } - case (ast.item_tag(?id, ?variants, _, _, _)) { - index.insert(id, ast.mie_item(it)); - let uint variant_idx = 0u; - for (ast.variant v in variants) { - index.insert(v.node.name, - ast.mie_tag_variant(it, variant_idx)); - variant_idx += 1u; - } - } - case (ast.item_obj(?id, _, _, _, _)) { - index.insert(id, ast.mie_item(it)); - } - } -} - -fn index_native_item(native_mod_index index, @native_item it) { - alt (it.node) { - case (ast.native_item_ty(?id, _)) { - index.insert(id, ast.nmie_item(it)); - } - case (ast.native_item_fn(?id, _, _, _, _, _)) { - index.insert(id, ast.nmie_item(it)); - } - } -} - -fn index_native_view_item(native_mod_index index, @view_item it) { - alt (it.node) { - case(ast.view_item_import(?def_ident,_,_)) { - index.insert(def_ident, ast.nmie_view_item(it)); - } - case(ast.view_item_export(_)) { - // NB: don't index these, they might collide with - // the import or use that they're exporting. Have - // to do linear search for exports. - } - } -} - fn is_exported(ident i, _mod m) -> bool { auto count = 0; for (@ast.view_item vi in m.view_items) { diff --git a/src/comp/front/eval.rs b/src/comp/front/eval.rs index e1ad59bc5b7..1d708f17004 100644 --- a/src/comp/front/eval.rs +++ b/src/comp/front/eval.rs @@ -236,13 +236,11 @@ fn eval_crate_directives(ctx cx, vec[@ast.crate_directive] cdirs, str prefix, &mutable vec[@ast.view_item] view_items, - &mutable vec[@ast.item] items, - hashmap[ast.ident, - ast.mod_index_entry] index) { + &mutable vec[@ast.item] items) { for (@ast.crate_directive sub_cdir in cdirs) { eval_crate_directive(cx, e, sub_cdir, prefix, - view_items, items, index); + view_items, items); } } @@ -252,12 +250,11 @@ fn eval_crate_directives_to_mod(ctx cx, env e, str prefix) -> ast._mod { let vec[@ast.view_item] view_items = vec(); let vec[@ast.item] items = vec(); - auto index = new_str_hash[ast.mod_index_entry](); eval_crate_directives(cx, e, cdirs, prefix, - view_items, items, index); + view_items, items); - ret rec(view_items=view_items, items=items, index=index); + ret rec(view_items=view_items, items=items); } @@ -266,15 +263,13 @@ fn eval_crate_directive_block(ctx cx, &ast.block blk, str prefix, &mutable vec[@ast.view_item] view_items, - &mutable vec[@ast.item] items, - hashmap[ast.ident, - ast.mod_index_entry] index) { + &mutable vec[@ast.item] items) { for (@ast.stmt s in blk.node.stmts) { alt (s.node) { case (ast.stmt_crate_directive(?cdir)) { eval_crate_directive(cx, e, cdir, prefix, - view_items, items, index); + view_items, items); } case (_) { cx.sess.span_err(s.span, @@ -289,9 +284,7 @@ fn eval_crate_directive_expr(ctx cx, @ast.expr x, str prefix, &mutable vec[@ast.view_item] view_items, - &mutable vec[@ast.item] items, - hashmap[ast.ident, - ast.mod_index_entry] index) { + &mutable vec[@ast.item] items) { alt (x.node) { case (ast.expr_if(?cond, ?thn, ?elopt, _)) { @@ -302,15 +295,13 @@ fn eval_crate_directive_expr(ctx cx, if (val_as_bool(cv)) { ret eval_crate_directive_block(cx, e, thn, prefix, - view_items, items, - index); + view_items, items); } alt (elopt) { case (some[@ast.expr](?els)) { ret eval_crate_directive_expr(cx, e, els, prefix, - view_items, items, - index); + view_items, items); } case (_) { // Absent-else is ok. @@ -326,14 +317,13 @@ fn eval_crate_directive_expr(ctx cx, auto pv = eval_lit(cx, arm.pat.span, lit); if (val_eq(cx.sess, arm.pat.span, vv, pv)) { ret eval_crate_directive_block - (cx, e, arm.block, prefix, - view_items, items, index); + (cx, e, arm.block, prefix, view_items, items); } } case (ast.pat_wild(_)) { ret eval_crate_directive_block (cx, e, arm.block, prefix, - view_items, items, index); + view_items, items); } case (_) { cx.sess.span_err(arm.pat.span, @@ -346,8 +336,7 @@ fn eval_crate_directive_expr(ctx cx, case (ast.expr_block(?block, _)) { ret eval_crate_directive_block(cx, e, block, prefix, - view_items, items, - index); + view_items, items); } case (_) { @@ -361,21 +350,19 @@ fn eval_crate_directive(ctx cx, @ast.crate_directive cdir, str prefix, &mutable vec[@ast.view_item] view_items, - &mutable vec[@ast.item] items, - hashmap[ast.ident, - ast.mod_index_entry] index) { + &mutable vec[@ast.item] items) { alt (cdir.node) { case (ast.cdir_let(?id, ?x, ?cdirs)) { auto v = eval_expr(cx, e, x); auto e0 = vec(tup(id, v)) + e; eval_crate_directives(cx, e0, cdirs, prefix, - view_items, items, index); + view_items, items); } case (ast.cdir_expr(?x)) { eval_crate_directive_expr(cx, e, x, prefix, - view_items, items, index); + view_items, items); } case (ast.cdir_src_mod(?id, ?file_opt)) { @@ -404,7 +391,6 @@ fn eval_crate_directive(ctx cx, cx.chpos = p0.get_chpos(); auto im = ast.item_mod(id, m0, next_id); auto i = @spanned(cdir.span.lo, cdir.span.hi, im); - ast.index_item(index, i); Vec.push[@ast.item](items, i); } @@ -422,13 +408,11 @@ fn eval_crate_directive(ctx cx, auto m0 = eval_crate_directives_to_mod(cx, e, cdirs, full_path); auto im = ast.item_mod(id, m0, cx.p.next_def_id()); auto i = @spanned(cdir.span.lo, cdir.span.hi, im); - ast.index_item(index, i); Vec.push[@ast.item](items, i); } case (ast.cdir_view_item(?vi)) { Vec.push[@ast.view_item](view_items, vi); - ast.index_view_item(index, vi); } case (ast.cdir_meta(?mi)) { diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 10432389df4..33b74d8d982 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -1889,17 +1889,12 @@ fn parse_item_obj(parser p, ast.layer lyr) -> @ast.item { } fn parse_mod_items(parser p, token.token term) -> ast._mod { - auto index = new_str_hash[ast.mod_index_entry](); - auto view_items = parse_view(p, index); + auto view_items = parse_view(p); let vec[@ast.item] items = vec(); while (p.peek() != term) { - auto item = parse_item(p); - items += vec(item); - - // Index the item. - ast.index_item(index, item); + items += vec(parse_item(p)); } - ret rec(view_items=view_items, items=items, index=index); + ret rec(view_items=view_items, items=items); } fn parse_item_const(parser p) -> @ast.item { @@ -1972,22 +1967,16 @@ fn parse_native_item(parser p) -> @ast.native_item { fn parse_native_mod_items(parser p, str native_name, ast.native_abi abi) -> ast.native_mod { - auto index = new_str_hash[ast.native_mod_index_entry](); let vec[@ast.native_item] items = vec(); - auto view_items = parse_native_view(p, index); + auto view_items = parse_native_view(p); while (p.peek() != token.RBRACE) { - auto item = parse_native_item(p); - items += vec(item); - - // Index the item. - ast.index_native_item(index, item); + items += vec(parse_native_item(p)); } ret rec(native_name=native_name, abi=abi, view_items=view_items, - items=items, - index=index); + items=items); } fn default_native_name(session.session sess, str id) -> str { @@ -2353,25 +2342,18 @@ fn is_view_item(token.token t) -> bool { ret false; } -fn parse_view(parser p, ast.mod_index index) -> vec[@ast.view_item] { +fn parse_view(parser p) -> vec[@ast.view_item] { let vec[@ast.view_item] items = vec(); while (is_view_item(p.peek())) { - auto item = parse_view_item(p); - items += vec(item); - - ast.index_view_item(index, item); + items += vec(parse_view_item(p)); } ret items; } -fn parse_native_view(parser p, ast.native_mod_index index) - -> vec[@ast.view_item] { +fn parse_native_view(parser p) -> vec[@ast.view_item] { let vec[@ast.view_item] items = vec(); while (is_view_item(p.peek())) { - auto item = parse_view_item(p); - items += vec(item); - - ast.index_native_view_item(index, item); + items += vec(parse_view_item(p)); } ret items; } diff --git a/src/comp/middle/fold.rs b/src/comp/middle/fold.rs index c55858b8171..06f4bfe5fb4 100644 --- a/src/comp/middle/fold.rs +++ b/src/comp/middle/fold.rs @@ -1057,21 +1057,18 @@ fn fold_mod[ENV](&ENV e, &ast_fold[ENV] fld, &ast._mod m) -> ast._mod { let vec[@view_item] view_items = vec(); let vec[@item] items = vec(); - auto index = new_str_hash[ast.mod_index_entry](); 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); - 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); - ast.index_item(index, new_item); } - ret fld.fold_mod(e, rec(view_items=view_items, items=items, index=index)); + ret fld.fold_mod(e, rec(view_items=view_items, items=items)); } fn fold_native_item[ENV](&ENV env, &ast_fold[ENV] fld, @@ -1098,7 +1095,6 @@ fn fold_native_mod[ENV](&ENV e, &ast_fold[ENV] fld, &ast.native_mod m) -> ast.native_mod { let vec[@view_item] view_items = vec(); let vec[@native_item] items = vec(); - auto index = new_str_hash[ast.native_mod_index_entry](); for (@view_item vi in m.view_items) { auto new_vi = fold_view_item[ENV](e, fld, vi); @@ -1108,14 +1104,12 @@ fn fold_native_mod[ENV](&ENV e, &ast_fold[ENV] fld, for (@native_item i in m.items) { auto new_item = fold_native_item[ENV](e, fld, i); Vec.push[@native_item](items, new_item); - ast.index_native_item(index, new_item); } ret fld.fold_native_mod(e, rec(native_name=m.native_name, abi=m.abi, view_items=view_items, - items=items, - index=index)); + items=items)); } fn fold_crate[ENV](&ENV env, &ast_fold[ENV] fld, diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs index b386c51aa7b..22c674595f3 100644 --- a/src/comp/middle/resolve.rs +++ b/src/comp/middle/resolve.rs @@ -7,6 +7,7 @@ import driver.session.session; import util.common.new_def_hash; import util.common.new_int_hash; +import util.common.new_str_hash; import util.common.span; import util.typestate_ann.ts_ann; import std.Map.hashmap; @@ -26,6 +27,11 @@ // locates all names (in expressions, types, and alt patterns) and resolves // them, storing the resulting def in the AST nodes. +// This module internally uses -1 as a def_id for the top_level module in a +// crate. The parser doesn't assign a def_id to this module. +// (FIXME See https://github.com/graydon/rust/issues/358 for the reason this +// isn't a const.) + tag scope { scope_crate(@ast.crate); scope_item(@ast.item); @@ -35,10 +41,6 @@ scope_arm(ast.arm); } -tag wrap_mod { - wmod(ast._mod); - wnmod(ast.native_mod); -} tag import_state { todo(@ast.view_item, list[scope]); resolving(span); @@ -57,8 +59,24 @@ fn eq(&tup(def_id,str) v1, &tup(def_id,str) v2) -> bool { ret std.Map.mk_hashmap[tup(def_id,str),def](hash, eq); } +tag mod_index_entry { + mie_view_item(@ast.view_item); + mie_item(@ast.item); + mie_tag_variant(@ast.item /* tag item */, uint /* variant index */); +} +type mod_index = hashmap[ident,mod_index_entry]; +type indexed_mod = rec(ast._mod m, mod_index index); + +tag native_mod_index_entry { + nmie_view_item(@ast.view_item); + nmie_item(@ast.native_item); +} +type nmod_index = hashmap[ident,native_mod_index_entry]; +type indexed_nmod = rec(ast.native_mod m, nmod_index index); + type env = rec(hashmap[ast.def_num,import_state] imports, - hashmap[ast.def_num,@wrap_mod] mod_map, + hashmap[ast.def_num,@indexed_mod] mod_map, + hashmap[ast.def_num,@indexed_nmod] nmod_map, hashmap[def_id,vec[ident]] ext_map, ext_hash ext_cache, session sess); @@ -74,7 +92,8 @@ fn eq(&tup(def_id,str) v1, &tup(def_id,str) v2) -> bool { fn resolve_crate(session sess, @ast.crate crate) -> @ast.crate { auto e = @rec(imports = new_int_hash[import_state](), - mod_map = new_int_hash[@wrap_mod](), + mod_map = new_int_hash[@indexed_mod](), + nmod_map = new_int_hash[@indexed_nmod](), ext_map = new_def_hash[vec[ident]](), ext_cache = new_ext_hash(), sess = sess); @@ -94,6 +113,9 @@ fn map_crate(&@env e, &ast.crate c) { visit_item_pre = bind push_env_for_item_map_mod(e, cell, _), visit_item_post = bind pop_env_for_item(cell, _) with walk.default_visitor()); + // Register the top-level mod + e.mod_map.insert(-1, @rec(m=c.node.module, + index=index_mod(c.node.module))); walk.walk_crate(v, c); // Helpers for this pass. @@ -108,10 +130,12 @@ fn push_env_for_item_map_mod(@env e, @mutable list[scope] sc, *sc = cons[scope](scope_item(i), @*sc); alt (i.node) { case (ast.item_mod(_, ?md, ?defid)) { - e.mod_map.insert(defid._1, @wmod(md)); + auto index = index_mod(md); + e.mod_map.insert(defid._1, @rec(m=md, index=index)); } case (ast.item_native_mod(_, ?nmd, ?defid)) { - e.mod_map.insert(defid._1, @wnmod(nmd)); + auto index = index_nmod(nmd); + e.nmod_map.insert(defid._1, @rec(m=nmd, index=index)); } case (_) {} } @@ -375,7 +399,8 @@ fn in_scope(&env e, ident id, &scope s, namespace ns) -> Option.t[def] { alt (s) { case (scope_crate(?c)) { - ret lookup_in_regular_mod(e, c.node.module, id, ns, inside); + auto defid = tup(ast.local_crate, -1); + ret lookup_in_regular_mod(e, defid, id, ns, inside); } case (scope_item(?it)) { alt (it.node) { @@ -390,11 +415,11 @@ fn in_scope(&env e, ident id, &scope s, namespace ns) ret lookup_in_ty_params(id, ty_params); } } - case (ast.item_mod(_, ?m, _)) { - ret lookup_in_regular_mod(e, m, id, ns, inside); + case (ast.item_mod(_, _, ?defid)) { + ret lookup_in_regular_mod(e, defid, id, ns, inside); } - case (ast.item_native_mod(_, ?m, _)) { - ret lookup_in_native_mod(e, m, id, ns); + case (ast.item_native_mod(_, ?m, ?defid)) { + ret lookup_in_native_mod(e, defid, id, ns); } case (ast.item_ty(_, _, ?ty_params, _, _)) { if (ns == ns_type) { @@ -606,8 +631,6 @@ fn lookup_in_mod(&env e, def m, ident id, namespace ns, dir dr) ret cached; } auto path = vec(id); - // def_num=-1 is a kludge to overload def_mod for external crates, - // since those don't get a def num if (defid._1 != -1) { path = e.ext_map.get(defid) + path; } @@ -619,18 +642,10 @@ fn lookup_in_mod(&env e, def m, ident id, namespace ns, dir dr) } alt (m) { case (ast.def_mod(?defid)) { - alt (*e.mod_map.get(defid._1)) { - case (wmod(?m)) { - ret lookup_in_regular_mod(e, m, id, ns, dr); - } - } + ret lookup_in_regular_mod(e, defid, id, ns, dr); } case (ast.def_native_mod(?defid)) { - alt (*e.mod_map.get(defid._1)) { - case (wnmod(?m)) { - ret lookup_in_native_mod(e, m, id, ns); - } - } + ret lookup_in_native_mod(e, defid, id, ns); } } } @@ -646,21 +661,22 @@ fn found_view_item(&env e, @ast.view_item vi, namespace ns) -> Option.t[def] { } } -fn lookup_in_regular_mod(&env e, &ast._mod md, ident id, namespace ns, dir dr) +fn lookup_in_regular_mod(&env e, def_id defid, ident id, namespace ns, dir dr) -> Option.t[def] { - auto found = md.index.find(id); - if (found == none[ast.mod_index_entry] || - (dr == outside && !ast.is_exported(id, md))) { + auto info = e.mod_map.get(defid._1); + auto found = info.index.find(id); + if (found == none[mod_index_entry] || + (dr == outside && !ast.is_exported(id, info.m))) { ret none[def]; } alt (Option.get(found)) { - case (ast.mie_view_item(?view_item)) { + case (mie_view_item(?view_item)) { ret found_view_item(e, view_item, ns); } - case (ast.mie_item(?item)) { + case (mie_item(?item)) { ret found_def_item(item, ns); } - case (ast.mie_tag_variant(?item, ?variant_idx)) { + case (mie_tag_variant(?item, ?variant_idx)) { alt (item.node) { case (ast.item_tag(_, ?variants, _, ?tid, _)) { if (ns == ns_value) { @@ -675,17 +691,18 @@ fn lookup_in_regular_mod(&env e, &ast._mod md, ident id, namespace ns, dir dr) } } -fn lookup_in_native_mod(&env e, &ast.native_mod md, ident id, namespace ns) +fn lookup_in_native_mod(&env e, def_id defid, ident id, namespace ns) -> Option.t[def] { - auto found = md.index.find(id); - if (found == none[ast.native_mod_index_entry]) { + auto info = e.nmod_map.get(defid._1); + auto found = info.index.find(id); + if (found == none[native_mod_index_entry]) { ret none[def]; } alt (Option.get(found)) { - case (ast.nmie_view_item(?view_item)) { + case (nmie_view_item(?view_item)) { ret found_view_item(e, view_item, ns); } - case (ast.nmie_item(?item)) { + case (nmie_item(?item)) { alt (item.node) { case (ast.native_item_ty(_, ?id)) { if (ns == ns_type) { @@ -704,6 +721,86 @@ fn lookup_in_native_mod(&env e, &ast.native_mod md, ident id, namespace ns) ret none[def]; } +// Module indexing + +fn index_mod(&ast._mod md) -> mod_index { + auto index = new_str_hash[mod_index_entry](); + + for (@ast.view_item it in md.view_items) { + alt (it.node) { + case(ast.view_item_use(?id, _, _, _)) { + index.insert(id, mie_view_item(it)); + } + case(ast.view_item_import(?def_ident,_,_)) { + index.insert(def_ident, mie_view_item(it)); + } + case(ast.view_item_export(_)) {} + } + } + + for (@ast.item it in md.items) { + alt (it.node) { + case (ast.item_const(?id, _, _, _, _)) { + index.insert(id, mie_item(it)); + } + case (ast.item_fn(?id, _, _, _, _)) { + index.insert(id, mie_item(it)); + } + case (ast.item_mod(?id, _, _)) { + index.insert(id, mie_item(it)); + } + case (ast.item_native_mod(?id, _, _)) { + index.insert(id, mie_item(it)); + } + case (ast.item_ty(?id, _, _, _, _)) { + index.insert(id, mie_item(it)); + } + case (ast.item_tag(?id, ?variants, _, _, _)) { + index.insert(id, mie_item(it)); + let uint variant_idx = 0u; + for (ast.variant v in variants) { + index.insert(v.node.name, + mie_tag_variant(it, variant_idx)); + variant_idx += 1u; + } + } + case (ast.item_obj(?id, _, _, _, _)) { + index.insert(id, mie_item(it)); + } + } + } + + ret index; +} + +fn index_nmod(&ast.native_mod md) -> nmod_index { + auto index = new_str_hash[native_mod_index_entry](); + + for (@ast.view_item it in md.view_items) { + alt (it.node) { + case(ast.view_item_import(?def_ident,_,_)) { + index.insert(def_ident, nmie_view_item(it)); + } + case(ast.view_item_export(_)) {} + } + } + + for (@ast.native_item it in md.items) { + alt (it.node) { + case (ast.native_item_ty(?id, _)) { + index.insert(id, nmie_item(it)); + } + case (ast.native_item_fn(?id, _, _, _, _, _)) { + index.insert(id, nmie_item(it)); + } + } + } + + ret index; +} + +// External lookups + // FIXME creader should handle multiple namespaces fn check_def_by_ns(def d, namespace ns) -> bool { ret alt (d) { diff --git a/src/comp/middle/typestate_check.rs b/src/comp/middle/typestate_check.rs index 1925dd15147..687b2e16614 100644 --- a/src/comp/middle/typestate_check.rs +++ b/src/comp/middle/typestate_check.rs @@ -6,7 +6,6 @@ import front.ast.item; import front.ast.block; import front.ast.block_; -import front.ast.mod_index_entry; import front.ast.obj_field; import front.ast.decl; import front.ast.arm; @@ -83,8 +82,6 @@ import front.ast._obj; import front.ast._mod; import front.ast.crate; -import front.ast.mod_index_entry; -import front.ast.mie_item; import front.ast.item_fn; import front.ast.item_obj; import front.ast.def_local; @@ -2357,14 +2354,12 @@ fn annotate_fn(&fn_info_map fm, &ast._fn f) -> ast._fn { } fn annotate_mod(&fn_info_map fm, &ast._mod m) -> ast._mod { let vec[@item] new_items = vec(); - auto new_index = new_str_hash[mod_index_entry](); for (@item i in m.items) { auto new_i = annotate_item(fm, 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); + ret rec(items=new_items with m); } fn annotate_method(&fn_info_map fm, &@method m) -> @method { auto f_info = get_fn_info(fm, m.node.id); @@ -2471,15 +2466,13 @@ fn annotate_item(&fn_info_map fm, &@ast.item item) -> @ast.item { fn annotate_module(&fn_info_map fm, &ast._mod module) -> ast._mod { let vec[@item] new_items = vec(); - auto new_index = new_str_hash[ast.mod_index_entry](); for (@item i in module.items) { auto new_item = annotate_item(fm, i); Vec.push[@item](new_items, new_item); - ast.index_item(new_index, new_item); } - ret rec(items = new_items, index = new_index with module); + ret rec(items = new_items with module); } fn annotate_crate(&fn_info_map fm, &@ast.crate crate) -> @ast.crate {