1 files changed, 254 insertions, 132 deletions

diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index cbce04315..94da700ad 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -4,6 +4,7 @@
 //! resolves imports and expands macros.
 
 use hir_expand::{
+    ast_id_map::FileAstId,
     builtin_derive::find_builtin_derive,
     builtin_macro::find_builtin_macro,
     name::{name, AsName, Name},
@@ -19,13 +20,16 @@ use test_utils::mark;
 use crate::{
     attr::Attrs,
     db::DefDatabase,
+    item_tree::{
+        self, FileItemTreeId, ItemTree, ItemTreeId, MacroCall, Mod, ModItem, ModKind, StructDefKind,
+    },
     nameres::{
         diagnostics::DefDiagnostic, mod_resolution::ModDir, path_resolution::ReachedFixedPoint,
-        raw, BuiltinShadowMode, CrateDefMap, ModuleData, ModuleOrigin, ResolveMode,
+        BuiltinShadowMode, CrateDefMap, ModuleData, ModuleOrigin, ResolveMode,
     },
     path::{ImportAlias, ModPath, PathKind},
     per_ns::PerNs,
-    visibility::Visibility,
+    visibility::{RawVisibility, Visibility},
     AdtId, AsMacroCall, AstId, AstIdWithPath, ConstLoc, ContainerId, EnumLoc, EnumVariantId,
     FunctionLoc, ImplLoc, Intern, LocalModuleId, ModuleDefId, ModuleId, StaticLoc, StructLoc,
     TraitLoc, TypeAliasLoc, UnionLoc,
@@ -102,10 +106,50 @@ impl PartialResolvedImport {
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
+struct Import {
+    pub path: ModPath,
+    pub alias: Option<ImportAlias>,
+    pub visibility: RawVisibility,
+    pub is_glob: bool,
+    pub is_prelude: bool,
+    pub is_extern_crate: bool,
+    pub is_macro_use: bool,
+}
+
+impl Import {
+    fn from_use(tree: &ItemTree, id: FileItemTreeId<item_tree::Import>) -> Self {
+        let it = &tree[id];
+        let visibility = &tree[it.visibility];
+        Self {
+            path: it.path.clone(),
+            alias: it.alias.clone(),
+            visibility: visibility.clone(),
+            is_glob: it.is_glob,
+            is_prelude: it.is_prelude,
+            is_extern_crate: false,
+            is_macro_use: false,
+        }
+    }
+
+    fn from_extern_crate(tree: &ItemTree, id: FileItemTreeId<item_tree::ExternCrate>) -> Self {
+        let it = &tree[id];
+        let visibility = &tree[it.visibility];
+        Self {
+            path: it.path.clone(),
+            alias: it.alias.clone(),
+            visibility: visibility.clone(),
+            is_glob: false,
+            is_prelude: false,
+            is_extern_crate: true,
+            is_macro_use: it.is_macro_use,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
 struct ImportDirective {
     module_id: LocalModuleId,
-    import_id: raw::Import,
-    import: raw::ImportData,
+    import: Import,
     status: PartialResolvedImport,
 }
 
@@ -123,6 +167,13 @@ struct DeriveDirective {
     ast_id: AstIdWithPath<ast::ModuleItem>,
 }
 
+struct DefData<'a> {
+    id: ModuleDefId,
+    name: &'a Name,
+    visibility: &'a RawVisibility,
+    has_constructor: bool,
+}
+
 /// Walks the tree of module recursively
 struct DefCollector<'a> {
     db: &'a dyn DefDatabase,
@@ -140,7 +191,7 @@ struct DefCollector<'a> {
 impl DefCollector<'_> {
     fn collect(&mut self) {
         let file_id = self.db.crate_graph()[self.def_map.krate].root_file_id;
-        let raw_items = self.db.raw_items(file_id.into());
+        let item_tree = self.db.item_tree(file_id.into());
         let module_id = self.def_map.root;
         self.def_map.modules[module_id].origin = ModuleOrigin::CrateRoot { definition: file_id };
         ModCollector {
@@ -148,10 +199,10 @@ impl DefCollector<'_> {
             macro_depth: 0,
             module_id,
             file_id: file_id.into(),
-            raw_items: &raw_items,
+            item_tree: &item_tree,
             mod_dir: ModDir::root(),
         }
-        .collect(raw_items.items());
+        .collect(item_tree.top_level_items());
 
         // main name resolution fixed-point loop.
         let mut i = 0;
@@ -286,7 +337,7 @@ impl DefCollector<'_> {
     fn import_macros_from_extern_crate(
         &mut self,
         current_module_id: LocalModuleId,
-        import: &raw::ImportData,
+        import: &item_tree::ExternCrate,
     ) {
         log::debug!(
             "importing macros from extern crate: {:?} ({:?})",
@@ -352,11 +403,7 @@ impl DefCollector<'_> {
         }
     }
 
-    fn resolve_import(
-        &self,
-        module_id: LocalModuleId,
-        import: &raw::ImportData,
-    ) -> PartialResolvedImport {
+    fn resolve_import(&self, module_id: LocalModuleId, import: &Import) -> PartialResolvedImport {
         log::debug!("resolving import: {:?} ({:?})", import, self.def_map.edition);
         if import.is_extern_crate {
             let res = self.def_map.resolve_name_in_extern_prelude(
@@ -649,17 +696,17 @@ impl DefCollector<'_> {
         depth: usize,
     ) {
         let file_id: HirFileId = macro_call_id.as_file();
-        let raw_items = self.db.raw_items(file_id);
+        let item_tree = self.db.item_tree(file_id);
         let mod_dir = self.mod_dirs[&module_id].clone();
         ModCollector {
             def_collector: &mut *self,
             macro_depth: depth,
             file_id,
             module_id,
-            raw_items: &raw_items,
+            item_tree: &item_tree,
             mod_dir,
         }
-        .collect(raw_items.items());
+        .collect(item_tree.top_level_items());
     }
 
     fn finish(self) -> CrateDefMap {
@@ -673,12 +720,12 @@ struct ModCollector<'a, 'b> {
     macro_depth: usize,
     module_id: LocalModuleId,
     file_id: HirFileId,
-    raw_items: &'a raw::RawItems,
+    item_tree: &'a ItemTree,
     mod_dir: ModDir,
 }
 
 impl ModCollector<'_, '_> {
-    fn collect(&mut self, items: &[raw::RawItem]) {
+    fn collect(&mut self, items: &[ModItem]) {
         // Note: don't assert that inserted value is fresh: it's simply not true
         // for macros.
         self.def_collector.mod_dirs.insert(self.module_id, self.mod_dir.clone());
@@ -695,64 +742,204 @@ impl ModCollector<'_, '_> {
         // `#[macro_use] extern crate` is hoisted to imports macros before collecting
         // any other items.
         for item in items {
-            if self.is_cfg_enabled(&item.attrs) {
-                if let raw::RawItemKind::Import(import_id) = item.kind {
-                    let import = self.raw_items[import_id].clone();
-                    if import.is_extern_crate && import.is_macro_use {
+            if self.is_cfg_enabled(self.item_tree.attrs(*item)) {
+                if let ModItem::ExternCrate(id) = item {
+                    let import = self.item_tree[*id].clone();
+                    if import.is_macro_use {
                         self.def_collector.import_macros_from_extern_crate(self.module_id, &import);
                     }
                 }
             }
         }
 
-        for item in items {
-            if self.is_cfg_enabled(&item.attrs) {
-                match item.kind {
-                    raw::RawItemKind::Module(m) => {
-                        self.collect_module(&self.raw_items[m], &item.attrs)
-                    }
-                    raw::RawItemKind::Import(import_id) => {
+        for &item in items {
+            let attrs = self.item_tree.attrs(item);
+            if self.is_cfg_enabled(attrs) {
+                let module =
+                    ModuleId { krate: self.def_collector.def_map.krate, local_id: self.module_id };
+                let container = ContainerId::ModuleId(module);
+
+                let mut def = None;
+                match item {
+                    ModItem::Mod(m) => self.collect_module(&self.item_tree[m], attrs),
+                    ModItem::Import(import_id) => {
                         self.def_collector.unresolved_imports.push(ImportDirective {
                             module_id: self.module_id,
-                            import_id,
-                            import: self.raw_items[import_id].clone(),
+                            import: Import::from_use(&self.item_tree, import_id),
                             status: PartialResolvedImport::Unresolved,
                         })
                     }
-                    raw::RawItemKind::Def(def) => {
-                        self.define_def(&self.raw_items[def], &item.attrs)
+                    ModItem::ExternCrate(import_id) => {
+                        self.def_collector.unresolved_imports.push(ImportDirective {
+                            module_id: self.module_id,
+                            import: Import::from_extern_crate(&self.item_tree, import_id),
+                            status: PartialResolvedImport::Unresolved,
+                        })
                     }
-                    raw::RawItemKind::Macro(mac) => self.collect_macro(&self.raw_items[mac]),
-                    raw::RawItemKind::Impl(imp) => {
+                    ModItem::MacroCall(mac) => self.collect_macro(&self.item_tree[mac]),
+                    ModItem::Impl(imp) => {
                         let module = ModuleId {
                             krate: self.def_collector.def_map.krate,
                             local_id: self.module_id,
                         };
                         let container = ContainerId::ModuleId(module);
-                        let ast_id = self.raw_items[imp].ast_id;
-                        let impl_id =
-                            ImplLoc { container, ast_id: AstId::new(self.file_id, ast_id) }
-                                .intern(self.def_collector.db);
+                        let impl_id = ImplLoc { container, id: ItemTreeId::new(self.file_id, imp) }
+                            .intern(self.def_collector.db);
                         self.def_collector.def_map.modules[self.module_id]
                             .scope
                             .define_impl(impl_id)
                     }
+                    ModItem::Function(id) => {
+                        let func = &self.item_tree[id];
+                        def = Some(DefData {
+                            id: FunctionLoc {
+                                container: container.into(),
+                                id: ItemTreeId::new(self.file_id, id),
+                            }
+                            .intern(self.def_collector.db)
+                            .into(),
+                            name: &func.name,
+                            visibility: &self.item_tree[func.visibility],
+                            has_constructor: false,
+                        });
+                    }
+                    ModItem::Struct(id) => {
+                        let it = &self.item_tree[id];
+
+                        // FIXME: check attrs to see if this is an attribute macro invocation;
+                        // in which case we don't add the invocation, just a single attribute
+                        // macro invocation
+                        self.collect_derives(attrs, it.ast_id.upcast());
+
+                        def = Some(DefData {
+                            id: StructLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                                .intern(self.def_collector.db)
+                                .into(),
+                            name: &it.name,
+                            visibility: &self.item_tree[it.visibility],
+                            has_constructor: it.kind != StructDefKind::Record,
+                        });
+                    }
+                    ModItem::Union(id) => {
+                        let it = &self.item_tree[id];
+
+                        // FIXME: check attrs to see if this is an attribute macro invocation;
+                        // in which case we don't add the invocation, just a single attribute
+                        // macro invocation
+                        self.collect_derives(attrs, it.ast_id.upcast());
+
+                        def = Some(DefData {
+                            id: UnionLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                                .intern(self.def_collector.db)
+                                .into(),
+                            name: &it.name,
+                            visibility: &self.item_tree[it.visibility],
+                            has_constructor: false,
+                        });
+                    }
+                    ModItem::Enum(id) => {
+                        let it = &self.item_tree[id];
+
+                        // FIXME: check attrs to see if this is an attribute macro invocation;
+                        // in which case we don't add the invocation, just a single attribute
+                        // macro invocation
+                        self.collect_derives(attrs, it.ast_id.upcast());
+
+                        def = Some(DefData {
+                            id: EnumLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                                .intern(self.def_collector.db)
+                                .into(),
+                            name: &it.name,
+                            visibility: &self.item_tree[it.visibility],
+                            has_constructor: false,
+                        });
+                    }
+                    ModItem::Const(id) => {
+                        let it = &self.item_tree[id];
+
+                        if let Some(name) = &it.name {
+                            def = Some(DefData {
+                                id: ConstLoc {
+                                    container: container.into(),
+                                    id: ItemTreeId::new(self.file_id, id),
+                                }
+                                .intern(self.def_collector.db)
+                                .into(),
+                                name,
+                                visibility: &self.item_tree[it.visibility],
+                                has_constructor: false,
+                            });
+                        }
+                    }
+                    ModItem::Static(id) => {
+                        let it = &self.item_tree[id];
+
+                        def = Some(DefData {
+                            id: StaticLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                                .intern(self.def_collector.db)
+                                .into(),
+                            name: &it.name,
+                            visibility: &self.item_tree[it.visibility],
+                            has_constructor: false,
+                        });
+                    }
+                    ModItem::Trait(id) => {
+                        let it = &self.item_tree[id];
+
+                        def = Some(DefData {
+                            id: TraitLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                                .intern(self.def_collector.db)
+                                .into(),
+                            name: &it.name,
+                            visibility: &self.item_tree[it.visibility],
+                            has_constructor: false,
+                        });
+                    }
+                    ModItem::TypeAlias(id) => {
+                        let it = &self.item_tree[id];
+
+                        def = Some(DefData {
+                            id: TypeAliasLoc {
+                                container: container.into(),
+                                id: ItemTreeId::new(self.file_id, id),
+                            }
+                            .intern(self.def_collector.db)
+                            .into(),
+                            name: &it.name,
+                            visibility: &self.item_tree[it.visibility],
+                            has_constructor: false,
+                        });
+                    }
+                }
+
+                if let Some(DefData { id, name, visibility, has_constructor }) = def {
+                    self.def_collector.def_map.modules[self.module_id].scope.define_def(id);
+                    let vis = self
+                        .def_collector
+                        .def_map
+                        .resolve_visibility(self.def_collector.db, self.module_id, visibility)
+                        .unwrap_or(Visibility::Public);
+                    self.def_collector.update(
+                        self.module_id,
+                        &[(name.clone(), PerNs::from_def(id, vis, has_constructor))],
+                        vis,
+                    )
                 }
             }
         }
     }
 
-    fn collect_module(&mut self, module: &raw::ModuleData, attrs: &Attrs) {
+    fn collect_module(&mut self, module: &Mod, attrs: &Attrs) {
         let path_attr = attrs.by_key("path").string_value();
         let is_macro_use = attrs.by_key("macro_use").exists();
-        match module {
+        match &module.kind {
             // inline module, just recurse
-            raw::ModuleData::Definition { name, visibility, items, ast_id } => {
+            ModKind::Inline { items } => {
                 let module_id = self.push_child_module(
-                    name.clone(),
-                    AstId::new(self.file_id, *ast_id),
+                    module.name.clone(),
+                    AstId::new(self.file_id, module.ast_id),
                     None,
-                    &visibility,
+                    &self.item_tree[module.visibility],
                 );
 
                 ModCollector {
@@ -760,8 +947,8 @@ impl ModCollector<'_, '_> {
                     macro_depth: self.macro_depth,
                     module_id,
                     file_id: self.file_id,
-                    raw_items: self.raw_items,
-                    mod_dir: self.mod_dir.descend_into_definition(name, path_attr),
+                    item_tree: self.item_tree,
+                    mod_dir: self.mod_dir.descend_into_definition(&module.name, path_attr),
                 }
                 .collect(&*items);
                 if is_macro_use {
@@ -769,31 +956,31 @@ impl ModCollector<'_, '_> {
                 }
             }
             // out of line module, resolve, parse and recurse
-            raw::ModuleData::Declaration { name, visibility, ast_id } => {
-                let ast_id = AstId::new(self.file_id, *ast_id);
+            ModKind::Outline {} => {
+                let ast_id = AstId::new(self.file_id, module.ast_id);
                 match self.mod_dir.resolve_declaration(
                     self.def_collector.db,
                     self.file_id,
-                    name,
+                    &module.name,
                     path_attr,
                 ) {
                     Ok((file_id, is_mod_rs, mod_dir)) => {
                         let module_id = self.push_child_module(
-                            name.clone(),
+                            module.name.clone(),
                             ast_id,
                             Some((file_id, is_mod_rs)),
-                            &visibility,
+                            &self.item_tree[module.visibility],
                         );
-                        let raw_items = self.def_collector.db.raw_items(file_id.into());
+                        let item_tree = self.def_collector.db.item_tree(file_id.into());
                         ModCollector {
                             def_collector: &mut *self.def_collector,
                             macro_depth: self.macro_depth,
                             module_id,
                             file_id: file_id.into(),
-                            raw_items: &raw_items,
+                            item_tree: &item_tree,
                             mod_dir,
                         }
-                        .collect(raw_items.items());
+                        .collect(item_tree.top_level_items());
                         if is_macro_use {
                             self.import_all_legacy_macros(module_id);
                         }
@@ -842,77 +1029,7 @@ impl ModCollector<'_, '_> {
         res
     }
 
-    fn define_def(&mut self, def: &raw::DefData, attrs: &Attrs) {
-        let module = ModuleId { krate: self.def_collector.def_map.krate, local_id: self.module_id };
-        // FIXME: check attrs to see if this is an attribute macro invocation;
-        // in which case we don't add the invocation, just a single attribute
-        // macro invocation
-        self.collect_derives(attrs, def);
-
-        let name = def.name.clone();
-        let container = ContainerId::ModuleId(module);
-        let vis = &def.visibility;
-        let mut has_constructor = false;
-
-        let def: ModuleDefId = match def.kind {
-            raw::DefKind::Function(ast_id) => FunctionLoc {
-                container: container.into(),
-                ast_id: AstId::new(self.file_id, ast_id),
-            }
-            .intern(self.def_collector.db)
-            .into(),
-            raw::DefKind::Struct(ast_id, mode) => {
-                has_constructor = mode != raw::StructDefKind::Record;
-                StructLoc { container, ast_id: AstId::new(self.file_id, ast_id) }
-                    .intern(self.def_collector.db)
-                    .into()
-            }
-            raw::DefKind::Union(ast_id) => {
-                UnionLoc { container, ast_id: AstId::new(self.file_id, ast_id) }
-                    .intern(self.def_collector.db)
-                    .into()
-            }
-            raw::DefKind::Enum(ast_id) => {
-                EnumLoc { container, ast_id: AstId::new(self.file_id, ast_id) }
-                    .intern(self.def_collector.db)
-                    .into()
-            }
-            raw::DefKind::Const(ast_id) => {
-                ConstLoc { container: container.into(), ast_id: AstId::new(self.file_id, ast_id) }
-                    .intern(self.def_collector.db)
-                    .into()
-            }
-            raw::DefKind::Static(ast_id) => {
-                StaticLoc { container, ast_id: AstId::new(self.file_id, ast_id) }
-                    .intern(self.def_collector.db)
-                    .into()
-            }
-            raw::DefKind::Trait(ast_id) => {
-                TraitLoc { container, ast_id: AstId::new(self.file_id, ast_id) }
-                    .intern(self.def_collector.db)
-                    .into()
-            }
-            raw::DefKind::TypeAlias(ast_id) => TypeAliasLoc {
-                container: container.into(),
-                ast_id: AstId::new(self.file_id, ast_id),
-            }
-            .intern(self.def_collector.db)
-            .into(),
-        };
-        self.def_collector.def_map.modules[self.module_id].scope.define_def(def);
-        let vis = self
-            .def_collector
-            .def_map
-            .resolve_visibility(self.def_collector.db, self.module_id, vis)
-            .unwrap_or(Visibility::Public);
-        self.def_collector.update(
-            self.module_id,
-            &[(name, PerNs::from_def(def, vis, has_constructor))],
-            vis,
-        )
-    }
-
-    fn collect_derives(&mut self, attrs: &Attrs, def: &raw::DefData) {
+    fn collect_derives(&mut self, attrs: &Attrs, ast_id: FileAstId<ast::ModuleItem>) {
         for derive_subtree in attrs.by_key("derive").tt_values() {
             // for #[derive(Copy, Clone)], `derive_subtree` is the `(Copy, Clone)` subtree
             for tt in &derive_subtree.token_trees {
@@ -923,7 +1040,7 @@ impl ModCollector<'_, '_> {
                 };
                 let path = ModPath::from_tt_ident(ident);
 
-                let ast_id = AstIdWithPath::new(self.file_id, def.kind.ast_id(), path);
+                let ast_id = AstIdWithPath::new(self.file_id, ast_id, path);
                 self.def_collector
                     .unexpanded_attribute_macros
                     .push(DeriveDirective { module_id: self.module_id, ast_id });
@@ -931,11 +1048,11 @@ impl ModCollector<'_, '_> {
         }
     }
 
-    fn collect_macro(&mut self, mac: &raw::MacroData) {
+    fn collect_macro(&mut self, mac: &MacroCall) {
         let mut ast_id = AstIdWithPath::new(self.file_id, mac.ast_id, mac.path.clone());
 
         // Case 0: builtin macros
-        if mac.builtin {
+        if mac.is_builtin {
             if let Some(name) = &mac.name {
                 let krate = self.def_collector.def_map.krate;
                 if let Some(macro_id) = find_builtin_macro(name, krate, ast_id.ast_id) {
@@ -943,7 +1060,7 @@ impl ModCollector<'_, '_> {
                         self.module_id,
                         name.clone(),
                         macro_id,
-                        mac.export,
+                        mac.is_export,
                     );
                     return;
                 }
@@ -957,9 +1074,14 @@ impl ModCollector<'_, '_> {
                     ast_id: Some(ast_id.ast_id),
                     krate: Some(self.def_collector.def_map.krate),
                     kind: MacroDefKind::Declarative,
-                    local_inner: mac.local_inner,
+                    local_inner: mac.is_local_inner,
                 };
-                self.def_collector.define_macro(self.module_id, name.clone(), macro_id, mac.export);
+                self.def_collector.define_macro(
+                    self.module_id,
+                    name.clone(),
+                    macro_id,
+                    mac.is_export,
+                );
             }
             return;
         }