From 2f24e740db3365afac56aad3e8a533340369ef7d Mon Sep 17 00:00:00 2001
From: Florian Diebold <flodiebold@gmail.com>
Date: Sun, 10 Feb 2019 16:19:50 +0100
Subject: Implement glob imports within the same crate

Fixes #231.
---
 crates/ra_hir/src/nameres.rs | 93 ++++++++++++++++++++++++++++++++++++--------
 1 file changed, 77 insertions(+), 16 deletions(-)

(limited to 'crates/ra_hir')

diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs
index 2442e754e..94f7db024 100644
--- a/crates/ra_hir/src/nameres.rs
+++ b/crates/ra_hir/src/nameres.rs
@@ -61,7 +61,7 @@ impl ModuleScope {
 
 /// `Resolution` is basically `DefId` atm, but it should account for stuff like
 /// multiple namespaces, ambiguity and errors.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub struct Resolution {
     /// None for unresolved
     pub def: PerNs<ModuleDef>,
@@ -154,6 +154,8 @@ struct Resolver<'a, DB> {
     krate: Crate,
     module_tree: Arc<ModuleTree>,
     processed_imports: FxHashSet<(ModuleId, ImportId)>,
+    /// If module `a` has `use b::*`, then this contains the mapping b -> a (and the import)
+    glob_imports: FxHashMap<ModuleId, Vec<(ModuleId, ImportId)>>,
     result: ItemMap,
 }
 
@@ -173,6 +175,7 @@ where
             krate,
             module_tree,
             processed_imports: FxHashSet::default(),
+            glob_imports: FxHashMap::default(),
             result: ItemMap::default(),
         }
     }
@@ -281,12 +284,28 @@ where
                         // glob import from other crate => we can just import everything once
                         let item_map = self.db.item_map(m.krate);
                         let scope = &item_map[m.module_id];
-                        self.update(module_id, |items| {
-                            // TODO: handle shadowing and visibility
-                            items.items.extend(
-                                scope.items.iter().map(|(name, res)| (name.clone(), res.clone())),
-                            );
-                        });
+                        let items = scope
+                            .items
+                            .iter()
+                            .map(|(name, res)| (name.clone(), res.clone()))
+                            .collect::<Vec<_>>();
+                        self.update(module_id, Some(import_id), &items);
+                    } else {
+                        // glob import from same crate => we do an initial
+                        // import, and then need to propagate any further
+                        // additions
+                        let scope = &self.result[m.module_id];
+                        let items = scope
+                            .items
+                            .iter()
+                            .map(|(name, res)| (name.clone(), res.clone()))
+                            .collect::<Vec<_>>();
+                        self.update(module_id, Some(import_id), &items);
+                        // record the glob import in case we add further items
+                        self.glob_imports
+                            .entry(m.module_id)
+                            .or_default()
+                            .push((module_id, import_id));
                     }
                 }
                 Some(ModuleDef::Enum(e)) => {
@@ -304,9 +323,7 @@ where
                             Some((name, res))
                         })
                         .collect::<Vec<_>>();
-                    self.update(module_id, |items| {
-                        items.items.extend(resolutions);
-                    });
+                    self.update(module_id, Some(import_id), &resolutions);
                 }
                 Some(d) => {
                     log::debug!("glob import {:?} from non-module/enum {:?}", import, d);
@@ -328,17 +345,61 @@ where
                     }
                 }
             }
-            self.update(module_id, |items| {
-                let res = Resolution { def, import: Some(import_id) };
-                items.items.insert(name, res);
-            });
+            let resolution = Resolution { def, import: Some(import_id) };
+            self.update(module_id, None, &[(name, resolution)]);
         }
         reached_fixedpoint
     }
 
-    fn update(&mut self, module_id: ModuleId, f: impl FnOnce(&mut ModuleScope)) {
+    fn update(
+        &mut self,
+        module_id: ModuleId,
+        import: Option<ImportId>,
+        resolutions: &[(Name, Resolution)],
+    ) {
+        self.update_recursive(module_id, import, resolutions, 0)
+    }
+
+    fn update_recursive(
+        &mut self,
+        module_id: ModuleId,
+        import: Option<ImportId>,
+        resolutions: &[(Name, Resolution)],
+        depth: usize,
+    ) {
+        if depth > 100 {
+            // prevent stack overflows (but this shouldn't be possible)
+            panic!("infinite recursion in glob imports!");
+        }
         let module_items = self.result.per_module.get_mut(module_id).unwrap();
-        f(module_items)
+        let mut changed = false;
+        for (name, res) in resolutions {
+            let existing = module_items.items.entry(name.clone()).or_default();
+            if existing.def.types.is_none() && res.def.types.is_some() {
+                existing.def.types = res.def.types;
+                existing.import = import.or(res.import);
+                changed = true;
+            }
+            if existing.def.values.is_none() && res.def.values.is_some() {
+                existing.def.values = res.def.values;
+                existing.import = import.or(res.import);
+                changed = true;
+            }
+        }
+        if !changed {
+            return;
+        }
+        let glob_imports = self
+            .glob_imports
+            .get(&module_id)
+            .into_iter()
+            .flat_map(|v| v.iter())
+            .cloned()
+            .collect::<Vec<_>>();
+        for (glob_importing_module, glob_import) in glob_imports {
+            // We pass the glob import so that the tracked import in those modules is that glob import
+            self.update_recursive(glob_importing_module, Some(glob_import), resolutions, depth + 1);
+        }
     }
 }
 
-- 
cgit v1.2.3