Move ids to hir_def crate

3 files changed, 226 insertions, 1 deletions

diff --git a/crates/ra_hir_def/Cargo.toml b/crates/ra_hir_def/Cargo.toml
index f22a678eb..75e93f254 100644
--- a/crates/ra_hir_def/Cargo.toml
+++ b/crates/ra_hir_def/Cargo.toml
@@ -11,3 +11,4 @@ ra_arena = { path = "../ra_arena" }
 ra_db = { path = "../ra_db" }
 ra_syntax = { path = "../ra_syntax" }
 ra_prof = { path = "../ra_prof" }
+hir_expand = { path = "../ra_hir_expand", package = "ra_hir_expand" }
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<ast::FnDef>) -> crate::FunctionId;
+    #[salsa::interned]
+    fn intern_struct(&self, loc: crate::ItemLoc<ast::StructDef>) -> crate::StructId;
+    #[salsa::interned]
+    fn intern_enum(&self, loc: crate::ItemLoc<ast::EnumDef>) -> crate::EnumId;
+    #[salsa::interned]
+    fn intern_const(&self, loc: crate::ItemLoc<ast::ConstDef>) -> crate::ConstId;
+    #[salsa::interned]
+    fn intern_static(&self, loc: crate::ItemLoc<ast::StaticDef>) -> crate::StaticId;
+    #[salsa::interned]
+    fn intern_trait(&self, loc: crate::ItemLoc<ast::TraitDef>) -> crate::TraitId;
+    #[salsa::interned]
+    fn intern_type_alias(&self, loc: crate::ItemLoc<ast::TypeAliasDef>) -> 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<T> {
+    pub file_id: HirFileId,
+    pub ast: T,
+}
+
+impl<T> Source<T> {
+    pub fn map<F: FnOnce(T) -> U, U>(self, f: F) -> Source<U> {
+        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<N: AstNode> {
+    pub(crate) module: ModuleId,
+    ast_id: AstId<N>,
+}
+
+impl<N: AstNode> PartialEq for ItemLoc<N> {
+    fn eq(&self, other: &Self) -> bool {
+        self.module == other.module && self.ast_id == other.ast_id
+    }
+}
+impl<N: AstNode> Eq for ItemLoc<N> {}
+impl<N: AstNode> Hash for ItemLoc<N> {
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        self.module.hash(hasher);
+        self.ast_id.hash(hasher);
+    }
+}
+
+impl<N: AstNode> Clone for ItemLoc<N> {
+    fn clone(&self) -> ItemLoc<N> {
+        ItemLoc { module: self.module, ast_id: self.ast_id }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub struct LocationCtx<DB> {
+    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<N, DEF>(self, ast: &N) -> DEF
+    where
+        N: AstNode,
+        DEF: AstItemDef<N>,
+    {
+        DEF::from_ast(self, ast)
+    }
+}
+
+pub trait AstItemDef<N: AstNode>: salsa::InternKey + Clone {
+    fn intern(db: &impl InternDatabase, loc: ItemLoc<N>) -> Self;
+    fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc<N>;
+
+    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<N>) -> 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<N> {
+        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<ast::FnDef> for FunctionId {
+    fn intern(db: &impl InternDatabase, loc: ItemLoc<ast::FnDef>) -> Self {
+        db.intern_function(loc)
+    }
+    fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc<ast::FnDef> {
+        db.lookup_intern_function(self)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct StructId(salsa::InternId);
+impl_intern_key!(StructId);
+impl AstItemDef<ast::StructDef> for StructId {
+    fn intern(db: &impl InternDatabase, loc: ItemLoc<ast::StructDef>) -> Self {
+        db.intern_struct(loc)
+    }
+    fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc<ast::StructDef> {
+        db.lookup_intern_struct(self)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct EnumId(salsa::InternId);
+impl_intern_key!(EnumId);
+impl AstItemDef<ast::EnumDef> for EnumId {
+    fn intern(db: &impl InternDatabase, loc: ItemLoc<ast::EnumDef>) -> Self {
+        db.intern_enum(loc)
+    }
+    fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc<ast::EnumDef> {
+        db.lookup_intern_enum(self)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct ConstId(salsa::InternId);
+impl_intern_key!(ConstId);
+impl AstItemDef<ast::ConstDef> for ConstId {
+    fn intern(db: &impl InternDatabase, loc: ItemLoc<ast::ConstDef>) -> Self {
+        db.intern_const(loc)
+    }
+    fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc<ast::ConstDef> {
+        db.lookup_intern_const(self)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct StaticId(salsa::InternId);
+impl_intern_key!(StaticId);
+impl AstItemDef<ast::StaticDef> for StaticId {
+    fn intern(db: &impl InternDatabase, loc: ItemLoc<ast::StaticDef>) -> Self {
+        db.intern_static(loc)
+    }
+    fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc<ast::StaticDef> {
+        db.lookup_intern_static(self)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct TraitId(salsa::InternId);
+impl_intern_key!(TraitId);
+impl AstItemDef<ast::TraitDef> for TraitId {
+    fn intern(db: &impl InternDatabase, loc: ItemLoc<ast::TraitDef>) -> Self {
+        db.intern_trait(loc)
+    }
+    fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc<ast::TraitDef> {
+        db.lookup_intern_trait(self)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct TypeAliasId(salsa::InternId);
+impl_intern_key!(TypeAliasId);
+impl AstItemDef<ast::TypeAliasDef> for TypeAliasId {
+    fn intern(db: &impl InternDatabase, loc: ItemLoc<ast::TypeAliasDef>) -> Self {
+        db.intern_type_alias(loc)
+    }
+    fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc<ast::TypeAliasDef> {
+        db.lookup_intern_type_alias(self)
+    }
+}