rust/crates/ra_hir/src/module/nameres.rs

339 lines
10 KiB
Rust
Raw Normal View History

2018-11-27 18:42:26 -06:00
//! Name resolution algorithm. The end result of the algorithm is `ItemMap`: a
//! map with maps each module to it's scope: the set of items, visible in the
//! module. That is, we only resolve imports here, name resolution of item
//! bodies will be done in a separate step.
//!
//! Like Rustc, we use an interative per-crate algorithm: we start with scopes
//! containing only directly defined items, and then iteratively resolve
//! imports.
//!
//! To make this work nicely in the IDE scenarios, we place `InputModuleItems`
//! in between raw syntax and name resolution. `InputModuleItems` are computed
//! using only the module's syntax, and it is all directly defined items plus
//! imports. The plain is to make `InputModuleItems` independent of local
//! modifications (that is, typing inside a function shold not change IMIs),
//! such that the results of name resolution can be preserved unless the module
//! structure itself is modified.
use std::{
sync::Arc,
};
use rustc_hash::FxHashMap;
use ra_syntax::{
TextRange,
SmolStr, SyntaxKind::{self, *},
ast::{self, AstNode}
};
use ra_db::SourceRootId;
use crate::{
Cancelable, FileId,
DefId, DefLoc,
SourceItemId, SourceFileItemId, SourceFileItems,
Path, PathKind,
HirDatabase,
module::{ModuleId, ModuleTree},
};
/// Item map is the result of the name resolution. Item map contains, for each
/// module, the set of visible items.
#[derive(Default, Debug, PartialEq, Eq)]
2018-11-27 19:09:44 -06:00
pub struct ItemMap {
pub per_module: FxHashMap<ModuleId, ModuleScope>,
2018-11-27 18:42:26 -06:00
}
#[derive(Debug, Default, PartialEq, Eq, Clone)]
2018-11-27 19:09:44 -06:00
pub struct ModuleScope {
pub items: FxHashMap<SmolStr, Resolution>,
2018-11-27 18:42:26 -06:00
}
impl ModuleScope {
2018-11-27 19:09:44 -06:00
pub fn entries<'a>(&'a self) -> impl Iterator<Item = (&'a SmolStr, &Resolution)> + 'a {
2018-11-27 18:42:26 -06:00
self.items.iter()
}
2018-11-27 19:09:44 -06:00
pub fn get(&self, name: &SmolStr) -> Option<&Resolution> {
2018-11-27 18:42:26 -06:00
self.items.get(name)
}
}
/// A set of items and imports declared inside a module, without relation to
/// other modules.
///
/// This stands in-between raw syntax and name resolution and alow us to avoid
/// recomputing name res: if `InputModuleItems` are the same, we can avoid
/// running name resolution.
#[derive(Debug, Default, PartialEq, Eq)]
2018-11-27 19:09:44 -06:00
pub struct InputModuleItems {
2018-11-27 18:42:26 -06:00
items: Vec<ModuleItem>,
imports: Vec<Import>,
}
#[derive(Debug, PartialEq, Eq)]
struct ModuleItem {
id: SourceFileItemId,
name: SmolStr,
kind: SyntaxKind,
vis: Vis,
}
#[derive(Debug, PartialEq, Eq)]
enum Vis {
// Priv,
Other,
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct Import {
path: Path,
kind: ImportKind,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2018-11-27 19:09:44 -06:00
pub struct NamedImport {
pub file_item_id: SourceFileItemId,
pub relative_range: TextRange,
2018-11-27 18:42:26 -06:00
}
impl NamedImport {
2018-11-27 19:09:44 -06:00
pub fn range(&self, db: &impl HirDatabase, file_id: FileId) -> TextRange {
2018-11-27 18:42:26 -06:00
let source_item_id = SourceItemId {
file_id,
item_id: self.file_item_id,
};
let syntax = db.file_item(source_item_id);
let offset = syntax.borrowed().range().start();
self.relative_range + offset
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
enum ImportKind {
Glob,
Named(NamedImport),
}
/// Resolution is basically `DefId` atm, but it should account for stuff like
/// multiple namespaces, ambiguity and errors.
#[derive(Debug, Clone, PartialEq, Eq)]
2018-11-27 19:09:44 -06:00
pub struct Resolution {
2018-11-27 18:42:26 -06:00
/// None for unresolved
2018-11-27 19:09:44 -06:00
pub def_id: Option<DefId>,
2018-11-27 18:42:26 -06:00
/// ident by whitch this is imported into local scope.
2018-11-27 19:09:44 -06:00
pub import: Option<NamedImport>,
2018-11-27 18:42:26 -06:00
}
// #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
// enum Namespace {
// Types,
// Values,
// }
// #[derive(Debug)]
// struct PerNs<T> {
// types: Option<T>,
// values: Option<T>,
// }
impl InputModuleItems {
pub(crate) fn new<'a>(
file_items: &SourceFileItems,
items: impl Iterator<Item = ast::ModuleItem<'a>>,
) -> InputModuleItems {
let mut res = InputModuleItems::default();
for item in items {
res.add_item(file_items, item);
}
res
}
fn add_item(&mut self, file_items: &SourceFileItems, item: ast::ModuleItem) -> Option<()> {
match item {
ast::ModuleItem::StructDef(it) => self.items.push(ModuleItem::new(file_items, it)?),
ast::ModuleItem::EnumDef(it) => self.items.push(ModuleItem::new(file_items, it)?),
ast::ModuleItem::FnDef(it) => self.items.push(ModuleItem::new(file_items, it)?),
ast::ModuleItem::TraitDef(it) => self.items.push(ModuleItem::new(file_items, it)?),
ast::ModuleItem::TypeDef(it) => self.items.push(ModuleItem::new(file_items, it)?),
ast::ModuleItem::ImplItem(_) => {
// impls don't define items
}
ast::ModuleItem::UseItem(it) => self.add_use_item(file_items, it),
ast::ModuleItem::ExternCrateItem(_) => {
// TODO
}
ast::ModuleItem::ConstDef(it) => self.items.push(ModuleItem::new(file_items, it)?),
ast::ModuleItem::StaticDef(it) => self.items.push(ModuleItem::new(file_items, it)?),
ast::ModuleItem::Module(it) => self.items.push(ModuleItem::new(file_items, it)?),
}
Some(())
}
fn add_use_item(&mut self, file_items: &SourceFileItems, item: ast::UseItem) {
let file_item_id = file_items.id_of(item.syntax());
let start_offset = item.syntax().range().start();
Path::expand_use_item(item, |path, range| {
let kind = match range {
None => ImportKind::Glob,
Some(range) => ImportKind::Named(NamedImport {
file_item_id,
relative_range: range - start_offset,
}),
};
self.imports.push(Import { kind, path })
})
}
}
impl ModuleItem {
fn new<'a>(file_items: &SourceFileItems, item: impl ast::NameOwner<'a>) -> Option<ModuleItem> {
let name = item.name()?.text();
let kind = item.syntax().kind();
let vis = Vis::Other;
let id = file_items.id_of(item.syntax());
let res = ModuleItem {
id,
name,
kind,
vis,
};
Some(res)
}
}
pub(crate) struct Resolver<'a, DB> {
pub db: &'a DB,
pub input: &'a FxHashMap<ModuleId, Arc<InputModuleItems>>,
pub source_root: SourceRootId,
pub module_tree: Arc<ModuleTree>,
pub result: ItemMap,
}
impl<'a, DB> Resolver<'a, DB>
where
DB: HirDatabase,
{
pub(crate) fn resolve(mut self) -> Cancelable<ItemMap> {
for (&module_id, items) in self.input.iter() {
self.populate_module(module_id, items)
}
for &module_id in self.input.keys() {
self.db.check_canceled()?;
self.resolve_imports(module_id);
}
Ok(self.result)
}
fn populate_module(&mut self, module_id: ModuleId, input: &InputModuleItems) {
let file_id = module_id.source(&self.module_tree).file_id();
let mut module_items = ModuleScope::default();
for import in input.imports.iter() {
if let Some(name) = import.path.segments.iter().last() {
if let ImportKind::Named(import) = import.kind {
module_items.items.insert(
name.clone(),
Resolution {
def_id: None,
import: Some(import),
},
);
}
}
}
for item in input.items.iter() {
if item.kind == MODULE {
// handle submodules separatelly
continue;
}
let def_loc = DefLoc::Item {
source_item_id: SourceItemId {
file_id,
item_id: item.id,
},
};
let def_id = def_loc.id(self.db);
let resolution = Resolution {
def_id: Some(def_id),
import: None,
};
module_items.items.insert(item.name.clone(), resolution);
}
for (name, mod_id) in module_id.children(&self.module_tree) {
let def_loc = DefLoc::Module {
id: mod_id,
source_root: self.source_root,
};
let def_id = def_loc.id(self.db);
let resolution = Resolution {
def_id: Some(def_id),
import: None,
};
module_items.items.insert(name, resolution);
}
self.result.per_module.insert(module_id, module_items);
}
fn resolve_imports(&mut self, module_id: ModuleId) {
for import in self.input[&module_id].imports.iter() {
self.resolve_import(module_id, import);
}
}
fn resolve_import(&mut self, module_id: ModuleId, import: &Import) {
let ptr = match import.kind {
ImportKind::Glob => return,
ImportKind::Named(ptr) => ptr,
};
let mut curr = match import.path.kind {
// TODO: handle extern crates
PathKind::Plain => return,
PathKind::Self_ => module_id,
PathKind::Super => {
match module_id.parent(&self.module_tree) {
Some(it) => it,
// TODO: error
None => return,
}
}
PathKind::Crate => module_id.crate_root(&self.module_tree),
};
for (i, name) in import.path.segments.iter().enumerate() {
let is_last = i == import.path.segments.len() - 1;
let def_id = match self.result.per_module[&curr].items.get(name) {
None => return,
Some(res) => match res.def_id {
Some(it) => it,
None => return,
},
};
if !is_last {
curr = match def_id.loc(self.db) {
DefLoc::Module { id, .. } => id,
_ => return,
}
} else {
self.update(module_id, |items| {
let res = Resolution {
def_id: Some(def_id),
import: Some(ptr),
};
items.items.insert(name.clone(), res);
})
}
}
}
fn update(&mut self, module_id: ModuleId, f: impl FnOnce(&mut ModuleScope)) {
let module_items = self.result.per_module.get_mut(&module_id).unwrap();
f(module_items)
}
}