From c9cd6aa370667783292de3bc580e0503a409e453 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Wed, 30 Oct 2019 13:10:38 +0300 Subject: Move ids to hir_def crate --- crates/ra_hir_def/src/db.rs | 22 +++++ crates/ra_hir_def/src/lib.rs | 204 ++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 225 insertions(+), 1 deletion(-) create mode 100644 crates/ra_hir_def/src/db.rs (limited to 'crates/ra_hir_def/src') diff --git a/crates/ra_hir_def/src/db.rs b/crates/ra_hir_def/src/db.rs new file mode 100644 index 000000000..f6f976c86 --- /dev/null +++ b/crates/ra_hir_def/src/db.rs @@ -0,0 +1,22 @@ +//! Defines database & queries for name resolution. + +use ra_db::{salsa, SourceDatabase}; +use ra_syntax::ast; + +#[salsa::query_group(InternDatabaseStorage)] +pub trait InternDatabase: SourceDatabase { + #[salsa::interned] + fn intern_function(&self, loc: crate::ItemLoc) -> crate::FunctionId; + #[salsa::interned] + fn intern_struct(&self, loc: crate::ItemLoc) -> crate::StructId; + #[salsa::interned] + fn intern_enum(&self, loc: crate::ItemLoc) -> crate::EnumId; + #[salsa::interned] + fn intern_const(&self, loc: crate::ItemLoc) -> crate::ConstId; + #[salsa::interned] + fn intern_static(&self, loc: crate::ItemLoc) -> crate::StaticId; + #[salsa::interned] + fn intern_trait(&self, loc: crate::ItemLoc) -> crate::TraitId; + #[salsa::interned] + fn intern_type_alias(&self, loc: crate::ItemLoc) -> crate::TypeAliasId; +} diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs index f5dd2ae6f..4d6b9db03 100644 --- a/crates/ra_hir_def/src/lib.rs +++ b/crates/ra_hir_def/src/lib.rs @@ -1,5 +1,37 @@ +//! `hir_def` crate contains everything between macro expansion and type +//! inference. +//! +//! It defines various items (structs, enums, traits) which comprises Rust code, +//! as well as an algorithm for resolving paths to such entities. +//! +//! Note that `hir_def` is a work in progress, so not all of the above is +//! actually true. + +pub mod db; + +use std::hash::{Hash, Hasher}; + +use hir_expand::{ast_id_map::FileAstId, db::AstDatabase, AstId, HirFileId}; use ra_arena::{impl_arena_id, RawId}; -use ra_db::CrateId; +use ra_db::{salsa, CrateId}; +use ra_syntax::{ast, AstNode, SyntaxNode}; + +use crate::db::InternDatabase; + +#[derive(Debug, PartialEq, Eq, Clone, Copy)] +pub struct Source { + pub file_id: HirFileId, + pub ast: T, +} + +impl Source { + pub fn map U, U>(self, f: F) -> Source { + Source { file_id: self.file_id, ast: f(self.ast) } + } + pub fn file_syntax(&self, db: &impl AstDatabase) -> SyntaxNode { + db.parse_or_expand(self.file_id).expect("source created from invalid file") + } +} #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct ModuleId { @@ -12,3 +44,173 @@ pub struct ModuleId { #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct CrateModuleId(RawId); impl_arena_id!(CrateModuleId); + +macro_rules! impl_intern_key { + ($name:ident) => { + impl salsa::InternKey for $name { + fn from_intern_id(v: salsa::InternId) -> Self { + $name(v) + } + fn as_intern_id(&self) -> salsa::InternId { + self.0 + } + } + }; +} + +#[derive(Debug)] +pub struct ItemLoc { + pub(crate) module: ModuleId, + ast_id: AstId, +} + +impl PartialEq for ItemLoc { + fn eq(&self, other: &Self) -> bool { + self.module == other.module && self.ast_id == other.ast_id + } +} +impl Eq for ItemLoc {} +impl Hash for ItemLoc { + fn hash(&self, hasher: &mut H) { + self.module.hash(hasher); + self.ast_id.hash(hasher); + } +} + +impl Clone for ItemLoc { + fn clone(&self) -> ItemLoc { + ItemLoc { module: self.module, ast_id: self.ast_id } + } +} + +#[derive(Clone, Copy)] +pub struct LocationCtx { + db: DB, + module: ModuleId, + file_id: HirFileId, +} + +impl<'a, DB> LocationCtx<&'a DB> { + pub fn new(db: &'a DB, module: ModuleId, file_id: HirFileId) -> LocationCtx<&'a DB> { + LocationCtx { db, module, file_id } + } +} + +impl<'a, DB: AstDatabase + InternDatabase> LocationCtx<&'a DB> { + pub fn to_def(self, ast: &N) -> DEF + where + N: AstNode, + DEF: AstItemDef, + { + DEF::from_ast(self, ast) + } +} + +pub trait AstItemDef: salsa::InternKey + Clone { + fn intern(db: &impl InternDatabase, loc: ItemLoc) -> Self; + fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc; + + fn from_ast(ctx: LocationCtx<&(impl AstDatabase + InternDatabase)>, ast: &N) -> Self { + let items = ctx.db.ast_id_map(ctx.file_id); + let item_id = items.ast_id(ast); + Self::from_ast_id(ctx, item_id) + } + fn from_ast_id(ctx: LocationCtx<&impl InternDatabase>, ast_id: FileAstId) -> Self { + let loc = ItemLoc { module: ctx.module, ast_id: AstId::new(ctx.file_id, ast_id) }; + Self::intern(ctx.db, loc) + } + fn source(self, db: &(impl AstDatabase + InternDatabase)) -> Source { + let loc = self.lookup_intern(db); + let ast = loc.ast_id.to_node(db); + Source { file_id: loc.ast_id.file_id(), ast } + } + fn module(self, db: &impl InternDatabase) -> ModuleId { + let loc = self.lookup_intern(db); + loc.module + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct FunctionId(salsa::InternId); +impl_intern_key!(FunctionId); + +impl AstItemDef for FunctionId { + fn intern(db: &impl InternDatabase, loc: ItemLoc) -> Self { + db.intern_function(loc) + } + fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc { + db.lookup_intern_function(self) + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct StructId(salsa::InternId); +impl_intern_key!(StructId); +impl AstItemDef for StructId { + fn intern(db: &impl InternDatabase, loc: ItemLoc) -> Self { + db.intern_struct(loc) + } + fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc { + db.lookup_intern_struct(self) + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct EnumId(salsa::InternId); +impl_intern_key!(EnumId); +impl AstItemDef for EnumId { + fn intern(db: &impl InternDatabase, loc: ItemLoc) -> Self { + db.intern_enum(loc) + } + fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc { + db.lookup_intern_enum(self) + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct ConstId(salsa::InternId); +impl_intern_key!(ConstId); +impl AstItemDef for ConstId { + fn intern(db: &impl InternDatabase, loc: ItemLoc) -> Self { + db.intern_const(loc) + } + fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc { + db.lookup_intern_const(self) + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct StaticId(salsa::InternId); +impl_intern_key!(StaticId); +impl AstItemDef for StaticId { + fn intern(db: &impl InternDatabase, loc: ItemLoc) -> Self { + db.intern_static(loc) + } + fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc { + db.lookup_intern_static(self) + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct TraitId(salsa::InternId); +impl_intern_key!(TraitId); +impl AstItemDef for TraitId { + fn intern(db: &impl InternDatabase, loc: ItemLoc) -> Self { + db.intern_trait(loc) + } + fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc { + db.lookup_intern_trait(self) + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct TypeAliasId(salsa::InternId); +impl_intern_key!(TypeAliasId); +impl AstItemDef for TypeAliasId { + fn intern(db: &impl InternDatabase, loc: ItemLoc) -> Self { + db.intern_type_alias(loc) + } + fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc { + db.lookup_intern_type_alias(self) + } +} -- cgit v1.2.3