Refactor how the prelude is handled

Author: jseyfried

src/librustc_resolve/build_reduced_graph.rs

@@ -664,11 +664,12 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
                 module_.increment_outstanding_references_for(target, ValueNS, is_public);
                 module_.increment_outstanding_references_for(target, TypeNS, is_public);
             }
-            GlobImport => {
+            GlobImport if !is_prelude => {
                 // Set the glob flag. This tells us that we don't know the
                 // module's exports ahead of time.
                 module_.inc_glob_count(is_public)
             }
+            _ => {}
         }
 
         let directive =

src/librustc_resolve/lib.rs

@@ -830,6 +830,7 @@ pub struct ModuleS<'a> {
     // entry block for `f`.
     module_children: RefCell<NodeMap<Module<'a>>>,
 
+    prelude: RefCell<Option<Module<'a>>>,
     shadowed_traits: RefCell<Vec<&'a NameBinding<'a>>>,
 
     glob_importers: RefCell<Vec<(Module<'a>, &'a ImportDirective)>>,
@@ -865,6 +866,7 @@ impl<'a> ModuleS<'a> {
             resolutions: RefCell::new(HashMap::new()),
             unresolved_imports: RefCell::new(Vec::new()),
             module_children: RefCell::new(NodeMap()),
+            prelude: RefCell::new(None),
             shadowed_traits: RefCell::new(Vec::new()),
             glob_importers: RefCell::new(Vec::new()),
             resolved_globs: RefCell::new((Vec::new(), Vec::new())),
@@ -3403,34 +3405,36 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                 None => {} // Nothing to do.
             }
 
-            // Look for trait children.
-            build_reduced_graph::populate_module_if_necessary(self, &search_module);
+            // Look for shadowed traits.
+            for binding in search_module.shadowed_traits.borrow().iter() {
+                let did = binding.def().unwrap().def_id();
+                if self.trait_item_map.contains_key(&(name, did)) {
+                    add_trait_info(&mut found_traits, did, name);
+                    let trait_name = self.get_trait_name(did);
+                    self.record_use(trait_name, TypeNS, binding);
+                }
+            }
 
-            search_module.for_each_child(|_, ns, name_binding| {
+            // Look for trait children.
+            let mut search_in_module = |module: Module<'a>| module.for_each_child(|_, ns, binding| {
                 if ns != TypeNS { return }
-                let trait_def_id = match name_binding.def() {
+                let trait_def_id = match binding.def() {
                     Some(Def::Trait(trait_def_id)) => trait_def_id,
                     Some(..) | None => return,
                 };
                 if self.trait_item_map.contains_key(&(name, trait_def_id)) {
                     add_trait_info(&mut found_traits, trait_def_id, name);
                     let trait_name = self.get_trait_name(trait_def_id);
-                    self.record_use(trait_name, TypeNS, name_binding);
-                }
-            });
-
-            // Look for shadowed traits.
-            for binding in search_module.shadowed_traits.borrow().iter() {
-                let did = binding.def().unwrap().def_id();
-                if self.trait_item_map.contains_key(&(name, did)) {
-                    add_trait_info(&mut found_traits, did, name);
-                    let trait_name = self.get_trait_name(did);
                     self.record_use(trait_name, TypeNS, binding);
                 }
-            }
+            });
+            search_in_module(search_module);
 
             match search_module.parent_link {
-                NoParentLink | ModuleParentLink(..) => break,
+                NoParentLink | ModuleParentLink(..) => {
+                    search_module.prelude.borrow().map(search_in_module);
+                    break;
+                }
                 BlockParentLink(parent_module, _) => {
                     search_module = parent_module;
                 }

src/librustc_resolve/resolve_imports.rs

@@ -98,9 +98,6 @@ impl ImportDirective {
         if let GlobImport = self.subclass {
             modifiers = modifiers | DefModifiers::GLOB_IMPORTED;
         }
-        if self.is_prelude {
-            modifiers = modifiers | DefModifiers::PRELUDE;
-        }
 
         NameBinding {
             kind: NameBindingKind::Import {
@@ -233,7 +230,8 @@ impl<'a> ::ModuleS<'a> {
             }
         }
 
-        resolution.result(true)
+        self.prelude.borrow().map(|prelude| prelude.resolve_name(name, ns, false))
+                             .unwrap_or(Failed(None))
     }
 
     // Define the name or return the existing binding if there is a collision.
@@ -607,6 +605,11 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
         }
         build_reduced_graph::populate_module_if_necessary(self.resolver, target_module);
 
+        if directive.is_prelude {
+            *module_.prelude.borrow_mut() = Some(target_module);
+            return Success(());
+        }
+
         // Add to target_module's glob_importers and module_'s resolved_globs
         target_module.glob_importers.borrow_mut().push((module_, directive));
         match *module_.resolved_globs.borrow_mut() {