Remove raw item query

crates/ra_hir/src/db.rs

@@ -6,8 +6,8 @@ pub use hir_def::db::{
     ExprScopesQuery, FunctionDataQuery, GenericParamsQuery, ImplDataQuery, ImportMapQuery,
     InternConstQuery, InternDatabase, InternDatabaseStorage, InternEnumQuery, InternFunctionQuery,
     InternImplQuery, InternStaticQuery, InternStructQuery, InternTraitQuery, InternTypeAliasQuery,
-    InternUnionQuery, LangItemQuery, ModuleLangItemsQuery, RawItemsQuery, StaticDataQuery,
+    InternUnionQuery, LangItemQuery, ModuleLangItemsQuery, StaticDataQuery, StructDataQuery,
-    StructDataQuery, TraitDataQuery, TypeAliasDataQuery, UnionDataQuery,
+    TraitDataQuery, TypeAliasDataQuery, UnionDataQuery,
 };
 pub use hir_expand::db::{
     AstDatabase, AstDatabaseStorage, AstIdMapQuery, InternEagerExpansionQuery, InternMacroQuery,

crates/ra_hir_def/src/db.rs

@@ -16,7 +16,7 @@ use crate::{
     import_map::ImportMap,
     item_tree::ItemTree,
     lang_item::{LangItemTarget, LangItems},
-    nameres::{raw::RawItems, CrateDefMap},
+    nameres::CrateDefMap,
     AttrDefId, ConstId, ConstLoc, DefWithBodyId, EnumId, EnumLoc, FunctionId, FunctionLoc,
     GenericDefId, ImplId, ImplLoc, ModuleId, StaticId, StaticLoc, StructId, StructLoc, TraitId,
     TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc,
@@ -46,9 +46,6 @@ pub trait InternDatabase: SourceDatabase {
 
 #[salsa::query_group(DefDatabaseStorage)]
 pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
-    #[salsa::invoke(RawItems::raw_items_query)]
-    fn raw_items(&self, file_id: HirFileId) -> Arc<RawItems>;
-
     #[salsa::invoke(ItemTree::item_tree_query)]
     fn item_tree(&self, file_id: HirFileId) -> Arc<ItemTree>;
 

crates/ra_hir_def/src/nameres.rs

@@ -47,7 +47,6 @@
 //! path and, upon success, we run macro expansion and "collect module" phase on
 //! the result
 
-pub(crate) mod raw;
 mod collector;
 mod mod_resolution;
 mod path_resolution;

crates/ra_hir_def/src/nameres/raw.rs

@@ -1,483 +0,0 @@
-//! Lowers syntax tree of a rust file into a raw representation of containing
-//! items, *without* attaching them to a module structure.
-//!
-//! That is, raw items don't have semantics, just as syntax, but, unlike syntax,
-//! they don't change with trivial source code edits, making them a great tool
-//! for building salsa recomputation firewalls.
-
-use std::{ops::Index, sync::Arc};
-
-use hir_expand::{
-    ast_id_map::AstIdMap,
-    hygiene::Hygiene,
-    name::{AsName, Name},
-};
-use ra_arena::{Arena, Idx};
-use ra_prof::profile;
-use ra_syntax::{
-    ast::{self, AttrsOwner, NameOwner, VisibilityOwner},
-    AstNode,
-};
-use test_utils::mark;
-
-use crate::{
-    attr::Attrs,
-    db::DefDatabase,
-    path::{ImportAlias, ModPath},
-    visibility::RawVisibility,
-    FileAstId, HirFileId, InFile,
-};
-
-/// `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<ModuleData>,
-    imports: Arena<ImportData>,
-    defs: Arena<DefData>,
-    macros: Arena<MacroData>,
-    impls: Arena<ImplData>,
-    /// items for top-level module
-    items: Vec<RawItem>,
-}
-
-impl RawItems {
-    pub(crate) fn raw_items_query(db: &dyn DefDatabase, file_id: HirFileId) -> Arc<RawItems> {
-        let _p = profile("raw_items_query");
-        db.item_tree(file_id);
-        let mut collector = RawItemsCollector {
-            raw_items: RawItems::default(),
-            source_ast_id_map: db.ast_id_map(file_id),
-            file_id,
-            hygiene: Hygiene::new(db.upcast(), file_id),
-        };
-        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);
-            }
-        }
-        let raw_items = collector.raw_items;
-        Arc::new(raw_items)
-    }
-
-    pub(super) fn items(&self) -> &[RawItem] {
-        &self.items
-    }
-}
-
-impl Index<Idx<ModuleData>> for RawItems {
-    type Output = ModuleData;
-    fn index(&self, idx: Idx<ModuleData>) -> &ModuleData {
-        &self.modules[idx]
-    }
-}
-
-impl Index<Import> for RawItems {
-    type Output = ImportData;
-    fn index(&self, idx: Import) -> &ImportData {
-        &self.imports[idx]
-    }
-}
-
-impl Index<Idx<DefData>> for RawItems {
-    type Output = DefData;
-    fn index(&self, idx: Idx<DefData>) -> &DefData {
-        &self.defs[idx]
-    }
-}
-
-impl Index<Idx<MacroData>> for RawItems {
-    type Output = MacroData;
-    fn index(&self, idx: Idx<MacroData>) -> &MacroData {
-        &self.macros[idx]
-    }
-}
-
-impl Index<Idx<ImplData>> for RawItems {
-    type Output = ImplData;
-    fn index(&self, idx: Idx<ImplData>) -> &ImplData {
-        &self.impls[idx]
-    }
-}
-
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub(super) struct RawItem {
-    pub(super) attrs: Attrs,
-    pub(super) kind: RawItemKind,
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub(super) enum RawItemKind {
-    Module(Idx<ModuleData>),
-    Import(Import),
-    Def(Idx<DefData>),
-    Macro(Idx<MacroData>),
-    Impl(Idx<ImplData>),
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub(super) enum ModuleData {
-    Declaration {
-        name: Name,
-        visibility: RawVisibility,
-        ast_id: FileAstId<ast::Module>,
-    },
-    Definition {
-        name: Name,
-        visibility: RawVisibility,
-        ast_id: FileAstId<ast::Module>,
-        items: Vec<RawItem>,
-    },
-}
-
-pub(crate) type Import = Idx<ImportData>;
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ImportData {
-    pub(super) path: ModPath,
-    pub(super) alias: Option<ImportAlias>,
-    pub(super) is_glob: bool,
-    pub(super) is_prelude: bool,
-    pub(super) is_extern_crate: bool,
-    pub(super) is_macro_use: bool,
-    pub(super) visibility: RawVisibility,
-}
-
-// type Def = Idx<DefData>;
-
-#[derive(Debug, PartialEq, Eq)]
-pub(super) struct DefData {
-    pub(super) name: Name,
-    pub(super) kind: DefKind,
-    pub(super) visibility: RawVisibility,
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub(super) enum StructDefKind {
-    Record,
-    Tuple,
-    Unit,
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub(super) enum DefKind {
-    Function(FileAstId<ast::FnDef>),
-    Struct(FileAstId<ast::StructDef>, StructDefKind),
-    Union(FileAstId<ast::UnionDef>),
-    Enum(FileAstId<ast::EnumDef>),
-    Const(FileAstId<ast::ConstDef>),
-    Static(FileAstId<ast::StaticDef>),
-    Trait(FileAstId<ast::TraitDef>),
-    TypeAlias(FileAstId<ast::TypeAliasDef>),
-}
-
-impl DefKind {
-    pub fn ast_id(self) -> FileAstId<ast::ModuleItem> {
-        match self {
-            DefKind::Function(it) => it.upcast(),
-            DefKind::Struct(it, _) => it.upcast(),
-            DefKind::Union(it) => it.upcast(),
-            DefKind::Enum(it) => it.upcast(),
-            DefKind::Const(it) => it.upcast(),
-            DefKind::Static(it) => it.upcast(),
-            DefKind::Trait(it) => it.upcast(),
-            DefKind::TypeAlias(it) => it.upcast(),
-        }
-    }
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub(super) struct MacroData {
-    pub(super) ast_id: FileAstId<ast::MacroCall>,
-    pub(super) path: ModPath,
-    pub(super) name: Option<Name>,
-    pub(super) export: bool,
-    pub(super) local_inner: bool,
-    pub(super) builtin: bool,
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub(super) struct ImplData {
-    pub(super) ast_id: FileAstId<ast::ImplDef>,
-}
-
-struct RawItemsCollector {
-    raw_items: RawItems,
-    source_ast_id_map: Arc<AstIdMap>,
-    file_id: HirFileId,
-    hygiene: Hygiene,
-}
-
-impl RawItemsCollector {
-    fn process_module(
-        &mut self,
-        current_module: Option<Idx<ModuleData>>,
-        body: impl ast::ModuleItemOwner,
-    ) {
-        for item in body.items() {
-            self.add_item(current_module, item)
-        }
-    }
-
-    fn add_item(&mut self, current_module: Option<Idx<ModuleData>>, item: ast::ModuleItem) {
-        let attrs = self.parse_attrs(&item);
-        let visibility = RawVisibility::from_ast_with_hygiene(item.visibility(), &self.hygiene);
-        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::ImplDef(it) => {
-                self.add_impl(current_module, it);
-                return;
-            }
-            ast::ModuleItem::StructDef(it) => {
-                let kind = match it.kind() {
-                    ast::StructKind::Record(_) => StructDefKind::Record,
-                    ast::StructKind::Tuple(_) => StructDefKind::Tuple,
-                    ast::StructKind::Unit => StructDefKind::Unit,
-                };
-                let id = self.source_ast_id_map.ast_id(&it);
-                let name = it.name();
-                (DefKind::Struct(id, kind), name)
-            }
-            ast::ModuleItem::UnionDef(it) => {
-                let id = self.source_ast_id_map.ast_id(&it);
-                let name = it.name();
-                (DefKind::Union(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())
-            }
-            ast::ModuleItem::MacroCall(it) => {
-                self.add_macro(current_module, it);
-                return;
-            }
-            ast::ModuleItem::ExternBlock(it) => {
-                self.add_extern_block(current_module, it);
-                return;
-            }
-        };
-        if let Some(name) = name {
-            let name = name.as_name();
-            let def = self.raw_items.defs.alloc(DefData { name, kind, visibility });
-            self.push_item(current_module, attrs, RawItemKind::Def(def));
-        }
-    }
-
-    fn add_extern_block(
-        &mut self,
-        current_module: Option<Idx<ModuleData>>,
-        block: ast::ExternBlock,
-    ) {
-        if let Some(items) = block.extern_item_list() {
-            for item in items.extern_items() {
-                let attrs = self.parse_attrs(&item);
-                let visibility =
-                    RawVisibility::from_ast_with_hygiene(item.visibility(), &self.hygiene);
-                let (kind, name) = match item {
-                    ast::ExternItem::FnDef(it) => {
-                        (DefKind::Function(self.source_ast_id_map.ast_id(&it)), it.name())
-                    }
-                    ast::ExternItem::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, visibility });
-                    self.push_item(current_module, attrs, RawItemKind::Def(def));
-                }
-            }
-        }
-    }
-
-    fn add_module(&mut self, current_module: Option<Idx<ModuleData>>, module: ast::Module) {
-        let name = match module.name() {
-            Some(it) => it.as_name(),
-            None => return,
-        };
-        let attrs = self.parse_attrs(&module);
-        let visibility = RawVisibility::from_ast_with_hygiene(module.visibility(), &self.hygiene);
-
-        let ast_id = self.source_ast_id_map.ast_id(&module);
-        if module.semicolon_token().is_some() {
-            let item =
-                self.raw_items.modules.alloc(ModuleData::Declaration { name, visibility, 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,
-                visibility,
-                ast_id,
-                items: Vec::new(),
-            });
-            self.process_module(Some(item), item_list);
-            self.push_item(current_module, attrs, RawItemKind::Module(item));
-            return;
-        }
-        mark::hit!(name_res_works_for_broken_modules);
-    }
-
-    fn add_use_item(&mut self, current_module: Option<Idx<ModuleData>>, use_item: ast::UseItem) {
-        // FIXME: cfg_attr
-        let is_prelude = use_item.has_atom_attr("prelude_import");
-        let attrs = self.parse_attrs(&use_item);
-        let visibility = RawVisibility::from_ast_with_hygiene(use_item.visibility(), &self.hygiene);
-
-        let mut buf = Vec::new();
-        ModPath::expand_use_item(
-            InFile { value: use_item, file_id: self.file_id },
-            &self.hygiene,
-            |path, _use_tree, is_glob, alias| {
-                let import_data = ImportData {
-                    path,
-                    alias,
-                    is_glob,
-                    is_prelude,
-                    is_extern_crate: false,
-                    is_macro_use: false,
-                    visibility: visibility.clone(),
-                };
-                buf.push(import_data);
-            },
-        );
-        for import_data in buf {
-            self.push_import(current_module, attrs.clone(), import_data);
-        }
-    }
-
-    fn add_extern_crate_item(
-        &mut self,
-        current_module: Option<Idx<ModuleData>>,
-        extern_crate: ast::ExternCrateItem,
-    ) {
-        if let Some(name_ref) = extern_crate.name_ref() {
-            let path = ModPath::from_name_ref(&name_ref);
-            let visibility =
-                RawVisibility::from_ast_with_hygiene(extern_crate.visibility(), &self.hygiene);
-            let alias = extern_crate.alias().map(|a| {
-                a.name().map(|it| it.as_name()).map_or(ImportAlias::Underscore, ImportAlias::Alias)
-            });
-            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,
-                visibility,
-            };
-            self.push_import(current_module, attrs, import_data);
-        }
-    }
-
-    fn add_macro(&mut self, current_module: Option<Idx<ModuleData>>, m: ast::MacroCall) {
-        let attrs = self.parse_attrs(&m);
-        let path = match m.path().and_then(|path| ModPath::from_src(path, &self.hygiene)) {
-            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_attr = attrs.by_key("macro_export");
-
-        let export = export_attr.exists();
-        let local_inner = if export {
-            export_attr.tt_values().map(|it| &it.token_trees).flatten().any(|it| match it {
-                tt::TokenTree::Leaf(tt::Leaf::Ident(ident)) => {
-                    ident.text.contains("local_inner_macros")
-                }
-                _ => false,
-            })
-        } else {
-            false
-        };
-
-        let builtin = attrs.by_key("rustc_builtin_macro").exists();
-
-        let m = self.raw_items.macros.alloc(MacroData {
-            ast_id,
-            path,
-            name,
-            export,
-            local_inner,
-            builtin,
-        });
-        self.push_item(current_module, attrs, RawItemKind::Macro(m));
-    }
-
-    fn add_impl(&mut self, current_module: Option<Idx<ModuleData>>, imp: ast::ImplDef) {
-        let attrs = self.parse_attrs(&imp);
-        let ast_id = self.source_ast_id_map.ast_id(&imp);
-        let imp = self.raw_items.impls.alloc(ImplData { ast_id });
-        self.push_item(current_module, attrs, RawItemKind::Impl(imp))
-    }
-
-    fn push_import(
-        &mut self,
-        current_module: Option<Idx<ModuleData>>,
-        attrs: Attrs,
-        data: ImportData,
-    ) {
-        let import = self.raw_items.imports.alloc(data);
-        self.push_item(current_module, attrs, RawItemKind::Import(import))
-    }
-
-    fn push_item(
-        &mut self,
-        current_module: Option<Idx<ModuleData>>,
-        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 {
-        Attrs::new(item, &self.hygiene)
-    }
-}

crates/ra_ide_db/src/change.rs

@@ -199,7 +199,6 @@ impl RootDatabase {
             hir::db::InternEagerExpansionQuery
 
             // DefDatabase
-            hir::db::RawItemsQuery
             hir::db::CrateDefMapQueryQuery
             hir::db::StructDataQuery
             hir::db::UnionDataQuery