1 files changed, 35 insertions, 211 deletions

diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs
index 499dcafea..dea288eb7 100644
--- a/crates/ra_hir/src/ids.rs
+++ b/crates/ra_hir/src/ids.rs
@@ -1,168 +1,21 @@
-//! FIXME: write short doc here
+//! hir makes heavy use of ids: integer (u32) handlers to various things. You
+//! can think of id as a pointer (but without a lifetime) or a file descriptor
+//! (but for hir objects).
+//!
+//! This module defines a bunch of ids we are using. The most important ones are
+//! probably `HirFileId` and `DefId`.
 
-use std::{
-    hash::{Hash, Hasher},
-    sync::Arc,
-};
+use std::hash::{Hash, Hasher};
 
-use mbe::MacroRules;
-use ra_db::{salsa, FileId};
-use ra_prof::profile;
-use ra_syntax::{ast, AstNode, Parse, SyntaxNode};
+use ra_db::salsa;
+use ra_syntax::{ast, AstNode};
 
 use crate::{
-    db::{AstDatabase, DefDatabase, InternDatabase},
-    AstId, Crate, FileAstId, Module, Source,
+    db::{AstDatabase, InternDatabase},
+    AstId, FileAstId, Module, Source,
 };
 
-/// hir makes heavy use of ids: integer (u32) handlers to various things. You
-/// can think of id as a pointer (but without a lifetime) or a file descriptor
-/// (but for hir objects).
-///
-/// This module defines a bunch of ids we are using. The most important ones are
-/// probably `HirFileId` and `DefId`.
-
-/// Input to the analyzer is a set of files, where each file is identified by
-/// `FileId` and contains source code. However, another source of source code in
-/// Rust are macros: each macro can be thought of as producing a "temporary
-/// file". To assign an id to such a file, we use the id of the macro call that
-/// produced the file. So, a `HirFileId` is either a `FileId` (source code
-/// written by user), or a `MacroCallId` (source code produced by macro).
-///
-/// What is a `MacroCallId`? Simplifying, it's a `HirFileId` of a file
-/// containing the call plus the offset of the macro call in the file. Note that
-/// this is a recursive definition! However, the size_of of `HirFileId` is
-/// finite (because everything bottoms out at the real `FileId`) and small
-/// (`MacroCallId` uses the location interner).
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct HirFileId(HirFileIdRepr);
-
-impl HirFileId {
-    /// For macro-expansion files, returns the file original source file the
-    /// expansion originated from.
-    pub fn original_file(self, db: &impl InternDatabase) -> FileId {
-        match self.0 {
-            HirFileIdRepr::File(file_id) => file_id,
-            HirFileIdRepr::Macro(macro_file) => {
-                let loc = macro_file.macro_call_id.loc(db);
-                loc.ast_id.file_id().original_file(db)
-            }
-        }
-    }
-
-    /// Get the crate which the macro lives in, if it is a macro file.
-    pub(crate) fn macro_crate(self, db: &impl AstDatabase) -> Option<Crate> {
-        match self.0 {
-            HirFileIdRepr::File(_) => None,
-            HirFileIdRepr::Macro(macro_file) => {
-                let loc = macro_file.macro_call_id.loc(db);
-                Some(loc.def.krate)
-            }
-        }
-    }
-
-    pub(crate) fn parse_or_expand_query(
-        db: &impl AstDatabase,
-        file_id: HirFileId,
-    ) -> Option<SyntaxNode> {
-        match file_id.0 {
-            HirFileIdRepr::File(file_id) => Some(db.parse(file_id).tree().syntax().clone()),
-            HirFileIdRepr::Macro(macro_file) => {
-                db.parse_macro(macro_file).map(|it| it.syntax_node())
-            }
-        }
-    }
-
-    pub(crate) fn parse_macro_query(
-        db: &impl AstDatabase,
-        macro_file: MacroFile,
-    ) -> Option<Parse<SyntaxNode>> {
-        let _p = profile("parse_macro_query");
-        let macro_call_id = macro_file.macro_call_id;
-        let tt = db
-            .macro_expand(macro_call_id)
-            .map_err(|err| {
-                // Note:
-                // The final goal we would like to make all parse_macro success,
-                // such that the following log will not call anyway.
-                log::warn!("fail on macro_parse: (reason: {})", err,);
-            })
-            .ok()?;
-        match macro_file.macro_file_kind {
-            MacroFileKind::Items => mbe::token_tree_to_items(&tt).ok().map(Parse::to_syntax),
-            MacroFileKind::Expr => mbe::token_tree_to_expr(&tt).ok().map(Parse::to_syntax),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-enum HirFileIdRepr {
-    File(FileId),
-    Macro(MacroFile),
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct MacroFile {
-    macro_call_id: MacroCallId,
-    macro_file_kind: MacroFileKind,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub(crate) enum MacroFileKind {
-    Items,
-    Expr,
-}
-
-impl From<FileId> for HirFileId {
-    fn from(file_id: FileId) -> HirFileId {
-        HirFileId(HirFileIdRepr::File(file_id))
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct MacroDefId {
-    pub(crate) ast_id: AstId<ast::MacroCall>,
-    pub(crate) krate: Crate,
-}
-
-pub(crate) fn macro_def_query(db: &impl AstDatabase, id: MacroDefId) -> Option<Arc<MacroRules>> {
-    let macro_call = id.ast_id.to_node(db);
-    let arg = macro_call.token_tree()?;
-    let (tt, _) = mbe::ast_to_token_tree(&arg).or_else(|| {
-        log::warn!("fail on macro_def to token tree: {:#?}", arg);
-        None
-    })?;
-    let rules = MacroRules::parse(&tt).ok().or_else(|| {
-        log::warn!("fail on macro_def parse: {:#?}", tt);
-        None
-    })?;
-    Some(Arc::new(rules))
-}
-
-pub(crate) fn macro_arg_query(db: &impl AstDatabase, id: MacroCallId) -> Option<Arc<tt::Subtree>> {
-    let loc = id.loc(db);
-    let macro_call = loc.ast_id.to_node(db);
-    let arg = macro_call.token_tree()?;
-    let (tt, _) = mbe::ast_to_token_tree(&arg)?;
-    Some(Arc::new(tt))
-}
-
-pub(crate) fn macro_expand_query(
-    db: &impl AstDatabase,
-    id: MacroCallId,
-) -> Result<Arc<tt::Subtree>, String> {
-    let loc = id.loc(db);
-    let macro_arg = db.macro_arg(id).ok_or("Fail to args in to tt::TokenTree")?;
-
-    let macro_rules = db.macro_def(loc.def).ok_or("Fail to find macro definition")?;
-    let tt = macro_rules.expand(&macro_arg).map_err(|err| format!("{:?}", err))?;
-    // Set a hard limit for the expanded tt
-    let count = tt.count();
-    if count > 65536 {
-        return Err(format!("Total tokens count exceed limit : count = {}", count));
-    }
-    Ok(Arc::new(tt))
-}
+pub use hir_expand::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile, MacroFileKind};
 
 macro_rules! impl_intern_key {
     ($name:ident) => {
@@ -177,35 +30,6 @@ macro_rules! impl_intern_key {
     };
 }
 
-/// `MacroCallId` identifies a particular macro invocation, like
-/// `println!("Hello, {}", world)`.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct MacroCallId(salsa::InternId);
-impl_intern_key!(MacroCallId);
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MacroCallLoc {
-    pub(crate) def: MacroDefId,
-    pub(crate) ast_id: AstId<ast::MacroCall>,
-}
-
-impl MacroCallId {
-    pub(crate) fn loc(self, db: &impl InternDatabase) -> MacroCallLoc {
-        db.lookup_intern_macro(self)
-    }
-
-    pub(crate) fn as_file(self, kind: MacroFileKind) -> HirFileId {
-        let macro_file = MacroFile { macro_call_id: self, macro_file_kind: kind };
-        HirFileId(HirFileIdRepr::Macro(macro_file))
-    }
-}
-
-impl MacroCallLoc {
-    pub(crate) fn id(self, db: &impl InternDatabase) -> MacroCallId {
-        db.intern_macro(self)
-    }
-}
-
 #[derive(Debug)]
 pub struct ItemLoc<N: AstNode> {
     pub(crate) module: Module,
@@ -238,13 +62,13 @@ pub(crate) struct LocationCtx<DB> {
     file_id: HirFileId,
 }
 
-impl<'a, DB: DefDatabase> LocationCtx<&'a DB> {
+impl<'a, DB> LocationCtx<&'a DB> {
     pub(crate) fn new(db: &'a DB, module: Module, file_id: HirFileId) -> LocationCtx<&'a DB> {
         LocationCtx { db, module, file_id }
     }
 }
 
-impl<'a, DB: DefDatabase + AstDatabase> LocationCtx<&'a DB> {
+impl<'a, DB: AstDatabase + InternDatabase> LocationCtx<&'a DB> {
     pub(crate) fn to_def<N, DEF>(self, ast: &N) -> DEF
     where
         N: AstNode,
@@ -255,24 +79,24 @@ impl<'a, DB: DefDatabase + AstDatabase> LocationCtx<&'a DB> {
 }
 
 pub(crate) trait AstItemDef<N: AstNode>: salsa::InternKey + Clone {
-    fn intern(db: &impl DefDatabase, loc: ItemLoc<N>) -> Self;
-    fn lookup_intern(self, db: &impl DefDatabase) -> ItemLoc<N>;
+    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 + DefDatabase)>, ast: &N) -> Self {
+    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 DefDatabase>, ast_id: FileAstId<N>) -> Self {
-        let loc = ItemLoc { module: ctx.module, ast_id: ast_id.with_file_id(ctx.file_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 + DefDatabase)) -> Source<N> {
+    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 DefDatabase) -> Module {
+    fn module(self, db: &impl InternDatabase) -> Module {
         let loc = self.lookup_intern(db);
         loc.module
     }
@@ -283,10 +107,10 @@ pub struct FunctionId(salsa::InternId);
 impl_intern_key!(FunctionId);
 
 impl AstItemDef<ast::FnDef> for FunctionId {
-    fn intern(db: &impl DefDatabase, loc: ItemLoc<ast::FnDef>) -> Self {
+    fn intern(db: &impl InternDatabase, loc: ItemLoc<ast::FnDef>) -> Self {
         db.intern_function(loc)
     }
-    fn lookup_intern(self, db: &impl DefDatabase) -> ItemLoc<ast::FnDef> {
+    fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc<ast::FnDef> {
         db.lookup_intern_function(self)
     }
 }
@@ -295,10 +119,10 @@ impl AstItemDef<ast::FnDef> for FunctionId {
 pub struct StructId(salsa::InternId);
 impl_intern_key!(StructId);
 impl AstItemDef<ast::StructDef> for StructId {
-    fn intern(db: &impl DefDatabase, loc: ItemLoc<ast::StructDef>) -> Self {
+    fn intern(db: &impl InternDatabase, loc: ItemLoc<ast::StructDef>) -> Self {
         db.intern_struct(loc)
     }
-    fn lookup_intern(self, db: &impl DefDatabase) -> ItemLoc<ast::StructDef> {
+    fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc<ast::StructDef> {
         db.lookup_intern_struct(self)
     }
 }
@@ -307,10 +131,10 @@ impl AstItemDef<ast::StructDef> for StructId {
 pub struct EnumId(salsa::InternId);
 impl_intern_key!(EnumId);
 impl AstItemDef<ast::EnumDef> for EnumId {
-    fn intern(db: &impl DefDatabase, loc: ItemLoc<ast::EnumDef>) -> Self {
+    fn intern(db: &impl InternDatabase, loc: ItemLoc<ast::EnumDef>) -> Self {
         db.intern_enum(loc)
     }
-    fn lookup_intern(self, db: &impl DefDatabase) -> ItemLoc<ast::EnumDef> {
+    fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc<ast::EnumDef> {
         db.lookup_intern_enum(self)
     }
 }
@@ -319,10 +143,10 @@ impl AstItemDef<ast::EnumDef> for EnumId {
 pub struct ConstId(salsa::InternId);
 impl_intern_key!(ConstId);
 impl AstItemDef<ast::ConstDef> for ConstId {
-    fn intern(db: &impl DefDatabase, loc: ItemLoc<ast::ConstDef>) -> Self {
+    fn intern(db: &impl InternDatabase, loc: ItemLoc<ast::ConstDef>) -> Self {
         db.intern_const(loc)
     }
-    fn lookup_intern(self, db: &impl DefDatabase) -> ItemLoc<ast::ConstDef> {
+    fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc<ast::ConstDef> {
         db.lookup_intern_const(self)
     }
 }
@@ -331,10 +155,10 @@ impl AstItemDef<ast::ConstDef> for ConstId {
 pub struct StaticId(salsa::InternId);
 impl_intern_key!(StaticId);
 impl AstItemDef<ast::StaticDef> for StaticId {
-    fn intern(db: &impl DefDatabase, loc: ItemLoc<ast::StaticDef>) -> Self {
+    fn intern(db: &impl InternDatabase, loc: ItemLoc<ast::StaticDef>) -> Self {
         db.intern_static(loc)
     }
-    fn lookup_intern(self, db: &impl DefDatabase) -> ItemLoc<ast::StaticDef> {
+    fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc<ast::StaticDef> {
         db.lookup_intern_static(self)
     }
 }
@@ -343,10 +167,10 @@ impl AstItemDef<ast::StaticDef> for StaticId {
 pub struct TraitId(salsa::InternId);
 impl_intern_key!(TraitId);
 impl AstItemDef<ast::TraitDef> for TraitId {
-    fn intern(db: &impl DefDatabase, loc: ItemLoc<ast::TraitDef>) -> Self {
+    fn intern(db: &impl InternDatabase, loc: ItemLoc<ast::TraitDef>) -> Self {
         db.intern_trait(loc)
     }
-    fn lookup_intern(self, db: &impl DefDatabase) -> ItemLoc<ast::TraitDef> {
+    fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc<ast::TraitDef> {
         db.lookup_intern_trait(self)
     }
 }
@@ -355,10 +179,10 @@ impl AstItemDef<ast::TraitDef> for TraitId {
 pub struct TypeAliasId(salsa::InternId);
 impl_intern_key!(TypeAliasId);
 impl AstItemDef<ast::TypeAliasDef> for TypeAliasId {
-    fn intern(db: &impl DefDatabase, loc: ItemLoc<ast::TypeAliasDef>) -> Self {
+    fn intern(db: &impl InternDatabase, loc: ItemLoc<ast::TypeAliasDef>) -> Self {
         db.intern_type_alias(loc)
     }
-    fn lookup_intern(self, db: &impl DefDatabase) -> ItemLoc<ast::TypeAliasDef> {
+    fn lookup_intern(self, db: &impl InternDatabase) -> ItemLoc<ast::TypeAliasDef> {
         db.lookup_intern_type_alias(self)
     }
 }