4 files changed, 29 insertions, 519 deletions
diff --git a/crates/ra_hir/src/nameres/collector.rs b/crates/ra_hir/src/nameres/collector.rs
index b5fe16bfa..ee0a4c99f 100644
--- a/crates/ra_hir/src/nameres/collector.rs
+++ b/crates/ra_hir/src/nameres/collector.rs
@@ -1,5 +1,10 @@
 //! FIXME: write short doc here
+use hir_def::{
+    attr::Attr,
+    nameres::{mod_resolution::ModDir, raw},
+};
+use hir_expand::name;
 use ra_cfg::CfgOptions;
 use ra_db::FileId;
 use ra_syntax::{ast, SmolStr};
@@ -7,13 +12,11 @@ use rustc_hash::FxHashMap;
 use test_utils::tested_by;
 use crate::{
-    attr::Attr,
    db::DefDatabase,
    ids::{AstItemDef, LocationCtx, MacroCallId, MacroCallLoc, MacroDefId, MacroFileKind},
-    name::MACRO_RULES,
    nameres::{
-        diagnostics::DefDiagnostic, mod_resolution::ModDir, raw, Crate, CrateDefMap, CrateModuleId,
+        diagnostics::DefDiagnostic, Crate, CrateDefMap, CrateModuleId, ModuleData, ModuleDef,
-        ModuleData, ModuleDef, PerNs, ReachedFixedPoint, Resolution, ResolveMode,
+        PerNs, ReachedFixedPoint, Resolution, ResolveMode,
    },
    Adt, AstId, Const, Enum, Function, HirFileId, MacroDef, Module, Name, Path, PathKind, Static,
    Struct, Trait, TypeAlias, Union,
@@ -212,7 +215,7 @@ where
        if let Some(ModuleDef::Module(m)) = res.take_types() {
            tested_by!(macro_rules_from_other_crates_are_visible_with_macro_use);
-            self.import_all_macros_exported(current_module_id, m.krate);
+            self.import_all_macros_exported(current_module_id, m.krate());
        }
    }
@@ -289,11 +292,11 @@ where
                    if import.is_prelude {
                        tested_by!(std_prelude);
                        self.def_map.prelude = Some(m);
-                    } else if m.krate != self.def_map.krate {
+                    } else if m.krate() != self.def_map.krate {
                        tested_by!(glob_across_crates);
                        // glob import from other crate => we can just import everything once
-                        let item_map = self.db.crate_def_map(m.krate);
+                        let item_map = self.db.crate_def_map(m.krate());
-                        let scope = &item_map[m.module_id].scope;
+                        let scope = &item_map[m.id.module_id].scope;
                        // Module scoped macros is included
                        let items = scope
@@ -307,7 +310,7 @@ where
                        // glob import from same crate => we do an initial
                        // import, and then need to propagate any further
                        // additions
-                        let scope = &self.def_map[m.module_id].scope;
+                        let scope = &self.def_map[m.id.module_id].scope;
                        // Module scoped macros is included
                        let items = scope
@@ -319,7 +322,7 @@ where
                        self.update(module_id, Some(import_id), &items);
                        // record the glob import in case we add further items
                        self.glob_imports
-                            .entry(m.module_id)
+                            .entry(m.id.module_id)
                            .or_default()
                            .push((module_id, import_id));
                    }
@@ -448,7 +451,7 @@ where
            );
            if let Some(def) = resolved_res.resolved_def.get_macros() {
-                let call_id = MacroCallLoc { def: def.id, ast_id: *ast_id }.id(self.db);
+                let call_id = self.db.intern_macro(MacroCallLoc { def: def.id, ast_id: *ast_id });
                resolved.push((*module_id, call_id, def.id));
                res = ReachedFixedPoint::No;
                return false;
@@ -523,9 +526,10 @@ where
        // Prelude module is always considered to be `#[macro_use]`.
        if let Some(prelude_module) = self.def_collector.def_map.prelude {
-            if prelude_module.krate != self.def_collector.def_map.krate {
+            if prelude_module.krate() != self.def_collector.def_map.krate {
                tested_by!(prelude_is_macro_use);
-                self.def_collector.import_all_macros_exported(self.module_id, prelude_module.krate);
+                self.def_collector
+                    .import_all_macros_exported(self.module_id, prelude_module.krate());
            }
        }
@@ -567,7 +571,7 @@ where
            // inline module, just recurse
            raw::ModuleData::Definition { name, items, ast_id } => {
                let module_id =
-                    self.push_child_module(name.clone(), ast_id.with_file_id(self.file_id), None);
+                    self.push_child_module(name.clone(), AstId::new(self.file_id, *ast_id), None);
                ModCollector {
                    def_collector: &mut *self.def_collector,
@@ -583,7 +587,7 @@ where
            }
            // out of line module, resolve, parse and recurse
            raw::ModuleData::Declaration { name, ast_id } => {
-                let ast_id = ast_id.with_file_id(self.file_id);
+                let ast_id = AstId::new(self.file_id, *ast_id);
                match self.mod_dir.resolve_declaration(
                    self.def_collector.db,
                    self.file_id,
@@ -631,9 +635,7 @@ where
        modules[res].scope.legacy_macros = modules[self.module_id].scope.legacy_macros.clone();
        modules[self.module_id].children.insert(name.clone(), res);
        let resolution = Resolution {
-            def: PerNs::types(
+            def: PerNs::types(Module::new(self.def_collector.def_map.krate, res).into()),
-                Module { krate: self.def_collector.def_map.krate, module_id: res }.into(),
-            ),
            import: None,
        };
        self.def_collector.update(self.module_id, None, &[(name, resolution)]);
@@ -641,8 +643,8 @@ where
    }
    fn define_def(&mut self, def: &raw::DefData) {
-        let module = Module { krate: self.def_collector.def_map.krate, module_id: self.module_id };
+        let module = Module::new(self.def_collector.def_map.krate, self.module_id);
-        let ctx = LocationCtx::new(self.def_collector.db, module, self.file_id);
+        let ctx = LocationCtx::new(self.def_collector.db, module.id, self.file_id);
        macro_rules! def {
            ($kind:ident, $ast_id:ident) => {
@@ -671,28 +673,26 @@ where
    }
    fn collect_macro(&mut self, mac: &raw::MacroData) {
+        let ast_id = AstId::new(self.file_id, mac.ast_id);
        // Case 1: macro rules, define a macro in crate-global mutable scope
        if is_macro_rules(&mac.path) {
            if let Some(name) = &mac.name {
-                let macro_id = MacroDefId {
+                let macro_id =
-                    ast_id: mac.ast_id.with_file_id(self.file_id),
+                    MacroDefId { ast_id, krate: self.def_collector.def_map.krate.crate_id };
-                    krate: self.def_collector.def_map.krate,
-                };
                let macro_ = MacroDef { id: macro_id };
                self.def_collector.define_macro(self.module_id, name.clone(), macro_, mac.export);
            }
            return;
        }
-        let ast_id = mac.ast_id.with_file_id(self.file_id);
        // Case 2: try to resolve in legacy scope and expand macro_rules, triggering
        // recursive item collection.
        if let Some(macro_def) = mac.path.as_ident().and_then(|name| {
            self.def_collector.def_map[self.module_id].scope.get_legacy_macro(&name)
        }) {
            let def = macro_def.id;
-            let macro_call_id = MacroCallLoc { def, ast_id }.id(self.def_collector.db);
+            let macro_call_id = self.def_collector.db.intern_macro(MacroCallLoc { def, ast_id });
            self.def_collector.collect_macro_expansion(self.module_id, macro_call_id, def);
            return;
@@ -728,7 +728,7 @@ where
 }
 fn is_macro_rules(path: &Path) -> bool {
-    path.as_ident() == Some(&MACRO_RULES)
+    path.as_ident() == Some(&name::MACRO_RULES)
 }
 #[cfg(test)]
diff --git a/crates/ra_hir/src/nameres/mod_resolution.rs b/crates/ra_hir/src/nameres/mod_resolution.rs
deleted file mode 100644
index e8b808514..000000000
--- a/crates/ra_hir/src/nameres/mod_resolution.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-//! This module resolves `mod foo;` declaration to file.
-use ra_db::FileId;
-use ra_syntax::SmolStr;
-use relative_path::RelativePathBuf;
-use crate::{db::DefDatabase, HirFileId, Name};
-#[derive(Clone, Debug)]
-pub(super) struct ModDir {
-    /// `.` for `mod.rs`, `lib.rs`
-    /// `./foo` for `foo.rs`
-    /// `./foo/bar` for `mod bar { mod x; }` nested in `foo.rs`
-    path: RelativePathBuf,
-    /// inside `./foo.rs`, mods with `#[path]` should *not* be relative to `./foo/`
-    root_non_dir_owner: bool,
-}
-impl ModDir {
-    pub(super) fn root() -> ModDir {
-        ModDir { path: RelativePathBuf::default(), root_non_dir_owner: false }
-    }
-    pub(super) fn descend_into_definition(
-        &self,
-        name: &Name,
-        attr_path: Option<&SmolStr>,
-    ) -> ModDir {
-        let mut path = self.path.clone();
-        match attr_to_path(attr_path) {
-            None => path.push(&name.to_string()),
-            Some(attr_path) => {
-                if self.root_non_dir_owner {
-                    // Workaround for relative path API: turn `lib.rs` into ``.
-                    if !path.pop() {
-                        path = RelativePathBuf::default();
-                    }
-                }
-                path.push(attr_path);
-            }
-        }
-        ModDir { path, root_non_dir_owner: false }
-    }
-    pub(super) fn resolve_declaration(
-        &self,
-        db: &impl DefDatabase,
-        file_id: HirFileId,
-        name: &Name,
-        attr_path: Option<&SmolStr>,
-    ) -> Result<(FileId, ModDir), RelativePathBuf> {
-        let empty_path = RelativePathBuf::default();
-        let file_id = file_id.original_file(db);
-        let mut candidate_files = Vec::new();
-        match attr_to_path(attr_path) {
-            Some(attr_path) => {
-                let base = if self.root_non_dir_owner {
-                    self.path.parent().unwrap_or(&empty_path)
-                } else {
-                    &self.path
-                };
-                candidate_files.push(base.join(attr_path))
-            }
-            None => {
-                candidate_files.push(self.path.join(&format!("{}.rs", name)));
-                candidate_files.push(self.path.join(&format!("{}/mod.rs", name)));
-            }
-        };
-        for candidate in candidate_files.iter() {
-            if let Some(file_id) = db.resolve_relative_path(file_id, candidate) {
-                let mut root_non_dir_owner = false;
-                let mut mod_path = RelativePathBuf::new();
-                if !(candidate.ends_with("mod.rs") || attr_path.is_some()) {
-                    root_non_dir_owner = true;
-                    mod_path.push(&name.to_string());
-                }
-                return Ok((file_id, ModDir { path: mod_path, root_non_dir_owner }));
-            }
-        }
-        Err(candidate_files.remove(0))
-    }
-}
-fn attr_to_path(attr: Option<&SmolStr>) -> Option<RelativePathBuf> {
-    attr.and_then(|it| RelativePathBuf::from_path(&it.replace("\\", "/")).ok())
-}
diff --git a/crates/ra_hir/src/nameres/raw.rs b/crates/ra_hir/src/nameres/raw.rs
deleted file mode 100644
index 57f2929c3..000000000
--- a/crates/ra_hir/src/nameres/raw.rs
+++ /dev/null
@@ -1,403 +0,0 @@
-//! FIXME: write short doc here
-use std::{ops::Index, sync::Arc};
-use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId};
-use ra_syntax::{
-    ast::{self, AttrsOwner, NameOwner},
-    AstNode, AstPtr, SourceFile,
-};
-use test_utils::tested_by;
-use crate::{
-    attr::Attr,
-    db::{AstDatabase, DefDatabase},
-    AsName, AstIdMap, Either, FileAstId, HirFileId, ModuleSource, Name, Path, Source,
-};
-/// `RawItems` is a set of top-level items in a file (except for impls).
-///
-/// It is the input to name resolution algorithm. `RawItems` are not invalidated
-/// on most edits.
-#[derive(Debug, Default, PartialEq, Eq)]
-pub struct RawItems {
-    modules: Arena<Module, ModuleData>,
-    imports: Arena<ImportId, ImportData>,
-    defs: Arena<Def, DefData>,
-    macros: Arena<Macro, MacroData>,
-    /// items for top-level module
-    items: Vec<RawItem>,
-}
-#[derive(Debug, Default, PartialEq, Eq)]
-pub struct ImportSourceMap {
-    map: ArenaMap<ImportId, ImportSourcePtr>,
-}
-type ImportSourcePtr = Either<AstPtr<ast::UseTree>, AstPtr<ast::ExternCrateItem>>;
-type ImportSource = Either<ast::UseTree, ast::ExternCrateItem>;
-impl ImportSourcePtr {
-    fn to_node(self, file: &SourceFile) -> ImportSource {
-        self.map(|ptr| ptr.to_node(file.syntax()), |ptr| ptr.to_node(file.syntax()))
-    }
-}
-impl ImportSourceMap {
-    fn insert(&mut self, import: ImportId, ptr: ImportSourcePtr) {
-        self.map.insert(import, ptr)
-    }
-    pub(crate) fn get(&self, source: &ModuleSource, import: ImportId) -> ImportSource {
-        let file = match source {
-            ModuleSource::SourceFile(file) => file.clone(),
-            ModuleSource::Module(m) => m.syntax().ancestors().find_map(SourceFile::cast).unwrap(),
-        };
-        self.map[import].to_node(&file)
-    }
-}
-impl RawItems {
-    pub(crate) fn raw_items_query(
-        db: &(impl DefDatabase + AstDatabase),
-        file_id: HirFileId,
-    ) -> Arc<RawItems> {
-        db.raw_items_with_source_map(file_id).0
-    }
-    pub(crate) fn raw_items_with_source_map_query(
-        db: &(impl DefDatabase + AstDatabase),
-        file_id: HirFileId,
-    ) -> (Arc<RawItems>, Arc<ImportSourceMap>) {
-        let mut collector = RawItemsCollector {
-            raw_items: RawItems::default(),
-            source_ast_id_map: db.ast_id_map(file_id),
-            source_map: ImportSourceMap::default(),
-            file_id,
-            db,
-        };
-        if let Some(node) = db.parse_or_expand(file_id) {
-            if let Some(source_file) = ast::SourceFile::cast(node.clone()) {
-                collector.process_module(None, source_file);
-            } else if let Some(item_list) = ast::MacroItems::cast(node) {
-                collector.process_module(None, item_list);
-            }
-        }
-        (Arc::new(collector.raw_items), Arc::new(collector.source_map))
-    }
-    pub(super) fn items(&self) -> &[RawItem] {
-        &self.items
-    }
-}
-impl Index<Module> for RawItems {
-    type Output = ModuleData;
-    fn index(&self, idx: Module) -> &ModuleData {
-        &self.modules[idx]
-    }
-}
-impl Index<ImportId> for RawItems {
-    type Output = ImportData;
-    fn index(&self, idx: ImportId) -> &ImportData {
-        &self.imports[idx]
-    }
-}
-impl Index<Def> for RawItems {
-    type Output = DefData;
-    fn index(&self, idx: Def) -> &DefData {
-        &self.defs[idx]
-    }
-}
-impl Index<Macro> for RawItems {
-    type Output = MacroData;
-    fn index(&self, idx: Macro) -> &MacroData {
-        &self.macros[idx]
-    }
-}
-// Avoid heap allocation on items without attributes.
-type Attrs = Option<Arc<[Attr]>>;
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub(super) struct RawItem {
-    attrs: Attrs,
-    pub(super) kind: RawItemKind,
-}
-impl RawItem {
-    pub(super) fn attrs(&self) -> &[Attr] {
-        self.attrs.as_ref().map_or(&[], |it| &*it)
-    }
-}
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub(super) enum RawItemKind {
-    Module(Module),
-    Import(ImportId),
-    Def(Def),
-    Macro(Macro),
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub(super) struct Module(RawId);
-impl_arena_id!(Module);
-#[derive(Debug, PartialEq, Eq)]
-pub(super) enum ModuleData {
-    Declaration { name: Name, ast_id: FileAstId<ast::Module> },
-    Definition { name: Name, ast_id: FileAstId<ast::Module>, items: Vec<RawItem> },
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct ImportId(RawId);
-impl_arena_id!(ImportId);
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ImportData {
-    pub(super) path: Path,
-    pub(super) alias: Option<Name>,
-    pub(super) is_glob: bool,
-    pub(super) is_prelude: bool,
-    pub(super) is_extern_crate: bool,
-    pub(super) is_macro_use: bool,
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub(super) struct Def(RawId);
-impl_arena_id!(Def);
-#[derive(Debug, PartialEq, Eq)]
-pub(super) struct DefData {
-    pub(super) name: Name,
-    pub(super) kind: DefKind,
-}
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub(super) enum DefKind {
-    Function(FileAstId<ast::FnDef>),
-    Struct(FileAstId<ast::StructDef>),
-    Union(FileAstId<ast::StructDef>),
-    Enum(FileAstId<ast::EnumDef>),
-    Const(FileAstId<ast::ConstDef>),
-    Static(FileAstId<ast::StaticDef>),
-    Trait(FileAstId<ast::TraitDef>),
-    TypeAlias(FileAstId<ast::TypeAliasDef>),
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub(super) struct Macro(RawId);
-impl_arena_id!(Macro);
-#[derive(Debug, PartialEq, Eq)]
-pub(super) struct MacroData {
-    pub(super) ast_id: FileAstId<ast::MacroCall>,
-    pub(super) path: Path,
-    pub(super) name: Option<Name>,
-    pub(super) export: bool,
-}
-struct RawItemsCollector<DB> {
-    raw_items: RawItems,
-    source_ast_id_map: Arc<AstIdMap>,
-    source_map: ImportSourceMap,
-    file_id: HirFileId,
-    db: DB,
-}
-impl<DB: AstDatabase> RawItemsCollector<&DB> {
-    fn process_module(&mut self, current_module: Option<Module>, body: impl ast::ModuleItemOwner) {
-        for item_or_macro in body.items_with_macros() {
-            match item_or_macro {
-                ast::ItemOrMacro::Macro(m) => self.add_macro(current_module, m),
-                ast::ItemOrMacro::Item(item) => self.add_item(current_module, item),
-            }
-        }
-    }
-    fn add_item(&mut self, current_module: Option<Module>, item: ast::ModuleItem) {
-        let attrs = self.parse_attrs(&item);
-        let (kind, name) = match item {
-            ast::ModuleItem::Module(module) => {
-                self.add_module(current_module, module);
-                return;
-            }
-            ast::ModuleItem::UseItem(use_item) => {
-                self.add_use_item(current_module, use_item);
-                return;
-            }
-            ast::ModuleItem::ExternCrateItem(extern_crate) => {
-                self.add_extern_crate_item(current_module, extern_crate);
-                return;
-            }
-            ast::ModuleItem::ImplBlock(_) => {
-                // impls don't participate in name resolution
-                return;
-            }
-            ast::ModuleItem::StructDef(it) => {
-                let id = self.source_ast_id_map.ast_id(&it);
-                let name = it.name();
-                if it.is_union() {
-                    (DefKind::Union(id), name)
-                } else {
-                    (DefKind::Struct(id), name)
-                }
-            }
-            ast::ModuleItem::EnumDef(it) => {
-                (DefKind::Enum(self.source_ast_id_map.ast_id(&it)), it.name())
-            }
-            ast::ModuleItem::FnDef(it) => {
-                (DefKind::Function(self.source_ast_id_map.ast_id(&it)), it.name())
-            }
-            ast::ModuleItem::TraitDef(it) => {
-                (DefKind::Trait(self.source_ast_id_map.ast_id(&it)), it.name())
-            }
-            ast::ModuleItem::TypeAliasDef(it) => {
-                (DefKind::TypeAlias(self.source_ast_id_map.ast_id(&it)), it.name())
-            }
-            ast::ModuleItem::ConstDef(it) => {
-                (DefKind::Const(self.source_ast_id_map.ast_id(&it)), it.name())
-            }
-            ast::ModuleItem::StaticDef(it) => {
-                (DefKind::Static(self.source_ast_id_map.ast_id(&it)), it.name())
-            }
-        };
-        if let Some(name) = name {
-            let name = name.as_name();
-            let def = self.raw_items.defs.alloc(DefData { name, kind });
-            self.push_item(current_module, attrs, RawItemKind::Def(def));
-        }
-    }
-    fn add_module(&mut self, current_module: Option<Module>, module: ast::Module) {
-        let name = match module.name() {
-            Some(it) => it.as_name(),
-            None => return,
-        };
-        let attrs = self.parse_attrs(&module);
-        let ast_id = self.source_ast_id_map.ast_id(&module);
-        if module.has_semi() {
-            let item = self.raw_items.modules.alloc(ModuleData::Declaration { name, ast_id });
-            self.push_item(current_module, attrs, RawItemKind::Module(item));
-            return;
-        }
-        if let Some(item_list) = module.item_list() {
-            let item = self.raw_items.modules.alloc(ModuleData::Definition {
-                name,
-                ast_id,
-                items: Vec::new(),
-            });
-            self.process_module(Some(item), item_list);
-            self.push_item(current_module, attrs, RawItemKind::Module(item));
-            return;
-        }
-        tested_by!(name_res_works_for_broken_modules);
-    }
-    fn add_use_item(&mut self, current_module: Option<Module>, use_item: ast::UseItem) {
-        // FIXME: cfg_attr
-        let is_prelude = use_item.has_atom_attr("prelude_import");
-        let attrs = self.parse_attrs(&use_item);
-        Path::expand_use_item(
-            Source { ast: use_item, file_id: self.file_id },
-            self.db,
-            |path, use_tree, is_glob, alias| {
-                let import_data = ImportData {
-                    path,
-                    alias,
-                    is_glob,
-                    is_prelude,
-                    is_extern_crate: false,
-                    is_macro_use: false,
-                };
-                self.push_import(
-                    current_module,
-                    attrs.clone(),
-                    import_data,
-                    Either::A(AstPtr::new(use_tree)),
-                );
-            },
-        )
-    }
-    fn add_extern_crate_item(
-        &mut self,
-        current_module: Option<Module>,
-        extern_crate: ast::ExternCrateItem,
-    ) {
-        if let Some(name_ref) = extern_crate.name_ref() {
-            let path = Path::from_name_ref(&name_ref);
-            let alias = extern_crate.alias().and_then(|a| a.name()).map(|it| it.as_name());
-            let attrs = self.parse_attrs(&extern_crate);
-            // FIXME: cfg_attr
-            let is_macro_use = extern_crate.has_atom_attr("macro_use");
-            let import_data = ImportData {
-                path,
-                alias,
-                is_glob: false,
-                is_prelude: false,
-                is_extern_crate: true,
-                is_macro_use,
-            };
-            self.push_import(
-                current_module,
-                attrs,
-                import_data,
-                Either::B(AstPtr::new(&extern_crate)),
-            );
-        }
-    }
-    fn add_macro(&mut self, current_module: Option<Module>, m: ast::MacroCall) {
-        let attrs = self.parse_attrs(&m);
-        let path = match m
-            .path()
-            .and_then(|path| Path::from_src(Source { ast: path, file_id: self.file_id }, self.db))
-        {
-            Some(it) => it,
-            _ => return,
-        };
-        let name = m.name().map(|it| it.as_name());
-        let ast_id = self.source_ast_id_map.ast_id(&m);
-        // FIXME: cfg_attr
-        let export = m.attrs().filter_map(|x| x.simple_name()).any(|name| name == "macro_export");
-        let m = self.raw_items.macros.alloc(MacroData { ast_id, path, name, export });
-        self.push_item(current_module, attrs, RawItemKind::Macro(m));
-    }
-    fn push_import(
-        &mut self,
-        current_module: Option<Module>,
-        attrs: Attrs,
-        data: ImportData,
-        source: ImportSourcePtr,
-    ) {
-        let import = self.raw_items.imports.alloc(data);
-        self.source_map.insert(import, source);
-        self.push_item(current_module, attrs, RawItemKind::Import(import))
-    }
-    fn push_item(&mut self, current_module: Option<Module>, attrs: Attrs, kind: RawItemKind) {
-        match current_module {
-            Some(module) => match &mut self.raw_items.modules[module] {
-                ModuleData::Definition { items, .. } => items,
-                ModuleData::Declaration { .. } => unreachable!(),
-            },
-            None => &mut self.raw_items.items,
-        }
-        .push(RawItem { attrs, kind })
-    }
-    fn parse_attrs(&self, item: &impl ast::AttrsOwner) -> Attrs {
-        Attr::from_attrs_owner(self.file_id, item, self.db)
-    }
-}
diff --git a/crates/ra_hir/src/nameres/tests/mod_resolution.rs b/crates/ra_hir/src/nameres/tests/mod_resolution.rs
index f569aacdc..abfe8b1c3 100644
--- a/crates/ra_hir/src/nameres/tests/mod_resolution.rs
+++ b/crates/ra_hir/src/nameres/tests/mod_resolution.rs
@@ -2,7 +2,7 @@ use super::*;
 #[test]
 fn name_res_works_for_broken_modules() {
-    covers!(name_res_works_for_broken_modules);
+    // covers!(name_res_works_for_broken_modules);
    let map = def_map(
        "
        //- /lib.rs