Drop collect_items pass, create decls on demand

This solves a problem with inlined functions that have inner functions.

Author: marijnh

src/rustc/driver/driver.rs

@@ -131,7 +131,7 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
 
     let ast_map =
         time(time_passes, "ast indexing",
-             bind middle::ast_map::map_crate(*crate));
+             bind middle::ast_map::map_crate(sess, *crate));
     time(time_passes, "external crate/lib resolution",
          bind creader::read_crates(sess, *crate));
     let {def_map, exp_map, impl_map} =

src/rustc/metadata/astencode.rs

@@ -89,7 +89,7 @@ fn decode_inlined_item(cdata: cstore::crate_metadata,
                     to_id_range: to_id_range};
         let raw_ii = decode_ast(ast_doc);
         let ii = renumber_ast(xcx, raw_ii);
-        ast_map::map_decoded_item(dcx.tcx.items, path, ii);
+        ast_map::map_decoded_item(tcx.sess, dcx.tcx.items, path, ii);
         #debug["Fn named: %s", ii.ident()];
         decode_side_tables(xcx, ast_doc);
         #debug["< Decoded inlined fn: %s::%s",

src/rustc/metadata/encoder.rs

@@ -328,7 +328,7 @@ fn purity_fn_family(p: purity) -> char {
 }
 
 fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
-                        &index: [entry<int>], path: ast_map::path) {
+                        &index: [entry<int>], path: ast_map::path) -> bool {
 
     fn should_inline(attrs: [attribute]) -> bool {
         alt attr::find_inline_attr(attrs) {
@@ -342,7 +342,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
       item_enum(_, _) | item_res(_, _, _, _, _) { true }
       _ { false }
     };
-    if !must_write && !ecx.reachable.contains_key(item.id) { ret; }
+    if !must_write && !ecx.reachable.contains_key(item.id) { ret false; }
 
     alt item.node {
       item_const(_, _) {
@@ -494,11 +494,13 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         ebml_w.end_tag();
       }
     }
+    ret true;
 }
 
 fn encode_info_for_native_item(ecx: @encode_ctxt, ebml_w: ebml::writer,
-                               nitem: @native_item, path: ast_map::path) {
-    if !ecx.reachable.contains_key(nitem.id) { ret; }
+                               nitem: @native_item, path: ast_map::path)
+    -> bool {
+    if !ecx.reachable.contains_key(nitem.id) { ret false; }
     ebml_w.start_tag(tag_items_data_item);
     alt nitem.node {
       native_item_fn(fn_decl, tps) {
@@ -511,6 +513,7 @@ fn encode_info_for_native_item(ecx: @encode_ctxt, ebml_w: ebml::writer,
       }
     }
     ebml_w.end_tag();
+    ret true;
 }
 
 fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer,
@@ -520,17 +523,17 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer,
     index += [{val: crate_node_id, pos: ebml_w.writer.tell()}];
     encode_info_for_mod(ecx, ebml_w, crate_mod, crate_node_id, [], "");
     ecx.ccx.tcx.items.items {|key, val|
-        alt val {
+        let where = ebml_w.writer.tell();
+        let written = alt val {
           middle::ast_map::node_item(i, path) {
-            index += [{val: key, pos: ebml_w.writer.tell()}];
-            encode_info_for_item(ecx, ebml_w, i, index, *path);
+            encode_info_for_item(ecx, ebml_w, i, index, *path)
           }
-          middle::ast_map::node_native_item(i, path) {
-            index += [{val: key, pos: ebml_w.writer.tell()}];
-            encode_info_for_native_item(ecx, ebml_w, i, *path);
+          middle::ast_map::node_native_item(i, _, path) {
+            encode_info_for_native_item(ecx, ebml_w, i, *path)
           }
-          _ { }
-        }
+          _ { false }
+        };
+        if written { index += [{val: key, pos: where}]; }
     };
     ebml_w.end_tag();
     ret index;

src/rustc/metadata/reachable.rs

@@ -58,7 +58,7 @@ fn traverse_def_id(cx: ctx, did: def_id) {
     alt cx.ccx.tcx.items.get(did.node) {
       ast_map::node_item(item, _) { traverse_public_item(cx, item); }
       ast_map::node_method(_, impl_id, _) { traverse_def_id(cx, impl_id); }
-      ast_map::node_native_item(item, _) { cx.rmap.insert(item.id, ()); }
+      ast_map::node_native_item(item, _, _) { cx.rmap.insert(item.id, ()); }
       ast_map::node_variant(v, _, _) { cx.rmap.insert(v.node.id, ()); }
       _ {}
     }

src/rustc/middle/ast_map.rs

@@ -4,6 +4,8 @@ import syntax::ast::*;
 import syntax::ast_util;
 import syntax::ast_util::inlined_item_methods;
 import syntax::{visit, codemap};
+import driver::session::session;
+import front::attr;
 
 enum path_elt { path_mod(str), path_name(str) }
 type path = [path_elt];
@@ -24,20 +26,21 @@ fn path_to_str(p: path) -> str {
 
 enum ast_node {
     node_item(@item, @path),
-    node_native_item(@native_item, @path),
+    node_native_item(@native_item, native_abi, @path),
     node_method(@method, def_id /* impl did */, @path /* path to the impl */),
-    node_variant(variant, def_id, @path),
+    node_variant(variant, @item, @path),
     node_expr(@expr),
     node_export(@view_path, @path),
     // Locals are numbered, because the alias analysis needs to know in which
     // order they are introduced.
     node_arg(arg, uint),
     node_local(uint),
-    node_res_ctor(@item),
+    node_ctor(@item),
 }
 
 type map = std::map::hashmap<node_id, ast_node>;
-type ctx = {map: map, mutable path: path, mutable local_id: uint};
+type ctx = {map: map, mutable path: path,
+            mutable local_id: uint, sess: session};
 type vt = visit::vt<ctx>;
 
 fn extend(cx: ctx, elt: str) -> @path {
@@ -47,7 +50,6 @@ fn extend(cx: ctx, elt: str) -> @path {
 fn mk_ast_map_visitor() -> vt {
     ret visit::mk_vt(@{
         visit_item: map_item,
-        visit_native_item: map_native_item,
         visit_expr: map_expr,
         visit_fn: map_fn,
         visit_local: map_local,
@@ -57,18 +59,19 @@ fn mk_ast_map_visitor() -> vt {
     });
 }
 
-fn map_crate(c: crate) -> map {
+fn map_crate(sess: session, c: crate) -> map {
     let cx = {map: std::map::new_int_hash(),
               mutable path: [],
-              mutable local_id: 0u};
+              mutable local_id: 0u,
+              sess: sess};
     visit::visit_crate(c, cx, mk_ast_map_visitor());
     ret cx.map;
 }
 
 // Used for items loaded from external crate that are being inlined into this
 // crate.  The `path` should be the path to the item but should not include
 // the item itself.
-fn map_decoded_item(map: map, path: path, ii: inlined_item) {
+fn map_decoded_item(sess: session, map: map, path: path, ii: inlined_item) {
     // I believe it is ok for the local IDs of inlined items from other crates
     // to overlap with the local ids from this crate, so just generate the ids
     // starting from 0.  (In particular, I think these ids are only used in
@@ -77,7 +80,8 @@ fn map_decoded_item(map: map, path: path, ii: inlined_item) {
     // variables that are simultaneously in scope).
     let cx = {map: map,
               mutable path: path,
-              mutable local_id: 0u};
+              mutable local_id: 0u,
+              sess: sess};
     let v = mk_ast_map_visitor();
 
     // methods get added to the AST map when their impl is visited.  Since we
@@ -86,7 +90,7 @@ fn map_decoded_item(map: map, path: path, ii: inlined_item) {
     alt ii {
       ii_item(i) { /* fallthrough */ }
       ii_method(impl_did, m) {
-        map_method(impl_did, @vec::init(path), m, cx);
+        map_method(impl_did, @path, m, cx);
       }
     }
 
@@ -137,19 +141,31 @@ fn map_item(i: @item, cx: ctx, v: vt) {
       item_impl(_, _, _, ms) {
         let impl_did = ast_util::local_def(i.id);
         for m in ms {
-            map_method(impl_did, item_path, m, cx);
+            map_method(impl_did, extend(cx, i.ident), m, cx);
         }
       }
       item_res(_, _, _, dtor_id, ctor_id) {
-        cx.map.insert(ctor_id, node_res_ctor(i));
+        cx.map.insert(ctor_id, node_ctor(i));
         cx.map.insert(dtor_id, node_item(i, item_path));
       }
       item_enum(vs, _) {
         for v in vs {
             cx.map.insert(v.node.id, node_variant(
-                v, ast_util::local_def(i.id), extend(cx, i.ident)));
+                v, i, extend(cx, i.ident)));
         }
       }
+      item_native_mod(nm) {
+        let abi = alt attr::native_abi(i.attrs) {
+          either::left(msg) { cx.sess.span_fatal(i.span, msg); }
+          either::right(abi) { abi }
+        };
+        for nitem in nm.items {
+            cx.map.insert(nitem.id, node_native_item(nitem, abi, @cx.path));
+        }
+      }
+      item_class(_, _, ctor) {
+        cx.map.insert(ctor.node.id, node_ctor(i));
+      }
       _ { }
     }
     alt i.node {
@@ -179,11 +195,6 @@ fn map_view_item(vi: @view_item, cx: ctx, _v: vt) {
     }
 }
 
-fn map_native_item(i: @native_item, cx: ctx, v: vt) {
-    cx.map.insert(i.id, node_native_item(i, @cx.path));
-    visit::visit_native_item(i, cx, v);
-}
-
 fn map_expr(ex: @expr, cx: ctx, v: vt) {
     cx.map.insert(ex.id, node_expr(ex));
     visit::visit_expr(ex, cx, v);