rustc_metadata: Do not encode unnecessary module children

compiler/rustc_data_structures/src/lib.rs

@@ -14,6 +14,8 @@
 #![feature(control_flow_enum)]
 #![feature(core_intrinsics)]
 #![feature(extend_one)]
+#![feature(generator_trait)]
+#![feature(generators)]
 #![feature(let_else)]
 #![feature(hash_raw_entry)]
 #![feature(maybe_uninit_uninit_array)]
@@ -113,6 +115,9 @@ pub mod unhash;
 pub use ena::undo_log;
 pub use ena::unify;
 
+use std::ops::{Generator, GeneratorState};
+use std::pin::Pin;
+
 pub struct OnDrop<F: Fn()>(pub F);
 
 impl<F: Fn()> OnDrop<F> {
@@ -131,6 +136,26 @@ impl<F: Fn()> Drop for OnDrop<F> {
     }
 }
 
+struct IterFromGenerator<G>(G);
+
+impl<G: Generator<Return = ()> + Unpin> Iterator for IterFromGenerator<G> {
+    type Item = G::Yield;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match Pin::new(&mut self.0).resume(()) {
+            GeneratorState::Yielded(n) => Some(n),
+            GeneratorState::Complete(_) => None,
+        }
+    }
+}
+
+/// An adapter for turning a generator closure into an iterator, similar to `iter::from_fn`.
+pub fn iter_from_generator<G: Generator<Return = ()> + Unpin>(
+    generator: G,
+) -> impl Iterator<Item = G::Yield> {
+    IterFromGenerator(generator)
+}
+
 // See comments in src/librustc_middle/lib.rs
 #[doc(hidden)]
 pub fn __noop_fix_for_27438() {}

compiler/rustc_metadata/src/lib.rs

@@ -1,6 +1,7 @@
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![feature(crate_visibility_modifier)]
 #![feature(drain_filter)]
+#![feature(generators)]
 #![feature(let_else)]
 #![feature(nll)]
 #![feature(once_cell)]

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -1089,7 +1089,7 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
         // Iterate over all children.
         if let Some(children) = self.root.tables.children.get(self, id) {
             for child_index in children.decode((self, sess)) {
-                if let Some(ident) = self.opt_item_ident(child_index, sess) {
+                let ident = self.item_ident(child_index, sess);
                 let kind = self.def_kind(child_index);
                 let def_id = self.local_def_id(child_index);
                 let res = Res::Def(kind, def_id);
@@ -1146,19 +1146,12 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
                                 vis = ty::Visibility::Restricted(crate_def_id);
                             }
                         }
-                            callback(ModChild {
+                        callback(ModChild { ident, res: ctor_res, vis, span, macro_rules: false });
-                                ident,
-                                res: ctor_res,
-                                vis,
-                                span,
-                                macro_rules: false,
-                            });
                     }
                     _ => {}
                 }
             }
         }
-        }
 
         match self.kind(id) {
             EntryKind::Mod(exports) => {

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -4,6 +4,7 @@ use crate::rmeta::*;
 
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::fx::{FxHashMap, FxIndexSet};
+use rustc_data_structures::iter_from_generator;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::sync::{join, par_iter, Lrc, ParallelIterator};
 use rustc_hir as hir;
@@ -1107,21 +1108,26 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             // Encode this here because we don't do it in encode_def_ids.
             record!(self.tables.expn_that_defined[def_id] <- tcx.expn_that_defined(local_def_id));
         } else {
-            let direct_children = md.item_ids.iter().map(|item_id| item_id.def_id.local_def_index);
+            record!(self.tables.children[def_id] <- iter_from_generator(|| {
-            // Foreign items are planted into their parent modules from name resolution point of view.
+                for item_id in md.item_ids {
-            let tcx = self.tcx;
+                    match tcx.hir().item(*item_id).kind {
-            let foreign_item_children = md
+                        // Foreign items are planted into their parent modules
-                .item_ids
+                        // from name resolution point of view.
-                .iter()
-                .filter_map(|item_id| match tcx.hir().item(*item_id).kind {
                         hir::ItemKind::ForeignMod { items, .. } => {
-                        Some(items.iter().map(|fi_ref| fi_ref.id.def_id.local_def_index))
+                            for foreign_item in items {
+                                yield foreign_item.id.def_id.local_def_index;
                             }
-                    _ => None,
+                        }
-                })
+                        // Only encode named non-reexport children, reexports are encoded
-                .flatten();
+                        // separately and unnamed items are not used by name resolution.
-
+                        hir::ItemKind::ExternCrate(..) => continue,
-            record!(self.tables.children[def_id] <- direct_children.chain(foreign_item_children));
+                        _ if tcx.def_key(item_id.def_id.to_def_id()).get_opt_name().is_some() => {
+                            yield item_id.def_id.local_def_index;
+                        }
+                        _ => continue,
+                    }
+                }
+            }));
         }
     }