Rewrite each_path to allow performance improvements in the future.

Instead of determining paths from the path tag, we iterate through
modules' children recursively in the metadata. This will allow for
lazy external module resolution.

4 files changed, 403 insertions, 140 deletions

diff --git a/src/librustc/metadata/common.rs b/src/librustc/metadata/common.rs
index f487c73372f..e7725436f2b 100644
--- a/src/librustc/metadata/common.rs
+++ b/src/librustc/metadata/common.rs
@@ -176,6 +176,10 @@ pub static tag_item_method_tps: uint = 0x7b;
 pub static tag_item_method_fty: uint = 0x7c;
 pub static tag_item_method_transformed_self_ty: uint = 0x7d;
 
+pub static tag_mod_child: uint = 0x7e;
+pub static tag_misc_info: uint = 0x7f;
+pub static tag_misc_info_crate_items: uint = 0x80;
+
 pub struct LinkMeta {
     name: @str,
     vers: @str,
diff --git a/src/librustc/metadata/csearch.rs b/src/librustc/metadata/csearch.rs
index bfc5d512b37..4ede9f96f1f 100644
--- a/src/librustc/metadata/csearch.rs
+++ b/src/librustc/metadata/csearch.rs
@@ -97,18 +97,14 @@ pub fn get_enum_variants(tcx: ty::ctxt, def: ast::def_id)
     return decoder::get_enum_variants(cstore.intr, cdata, def.node, tcx)
 }
 
-pub fn get_impls_for_mod(cstore: @mut cstore::CStore, def: ast::def_id,
-                         name: Option<ast::ident>)
-                      -> @~[@resolve::Impl] {
-    let cdata = cstore::get_crate_data(cstore, def.crate);
-    do decoder::get_impls_for_mod(cstore.intr, cdata, def.node, name) |cnum| {
-        cstore::get_crate_data(cstore, cnum)
-    }
+/// Returns information about the given implementation.
+pub fn get_impl(cstore: @mut cstore::CStore, impl_def_id: ast::def_id)
+                -> resolve::Impl {
+    let cdata = cstore::get_crate_data(cstore, impl_def_id.crate);
+    decoder::get_impl(cstore.intr, cdata, impl_def_id.node)
 }
 
-pub fn get_method(tcx: ty::ctxt,
-                  def: ast::def_id) -> ty::Method
-{
+pub fn get_method(tcx: ty::ctxt, def: ast::def_id) -> ty::Method {
     let cdata = cstore::get_crate_data(tcx.cstore, def.crate);
     decoder::get_method(tcx.cstore.intr, cdata, def.node, tcx)
 }
diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs
index b11badd65cc..2ebaa2b739f 100644
--- a/src/librustc/metadata/decoder.rs
+++ b/src/librustc/metadata/decoder.rs
@@ -458,64 +458,192 @@ pub fn each_lang_item(cdata: cmd, f: &fn(ast::node_id, uint) -> bool) -> bool {
     return true;
 }
 
-/// Iterates over all the paths in the given crate.
-pub fn each_path(intr: @ident_interner,
-                 cdata: cmd,
-                 get_crate_data: GetCrateDataCb,
-                 f: &fn(&str, def_like, ast::visibility) -> bool)
-                 -> bool {
-    // FIXME #4572: This function needs to be nuked, as it's impossible to make fast.
-    // It's the source of most of the performance problems when compiling small crates.
+struct EachItemContext<'self> {
+    intr: @ident_interner,
+    cdata: cmd,
+    get_crate_data: GetCrateDataCb<'self>,
+    path_builder: &'self mut ~str,
+    callback: &'self fn(&str, def_like, ast::visibility) -> bool,
+}
 
-    let root = reader::Doc(cdata.data);
-    let items = reader::get_doc(root, tag_items);
-    let items_data = reader::get_doc(items, tag_items_data);
-
-    // First, go through all the explicit items.
-    for reader::tagged_docs(items_data, tag_items_data_item) |item_doc| {
-        let path = ast_map::path_to_str(item_path(item_doc), intr);
-        let path_is_empty = path.is_empty();
-        if !path_is_empty {
-            // Extract the def ID.
-            let def_id = item_def_id(item_doc, cdata);
-
-            // Construct the def for this item.
-            debug!("(each_path) yielding explicit item: %s", path);
-            let def_like = item_to_def_like(item_doc, def_id, cdata.cnum);
-
-            let vis = item_visibility(item_doc);
-
-            // Hand the information off to the iteratee.
-            if !f(path, def_like, vis) {
-                return false;
+impl<'self> EachItemContext<'self> {
+    // Pushes the given name and returns the old length.
+    fn push_name(&mut self, string: &str) -> uint {
+        let path_len = self.path_builder.len();
+        if path_len != 0 {
+            self.path_builder.push_str("::")
+        }
+        self.path_builder.push_str(string);
+        path_len
+    }
+
+    // Pops the given name.
+    fn pop_name(&mut self, old_len: uint) {
+        // XXX(pcwalton): There's no safe function to do this. :(
+        unsafe {
+            str::raw::set_len(self.path_builder, old_len)
+        }
+    }
+
+    fn process_item_and_pop_name(&mut self,
+                                 doc: ebml::Doc,
+                                 def_id: ast::def_id,
+                                 old_len: uint)
+                                 -> bool {
+        let def_like = item_to_def_like(doc, def_id, self.cdata.cnum);
+        match def_like {
+            dl_def(def) => {
+                debug!("(iterating over each item of a module) processing \
+                        `%s` (def %?)",
+                       *self.path_builder,
+                       def);
+            }
+            _ => {
+                debug!("(iterating over each item of a module) processing \
+                        `%s` (%d:%d)",
+                       *self.path_builder,
+                       def_id.crate,
+                       def_id.node);
             }
         }
 
-        // If this is a module, find the reexports.
-        for each_reexport(item_doc) |reexport_doc| {
-            let def_id_doc =
-                reader::get_doc(reexport_doc,
-                                tag_items_data_item_reexport_def_id);
-            let def_id = reader::with_doc_data(def_id_doc, parse_def_id);
-            let def_id = translate_def_id(cdata, def_id);
-
-            let reexport_name_doc =
-                reader::get_doc(reexport_doc,
-                                tag_items_data_item_reexport_name);
-            let reexport_name = reexport_name_doc.as_str_slice();
-
-            let reexport_path;
-            if path_is_empty {
-                reexport_path = reexport_name.to_owned();
+        let vis = item_visibility(doc);
+
+        let mut continue = (self.callback)(*self.path_builder, def_like, vis);
+
+        let family = item_family(doc);
+        if family == ForeignMod {
+            // These are unnamed; pop the name now.
+            self.pop_name(old_len)
+        }
+
+        if continue {
+            // Recurse if necessary.
+            match family {
+                Mod | ForeignMod | Trait | Impl => {
+                    continue = self.each_item_of_module(def_id);
+                }
+                Freeze | Struct | UnsafeFn | Fn | PureFn | ForeignFn |
+                UnsafeStaticMethod | StaticMethod | PureStaticMethod | Type |
+                ForeignType | Variant | Enum | PublicField | PrivateField |
+                InheritedField => {}
+            }
+        }
+
+        if family != ForeignMod {
+            self.pop_name(old_len)
+        }
+
+        continue
+    }
+
+    fn each_item_of_module(&mut self, def_id: ast::def_id) -> bool {
+        // This item might not be in this crate. If it's not, look it up.
+        let (cdata, items) = if def_id.crate == self.cdata.cnum {
+            let items = reader::get_doc(reader::Doc(self.cdata.data),
+                                        tag_items);
+            (self.cdata, items)
+        } else {
+            let crate_data = (self.get_crate_data)(def_id.crate);
+            let root = reader::Doc(crate_data.data);
+            (crate_data, reader::get_doc(root, tag_items))
+        };
+
+        // Look up the item.
+        let item_doc = match maybe_find_item(def_id.node, items) {
+            None => return false,
+            Some(item_doc) => item_doc,
+        };
+
+        self.each_child_of_module_or_crate(item_doc)
+    }
+
+    fn each_child_of_module_or_crate(&mut self, item_doc: ebml::Doc) -> bool {
+        let mut continue = true;
+
+        // Iterate over all children.
+        for reader::tagged_docs(item_doc, tag_mod_child) |child_info_doc| {
+            let child_def_id = reader::with_doc_data(child_info_doc,
+                                                     parse_def_id);
+            let child_def_id = translate_def_id(self.cdata, child_def_id);
+
+            // This item may be in yet another crate, if it was the child of
+            // a reexport.
+            let other_crates_items = if child_def_id.crate ==
+                    self.cdata.cnum {
+                reader::get_doc(reader::Doc(self.cdata.data), tag_items)
             } else {
-                reexport_path = path + "::" + reexport_name;
+                let crate_data = (self.get_crate_data)(child_def_id.crate);
+                let root = reader::Doc(crate_data.data);
+                reader::get_doc(root, tag_items)
+            };
+
+            debug!("(iterating over each item of a module) looking up item \
+                    %d:%d in `%s`, crate %d",
+                   child_def_id.crate,
+                   child_def_id.node,
+                   *self.path_builder,
+                   self.cdata.cnum);
+
+            // Get the item.
+            match maybe_find_item(child_def_id.node, other_crates_items) {
+                None => {}
+                Some(child_item_doc) => {
+                    // Push the name.
+                    let child_name = item_name(self.intr, child_item_doc);
+                    debug!("(iterating over each item of a module) pushing \
+                            name `%s` onto `%s`",
+                           token::ident_to_str(&child_name),
+                           *self.path_builder);
+                    let old_len =
+                        self.push_name(token::ident_to_str(&child_name));
+
+                    // Process this item.
+                    continue = self.process_item_and_pop_name(child_item_doc,
+                                                              child_def_id,
+                                                              old_len);
+
+                    if !continue {
+                        break
+                    }
+                }
             }
+        }
+
+        if !continue {
+            return false
+        }
 
-            // This reexport may be in yet another crate
-            let other_crates_items = if def_id.crate == cdata.cnum {
-                items
+        // Iterate over reexports.
+        for each_reexport(item_doc) |reexport_doc| {
+            let def_id_doc = reader::get_doc(
+                reexport_doc,
+                tag_items_data_item_reexport_def_id);
+            let orig_def_id = reader::with_doc_data(def_id_doc, parse_def_id);
+
+            // NB: was "cdata"
+            let def_id = translate_def_id(self.cdata, orig_def_id);
+
+            let name_doc = reader::get_doc(reexport_doc,
+                                           tag_items_data_item_reexport_name);
+            let name = name_doc.as_str_slice();
+
+            // Push the name.
+            debug!("(iterating over each item of a module) pushing \
+                    reexported name `%s` onto `%s` (crate %d, orig %d, \
+                    in crate %d)",
+                   name,
+                   *self.path_builder,
+                   def_id.crate,
+                   orig_def_id.crate,
+                   self.cdata.cnum);
+            let old_len = self.push_name(name);
+
+            // This reexport may be in yet another crate.
+            let other_crates_items = if def_id.crate == self.cdata.cnum {
+                reader::get_doc(reader::Doc(self.cdata.data), tag_items)
             } else {
-                let crate_data = get_crate_data(def_id.crate);
+                let crate_data = (self.get_crate_data)(def_id.crate);
                 let root = reader::Doc(crate_data.data);
                 reader::get_doc(root, tag_items)
             };
@@ -523,29 +651,53 @@ pub fn each_path(intr: @ident_interner,
             // Get the item.
             match maybe_find_item(def_id.node, other_crates_items) {
                 None => {}
-                Some(item_doc) => {
-                    // Construct the def for this item.
-                    let def_like = item_to_def_like(item_doc,
-                                                    def_id,
-                                                    cdata.cnum);
-
-                    // Hand the information off to the iteratee.
-                    debug!("(each_path) yielding reexported \
-                           item: %s", reexport_path);
-
-                    if (!f(reexport_path, def_like, ast::public)) {
-                        return false;
-                    }
+                Some(reexported_item_doc) => {
+                    continue = self.process_item_and_pop_name(
+                        reexported_item_doc,
+                        def_id,
+                        old_len);
                 }
             }
+
+            if !continue {
+                break
+            }
         }
+
+        continue
     }
+}
 
-    return true;
+/// Iterates over all the paths in the given crate.
+pub fn each_path(intr: @ident_interner,
+                 cdata: cmd,
+                 get_crate_data: GetCrateDataCb,
+                 f: &fn(&str, def_like, ast::visibility) -> bool)
+                 -> bool {
+    // FIXME #4572: This function needs to be nuked, as it's impossible to
+    // make fast. It's the source of most of the performance problems when
+    // compiling small crates.
+
+    let root_doc = reader::Doc(cdata.data);
+    let misc_info_doc = reader::get_doc(root_doc, tag_misc_info);
+    let crate_items_doc = reader::get_doc(misc_info_doc,
+                                          tag_misc_info_crate_items);
+
+    let mut path_builder = ~"";
+
+    let mut context = EachItemContext {
+        intr: intr,
+        cdata: cdata,
+        get_crate_data: get_crate_data,
+        path_builder: &mut path_builder,
+        callback: f,
+    };
+
+    // Iterate over all top-level crate items.
+    context.each_child_of_module_or_crate(crate_items_doc)
 }
 
-pub fn get_item_path(cdata: cmd, id: ast::node_id)
-    -> ast_map::path {
+pub fn get_item_path(cdata: cmd, id: ast::node_id) -> ast_map::path {
     item_path(lookup_item(id, cdata.data))
 }
 
@@ -661,35 +813,20 @@ fn item_impl_methods(intr: @ident_interner, cdata: cmd, item: ebml::Doc,
     rslt
 }
 
-pub fn get_impls_for_mod(intr: @ident_interner,
-                         cdata: cmd,
-                         m_id: ast::node_id,
-                         name: Option<ast::ident>,
-                         get_cdata: &fn(ast::crate_num) -> cmd)
-                      -> @~[@resolve::Impl] {
+/// Returns information about the given implementation.
+pub fn get_impl(intr: @ident_interner, cdata: cmd, impl_id: ast::node_id)
+                -> resolve::Impl {
     let data = cdata.data;
-    let mod_item = lookup_item(m_id, data);
-    let mut result = ~[];
-    for reader::tagged_docs(mod_item, tag_mod_impl) |doc| {
-        let did = reader::with_doc_data(doc, parse_def_id);
-        let local_did = translate_def_id(cdata, did);
-        debug!("(get impls for mod) getting did %? for '%?'",
-               local_did, name);
-          // The impl may be defined in a different crate. Ask the caller
-          // to give us the metadata
-        let impl_cdata = get_cdata(local_did.crate);
-        let impl_data = impl_cdata.data;
-        let item = lookup_item(local_did.node, impl_data);
-        let nm = item_name(intr, item);
-        if match name { Some(n) => { n == nm } None => { true } } {
-           let base_tps = item_ty_param_count(item);
-           result.push(@resolve::Impl {
-                did: local_did, ident: nm,
-                methods: item_impl_methods(intr, impl_cdata, item, base_tps)
-            });
-        };
+    let impl_item = lookup_item(impl_id, data);
+    let base_tps = item_ty_param_count(impl_item);
+    resolve::Impl {
+        did: ast::def_id {
+            crate: cdata.cnum,
+            node: impl_id,
+        },
+        ident: item_name(intr, impl_item),
+        methods: item_impl_methods(intr, cdata, impl_item, base_tps),
     }
-    @result
 }
 
 pub fn get_method_name_and_explicit_self(
diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs
index 5ff52b1859a..187f2a99ed4 100644
--- a/src/librustc/metadata/encoder.rs
+++ b/src/librustc/metadata/encoder.rs
@@ -22,7 +22,7 @@ use middle;
 use util::ppaux::ty_to_str;
 
 use core::hash::HashUtil;
-use core::hashmap::HashMap;
+use core::hashmap::{HashMap, HashSet};
 use core::int;
 use core::io;
 use core::str;
@@ -64,7 +64,8 @@ pub struct EncodeParams<'self> {
     discrim_symbols: &'self HashMap<ast::node_id, @str>,
     link_meta: &'self LinkMeta,
     cstore: @mut cstore::CStore,
-    encode_inlined_item: encode_inlined_item<'self>
+    encode_inlined_item: encode_inlined_item<'self>,
+    reachable: @mut HashSet<ast::node_id>,
 }
 
 struct Stats {
@@ -73,6 +74,7 @@ struct Stats {
     dep_bytes: uint,
     lang_item_bytes: uint,
     link_args_bytes: uint,
+    misc_bytes: uint,
     item_bytes: uint,
     index_bytes: uint,
     zero_bytes: uint,
@@ -91,7 +93,8 @@ pub struct EncodeContext<'self> {
     link_meta: &'self LinkMeta,
     cstore: &'self cstore::CStore,
     encode_inlined_item: encode_inlined_item<'self>,
-    type_abbrevs: abbrev_map
+    type_abbrevs: abbrev_map,
+    reachable: @mut HashSet<ast::node_id>,
 }
 
 pub fn reachable(ecx: &EncodeContext, id: node_id) -> bool {
@@ -470,12 +473,77 @@ fn encode_reexported_static_methods(ecx: &EncodeContext,
     }
 }
 
+/// Iterates through "auxiliary node IDs", which are node IDs that describe
+/// top-level items that are sub-items of the given item. Specifically:
+///
+/// * For enums, iterates through the node IDs of the variants.
+///
+/// * For newtype structs, iterates through the node ID of the constructor.
+fn each_auxiliary_node_id(item: @item, callback: &fn(node_id) -> bool)
+                          -> bool {
+    let mut continue = true;
+    match item.node {
+        item_enum(ref enum_def, _) => {
+            for enum_def.variants.each |variant| {
+                continue = callback(variant.node.id);
+                if !continue {
+                    break
+                }
+            }
+        }
+        item_struct(struct_def, _) => {
+            // If this is a newtype struct, return the constructor.
+            match struct_def.ctor_id {
+                Some(ctor_id) if struct_def.fields.len() > 0 &&
+                        struct_def.fields[0].node.kind ==
+                        ast::unnamed_field => {
+                    continue = callback(ctor_id);
+                }
+                _ => {}
+            }
+        }
+        _ => {}
+    }
+
+    continue
+}
+
+fn encode_reexports(ecx: &EncodeContext,
+                    ebml_w: &mut writer::Encoder,
+                    id: node_id,
+                    path: &[ast_map::path_elt]) {
+    debug!("(encoding info for module) encoding reexports for %d", id);
+    match ecx.reexports2.find(&id) {
+        Some(ref exports) => {
+            debug!("(encoding info for module) found reexports for %d", id);
+            for exports.each |exp| {
+                debug!("(encoding info for module) reexport '%s' for %d",
+                       exp.name, id);
+                ebml_w.start_tag(tag_items_data_item_reexport);
+                ebml_w.start_tag(tag_items_data_item_reexport_def_id);
+                ebml_w.wr_str(def_to_str(exp.def_id));
+                ebml_w.end_tag();
+                ebml_w.start_tag(tag_items_data_item_reexport_name);
+                ebml_w.wr_str(exp.name);
+                ebml_w.end_tag();
+                ebml_w.end_tag();
+                encode_reexported_static_methods(ecx, ebml_w, path, exp);
+            }
+        }
+        None => {
+            debug!("(encoding info for module) found no reexports for %d",
+                   id);
+        }
+    }
+}
+
 fn encode_info_for_mod(ecx: &EncodeContext,
                        ebml_w: &mut writer::Encoder,
                        md: &_mod,
                        id: node_id,
                        path: &[ast_map::path_elt],
-                       name: ident) {
+                       name: ident,
+                       vis: visibility) {
     ebml_w.start_tag(tag_items_data_item);
     encode_def_id(ebml_w, local_def(id));
     encode_family(ebml_w, 'm');
@@ -484,6 +552,16 @@ fn encode_info_for_mod(ecx: &EncodeContext,
 
     // Encode info about all the module children.
     for md.items.iter().advance |item| {
+        ebml_w.start_tag(tag_mod_child);
+        ebml_w.wr_str(def_to_str(local_def(item.id)));
+        ebml_w.end_tag();
+
+        for each_auxiliary_node_id(*item) |auxiliary_node_id| {
+            ebml_w.start_tag(tag_mod_child);
+            ebml_w.wr_str(def_to_str(local_def(auxiliary_node_id)));
+            ebml_w.end_tag();
+        }
+
         match item.node {
             item_impl(*) => {
                 let (ident, did) = (item.ident, item.id);
@@ -497,35 +575,16 @@ fn encode_info_for_mod(ecx: &EncodeContext,
                 ebml_w.wr_str(def_to_str(local_def(did)));
                 ebml_w.end_tag();
             }
-            _ => {} // FIXME #4573: Encode these too.
+            _ => {}
         }
     }
 
     encode_path(ecx, ebml_w, path, ast_map::path_mod(name));
 
-    // Encode the reexports of this module.
-    debug!("(encoding info for module) encoding reexports for %d", id);
-    match ecx.reexports2.find(&id) {
-        Some(ref exports) => {
-            debug!("(encoding info for module) found reexports for %d", id);
-            for exports.iter().advance |exp| {
-                debug!("(encoding info for module) reexport '%s' for %d",
-                       exp.name, id);
-                ebml_w.start_tag(tag_items_data_item_reexport);
-                ebml_w.start_tag(tag_items_data_item_reexport_def_id);
-                ebml_w.wr_str(def_to_str(exp.def_id));
-                ebml_w.end_tag();
-                ebml_w.start_tag(tag_items_data_item_reexport_name);
-                ebml_w.wr_str(exp.name);
-                ebml_w.end_tag();
-                ebml_w.end_tag();
-                encode_reexported_static_methods(ecx, ebml_w, path, exp);
-            }
-        }
-        None => {
-            debug!("(encoding info for module) found no reexports for %d",
-                   id);
-        }
+    // Encode the reexports of this module, if this module is public.
+    if vis == public {
+        debug!("(encoding info for module) encoding reexports for %d", id);
+        encode_reexports(ecx, ebml_w, id, path);
     }
 
     ebml_w.end_tag();
@@ -799,6 +858,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
         }
         encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
         encode_symbol(ecx, ebml_w, item.id);
+        encode_name(ecx, ebml_w, item.ident);
         encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
         (ecx.encode_inlined_item)(ecx, ebml_w, path, ii_item(item));
         ebml_w.end_tag();
@@ -811,6 +871,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
         let tps_len = generics.ty_params.len();
         encode_type_param_bounds(ebml_w, ecx, &generics.ty_params);
         encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
+        encode_name(ecx, ebml_w, item.ident);
         encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
         encode_attributes(ebml_w, item.attrs);
         if tps_len > 0u || should_inline(item.attrs) {
@@ -822,15 +883,29 @@ fn encode_info_for_item(ecx: &EncodeContext,
       }
       item_mod(ref m) => {
         add_to_index();
-        encode_info_for_mod(ecx, ebml_w, m, item.id, path, item.ident);
+        encode_info_for_mod(ecx,
+                            ebml_w,
+                            m,
+                            item.id,
+                            path,
+                            item.ident,
+                            item.vis);
       }
-      item_foreign_mod(_) => {
+      item_foreign_mod(ref fm) => {
         add_to_index();
         ebml_w.start_tag(tag_items_data_item);
         encode_def_id(ebml_w, local_def(item.id));
         encode_family(ebml_w, 'n');
         encode_name(ecx, ebml_w, item.ident);
         encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
+
+        // Encode all the items in this module.
+        for fm.items.each |foreign_item| {
+            ebml_w.start_tag(tag_mod_child);
+            ebml_w.wr_str(def_to_str(local_def(foreign_item.id)));
+            ebml_w.end_tag();
+        }
+
         ebml_w.end_tag();
       }
       item_ty(_, ref generics) => {
@@ -998,6 +1073,10 @@ fn encode_info_for_item(ecx: &EncodeContext,
             ebml_w.start_tag(tag_item_trait_method);
             encode_def_id(ebml_w, method_def_id);
             ebml_w.end_tag();
+
+            ebml_w.start_tag(tag_mod_child);
+            ebml_w.wr_str(def_to_str(method_def_id));
+            ebml_w.end_tag();
         }
         encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
         for super_traits.iter().advance |ast_trait_ref| {
@@ -1091,6 +1170,7 @@ fn encode_info_for_foreign_item(ecx: &EncodeContext,
         encode_family(ebml_w, purity_fn_family(purity));
         encode_type_param_bounds(ebml_w, ecx, &generics.ty_params);
         encode_type(ecx, ebml_w, node_id_to_type(ecx.tcx, nitem.id));
+        encode_name(ecx, ebml_w, nitem.ident);
         if abi.is_intrinsic() {
             (ecx.encode_inlined_item)(ecx, ebml_w, path, ii_foreign(nitem));
         } else {
@@ -1107,6 +1187,7 @@ fn encode_info_for_foreign_item(ecx: &EncodeContext,
         }
         encode_type(ecx, ebml_w, node_id_to_type(ecx.tcx, nitem.id));
         encode_symbol(ecx, ebml_w, nitem.id);
+        encode_name(ecx, ebml_w, nitem.ident);
         encode_path(ecx, ebml_w, path, ast_map::path_name(nitem.ident));
       }
     }
@@ -1120,9 +1201,13 @@ fn encode_info_for_items(ecx: &EncodeContext,
     let index = @mut ~[];
     ebml_w.start_tag(tag_items_data);
     index.push(entry { val: crate_node_id, pos: ebml_w.writer.tell() });
-    encode_info_for_mod(ecx, ebml_w, &crate.node.module,
-                        crate_node_id, [],
-                        syntax::parse::token::special_idents::invalid);
+    encode_info_for_mod(ecx,
+                        ebml_w,
+                        &crate.node.module,
+                        crate_node_id,
+                        [],
+                        syntax::parse::token::special_idents::invalid,
+                        public);
     let items = ecx.tcx.items;
 
     // See comment in `encode_side_tables_for_ii` in astencode
@@ -1416,6 +1501,30 @@ fn encode_link_args(ecx: &EncodeContext, ebml_w: &mut writer::Encoder) {
     ebml_w.end_tag();
 }
 
+fn encode_misc_info(ecx: &EncodeContext,
+                    crate: &crate,
+                    ebml_w: &mut writer::Encoder) {
+    ebml_w.start_tag(tag_misc_info);
+    ebml_w.start_tag(tag_misc_info_crate_items);
+    for crate.node.module.items.each |&item| {
+        ebml_w.start_tag(tag_mod_child);
+        ebml_w.wr_str(def_to_str(local_def(item.id)));
+        ebml_w.end_tag();
+
+        for each_auxiliary_node_id(item) |auxiliary_node_id| {
+            ebml_w.start_tag(tag_mod_child);
+            ebml_w.wr_str(def_to_str(local_def(auxiliary_node_id)));
+            ebml_w.end_tag();
+        }
+    }
+
+    // Encode reexports for the root module.
+    encode_reexports(ecx, ebml_w, 0, []);
+
+    ebml_w.end_tag();
+    ebml_w.end_tag();
+}
+
 fn encode_crate_dep(ecx: &EncodeContext,
                     ebml_w: &mut writer::Encoder,
                     dep: decoder::crate_dep) {
@@ -1455,15 +1564,25 @@ pub fn encode_metadata(parms: EncodeParams, crate: &crate) -> ~[u8] {
         dep_bytes: 0,
         lang_item_bytes: 0,
         link_args_bytes: 0,
+        misc_bytes: 0,
         item_bytes: 0,
         index_bytes: 0,
         zero_bytes: 0,
         total_bytes: 0,
         n_inlines: 0
     };
-    let EncodeParams{item_symbols, diag, tcx, reexports2,
-                     discrim_symbols, cstore, encode_inlined_item,
-                     link_meta, _} = parms;
+    let EncodeParams {
+        item_symbols,
+        diag,
+        tcx,
+        reexports2,
+        discrim_symbols,
+        cstore,
+        encode_inlined_item,
+        link_meta,
+        reachable,
+        _
+    } = parms;
     let type_abbrevs = @mut HashMap::new();
     let stats = @mut stats;
     let ecx = EncodeContext {
@@ -1476,7 +1595,8 @@ pub fn encode_metadata(parms: EncodeParams, crate: &crate) -> ~[u8] {
         link_meta: link_meta,
         cstore: cstore,
         encode_inlined_item: encode_inlined_item,
-        type_abbrevs: type_abbrevs
+        type_abbrevs: type_abbrevs,
+        reachable: reachable,
      };
 
     let mut ebml_w = writer::Encoder(wr as @io::Writer);
@@ -1502,6 +1622,11 @@ pub fn encode_metadata(parms: EncodeParams, crate: &crate) -> ~[u8] {
     encode_link_args(&ecx, &mut ebml_w);
     ecx.stats.link_args_bytes = *wr.pos - i;
 
+    // Encode miscellaneous info.
+    i = *wr.pos;
+    encode_misc_info(&ecx, crate, &mut ebml_w);
+    ecx.stats.misc_bytes = *wr.pos - i;
+
     // Encode and index the items.
     ebml_w.start_tag(tag_items);
     i = *wr.pos;
@@ -1529,6 +1654,7 @@ pub fn encode_metadata(parms: EncodeParams, crate: &crate) -> ~[u8] {
         io::println(fmt!("       dep bytes: %u", ecx.stats.dep_bytes));
         io::println(fmt!(" lang item bytes: %u", ecx.stats.lang_item_bytes));
         io::println(fmt!(" link args bytes: %u", ecx.stats.link_args_bytes));
+        io::println(fmt!("      misc bytes: %u", ecx.stats.misc_bytes));
         io::println(fmt!("      item bytes: %u", ecx.stats.item_bytes));
         io::println(fmt!("     index bytes: %u", ecx.stats.index_bytes));
         io::println(fmt!("      zero bytes: %u", ecx.stats.zero_bytes));