1 files changed, 82 insertions, 34 deletions
diff --git a/crates/ra_hir/src/resolve.rs b/crates/ra_hir/src/resolve.rs
index b7fbf6df2..36daed65b 100644
--- a/crates/ra_hir/src/resolve.rs
+++ b/crates/ra_hir/src/resolve.rs
@@ -1,30 +1,29 @@
-#![allow(unused_variables, dead_code)]
 //! Name resolution.
 use std::sync::Arc;
 use rustc_hash::FxHashMap;
 use crate::{
-    ModuleDef,
+    ModuleDef, Module,
-    name::Name,
+    db::HirDatabase,
-    nameres::{PerNs, lower::ImportId, ItemMap},
+    name::{Name, KnownName},
-    module_tree::ModuleId,
+    nameres::{PerNs, ItemMap},
    generics::GenericParams,
-    expr::{Body, scope::{ExprScopes, ScopeId}, PatId},
+    expr::{scope::{ExprScopes, ScopeId}, PatId},
    impl_block::ImplBlock,
    path::Path,
 };
 #[derive(Debug, Clone, Default)]
 pub struct Resolver {
-    scopes: Vec<Scope>, // maybe a 'linked list' of scopes? or allow linking a Resolver to a parent Resolver? that's an optimization that might not be necessary, though
+    scopes: Vec<Scope>,
 }
 // TODO how to store these best
 #[derive(Debug, Clone)]
 pub(crate) struct ModuleItemMap {
    item_map: Arc<ItemMap>,
-    module_id: ModuleId,
+    module: Module,
 }
 #[derive(Debug, Clone)]
@@ -39,8 +38,6 @@ pub(crate) enum Scope {
    ModuleScope(ModuleItemMap),
    /// Brings the generic parameters of an item into scope
    GenericParams(Arc<GenericParams>),
-    /// Brings the function parameters into scope
-    FunctionParams(Arc<Body>),
    /// Brings `Self` into scope
    ImplBlockScope(ImplBlock),
    /// Local bindings
@@ -49,36 +46,64 @@ pub(crate) enum Scope {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Resolution {
+    // FIXME make these tuple variants
    /// An item
    Def {
        def: ModuleDef,
-        import: Option<ImportId>,
    },
    /// A local binding (only value namespace)
-    LocalBinding { pat: PatId },
+    LocalBinding {
+        pat: PatId,
+    },
    /// A generic parameter
-    GenericParam { idx: u32 },
+    GenericParam {
-    // TODO how does `Self` resolve?
+        idx: u32,
+    },
+    SelfType(ImplBlock),
 }
 impl Resolver {
    pub fn resolve_name(&self, name: &Name) -> PerNs<Resolution> {
+        let mut resolution = PerNs::none();
        for scope in self.scopes.iter().rev() {
-            let resolution = scope.resolve_name(name);
+            resolution = resolution.combine(scope.resolve_name(name));
-            if !resolution.is_none() {
+            if resolution.is_both() {
                return resolution;
            }
        }
-        PerNs::none()
+        resolution
    }
-    pub fn resolve_path(&self, path: &Path) -> PerNs<Resolution> {
+    pub fn resolve_path(&self, db: &impl HirDatabase, path: &Path) -> PerNs<Resolution> {
-        unimplemented!()
+        if let Some(name) = path.as_ident() {
+            self.resolve_name(name)
+        } else if path.is_self() {
+            self.resolve_name(&Name::self_param())
+        } else {
+            let (item_map, module) = match self.module() {
+                Some(m) => m,
+                _ => return PerNs::none(),
+            };
+            let module_res = item_map.resolve_path(db, module, path);
+            module_res.map(|def| Resolution::Def { def })
+        }
    }
    pub fn all_names(&self) -> FxHashMap<Name, Resolution> {
        unimplemented!()
    }
+    fn module(&self) -> Option<(&ItemMap, Module)> {
+        for scope in self.scopes.iter().rev() {
+            match scope {
+                Scope::ModuleScope(m) => {
+                    return Some((&m.item_map, m.module.clone()));
+                }
+                _ => {}
+            }
+        }
+        None
+    }
 }
 impl Resolver {
@@ -95,11 +120,8 @@ impl Resolver {
        self.push_scope(Scope::ImplBlockScope(impl_block))
    }
-    pub(crate) fn push_module_scope(self, item_map: Arc<ItemMap>, module_id: ModuleId) -> Resolver {
+    pub(crate) fn push_module_scope(self, item_map: Arc<ItemMap>, module: Module) -> Resolver {
-        self.push_scope(Scope::ModuleScope(ModuleItemMap {
+        self.push_scope(Scope::ModuleScope(ModuleItemMap { item_map, module }))
-            item_map,
-            module_id,
-        }))
    }
    pub(crate) fn push_expr_scope(
@@ -112,19 +134,45 @@ impl Resolver {
            scope_id,
        }))
    }
-    pub(crate) fn push_function_params(self, body: Arc<Body>) -> Resolver {
-        self.push_scope(Scope::FunctionParams(body))
-    }
-    pub(crate) fn pop_scope(mut self) -> Resolver {
-        self.scopes.pop();
-        self
-    }
 }
 impl Scope {
    fn resolve_name(&self, name: &Name) -> PerNs<Resolution> {
-        unimplemented!()
+        match self {
+            Scope::ModuleScope(m) => {
+                if let Some(KnownName::SelfParam) = name.as_known_name() {
+                    PerNs::types(Resolution::Def {
+                        def: m.module.into(),
+                    })
+                } else {
+                    match m.item_map[m.module.module_id].get(name) {
+                        Some(res) => res.def.map(|def| Resolution::Def { def }),
+                        None => PerNs::none(),
+                    }
+                }
+            }
+            Scope::GenericParams(gp) => match gp.find_by_name(name) {
+                Some(gp) => PerNs::types(Resolution::GenericParam { idx: gp.idx }),
+                None => PerNs::none(),
+            },
+            Scope::ImplBlockScope(i) => {
+                if name.as_known_name() == Some(KnownName::SelfType) {
+                    PerNs::types(Resolution::SelfType(i.clone()))
+                } else {
+                    PerNs::none()
+                }
+            }
+            Scope::ExprScope(e) => {
+                let entry = e
+                    .expr_scopes
+                    .entries(e.scope_id)
+                    .iter()
+                    .find(|entry| entry.name() == name);
+                match entry {
+                    Some(e) => PerNs::values(Resolution::LocalBinding { pat: e.pat() }),
+                    None => PerNs::none(),
+                }
+            }
+        }
    }
 }