From 5b803055b7b690a57f1c08da8f1640139c739e76 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Tue, 29 Oct 2019 14:59:55 +0300
Subject: rename hir_def -> hir_expand

---
 crates/ra_hir_expand/src/ast_id_map.rs | 114 ++++++++++++++++
 crates/ra_hir_expand/src/db.rs         |  46 +++++++
 crates/ra_hir_expand/src/expand.rs     | 243 +++++++++++++++++++++++++++++++++
 crates/ra_hir_expand/src/lib.rs        |  11 ++
 4 files changed, 414 insertions(+)
 create mode 100644 crates/ra_hir_expand/src/ast_id_map.rs
 create mode 100644 crates/ra_hir_expand/src/db.rs
 create mode 100644 crates/ra_hir_expand/src/expand.rs
 create mode 100644 crates/ra_hir_expand/src/lib.rs

(limited to 'crates/ra_hir_expand/src')

diff --git a/crates/ra_hir_expand/src/ast_id_map.rs b/crates/ra_hir_expand/src/ast_id_map.rs
new file mode 100644
index 000000000..c3b389102
--- /dev/null
+++ b/crates/ra_hir_expand/src/ast_id_map.rs
@@ -0,0 +1,114 @@
+//! `AstIdMap` allows to create stable IDs for "large" syntax nodes like items
+//! and macro calls.
+//!
+//! Specifically, it enumerates all items in a file and uses position of a an
+//! item as an ID. That way, id's don't change unless the set of items itself
+//! changes.
+
+use std::{
+    hash::{Hash, Hasher},
+    marker::PhantomData,
+    ops,
+};
+
+use ra_arena::{impl_arena_id, Arena, RawId};
+use ra_syntax::{ast, AstNode, SyntaxNode, SyntaxNodePtr};
+
+/// `AstId` points to an AST node in a specific file.
+#[derive(Debug)]
+pub struct FileAstId<N: AstNode> {
+    raw: ErasedFileAstId,
+    _ty: PhantomData<fn() -> N>,
+}
+
+impl<N: AstNode> Clone for FileAstId<N> {
+    fn clone(&self) -> FileAstId<N> {
+        *self
+    }
+}
+impl<N: AstNode> Copy for FileAstId<N> {}
+
+impl<N: AstNode> PartialEq for FileAstId<N> {
+    fn eq(&self, other: &Self) -> bool {
+        self.raw == other.raw
+    }
+}
+impl<N: AstNode> Eq for FileAstId<N> {}
+impl<N: AstNode> Hash for FileAstId<N> {
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        self.raw.hash(hasher);
+    }
+}
+
+impl<N: AstNode> From<FileAstId<N>> for ErasedFileAstId {
+    fn from(id: FileAstId<N>) -> Self {
+        id.raw
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ErasedFileAstId(RawId);
+impl_arena_id!(ErasedFileAstId);
+
+/// Maps items' `SyntaxNode`s to `ErasedFileAstId`s and back.
+#[derive(Debug, PartialEq, Eq, Default)]
+pub struct AstIdMap {
+    arena: Arena<ErasedFileAstId, SyntaxNodePtr>,
+}
+
+impl AstIdMap {
+    pub fn from_source(node: &SyntaxNode) -> AstIdMap {
+        assert!(node.parent().is_none());
+        let mut res = AstIdMap { arena: Arena::default() };
+        // By walking the tree in bread-first order we make sure that parents
+        // get lower ids then children. That is, adding a new child does not
+        // change parent's id. This means that, say, adding a new function to a
+        // trait does not change ids of top-level items, which helps caching.
+        bfs(node, |it| {
+            if let Some(module_item) = ast::ModuleItem::cast(it.clone()) {
+                res.alloc(module_item.syntax());
+            } else if let Some(macro_call) = ast::MacroCall::cast(it) {
+                res.alloc(macro_call.syntax());
+            }
+        });
+        res
+    }
+
+    pub fn ast_id<N: AstNode>(&self, item: &N) -> FileAstId<N> {
+        let ptr = SyntaxNodePtr::new(item.syntax());
+        let raw = match self.arena.iter().find(|(_id, i)| **i == ptr) {
+            Some((it, _)) => it,
+            None => panic!(
+                "Can't find {:?} in AstIdMap:\n{:?}",
+                item.syntax(),
+                self.arena.iter().map(|(_id, i)| i).collect::<Vec<_>>(),
+            ),
+        };
+
+        FileAstId { raw, _ty: PhantomData }
+    }
+
+    fn alloc(&mut self, item: &SyntaxNode) -> ErasedFileAstId {
+        self.arena.alloc(SyntaxNodePtr::new(item))
+    }
+}
+
+impl ops::Index<ErasedFileAstId> for AstIdMap {
+    type Output = SyntaxNodePtr;
+    fn index(&self, index: ErasedFileAstId) -> &SyntaxNodePtr {
+        &self.arena[index]
+    }
+}
+
+/// Walks the subtree in bfs order, calling `f` for each node.
+fn bfs(node: &SyntaxNode, mut f: impl FnMut(SyntaxNode)) {
+    let mut curr_layer = vec![node.clone()];
+    let mut next_layer = vec![];
+    while !curr_layer.is_empty() {
+        curr_layer.drain(..).for_each(|node| {
+            next_layer.extend(node.children());
+            f(node);
+        });
+        std::mem::swap(&mut curr_layer, &mut next_layer);
+    }
+}
diff --git a/crates/ra_hir_expand/src/db.rs b/crates/ra_hir_expand/src/db.rs
new file mode 100644
index 000000000..7133b61db
--- /dev/null
+++ b/crates/ra_hir_expand/src/db.rs
@@ -0,0 +1,46 @@
+use std::sync::Arc;
+
+use ra_db::{salsa, SourceDatabase};
+use ra_syntax::{Parse, SyntaxNode};
+
+use crate::{
+    ast_id_map::{AstIdMap, ErasedFileAstId},
+    expand::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile},
+};
+
+#[salsa::query_group(AstDatabaseStorage)]
+pub trait AstDatabase: SourceDatabase {
+    fn ast_id_map(&self, file_id: HirFileId) -> Arc<AstIdMap>;
+    #[salsa::transparent]
+    fn ast_id_to_node(&self, file_id: HirFileId, ast_id: ErasedFileAstId) -> SyntaxNode;
+
+    #[salsa::transparent]
+    #[salsa::invoke(crate::expand::parse_or_expand_query)]
+    fn parse_or_expand(&self, file_id: HirFileId) -> Option<SyntaxNode>;
+
+    #[salsa::interned]
+    fn intern_macro(&self, macro_call: MacroCallLoc) -> MacroCallId;
+    #[salsa::invoke(crate::expand::macro_arg_query)]
+    fn macro_arg(&self, id: MacroCallId) -> Option<Arc<tt::Subtree>>;
+    #[salsa::invoke(crate::expand::macro_def_query)]
+    fn macro_def(&self, id: MacroDefId) -> Option<Arc<mbe::MacroRules>>;
+    #[salsa::invoke(crate::expand::parse_macro_query)]
+    fn parse_macro(&self, macro_file: MacroFile) -> Option<Parse<SyntaxNode>>;
+    #[salsa::invoke(crate::expand::macro_expand_query)]
+    fn macro_expand(&self, macro_call: MacroCallId) -> Result<Arc<tt::Subtree>, String>;
+}
+
+pub(crate) fn ast_id_map(db: &impl AstDatabase, file_id: HirFileId) -> Arc<AstIdMap> {
+    let map =
+        db.parse_or_expand(file_id).map_or_else(AstIdMap::default, |it| AstIdMap::from_source(&it));
+    Arc::new(map)
+}
+
+pub(crate) fn ast_id_to_node(
+    db: &impl AstDatabase,
+    file_id: HirFileId,
+    ast_id: ErasedFileAstId,
+) -> SyntaxNode {
+    let node = db.parse_or_expand(file_id).unwrap();
+    db.ast_id_map(file_id)[ast_id].to_node(&node)
+}
diff --git a/crates/ra_hir_expand/src/expand.rs b/crates/ra_hir_expand/src/expand.rs
new file mode 100644
index 000000000..6517ea84d
--- /dev/null
+++ b/crates/ra_hir_expand/src/expand.rs
@@ -0,0 +1,243 @@
+use std::{
+    hash::{Hash, Hasher},
+    sync::Arc,
+};
+
+use mbe::MacroRules;
+use ra_db::{salsa, CrateId, FileId};
+use ra_prof::profile;
+use ra_syntax::{
+    ast::{self, AstNode},
+    Parse, SyntaxNode,
+};
+
+use crate::{ast_id_map::FileAstId, db::AstDatabase};
+
+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
+            }
+        }
+    };
+}
+
+/// 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 enum HirFileId {
+    FileId(FileId),
+    MacroFile(MacroFile),
+}
+
+impl From<FileId> for HirFileId {
+    fn from(id: FileId) -> Self {
+        HirFileId::FileId(id)
+    }
+}
+
+impl From<MacroFile> for HirFileId {
+    fn from(id: MacroFile) -> Self {
+        HirFileId::MacroFile(id)
+    }
+}
+
+impl HirFileId {
+    /// For macro-expansion files, returns the file original source file the
+    /// expansion originated from.
+    pub fn original_file(self, db: &impl AstDatabase) -> FileId {
+        match self {
+            HirFileId::FileId(file_id) => file_id,
+            HirFileId::MacroFile(macro_file) => {
+                let loc = db.lookup_intern_macro(macro_file.macro_call_id);
+                loc.ast_id.file_id().original_file(db)
+            }
+        }
+    }
+
+    /// Get the crate which the macro lives in, if it is a macro file.
+    pub fn macro_crate(self, db: &impl AstDatabase) -> Option<CrateId> {
+        match self {
+            HirFileId::FileId(_) => None,
+            HirFileId::MacroFile(macro_file) => {
+                let loc = db.lookup_intern_macro(macro_file.macro_call_id);
+                Some(loc.def.krate)
+            }
+        }
+    }
+}
+
+#[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 enum MacroFileKind {
+    Items,
+    Expr,
+}
+
+/// `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, Copy, PartialEq, Eq, Hash)]
+pub struct MacroDefId {
+    pub krate: CrateId,
+    pub ast_id: AstId<ast::MacroCall>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct MacroCallLoc {
+    pub def: MacroDefId,
+    pub ast_id: AstId<ast::MacroCall>,
+}
+
+impl MacroCallId {
+    pub fn loc(self, db: &impl AstDatabase) -> MacroCallLoc {
+        db.lookup_intern_macro(self)
+    }
+
+    pub fn as_file(self, kind: MacroFileKind) -> HirFileId {
+        let macro_file = MacroFile { macro_call_id: self, macro_file_kind: kind };
+        macro_file.into()
+    }
+}
+
+impl MacroCallLoc {
+    pub fn id(self, db: &impl AstDatabase) -> MacroCallId {
+        db.intern_macro(self)
+    }
+}
+
+/// `AstId` points to an AST node in any file.
+///
+/// It is stable across reparses, and can be used as salsa key/value.
+// FIXME: isn't this just a `Source<FileAstId<N>>` ?
+#[derive(Debug)]
+pub struct AstId<N: AstNode> {
+    file_id: HirFileId,
+    file_ast_id: FileAstId<N>,
+}
+
+impl<N: AstNode> Clone for AstId<N> {
+    fn clone(&self) -> AstId<N> {
+        *self
+    }
+}
+impl<N: AstNode> Copy for AstId<N> {}
+
+impl<N: AstNode> PartialEq for AstId<N> {
+    fn eq(&self, other: &Self) -> bool {
+        (self.file_id, self.file_ast_id) == (other.file_id, other.file_ast_id)
+    }
+}
+impl<N: AstNode> Eq for AstId<N> {}
+impl<N: AstNode> Hash for AstId<N> {
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        (self.file_id, self.file_ast_id).hash(hasher);
+    }
+}
+
+impl<N: AstNode> AstId<N> {
+    pub fn new(file_id: HirFileId, file_ast_id: FileAstId<N>) -> AstId<N> {
+        AstId { file_id, file_ast_id }
+    }
+
+    pub fn file_id(&self) -> HirFileId {
+        self.file_id
+    }
+
+    pub fn to_node(&self, db: &impl AstDatabase) -> N {
+        let syntax_node = db.ast_id_to_node(self.file_id, self.file_ast_id.into());
+        N::cast(syntax_node).unwrap()
+    }
+}
+
+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 = db.lookup_intern_macro(id);
+    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 = db.lookup_intern_macro(id);
+    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(crate) fn parse_or_expand_query(
+    db: &impl AstDatabase,
+    file_id: HirFileId,
+) -> Option<SyntaxNode> {
+    match file_id {
+        HirFileId::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()),
+        HirFileId::MacroFile(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),
+    }
+}
diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs
new file mode 100644
index 000000000..6ccb11068
--- /dev/null
+++ b/crates/ra_hir_expand/src/lib.rs
@@ -0,0 +1,11 @@
+//! `ra_hir_def` contains initial "phases" of the compiler. Roughly, everything
+//! before types.
+//!
+//! Note that we are in the process of moving parts of `ra_hir` into
+//! `ra_hir_def`, so this crates doesn't contain a lot at the moment.
+
+pub mod db;
+
+pub mod ast_id_map;
+
+pub mod expand;
-- 
cgit v1.2.3


From dba767802d05c493b7798b0173a2d102dcc73a95 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Tue, 29 Oct 2019 15:01:55 +0300
Subject: make file id repr private again

---
 crates/ra_hir_expand/src/expand.rs | 29 +++++++++++++++++------------
 1 file changed, 17 insertions(+), 12 deletions(-)

(limited to 'crates/ra_hir_expand/src')

diff --git a/crates/ra_hir_expand/src/expand.rs b/crates/ra_hir_expand/src/expand.rs
index 6517ea84d..3921175cb 100644
--- a/crates/ra_hir_expand/src/expand.rs
+++ b/crates/ra_hir_expand/src/expand.rs
@@ -39,20 +39,23 @@ macro_rules! impl_intern_key {
 /// finite (because everything bottoms out at the real `FileId`) and small
 /// (`MacroCallId` uses the location interner).
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum HirFileId {
+pub struct HirFileId(HirFileIdRepr);
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+enum HirFileIdRepr {
     FileId(FileId),
     MacroFile(MacroFile),
 }
 
 impl From<FileId> for HirFileId {
     fn from(id: FileId) -> Self {
-        HirFileId::FileId(id)
+        HirFileId(HirFileIdRepr::FileId(id))
     }
 }
 
 impl From<MacroFile> for HirFileId {
     fn from(id: MacroFile) -> Self {
-        HirFileId::MacroFile(id)
+        HirFileId(HirFileIdRepr::MacroFile(id))
     }
 }
 
@@ -60,9 +63,9 @@ impl HirFileId {
     /// For macro-expansion files, returns the file original source file the
     /// expansion originated from.
     pub fn original_file(self, db: &impl AstDatabase) -> FileId {
-        match self {
-            HirFileId::FileId(file_id) => file_id,
-            HirFileId::MacroFile(macro_file) => {
+        match self.0 {
+            HirFileIdRepr::FileId(file_id) => file_id,
+            HirFileIdRepr::MacroFile(macro_file) => {
                 let loc = db.lookup_intern_macro(macro_file.macro_call_id);
                 loc.ast_id.file_id().original_file(db)
             }
@@ -71,9 +74,9 @@ impl HirFileId {
 
     /// Get the crate which the macro lives in, if it is a macro file.
     pub fn macro_crate(self, db: &impl AstDatabase) -> Option<CrateId> {
-        match self {
-            HirFileId::FileId(_) => None,
-            HirFileId::MacroFile(macro_file) => {
+        match self.0 {
+            HirFileIdRepr::FileId(_) => None,
+            HirFileIdRepr::MacroFile(macro_file) => {
                 let loc = db.lookup_intern_macro(macro_file.macro_call_id);
                 Some(loc.def.krate)
             }
@@ -215,9 +218,11 @@ pub(crate) fn parse_or_expand_query(
     db: &impl AstDatabase,
     file_id: HirFileId,
 ) -> Option<SyntaxNode> {
-    match file_id {
-        HirFileId::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()),
-        HirFileId::MacroFile(macro_file) => db.parse_macro(macro_file).map(|it| it.syntax_node()),
+    match file_id.0 {
+        HirFileIdRepr::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()),
+        HirFileIdRepr::MacroFile(macro_file) => {
+            db.parse_macro(macro_file).map(|it| it.syntax_node())
+        }
     }
 }
 
-- 
cgit v1.2.3


From 6bf7faf315c57dbec6cb3d5a7c7089016603b309 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Tue, 29 Oct 2019 15:11:42 +0300
Subject: flatten hir_expand

---
 crates/ra_hir_expand/src/db.rs     |  80 ++++++++++--
 crates/ra_hir_expand/src/expand.rs | 248 -------------------------------------
 crates/ra_hir_expand/src/lib.rs    | 170 ++++++++++++++++++++++++-
 3 files changed, 241 insertions(+), 257 deletions(-)
 delete mode 100644 crates/ra_hir_expand/src/expand.rs

(limited to 'crates/ra_hir_expand/src')

diff --git a/crates/ra_hir_expand/src/db.rs b/crates/ra_hir_expand/src/db.rs
index 7133b61db..912599e57 100644
--- a/crates/ra_hir_expand/src/db.rs
+++ b/crates/ra_hir_expand/src/db.rs
@@ -1,11 +1,13 @@
 use std::sync::Arc;
 
+use mbe::MacroRules;
 use ra_db::{salsa, SourceDatabase};
-use ra_syntax::{Parse, SyntaxNode};
+use ra_prof::profile;
+use ra_syntax::{AstNode, Parse, SyntaxNode};
 
 use crate::{
     ast_id_map::{AstIdMap, ErasedFileAstId},
-    expand::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile},
+    HirFileId, HirFileIdRepr, MacroCallId, MacroCallLoc, MacroDefId, MacroFile, MacroFileKind,
 };
 
 #[salsa::query_group(AstDatabaseStorage)]
@@ -15,18 +17,13 @@ pub trait AstDatabase: SourceDatabase {
     fn ast_id_to_node(&self, file_id: HirFileId, ast_id: ErasedFileAstId) -> SyntaxNode;
 
     #[salsa::transparent]
-    #[salsa::invoke(crate::expand::parse_or_expand_query)]
     fn parse_or_expand(&self, file_id: HirFileId) -> Option<SyntaxNode>;
 
     #[salsa::interned]
     fn intern_macro(&self, macro_call: MacroCallLoc) -> MacroCallId;
-    #[salsa::invoke(crate::expand::macro_arg_query)]
     fn macro_arg(&self, id: MacroCallId) -> Option<Arc<tt::Subtree>>;
-    #[salsa::invoke(crate::expand::macro_def_query)]
     fn macro_def(&self, id: MacroDefId) -> Option<Arc<mbe::MacroRules>>;
-    #[salsa::invoke(crate::expand::parse_macro_query)]
     fn parse_macro(&self, macro_file: MacroFile) -> Option<Parse<SyntaxNode>>;
-    #[salsa::invoke(crate::expand::macro_expand_query)]
     fn macro_expand(&self, macro_call: MacroCallId) -> Result<Arc<tt::Subtree>, String>;
 }
 
@@ -44,3 +41,72 @@ pub(crate) fn ast_id_to_node(
     let node = db.parse_or_expand(file_id).unwrap();
     db.ast_id_map(file_id)[ast_id].to_node(&node)
 }
+
+pub(crate) fn macro_def(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(db: &impl AstDatabase, id: MacroCallId) -> Option<Arc<tt::Subtree>> {
+    let loc = db.lookup_intern_macro(id);
+    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(
+    db: &impl AstDatabase,
+    id: MacroCallId,
+) -> Result<Arc<tt::Subtree>, String> {
+    let loc = db.lookup_intern_macro(id);
+    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(crate) fn parse_or_expand(db: &impl AstDatabase, file_id: HirFileId) -> Option<SyntaxNode> {
+    match file_id.0 {
+        HirFileIdRepr::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()),
+        HirFileIdRepr::MacroFile(macro_file) => {
+            db.parse_macro(macro_file).map(|it| it.syntax_node())
+        }
+    }
+}
+
+pub(crate) fn parse_macro(
+    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),
+    }
+}
diff --git a/crates/ra_hir_expand/src/expand.rs b/crates/ra_hir_expand/src/expand.rs
deleted file mode 100644
index 3921175cb..000000000
--- a/crates/ra_hir_expand/src/expand.rs
+++ /dev/null
@@ -1,248 +0,0 @@
-use std::{
-    hash::{Hash, Hasher},
-    sync::Arc,
-};
-
-use mbe::MacroRules;
-use ra_db::{salsa, CrateId, FileId};
-use ra_prof::profile;
-use ra_syntax::{
-    ast::{self, AstNode},
-    Parse, SyntaxNode,
-};
-
-use crate::{ast_id_map::FileAstId, db::AstDatabase};
-
-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
-            }
-        }
-    };
-}
-
-/// 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);
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-enum HirFileIdRepr {
-    FileId(FileId),
-    MacroFile(MacroFile),
-}
-
-impl From<FileId> for HirFileId {
-    fn from(id: FileId) -> Self {
-        HirFileId(HirFileIdRepr::FileId(id))
-    }
-}
-
-impl From<MacroFile> for HirFileId {
-    fn from(id: MacroFile) -> Self {
-        HirFileId(HirFileIdRepr::MacroFile(id))
-    }
-}
-
-impl HirFileId {
-    /// For macro-expansion files, returns the file original source file the
-    /// expansion originated from.
-    pub fn original_file(self, db: &impl AstDatabase) -> FileId {
-        match self.0 {
-            HirFileIdRepr::FileId(file_id) => file_id,
-            HirFileIdRepr::MacroFile(macro_file) => {
-                let loc = db.lookup_intern_macro(macro_file.macro_call_id);
-                loc.ast_id.file_id().original_file(db)
-            }
-        }
-    }
-
-    /// Get the crate which the macro lives in, if it is a macro file.
-    pub fn macro_crate(self, db: &impl AstDatabase) -> Option<CrateId> {
-        match self.0 {
-            HirFileIdRepr::FileId(_) => None,
-            HirFileIdRepr::MacroFile(macro_file) => {
-                let loc = db.lookup_intern_macro(macro_file.macro_call_id);
-                Some(loc.def.krate)
-            }
-        }
-    }
-}
-
-#[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 enum MacroFileKind {
-    Items,
-    Expr,
-}
-
-/// `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, Copy, PartialEq, Eq, Hash)]
-pub struct MacroDefId {
-    pub krate: CrateId,
-    pub ast_id: AstId<ast::MacroCall>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MacroCallLoc {
-    pub def: MacroDefId,
-    pub ast_id: AstId<ast::MacroCall>,
-}
-
-impl MacroCallId {
-    pub fn loc(self, db: &impl AstDatabase) -> MacroCallLoc {
-        db.lookup_intern_macro(self)
-    }
-
-    pub fn as_file(self, kind: MacroFileKind) -> HirFileId {
-        let macro_file = MacroFile { macro_call_id: self, macro_file_kind: kind };
-        macro_file.into()
-    }
-}
-
-impl MacroCallLoc {
-    pub fn id(self, db: &impl AstDatabase) -> MacroCallId {
-        db.intern_macro(self)
-    }
-}
-
-/// `AstId` points to an AST node in any file.
-///
-/// It is stable across reparses, and can be used as salsa key/value.
-// FIXME: isn't this just a `Source<FileAstId<N>>` ?
-#[derive(Debug)]
-pub struct AstId<N: AstNode> {
-    file_id: HirFileId,
-    file_ast_id: FileAstId<N>,
-}
-
-impl<N: AstNode> Clone for AstId<N> {
-    fn clone(&self) -> AstId<N> {
-        *self
-    }
-}
-impl<N: AstNode> Copy for AstId<N> {}
-
-impl<N: AstNode> PartialEq for AstId<N> {
-    fn eq(&self, other: &Self) -> bool {
-        (self.file_id, self.file_ast_id) == (other.file_id, other.file_ast_id)
-    }
-}
-impl<N: AstNode> Eq for AstId<N> {}
-impl<N: AstNode> Hash for AstId<N> {
-    fn hash<H: Hasher>(&self, hasher: &mut H) {
-        (self.file_id, self.file_ast_id).hash(hasher);
-    }
-}
-
-impl<N: AstNode> AstId<N> {
-    pub fn new(file_id: HirFileId, file_ast_id: FileAstId<N>) -> AstId<N> {
-        AstId { file_id, file_ast_id }
-    }
-
-    pub fn file_id(&self) -> HirFileId {
-        self.file_id
-    }
-
-    pub fn to_node(&self, db: &impl AstDatabase) -> N {
-        let syntax_node = db.ast_id_to_node(self.file_id, self.file_ast_id.into());
-        N::cast(syntax_node).unwrap()
-    }
-}
-
-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 = db.lookup_intern_macro(id);
-    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 = db.lookup_intern_macro(id);
-    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(crate) fn parse_or_expand_query(
-    db: &impl AstDatabase,
-    file_id: HirFileId,
-) -> Option<SyntaxNode> {
-    match file_id.0 {
-        HirFileIdRepr::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()),
-        HirFileIdRepr::MacroFile(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),
-    }
-}
diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs
index 6ccb11068..002a5b45a 100644
--- a/crates/ra_hir_expand/src/lib.rs
+++ b/crates/ra_hir_expand/src/lib.rs
@@ -5,7 +5,173 @@
 //! `ra_hir_def`, so this crates doesn't contain a lot at the moment.
 
 pub mod db;
-
 pub mod ast_id_map;
 
-pub mod expand;
+use std::hash::{Hash, Hasher};
+
+use ra_db::{salsa, CrateId, FileId};
+use ra_syntax::ast::{self, AstNode};
+
+use crate::{ast_id_map::FileAstId, db::AstDatabase};
+
+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
+            }
+        }
+    };
+}
+
+/// 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);
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+enum HirFileIdRepr {
+    FileId(FileId),
+    MacroFile(MacroFile),
+}
+
+impl From<FileId> for HirFileId {
+    fn from(id: FileId) -> Self {
+        HirFileId(HirFileIdRepr::FileId(id))
+    }
+}
+
+impl From<MacroFile> for HirFileId {
+    fn from(id: MacroFile) -> Self {
+        HirFileId(HirFileIdRepr::MacroFile(id))
+    }
+}
+
+impl HirFileId {
+    /// For macro-expansion files, returns the file original source file the
+    /// expansion originated from.
+    pub fn original_file(self, db: &impl AstDatabase) -> FileId {
+        match self.0 {
+            HirFileIdRepr::FileId(file_id) => file_id,
+            HirFileIdRepr::MacroFile(macro_file) => {
+                let loc = db.lookup_intern_macro(macro_file.macro_call_id);
+                loc.ast_id.file_id().original_file(db)
+            }
+        }
+    }
+
+    /// Get the crate which the macro lives in, if it is a macro file.
+    pub fn macro_crate(self, db: &impl AstDatabase) -> Option<CrateId> {
+        match self.0 {
+            HirFileIdRepr::FileId(_) => None,
+            HirFileIdRepr::MacroFile(macro_file) => {
+                let loc = db.lookup_intern_macro(macro_file.macro_call_id);
+                Some(loc.def.krate)
+            }
+        }
+    }
+}
+
+#[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 enum MacroFileKind {
+    Items,
+    Expr,
+}
+
+/// `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, Copy, PartialEq, Eq, Hash)]
+pub struct MacroDefId {
+    pub krate: CrateId,
+    pub ast_id: AstId<ast::MacroCall>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct MacroCallLoc {
+    pub def: MacroDefId,
+    pub ast_id: AstId<ast::MacroCall>,
+}
+
+impl MacroCallId {
+    pub fn loc(self, db: &impl AstDatabase) -> MacroCallLoc {
+        db.lookup_intern_macro(self)
+    }
+
+    pub fn as_file(self, kind: MacroFileKind) -> HirFileId {
+        let macro_file = MacroFile { macro_call_id: self, macro_file_kind: kind };
+        macro_file.into()
+    }
+}
+
+impl MacroCallLoc {
+    pub fn id(self, db: &impl AstDatabase) -> MacroCallId {
+        db.intern_macro(self)
+    }
+}
+
+/// `AstId` points to an AST node in any file.
+///
+/// It is stable across reparses, and can be used as salsa key/value.
+// FIXME: isn't this just a `Source<FileAstId<N>>` ?
+#[derive(Debug)]
+pub struct AstId<N: AstNode> {
+    file_id: HirFileId,
+    file_ast_id: FileAstId<N>,
+}
+
+impl<N: AstNode> Clone for AstId<N> {
+    fn clone(&self) -> AstId<N> {
+        *self
+    }
+}
+impl<N: AstNode> Copy for AstId<N> {}
+
+impl<N: AstNode> PartialEq for AstId<N> {
+    fn eq(&self, other: &Self) -> bool {
+        (self.file_id, self.file_ast_id) == (other.file_id, other.file_ast_id)
+    }
+}
+impl<N: AstNode> Eq for AstId<N> {}
+impl<N: AstNode> Hash for AstId<N> {
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        (self.file_id, self.file_ast_id).hash(hasher);
+    }
+}
+
+impl<N: AstNode> AstId<N> {
+    pub fn new(file_id: HirFileId, file_ast_id: FileAstId<N>) -> AstId<N> {
+        AstId { file_id, file_ast_id }
+    }
+
+    pub fn file_id(&self) -> HirFileId {
+        self.file_id
+    }
+
+    pub fn to_node(&self, db: &impl AstDatabase) -> N {
+        let syntax_node = db.ast_id_to_node(self.file_id, self.file_ast_id.into());
+        N::cast(syntax_node).unwrap()
+    }
+}
-- 
cgit v1.2.3


From 858dd48af26e851897b2e8d2fbf757f3adfbc92c Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Tue, 29 Oct 2019 15:20:08 +0300
Subject: less generics

---
 crates/ra_hir_expand/src/ast_id_map.rs | 14 ++++++++------
 crates/ra_hir_expand/src/db.rs         |  1 +
 2 files changed, 9 insertions(+), 6 deletions(-)

(limited to 'crates/ra_hir_expand/src')

diff --git a/crates/ra_hir_expand/src/ast_id_map.rs b/crates/ra_hir_expand/src/ast_id_map.rs
index c3b389102..2f43abe15 100644
--- a/crates/ra_hir_expand/src/ast_id_map.rs
+++ b/crates/ra_hir_expand/src/ast_id_map.rs
@@ -75,17 +75,19 @@ impl AstIdMap {
     }
 
     pub fn ast_id<N: AstNode>(&self, item: &N) -> FileAstId<N> {
-        let ptr = SyntaxNodePtr::new(item.syntax());
-        let raw = match self.arena.iter().find(|(_id, i)| **i == ptr) {
+        let raw = self.erased_ast_id(item.syntax());
+        FileAstId { raw, _ty: PhantomData }
+    }
+    fn erased_ast_id(&self, item: &SyntaxNode) -> ErasedFileAstId {
+        let ptr = SyntaxNodePtr::new(item);
+        match self.arena.iter().find(|(_id, i)| **i == ptr) {
             Some((it, _)) => it,
             None => panic!(
                 "Can't find {:?} in AstIdMap:\n{:?}",
-                item.syntax(),
+                item,
                 self.arena.iter().map(|(_id, i)| i).collect::<Vec<_>>(),
             ),
-        };
-
-        FileAstId { raw, _ty: PhantomData }
+        }
     }
 
     fn alloc(&mut self, item: &SyntaxNode) -> ErasedFileAstId {
diff --git a/crates/ra_hir_expand/src/db.rs b/crates/ra_hir_expand/src/db.rs
index 912599e57..12aa7ad0e 100644
--- a/crates/ra_hir_expand/src/db.rs
+++ b/crates/ra_hir_expand/src/db.rs
@@ -10,6 +10,7 @@ use crate::{
     HirFileId, HirFileIdRepr, MacroCallId, MacroCallLoc, MacroDefId, MacroFile, MacroFileKind,
 };
 
+// FIXME: rename to ExpandDatabase
 #[salsa::query_group(AstDatabaseStorage)]
 pub trait AstDatabase: SourceDatabase {
     fn ast_id_map(&self, file_id: HirFileId) -> Arc<AstIdMap>;
-- 
cgit v1.2.3


From d095d9273eb2c03d1c28e0122c21fccf4099660e Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Tue, 29 Oct 2019 15:22:20 +0300
Subject: remove unused query

---
 crates/ra_hir_expand/src/db.rs  | 15 ++-------------
 crates/ra_hir_expand/src/lib.rs |  5 +++--
 2 files changed, 5 insertions(+), 15 deletions(-)

(limited to 'crates/ra_hir_expand/src')

diff --git a/crates/ra_hir_expand/src/db.rs b/crates/ra_hir_expand/src/db.rs
index 12aa7ad0e..8b92d4c1f 100644
--- a/crates/ra_hir_expand/src/db.rs
+++ b/crates/ra_hir_expand/src/db.rs
@@ -6,16 +6,14 @@ use ra_prof::profile;
 use ra_syntax::{AstNode, Parse, SyntaxNode};
 
 use crate::{
-    ast_id_map::{AstIdMap, ErasedFileAstId},
-    HirFileId, HirFileIdRepr, MacroCallId, MacroCallLoc, MacroDefId, MacroFile, MacroFileKind,
+    ast_id_map::AstIdMap, HirFileId, HirFileIdRepr, MacroCallId, MacroCallLoc, MacroDefId,
+    MacroFile, MacroFileKind,
 };
 
 // FIXME: rename to ExpandDatabase
 #[salsa::query_group(AstDatabaseStorage)]
 pub trait AstDatabase: SourceDatabase {
     fn ast_id_map(&self, file_id: HirFileId) -> Arc<AstIdMap>;
-    #[salsa::transparent]
-    fn ast_id_to_node(&self, file_id: HirFileId, ast_id: ErasedFileAstId) -> SyntaxNode;
 
     #[salsa::transparent]
     fn parse_or_expand(&self, file_id: HirFileId) -> Option<SyntaxNode>;
@@ -34,15 +32,6 @@ pub(crate) fn ast_id_map(db: &impl AstDatabase, file_id: HirFileId) -> Arc<AstId
     Arc::new(map)
 }
 
-pub(crate) fn ast_id_to_node(
-    db: &impl AstDatabase,
-    file_id: HirFileId,
-    ast_id: ErasedFileAstId,
-) -> SyntaxNode {
-    let node = db.parse_or_expand(file_id).unwrap();
-    db.ast_id_map(file_id)[ast_id].to_node(&node)
-}
-
 pub(crate) fn macro_def(db: &impl AstDatabase, id: MacroDefId) -> Option<Arc<MacroRules>> {
     let macro_call = id.ast_id.to_node(db);
     let arg = macro_call.token_tree()?;
diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs
index 002a5b45a..1fb124374 100644
--- a/crates/ra_hir_expand/src/lib.rs
+++ b/crates/ra_hir_expand/src/lib.rs
@@ -171,7 +171,8 @@ impl<N: AstNode> AstId<N> {
     }
 
     pub fn to_node(&self, db: &impl AstDatabase) -> N {
-        let syntax_node = db.ast_id_to_node(self.file_id, self.file_ast_id.into());
-        N::cast(syntax_node).unwrap()
+        let root = db.parse_or_expand(self.file_id).unwrap();
+        let node = db.ast_id_map(self.file_id)[self.file_ast_id.into()].to_node(&root);
+        N::cast(node).unwrap()
     }
 }
-- 
cgit v1.2.3


From 2a5254c106df41dc53c34508e9f5ba77243b7a51 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Tue, 29 Oct 2019 15:25:46 +0300
Subject: reduce visibility

---
 crates/ra_hir_expand/src/ast_id_map.rs | 22 ++++++----------------
 crates/ra_hir_expand/src/lib.rs        |  3 +--
 2 files changed, 7 insertions(+), 18 deletions(-)

(limited to 'crates/ra_hir_expand/src')

diff --git a/crates/ra_hir_expand/src/ast_id_map.rs b/crates/ra_hir_expand/src/ast_id_map.rs
index 2f43abe15..919ede0a0 100644
--- a/crates/ra_hir_expand/src/ast_id_map.rs
+++ b/crates/ra_hir_expand/src/ast_id_map.rs
@@ -8,11 +8,10 @@
 use std::{
     hash::{Hash, Hasher},
     marker::PhantomData,
-    ops,
 };
 
 use ra_arena::{impl_arena_id, Arena, RawId};
-use ra_syntax::{ast, AstNode, SyntaxNode, SyntaxNodePtr};
+use ra_syntax::{ast, AstNode, AstPtr, SyntaxNode, SyntaxNodePtr};
 
 /// `AstId` points to an AST node in a specific file.
 #[derive(Debug)]
@@ -40,14 +39,8 @@ impl<N: AstNode> Hash for FileAstId<N> {
     }
 }
 
-impl<N: AstNode> From<FileAstId<N>> for ErasedFileAstId {
-    fn from(id: FileAstId<N>) -> Self {
-        id.raw
-    }
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct ErasedFileAstId(RawId);
+struct ErasedFileAstId(RawId);
 impl_arena_id!(ErasedFileAstId);
 
 /// Maps items' `SyntaxNode`s to `ErasedFileAstId`s and back.
@@ -90,15 +83,12 @@ impl AstIdMap {
         }
     }
 
-    fn alloc(&mut self, item: &SyntaxNode) -> ErasedFileAstId {
-        self.arena.alloc(SyntaxNodePtr::new(item))
+    pub fn get<N: AstNode>(&self, id: FileAstId<N>) -> AstPtr<N> {
+        self.arena[id.raw].cast::<N>().unwrap()
     }
-}
 
-impl ops::Index<ErasedFileAstId> for AstIdMap {
-    type Output = SyntaxNodePtr;
-    fn index(&self, index: ErasedFileAstId) -> &SyntaxNodePtr {
-        &self.arena[index]
+    fn alloc(&mut self, item: &SyntaxNode) -> ErasedFileAstId {
+        self.arena.alloc(SyntaxNodePtr::new(item))
     }
 }
 
diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs
index 1fb124374..a31b9fa4c 100644
--- a/crates/ra_hir_expand/src/lib.rs
+++ b/crates/ra_hir_expand/src/lib.rs
@@ -172,7 +172,6 @@ impl<N: AstNode> AstId<N> {
 
     pub fn to_node(&self, db: &impl AstDatabase) -> N {
         let root = db.parse_or_expand(self.file_id).unwrap();
-        let node = db.ast_id_map(self.file_id)[self.file_ast_id.into()].to_node(&root);
-        N::cast(node).unwrap()
+        db.ast_id_map(self.file_id).get(self.file_ast_id).to_node(&root)
     }
 }
-- 
cgit v1.2.3


From 7de6eaa58ae994a5c5d39a66253e347fb039fa94 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Tue, 29 Oct 2019 16:01:14 +0300
Subject: remove not that useful indirection

---
 crates/ra_hir_expand/src/lib.rs | 18 ++++--------------
 1 file changed, 4 insertions(+), 14 deletions(-)

(limited to 'crates/ra_hir_expand/src')

diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs
index a31b9fa4c..9100bd15c 100644
--- a/crates/ra_hir_expand/src/lib.rs
+++ b/crates/ra_hir_expand/src/lib.rs
@@ -1,8 +1,8 @@
-//! `ra_hir_def` contains initial "phases" of the compiler. Roughly, everything
-//! before types.
+//! `ra_hir_expand` deals with macro expansion.
 //!
-//! Note that we are in the process of moving parts of `ra_hir` into
-//! `ra_hir_def`, so this crates doesn't contain a lot at the moment.
+//! Specifically, it implements a concept of `MacroFile` -- a file whose syntax
+//! tree originates not from the text of some `FileId`, but from some macro
+//! expansion.
 
 pub mod db;
 pub mod ast_id_map;
@@ -116,22 +116,12 @@ pub struct MacroCallLoc {
 }
 
 impl MacroCallId {
-    pub fn loc(self, db: &impl AstDatabase) -> MacroCallLoc {
-        db.lookup_intern_macro(self)
-    }
-
     pub fn as_file(self, kind: MacroFileKind) -> HirFileId {
         let macro_file = MacroFile { macro_call_id: self, macro_file_kind: kind };
         macro_file.into()
     }
 }
 
-impl MacroCallLoc {
-    pub fn id(self, db: &impl AstDatabase) -> MacroCallId {
-        db.intern_macro(self)
-    }
-}
-
 /// `AstId` points to an AST node in any file.
 ///
 /// It is stable across reparses, and can be used as salsa key/value.
-- 
cgit v1.2.3


From 1ec418c3b8af987e1531c5cfd5bc1e817f237036 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Tue, 29 Oct 2019 16:03:29 +0300
Subject: add doc comment

---
 crates/ra_hir_expand/src/db.rs | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'crates/ra_hir_expand/src')

diff --git a/crates/ra_hir_expand/src/db.rs b/crates/ra_hir_expand/src/db.rs
index 8b92d4c1f..dc4944c05 100644
--- a/crates/ra_hir_expand/src/db.rs
+++ b/crates/ra_hir_expand/src/db.rs
@@ -1,3 +1,5 @@
+//! Defines database & queries for macro expansion.
+
 use std::sync::Arc;
 
 use mbe::MacroRules;
-- 
cgit v1.2.3


From 3260639608112738089d134c47c1d575515c9cb7 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Tue, 29 Oct 2019 16:08:06 +0300
Subject: reduce visibility

---
 crates/ra_hir_expand/src/ast_id_map.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'crates/ra_hir_expand/src')

diff --git a/crates/ra_hir_expand/src/ast_id_map.rs b/crates/ra_hir_expand/src/ast_id_map.rs
index 919ede0a0..cb464c3ff 100644
--- a/crates/ra_hir_expand/src/ast_id_map.rs
+++ b/crates/ra_hir_expand/src/ast_id_map.rs
@@ -50,7 +50,7 @@ pub struct AstIdMap {
 }
 
 impl AstIdMap {
-    pub fn from_source(node: &SyntaxNode) -> AstIdMap {
+    pub(crate) fn from_source(node: &SyntaxNode) -> AstIdMap {
         assert!(node.parent().is_none());
         let mut res = AstIdMap { arena: Arena::default() };
         // By walking the tree in bread-first order we make sure that parents
@@ -83,7 +83,7 @@ impl AstIdMap {
         }
     }
 
-    pub fn get<N: AstNode>(&self, id: FileAstId<N>) -> AstPtr<N> {
+    pub(crate) fn get<N: AstNode>(&self, id: FileAstId<N>) -> AstPtr<N> {
         self.arena[id.raw].cast::<N>().unwrap()
     }
 
-- 
cgit v1.2.3


From 99b6ecfab061396613c5f459fae43ea17b5675b8 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Tue, 29 Oct 2019 16:12:54 +0300
Subject: switch expand to dyn Trait

---
 crates/ra_hir_expand/src/db.rs  | 12 ++++++------
 crates/ra_hir_expand/src/lib.rs |  6 +++---
 2 files changed, 9 insertions(+), 9 deletions(-)

(limited to 'crates/ra_hir_expand/src')

diff --git a/crates/ra_hir_expand/src/db.rs b/crates/ra_hir_expand/src/db.rs
index dc4944c05..a4ee9a529 100644
--- a/crates/ra_hir_expand/src/db.rs
+++ b/crates/ra_hir_expand/src/db.rs
@@ -28,13 +28,13 @@ pub trait AstDatabase: SourceDatabase {
     fn macro_expand(&self, macro_call: MacroCallId) -> Result<Arc<tt::Subtree>, String>;
 }
 
-pub(crate) fn ast_id_map(db: &impl AstDatabase, file_id: HirFileId) -> Arc<AstIdMap> {
+pub(crate) fn ast_id_map(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<AstIdMap> {
     let map =
         db.parse_or_expand(file_id).map_or_else(AstIdMap::default, |it| AstIdMap::from_source(&it));
     Arc::new(map)
 }
 
-pub(crate) fn macro_def(db: &impl AstDatabase, id: MacroDefId) -> Option<Arc<MacroRules>> {
+pub(crate) fn macro_def(db: &dyn 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(|| {
@@ -48,7 +48,7 @@ pub(crate) fn macro_def(db: &impl AstDatabase, id: MacroDefId) -> Option<Arc<Mac
     Some(Arc::new(rules))
 }
 
-pub(crate) fn macro_arg(db: &impl AstDatabase, id: MacroCallId) -> Option<Arc<tt::Subtree>> {
+pub(crate) fn macro_arg(db: &dyn AstDatabase, id: MacroCallId) -> Option<Arc<tt::Subtree>> {
     let loc = db.lookup_intern_macro(id);
     let macro_call = loc.ast_id.to_node(db);
     let arg = macro_call.token_tree()?;
@@ -57,7 +57,7 @@ pub(crate) fn macro_arg(db: &impl AstDatabase, id: MacroCallId) -> Option<Arc<tt
 }
 
 pub(crate) fn macro_expand(
-    db: &impl AstDatabase,
+    db: &dyn AstDatabase,
     id: MacroCallId,
 ) -> Result<Arc<tt::Subtree>, String> {
     let loc = db.lookup_intern_macro(id);
@@ -73,7 +73,7 @@ pub(crate) fn macro_expand(
     Ok(Arc::new(tt))
 }
 
-pub(crate) fn parse_or_expand(db: &impl AstDatabase, file_id: HirFileId) -> Option<SyntaxNode> {
+pub(crate) fn parse_or_expand(db: &dyn AstDatabase, file_id: HirFileId) -> Option<SyntaxNode> {
     match file_id.0 {
         HirFileIdRepr::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()),
         HirFileIdRepr::MacroFile(macro_file) => {
@@ -83,7 +83,7 @@ pub(crate) fn parse_or_expand(db: &impl AstDatabase, file_id: HirFileId) -> Opti
 }
 
 pub(crate) fn parse_macro(
-    db: &impl AstDatabase,
+    db: &dyn AstDatabase,
     macro_file: MacroFile,
 ) -> Option<Parse<SyntaxNode>> {
     let _p = profile("parse_macro_query");
diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs
index 9100bd15c..749227465 100644
--- a/crates/ra_hir_expand/src/lib.rs
+++ b/crates/ra_hir_expand/src/lib.rs
@@ -63,7 +63,7 @@ impl From<MacroFile> for HirFileId {
 impl HirFileId {
     /// For macro-expansion files, returns the file original source file the
     /// expansion originated from.
-    pub fn original_file(self, db: &impl AstDatabase) -> FileId {
+    pub fn original_file(self, db: &dyn AstDatabase) -> FileId {
         match self.0 {
             HirFileIdRepr::FileId(file_id) => file_id,
             HirFileIdRepr::MacroFile(macro_file) => {
@@ -74,7 +74,7 @@ impl HirFileId {
     }
 
     /// Get the crate which the macro lives in, if it is a macro file.
-    pub fn macro_crate(self, db: &impl AstDatabase) -> Option<CrateId> {
+    pub fn macro_crate(self, db: &dyn AstDatabase) -> Option<CrateId> {
         match self.0 {
             HirFileIdRepr::FileId(_) => None,
             HirFileIdRepr::MacroFile(macro_file) => {
@@ -160,7 +160,7 @@ impl<N: AstNode> AstId<N> {
         self.file_id
     }
 
-    pub fn to_node(&self, db: &impl AstDatabase) -> N {
+    pub fn to_node(&self, db: &dyn AstDatabase) -> N {
         let root = db.parse_or_expand(self.file_id).unwrap();
         db.ast_id_map(self.file_id).get(self.file_ast_id).to_node(&root)
     }
-- 
cgit v1.2.3


From bca708ba4c5eb474448ef2f2882a66ec935f2fee Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Tue, 29 Oct 2019 16:19:08 +0300
Subject: cleanup

---
 crates/ra_hir_expand/src/lib.rs | 22 ++++++++--------------
 1 file changed, 8 insertions(+), 14 deletions(-)

(limited to 'crates/ra_hir_expand/src')

diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs
index 749227465..6b3538673 100644
--- a/crates/ra_hir_expand/src/lib.rs
+++ b/crates/ra_hir_expand/src/lib.rs
@@ -14,19 +14,6 @@ use ra_syntax::ast::{self, AstNode};
 
 use crate::{ast_id_map::FileAstId, db::AstDatabase};
 
-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
-            }
-        }
-    };
-}
-
 /// 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
@@ -101,7 +88,14 @@ pub enum MacroFileKind {
 /// `println!("Hello, {}", world)`.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct MacroCallId(salsa::InternId);
-impl_intern_key!(MacroCallId);
+impl salsa::InternKey for MacroCallId {
+    fn from_intern_id(v: salsa::InternId) -> Self {
+        MacroCallId(v)
+    }
+    fn as_intern_id(&self) -> salsa::InternId {
+        self.0
+    }
+}
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct MacroDefId {
-- 
cgit v1.2.3


From 16e620c052016010b2f17070a98bdc1e7e849ab3 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Wed, 30 Oct 2019 16:12:55 +0300
Subject: move raw_items to hir_def

---
 crates/ra_hir_expand/src/lib.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'crates/ra_hir_expand/src')

diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs
index 6b3538673..3c0ef8f1c 100644
--- a/crates/ra_hir_expand/src/lib.rs
+++ b/crates/ra_hir_expand/src/lib.rs
@@ -12,7 +12,7 @@ use std::hash::{Hash, Hasher};
 use ra_db::{salsa, CrateId, FileId};
 use ra_syntax::ast::{self, AstNode};
 
-use crate::{ast_id_map::FileAstId, db::AstDatabase};
+use crate::ast_id_map::FileAstId;
 
 /// 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
@@ -50,7 +50,7 @@ impl From<MacroFile> for HirFileId {
 impl HirFileId {
     /// For macro-expansion files, returns the file original source file the
     /// expansion originated from.
-    pub fn original_file(self, db: &dyn AstDatabase) -> FileId {
+    pub fn original_file(self, db: &dyn db::AstDatabase) -> FileId {
         match self.0 {
             HirFileIdRepr::FileId(file_id) => file_id,
             HirFileIdRepr::MacroFile(macro_file) => {
@@ -61,7 +61,7 @@ impl HirFileId {
     }
 
     /// Get the crate which the macro lives in, if it is a macro file.
-    pub fn macro_crate(self, db: &dyn AstDatabase) -> Option<CrateId> {
+    pub fn macro_crate(self, db: &dyn db::AstDatabase) -> Option<CrateId> {
         match self.0 {
             HirFileIdRepr::FileId(_) => None,
             HirFileIdRepr::MacroFile(macro_file) => {
@@ -154,7 +154,7 @@ impl<N: AstNode> AstId<N> {
         self.file_id
     }
 
-    pub fn to_node(&self, db: &dyn AstDatabase) -> N {
+    pub fn to_node(&self, db: &dyn db::AstDatabase) -> N {
         let root = db.parse_or_expand(self.file_id).unwrap();
         db.ast_id_map(self.file_id).get(self.file_ast_id).to_node(&root)
     }
-- 
cgit v1.2.3


From b05d6e53fb0e9a008dc2e1220b1201818e63ed2d Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Wed, 30 Oct 2019 18:50:10 +0300
Subject: push either to hir_expand

---
 crates/ra_hir_expand/src/either.rs | 54 ++++++++++++++++++++++++++++++++++++++
 crates/ra_hir_expand/src/lib.rs    |  1 +
 2 files changed, 55 insertions(+)
 create mode 100644 crates/ra_hir_expand/src/either.rs

(limited to 'crates/ra_hir_expand/src')

diff --git a/crates/ra_hir_expand/src/either.rs b/crates/ra_hir_expand/src/either.rs
new file mode 100644
index 000000000..83583ef8b
--- /dev/null
+++ b/crates/ra_hir_expand/src/either.rs
@@ -0,0 +1,54 @@
+//! FIXME: write short doc here
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Either<A, B> {
+    A(A),
+    B(B),
+}
+
+impl<A, B> Either<A, B> {
+    pub fn either<R, F1, F2>(self, f1: F1, f2: F2) -> R
+    where
+        F1: FnOnce(A) -> R,
+        F2: FnOnce(B) -> R,
+    {
+        match self {
+            Either::A(a) => f1(a),
+            Either::B(b) => f2(b),
+        }
+    }
+    pub fn map<U, V, F1, F2>(self, f1: F1, f2: F2) -> Either<U, V>
+    where
+        F1: FnOnce(A) -> U,
+        F2: FnOnce(B) -> V,
+    {
+        match self {
+            Either::A(a) => Either::A(f1(a)),
+            Either::B(b) => Either::B(f2(b)),
+        }
+    }
+    pub fn map_a<U, F>(self, f: F) -> Either<U, B>
+    where
+        F: FnOnce(A) -> U,
+    {
+        self.map(f, |it| it)
+    }
+    pub fn a(self) -> Option<A> {
+        match self {
+            Either::A(it) => Some(it),
+            Either::B(_) => None,
+        }
+    }
+    pub fn b(self) -> Option<B> {
+        match self {
+            Either::A(_) => None,
+            Either::B(it) => Some(it),
+        }
+    }
+    pub fn as_ref(&self) -> Either<&A, &B> {
+        match self {
+            Either::A(it) => Either::A(it),
+            Either::B(it) => Either::B(it),
+        }
+    }
+}
diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs
index 3c0ef8f1c..6359b2b4d 100644
--- a/crates/ra_hir_expand/src/lib.rs
+++ b/crates/ra_hir_expand/src/lib.rs
@@ -6,6 +6,7 @@
 
 pub mod db;
 pub mod ast_id_map;
+pub mod either;
 
 use std::hash::{Hash, Hasher};
 
-- 
cgit v1.2.3


From 872ac566bfc6cf43ac55354cf5223b962dbc1d92 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Wed, 30 Oct 2019 18:56:20 +0300
Subject: push name down to hir_expand

---
 crates/ra_hir_expand/src/lib.rs  |   1 +
 crates/ra_hir_expand/src/name.rs | 142 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 143 insertions(+)
 create mode 100644 crates/ra_hir_expand/src/name.rs

(limited to 'crates/ra_hir_expand/src')

diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs
index 6359b2b4d..cf28de3d8 100644
--- a/crates/ra_hir_expand/src/lib.rs
+++ b/crates/ra_hir_expand/src/lib.rs
@@ -7,6 +7,7 @@
 pub mod db;
 pub mod ast_id_map;
 pub mod either;
+pub mod name;
 
 use std::hash::{Hash, Hasher};
 
diff --git a/crates/ra_hir_expand/src/name.rs b/crates/ra_hir_expand/src/name.rs
new file mode 100644
index 000000000..720896ee8
--- /dev/null
+++ b/crates/ra_hir_expand/src/name.rs
@@ -0,0 +1,142 @@
+//! FIXME: write short doc here
+
+use std::fmt;
+
+use ra_syntax::{ast, SmolStr};
+
+/// `Name` is a wrapper around string, which is used in hir for both references
+/// and declarations. In theory, names should also carry hygiene info, but we are
+/// not there yet!
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct Name(Repr);
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+enum Repr {
+    Text(SmolStr),
+    TupleField(usize),
+}
+
+impl fmt::Display for Name {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match &self.0 {
+            Repr::Text(text) => fmt::Display::fmt(&text, f),
+            Repr::TupleField(idx) => fmt::Display::fmt(&idx, f),
+        }
+    }
+}
+
+impl Name {
+    /// Note: this is private to make creating name from random string hard.
+    /// Hopefully, this should allow us to integrate hygiene cleaner in the
+    /// future, and to switch to interned representation of names.
+    const fn new_text(text: SmolStr) -> Name {
+        Name(Repr::Text(text))
+    }
+
+    pub fn new_tuple_field(idx: usize) -> Name {
+        Name(Repr::TupleField(idx))
+    }
+
+    /// Shortcut to create inline plain text name
+    const fn new_inline_ascii(len: usize, text: &[u8]) -> Name {
+        Name::new_text(SmolStr::new_inline_from_ascii(len, text))
+    }
+
+    /// Resolve a name from the text of token.
+    fn resolve(raw_text: &SmolStr) -> Name {
+        let raw_start = "r#";
+        if raw_text.as_str().starts_with(raw_start) {
+            Name::new_text(SmolStr::new(&raw_text[raw_start.len()..]))
+        } else {
+            Name::new_text(raw_text.clone())
+        }
+    }
+
+    pub fn missing() -> Name {
+        Name::new_text("[missing name]".into())
+    }
+
+    pub fn as_tuple_index(&self) -> Option<usize> {
+        match self.0 {
+            Repr::TupleField(idx) => Some(idx),
+            _ => None,
+        }
+    }
+}
+
+pub trait AsName {
+    fn as_name(&self) -> Name;
+}
+
+impl AsName for ast::NameRef {
+    fn as_name(&self) -> Name {
+        match self.as_tuple_field() {
+            Some(idx) => Name::new_tuple_field(idx),
+            None => Name::resolve(self.text()),
+        }
+    }
+}
+
+impl AsName for ast::Name {
+    fn as_name(&self) -> Name {
+        Name::resolve(self.text())
+    }
+}
+
+impl AsName for ast::FieldKind {
+    fn as_name(&self) -> Name {
+        match self {
+            ast::FieldKind::Name(nr) => nr.as_name(),
+            ast::FieldKind::Index(idx) => Name::new_tuple_field(idx.text().parse().unwrap()),
+        }
+    }
+}
+
+impl AsName for ra_db::Dependency {
+    fn as_name(&self) -> Name {
+        Name::new_text(self.name.clone())
+    }
+}
+
+// Primitives
+pub const ISIZE: Name = Name::new_inline_ascii(5, b"isize");
+pub const I8: Name = Name::new_inline_ascii(2, b"i8");
+pub const I16: Name = Name::new_inline_ascii(3, b"i16");
+pub const I32: Name = Name::new_inline_ascii(3, b"i32");
+pub const I64: Name = Name::new_inline_ascii(3, b"i64");
+pub const I128: Name = Name::new_inline_ascii(4, b"i128");
+pub const USIZE: Name = Name::new_inline_ascii(5, b"usize");
+pub const U8: Name = Name::new_inline_ascii(2, b"u8");
+pub const U16: Name = Name::new_inline_ascii(3, b"u16");
+pub const U32: Name = Name::new_inline_ascii(3, b"u32");
+pub const U64: Name = Name::new_inline_ascii(3, b"u64");
+pub const U128: Name = Name::new_inline_ascii(4, b"u128");
+pub const F32: Name = Name::new_inline_ascii(3, b"f32");
+pub const F64: Name = Name::new_inline_ascii(3, b"f64");
+pub const BOOL: Name = Name::new_inline_ascii(4, b"bool");
+pub const CHAR: Name = Name::new_inline_ascii(4, b"char");
+pub const STR: Name = Name::new_inline_ascii(3, b"str");
+
+// Special names
+pub const SELF_PARAM: Name = Name::new_inline_ascii(4, b"self");
+pub const SELF_TYPE: Name = Name::new_inline_ascii(4, b"Self");
+pub const MACRO_RULES: Name = Name::new_inline_ascii(11, b"macro_rules");
+
+// Components of known path (value or mod name)
+pub const STD: Name = Name::new_inline_ascii(3, b"std");
+pub const ITER: Name = Name::new_inline_ascii(4, b"iter");
+pub const OPS: Name = Name::new_inline_ascii(3, b"ops");
+pub const FUTURE: Name = Name::new_inline_ascii(6, b"future");
+pub const RESULT: Name = Name::new_inline_ascii(6, b"result");
+pub const BOXED: Name = Name::new_inline_ascii(5, b"boxed");
+
+// Components of known path (type name)
+pub const INTO_ITERATOR_TYPE: Name = Name::new_inline_ascii(12, b"IntoIterator");
+pub const ITEM_TYPE: Name = Name::new_inline_ascii(4, b"Item");
+pub const TRY_TYPE: Name = Name::new_inline_ascii(3, b"Try");
+pub const OK_TYPE: Name = Name::new_inline_ascii(2, b"Ok");
+pub const FUTURE_TYPE: Name = Name::new_inline_ascii(6, b"Future");
+pub const RESULT_TYPE: Name = Name::new_inline_ascii(6, b"Result");
+pub const OUTPUT_TYPE: Name = Name::new_inline_ascii(6, b"Output");
+pub const TARGET_TYPE: Name = Name::new_inline_ascii(6, b"Target");
+pub const BOX_TYPE: Name = Name::new_inline_ascii(3, b"Box");
-- 
cgit v1.2.3


From ab559f170ee02e3bdd9aeeb55933bb143b520c34 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Wed, 30 Oct 2019 19:10:53 +0300
Subject: move hygiene to hir_expand

---
 crates/ra_hir_expand/src/hygiene.rs | 46 +++++++++++++++++++++++++++++++++++++
 crates/ra_hir_expand/src/lib.rs     | 12 +---------
 2 files changed, 47 insertions(+), 11 deletions(-)
 create mode 100644 crates/ra_hir_expand/src/hygiene.rs

(limited to 'crates/ra_hir_expand/src')

diff --git a/crates/ra_hir_expand/src/hygiene.rs b/crates/ra_hir_expand/src/hygiene.rs
new file mode 100644
index 000000000..77428ec99
--- /dev/null
+++ b/crates/ra_hir_expand/src/hygiene.rs
@@ -0,0 +1,46 @@
+//! This modules handles hygiene information.
+//!
+//! Specifically, `ast` + `Hygiene` allows you to create a `Name`. Note that, at
+//! this moment, this is horribly incomplete and handles only `$crate`.
+use ra_db::CrateId;
+use ra_syntax::ast;
+
+use crate::{
+    db::AstDatabase,
+    either::Either,
+    name::{AsName, Name},
+    HirFileId, HirFileIdRepr,
+};
+
+#[derive(Debug)]
+pub struct Hygiene {
+    // This is what `$crate` expands to
+    def_crate: Option<CrateId>,
+}
+
+impl Hygiene {
+    pub fn new(db: &impl AstDatabase, file_id: HirFileId) -> Hygiene {
+        let def_crate = match file_id.0 {
+            HirFileIdRepr::FileId(_) => None,
+            HirFileIdRepr::MacroFile(macro_file) => {
+                let loc = db.lookup_intern_macro(macro_file.macro_call_id);
+                Some(loc.def.krate)
+            }
+        };
+        Hygiene { def_crate }
+    }
+
+    pub fn new_unhygienic() -> Hygiene {
+        Hygiene { def_crate: None }
+    }
+
+    // FIXME: this should just return name
+    pub fn name_ref_to_name(&self, name_ref: ast::NameRef) -> Either<Name, CrateId> {
+        if let Some(def_crate) = self.def_crate {
+            if name_ref.text() == "$crate" {
+                return Either::B(def_crate);
+            }
+        }
+        Either::A(name_ref.as_name())
+    }
+}
diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs
index cf28de3d8..5a0e5a19c 100644
--- a/crates/ra_hir_expand/src/lib.rs
+++ b/crates/ra_hir_expand/src/lib.rs
@@ -8,6 +8,7 @@ pub mod db;
 pub mod ast_id_map;
 pub mod either;
 pub mod name;
+pub mod hygiene;
 
 use std::hash::{Hash, Hasher};
 
@@ -61,17 +62,6 @@ impl HirFileId {
             }
         }
     }
-
-    /// Get the crate which the macro lives in, if it is a macro file.
-    pub fn macro_crate(self, db: &dyn db::AstDatabase) -> Option<CrateId> {
-        match self.0 {
-            HirFileIdRepr::FileId(_) => None,
-            HirFileIdRepr::MacroFile(macro_file) => {
-                let loc = db.lookup_intern_macro(macro_file.macro_call_id);
-                Some(loc.def.krate)
-            }
-        }
-    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-- 
cgit v1.2.3