1 files changed, 226 insertions, 0 deletions
diff --git a/crates/ra_hir/src/resolve.rs b/crates/ra_hir/src/resolve.rs
new file mode 100644
index 000000000..6c87d0df7
--- /dev/null
+++ b/crates/ra_hir/src/resolve.rs
@@ -0,0 +1,226 @@
+//! Name resolution.
+use std::sync::Arc;
+use rustc_hash::FxHashMap;
+use crate::{
+    ModuleDef, Module,
+    db::HirDatabase,
+    name::{Name, KnownName},
+    nameres::{PerNs, ItemMap},
+    generics::GenericParams,
+    expr::{scope::{ExprScopes, ScopeId}, PatId, Body},
+    impl_block::ImplBlock,
+    path::Path,
+};
+#[derive(Debug, Clone, Default)]
+pub struct Resolver {
+    scopes: Vec<Scope>,
+}
+// TODO how to store these best
+#[derive(Debug, Clone)]
+pub(crate) struct ModuleItemMap {
+    item_map: Arc<ItemMap>,
+    module: Module,
+}
+#[derive(Debug, Clone)]
+pub(crate) struct ExprScope {
+    expr_scopes: Arc<ExprScopes>,
+    scope_id: ScopeId,
+}
+#[derive(Debug, Clone)]
+pub(crate) enum Scope {
+    /// All the items and imported names of a module
+    ModuleScope(ModuleItemMap),
+    /// Brings the generic parameters of an item into scope
+    GenericParams(Arc<GenericParams>),
+    /// Brings `Self` into scope
+    ImplBlockScope(ImplBlock),
+    /// Local bindings
+    ExprScope(ExprScope),
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Resolution {
+    /// An item
+    Def(ModuleDef),
+    /// A local binding (only value namespace)
+    LocalBinding(PatId),
+    /// A generic parameter
+    GenericParam(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() {
+            resolution = resolution.combine(scope.resolve_name(name));
+            if resolution.is_both() {
+                return resolution;
+            }
+        }
+        resolution
+    }
+    pub fn resolve_path(&self, db: &impl HirDatabase, path: &Path) -> PerNs<Resolution> {
+        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, PerNs<Resolution>> {
+        let mut names = FxHashMap::default();
+        for scope in self.scopes.iter().rev() {
+            scope.collect_names(&mut |name, res| {
+                let current: &mut PerNs<Resolution> = names.entry(name).or_default();
+                if current.types.is_none() {
+                    current.types = res.types;
+                }
+                if current.values.is_none() {
+                    current.values = res.values;
+                }
+            });
+        }
+        names
+    }
+    fn module(&self) -> Option<(&ItemMap, Module)> {
+        self.scopes.iter().rev().find_map(|scope| match scope {
+            Scope::ModuleScope(m) => Some((&*m.item_map, m.module.clone())),
+            _ => None,
+        })
+    }
+    /// The body from which any `LocalBinding` resolutions in this resolver come.
+    pub fn body(&self) -> Option<Arc<Body>> {
+        self.scopes.iter().rev().find_map(|scope| match scope {
+            Scope::ExprScope(expr_scope) => Some(expr_scope.expr_scopes.body()),
+            _ => None,
+        })
+    }
+}
+impl Resolver {
+    pub(crate) fn push_scope(mut self, scope: Scope) -> Resolver {
+        self.scopes.push(scope);
+        self
+    }
+    pub(crate) fn push_generic_params_scope(self, params: Arc<GenericParams>) -> Resolver {
+        self.push_scope(Scope::GenericParams(params))
+    }
+    pub(crate) fn push_impl_block_scope(self, impl_block: ImplBlock) -> Resolver {
+        self.push_scope(Scope::ImplBlockScope(impl_block))
+    }
+    pub(crate) fn push_module_scope(self, item_map: Arc<ItemMap>, module: Module) -> Resolver {
+        self.push_scope(Scope::ModuleScope(ModuleItemMap { item_map, module }))
+    }
+    pub(crate) fn push_expr_scope(
+        self,
+        expr_scopes: Arc<ExprScopes>,
+        scope_id: ScopeId,
+    ) -> Resolver {
+        self.push_scope(Scope::ExprScope(ExprScope {
+            expr_scopes,
+            scope_id,
+        }))
+    }
+}
+impl Scope {
+    fn resolve_name(&self, name: &Name) -> PerNs<Resolution> {
+        match self {
+            Scope::ModuleScope(m) => {
+                if let Some(KnownName::SelfParam) = name.as_known_name() {
+                    PerNs::types(Resolution::Def(m.module.into()))
+                } else {
+                    match m.item_map[m.module.module_id].get(name) {
+                        Some(res) => res.def.map(Resolution::Def),
+                        None => PerNs::none(),
+                    }
+                }
+            }
+            Scope::GenericParams(gp) => match gp.find_by_name(name) {
+                Some(gp) => PerNs::types(Resolution::GenericParam(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(e.pat())),
+                    None => PerNs::none(),
+                }
+            }
+        }
+    }
+    fn collect_names(&self, f: &mut FnMut(Name, PerNs<Resolution>)) {
+        match self {
+            Scope::ModuleScope(m) => {
+                // TODO: should we provide `self` here?
+                // f(
+                //     Name::self_param(),
+                //     PerNs::types(Resolution::Def {
+                //         def: m.module.into(),
+                //     }),
+                // );
+                m.item_map[m.module.module_id]
+                    .entries()
+                    .for_each(|(name, res)| {
+                        f(name.clone(), res.def.map(Resolution::Def));
+                    })
+            }
+            Scope::GenericParams(gp) => {
+                for param in &gp.params {
+                    f(
+                        param.name.clone(),
+                        PerNs::types(Resolution::GenericParam(param.idx)),
+                    )
+                }
+            }
+            Scope::ImplBlockScope(i) => {
+                f(
+                    Name::self_type(),
+                    PerNs::types(Resolution::SelfType(i.clone())),
+                );
+            }
+            Scope::ExprScope(e) => {
+                e.expr_scopes.entries(e.scope_id).iter().for_each(|e| {
+                    f(
+                        e.name().clone(),
+                        PerNs::values(Resolution::LocalBinding(e.pat())),
+                    );
+                });
+            }
+        }
+    }
+}

diff --git a/crates/ra_hir/src/resolve.rs b/crates/ra_hir/src/resolve.rs new file mode 100644 index 000000000..6c87d0df7 --- /dev/null +++ b/crates/ra_hir/src/resolve.rs
@@ -0,0 +1,226 @@
	1	//! Name resolution.
	2	use std::sync::Arc;
	3
	4	use rustc_hash::FxHashMap;
	5
	6	use crate::{
	7	ModuleDef, Module,
	8	db::HirDatabase,
	9	name::{Name, KnownName},
	10	nameres::{PerNs, ItemMap},
	11	generics::GenericParams,
	12	expr::{scope::{ExprScopes, ScopeId}, PatId, Body},
	13	impl_block::ImplBlock,
	14	path::Path,
	15	};
	16
	17	#[derive(Debug, Clone, Default)]
	18	pub struct Resolver {
	19	scopes: Vec<Scope>,
	20	}
	21
	22	// TODO how to store these best
	23	#[derive(Debug, Clone)]
	24	pub(crate) struct ModuleItemMap {
	25	item_map: Arc<ItemMap>,
	26	module: Module,
	27	}
	28
	29	#[derive(Debug, Clone)]
	30	pub(crate) struct ExprScope {
	31	expr_scopes: Arc<ExprScopes>,
	32	scope_id: ScopeId,
	33	}
	34
	35	#[derive(Debug, Clone)]
	36	pub(crate) enum Scope {
	37	/// All the items and imported names of a module
	38	ModuleScope(ModuleItemMap),
	39	/// Brings the generic parameters of an item into scope
	40	GenericParams(Arc<GenericParams>),
	41	/// Brings `Self` into scope
	42	ImplBlockScope(ImplBlock),
	43	/// Local bindings
	44	ExprScope(ExprScope),
	45	}
	46
	47	#[derive(Debug, Clone, PartialEq, Eq)]
	48	pub enum Resolution {
	49	/// An item
	50	Def(ModuleDef),
	51	/// A local binding (only value namespace)
	52	LocalBinding(PatId),
	53	/// A generic parameter
	54	GenericParam(u32),
	55	SelfType(ImplBlock),
	56	}
	57
	58	impl Resolver {
	59	pub fn resolve_name(&self, name: &Name) -> PerNs<Resolution> {
	60	let mut resolution = PerNs::none();
	61	for scope in self.scopes.iter().rev() {
	62	resolution = resolution.combine(scope.resolve_name(name));
	63	if resolution.is_both() {
	64	return resolution;
	65	}
	66	}
	67	resolution
	68	}
	69
	70	pub fn resolve_path(&self, db: &impl HirDatabase, path: &Path) -> PerNs<Resolution> {
	71	if let Some(name) = path.as_ident() {
	72	self.resolve_name(name)
	73	} else if path.is_self() {
	74	self.resolve_name(&Name::self_param())
	75	} else {
	76	let (item_map, module) = match self.module() {
	77	Some(m) => m,
	78	_ => return PerNs::none(),
	79	};
	80	let module_res = item_map.resolve_path(db, module, path);
	81	module_res.map(\|def\| Resolution::Def(def))
	82	}
	83	}
	84
	85	pub fn all_names(&self) -> FxHashMap<Name, PerNs<Resolution>> {
	86	let mut names = FxHashMap::default();
	87	for scope in self.scopes.iter().rev() {
	88	scope.collect_names(&mut \|name, res\| {
	89	let current: &mut PerNs<Resolution> = names.entry(name).or_default();
	90	if current.types.is_none() {
	91	current.types = res.types;
	92	}
	93	if current.values.is_none() {
	94	current.values = res.values;
	95	}
	96	});
	97	}
	98	names
	99	}
	100
	101	fn module(&self) -> Option<(&ItemMap, Module)> {
	102	self.scopes.iter().rev().find_map(\|scope\| match scope {
	103	Scope::ModuleScope(m) => Some((&*m.item_map, m.module.clone())),
	104
	105	_ => None,
	106	})
	107	}
	108
	109	/// The body from which any `LocalBinding` resolutions in this resolver come.
	110	pub fn body(&self) -> Option<Arc<Body>> {
	111	self.scopes.iter().rev().find_map(\|scope\| match scope {
	112	Scope::ExprScope(expr_scope) => Some(expr_scope.expr_scopes.body()),
	113	_ => None,
	114	})
	115	}
	116	}
	117
	118	impl Resolver {
	119	pub(crate) fn push_scope(mut self, scope: Scope) -> Resolver {
	120	self.scopes.push(scope);
	121	self
	122	}
	123
	124	pub(crate) fn push_generic_params_scope(self, params: Arc<GenericParams>) -> Resolver {
	125	self.push_scope(Scope::GenericParams(params))
	126	}
	127
	128	pub(crate) fn push_impl_block_scope(self, impl_block: ImplBlock) -> Resolver {
	129	self.push_scope(Scope::ImplBlockScope(impl_block))
	130	}
	131
	132	pub(crate) fn push_module_scope(self, item_map: Arc<ItemMap>, module: Module) -> Resolver {
	133	self.push_scope(Scope::ModuleScope(ModuleItemMap { item_map, module }))
	134	}
	135
	136	pub(crate) fn push_expr_scope(
	137	self,
	138	expr_scopes: Arc<ExprScopes>,
	139	scope_id: ScopeId,
	140	) -> Resolver {
	141	self.push_scope(Scope::ExprScope(ExprScope {
	142	expr_scopes,
	143	scope_id,
	144	}))
	145	}
	146	}
	147
	148	impl Scope {
	149	fn resolve_name(&self, name: &Name) -> PerNs<Resolution> {
	150	match self {
	151	Scope::ModuleScope(m) => {
	152	if let Some(KnownName::SelfParam) = name.as_known_name() {
	153	PerNs::types(Resolution::Def(m.module.into()))
	154	} else {
	155	match m.item_map[m.module.module_id].get(name) {
	156	Some(res) => res.def.map(Resolution::Def),
	157	None => PerNs::none(),
	158	}
	159	}
	160	}
	161	Scope::GenericParams(gp) => match gp.find_by_name(name) {
	162	Some(gp) => PerNs::types(Resolution::GenericParam(gp.idx)),
	163	None => PerNs::none(),
	164	},
	165	Scope::ImplBlockScope(i) => {
	166	if name.as_known_name() == Some(KnownName::SelfType) {
	167	PerNs::types(Resolution::SelfType(i.clone()))
	168	} else {
	169	PerNs::none()
	170	}
	171	}
	172	Scope::ExprScope(e) => {
	173	let entry = e
	174	.expr_scopes
	175	.entries(e.scope_id)
	176	.iter()
	177	.find(\|entry\| entry.name() == name);
	178	match entry {
	179	Some(e) => PerNs::values(Resolution::LocalBinding(e.pat())),
	180	None => PerNs::none(),
	181	}
	182	}
	183	}
	184	}
	185
	186	fn collect_names(&self, f: &mut FnMut(Name, PerNs<Resolution>)) {
	187	match self {
	188	Scope::ModuleScope(m) => {
	189	// TODO: should we provide `self` here?
	190	// f(
	191	// Name::self_param(),
	192	// PerNs::types(Resolution::Def {
	193	// def: m.module.into(),
	194	// }),
	195	// );
	196	m.item_map[m.module.module_id]
	197	.entries()
	198	.for_each(\|(name, res)\| {
	199	f(name.clone(), res.def.map(Resolution::Def));
	200	})
	201	}
	202	Scope::GenericParams(gp) => {
	203	for param in &gp.params {
	204	f(
	205	param.name.clone(),
	206	PerNs::types(Resolution::GenericParam(param.idx)),
	207	)
	208	}
	209	}
	210	Scope::ImplBlockScope(i) => {
	211	f(
	212	Name::self_type(),
	213	PerNs::types(Resolution::SelfType(i.clone())),
	214	);
	215	}
	216	Scope::ExprScope(e) => {
	217	e.expr_scopes.entries(e.scope_id).iter().for_each(\|e\| {
	218	f(
	219	e.name().clone(),
	220	PerNs::values(Resolution::LocalBinding(e.pat())),
	221	);
	222	});
	223	}
	224	}
	225	}
	226	}