Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2024-12-25 20:43:21 +00:00
Code Issues Projects Releases Packages Wiki Activity

Remove raw item query

Browse source
This commit is contained in:
Jonas Schievink 2020-06-15 19:16:43 +02:00
parent 7054e89d18
commit 0e2602f75e
5 changed files with 3 additions and 491 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
crates/ra_hir/src/db.rs
View file

@ -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,
StructDataQuery, TraitDataQuery, TypeAliasDataQuery, UnionDataQuery,
InternUnionQuery, LangItemQuery, ModuleLangItemsQuery, StaticDataQuery, StructDataQuery,
TraitDataQuery, TypeAliasDataQuery, UnionDataQuery,
};
pub use hir_expand::db::{
AstDatabase, AstDatabaseStorage, AstIdMapQuery, InternEagerExpansionQuery, InternMacroQuery,

5
crates/ra_hir_def/src/db.rs
View file

@ -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>;

1
crates/ra_hir_def/src/nameres.rs
View file

@ -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;

483
crates/ra_hir_def/src/nameres/raw.rs
View file

@ -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)
}
}

1
crates/ra_ide_db/src/change.rs
View file

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