mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge #8138

Browse Source 
8138: Set up a search scope when searching for mbe macro references r=Veykril a=Veykril

Closes #6184

Co-authored-by: Lukas Wirth <lukastw97@gmail.com>
This commit is contained in:
bors[bot] 2021-03-23 12:05:45 +00:00 committed by GitHub
commit 258afb8fb8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 150 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
crates/hir/src/lib.rs
View File

@ -1116,6 +1116,14 @@ impl BuiltinType {
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum MacroKind {
Declarative,
ProcMacro,
Derive,
BuiltIn,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct MacroDef {
pub(crate) id: MacroDefId,
@ -1140,15 +1148,15 @@ impl MacroDef {
}
}
/// Indicate it is a proc-macro
pub fn is_proc_macro(&self) -> bool {
matches!(self.id.kind, MacroDefKind::ProcMacro(..))
}
/// Indicate it is a derive macro
pub fn is_derive_macro(&self) -> bool {
// FIXME: wrong for `ProcMacro`
matches!(self.id.kind, MacroDefKind::ProcMacro(..) | MacroDefKind::BuiltInDerive(..))
pub fn kind(&self) -> MacroKind {
match self.id.kind {
MacroDefKind::Declarative(_) => MacroKind::Declarative,
MacroDefKind::BuiltIn(_, _) => MacroKind::BuiltIn,
MacroDefKind::BuiltInDerive(_, _) => MacroKind::Derive,
MacroDefKind::BuiltInEager(_, _) => MacroKind::BuiltIn,
// FIXME might be a derive
MacroDefKind::ProcMacro(_, _) => MacroKind::ProcMacro,
}
}
}

30
crates/ide/src/references.rs
View File

@ -1294,4 +1294,34 @@ pub use level1::Foo;
"#]],
);
}
#[test]
fn test_decl_macro_references() {
check(
r#"
//- /lib.rs crate:lib
#[macro_use]
mod qux;
mod bar;
pub use self::foo;
//- /qux.rs
#[macro_export]
macro_rules! foo$0 {
() => {struct Foo;};
}
//- /bar.rs
foo!();
//- /other.rs crate:other deps:lib new_source_root:
lib::foo!();
"#,
expect![[r#"
foo Macro FileId(1) 0..61 29..32
FileId(0) 46..49
FileId(2) 0..3
FileId(3) 5..8
"#]],
);
}
}

3
crates/ide_completion/src/completions/attribute.rs
View File

@ -246,7 +246,8 @@ fn get_derive_names_in_scope(ctx: &CompletionContext) -> FxHashSet<String> {
let mut result = FxHashSet::default();
ctx.scope.process_all_names(&mut |name, scope_def| {
if let hir::ScopeDef::MacroDef(mac) = scope_def {
if mac.is_derive_macro() {
// FIXME kind() doesn't check whether proc-macro is a derive
if mac.kind() == hir::MacroKind::Derive || mac.kind() == hir::MacroKind::ProcMacro {
result.insert(name.to_string());
}
}

174
crates/ide_db/src/search.rs
View File

@ -7,7 +7,7 @@
use std::{convert::TryInto, mem};
use base_db::{FileId, FileRange, SourceDatabase, SourceDatabaseExt};
use hir::{DefWithBody, HasSource, Module, ModuleSource, Semantics, Visibility};
use hir::{DefWithBody, HasAttrs, HasSource, InFile, ModuleSource, Semantics, Visibility};
use once_cell::unsync::Lazy;
use rustc_hash::FxHashMap;
use syntax::{ast, match_ast, AstNode, TextRange, TextSize};
@ -78,6 +78,76 @@ impl SearchScope {
SearchScope { entries }
}
fn crate_graph(db: &RootDatabase) -> SearchScope {
let mut entries = FxHashMap::default();
let graph = db.crate_graph();
for krate in graph.iter() {
let root_file = graph[krate].root_file_id;
let source_root_id = db.file_source_root(root_file);
let source_root = db.source_root(source_root_id);
entries.extend(source_root.iter().map(|id| (id, None)));
}
SearchScope { entries }
}
fn reverse_dependencies(db: &RootDatabase, of: hir::Crate) -> SearchScope {
let mut entries = FxHashMap::default();
for rev_dep in of.transitive_reverse_dependencies(db) {
let root_file = rev_dep.root_file(db);
let source_root_id = db.file_source_root(root_file);
let source_root = db.source_root(source_root_id);
entries.extend(source_root.iter().map(|id| (id, None)));
}
SearchScope { entries }
}
fn krate(db: &RootDatabase, of: hir::Crate) -> SearchScope {
let root_file = of.root_file(db);
let source_root_id = db.file_source_root(root_file);
let source_root = db.source_root(source_root_id);
SearchScope {
entries: source_root.iter().map(|id| (id, None)).collect::<FxHashMap<_, _>>(),
}
}
fn module(db: &RootDatabase, module: hir::Module) -> SearchScope {
let mut entries = FxHashMap::default();
let mut to_visit = vec![module];
let mut is_first = true;
while let Some(module) = to_visit.pop() {
let src = module.definition_source(db);
let file_id = src.file_id.original_file(db);
match src.value {
ModuleSource::Module(m) => {
if is_first {
let range = Some(m.syntax().text_range());
entries.insert(file_id, range);
} else {
// We have already added the enclosing file to the search scope,
// so do nothing.
}
}
ModuleSource::BlockExpr(b) => {
if is_first {
let range = Some(b.syntax().text_range());
entries.insert(file_id, range);
} else {
// We have already added the enclosing file to the search scope,
// so do nothing.
}
}
ModuleSource::SourceFile(_) => {
entries.insert(file_id, None);
}
};
is_first = false;
to_visit.extend(module.children(db));
}
SearchScope { entries }
}
pub fn empty() -> SearchScope {
SearchScope::new(FxHashMap::default())
}
@ -140,24 +210,15 @@ impl Definition {
let _p = profile::span("search_scope");
if let Definition::ModuleDef(hir::ModuleDef::BuiltinType(_)) = self {
let mut res = FxHashMap::default();
let graph = db.crate_graph();
for krate in graph.iter() {
let root_file = graph[krate].root_file_id;
let source_root_id = db.file_source_root(root_file);
let source_root = db.source_root(source_root_id);
res.extend(source_root.iter().map(|id| (id, None)));
}
return SearchScope::new(res);
return SearchScope::crate_graph(db);
}
let module = match self.module(db) {
Some(it) => it,
None => return SearchScope::empty(),
};
let module_src = module.definition_source(db);
let file_id = module_src.file_id.original_file(db);
let InFile { file_id, value: module_source } = module.definition_source(db);
let file_id = file_id.original_file(db);
if let Definition::Local(var) = self {
let range = match var.parent(db) {
@ -165,9 +226,10 @@ impl Definition {
DefWithBody::Const(c) => c.source(db).map(|src| src.value.syntax().text_range()),
DefWithBody::Static(s) => s.source(db).map(|src| src.value.syntax().text_range()),
};
let mut res = FxHashMap::default();
res.insert(file_id, range);
return SearchScope::new(res);
return match range {
Some(range) => SearchScope::file_range(FileRange { file_id, range }),
None => SearchScope::single_file(file_id),
};
}
if let Definition::GenericParam(hir::GenericParam::LifetimeParam(param)) = self {
@ -198,73 +260,39 @@ impl Definition {
it.source(db).map(|src| src.value.syntax().text_range())
}
};
let mut res = FxHashMap::default();
res.insert(file_id, range);
return SearchScope::new(res);
return match range {
Some(range) => SearchScope::file_range(FileRange { file_id, range }),
None => SearchScope::single_file(file_id),
};
}
if let Definition::Macro(macro_def) = self {
if macro_def.kind() == hir::MacroKind::Declarative {
return if macro_def.attrs(db).by_key("macro_export").exists() {
SearchScope::reverse_dependencies(db, module.krate())
} else {
SearchScope::krate(db, module.krate())
};
}
}
let vis = self.visibility(db);
if let Some(Visibility::Module(module)) = vis.and_then(|it| it.into()) {
let module: Module = module.into();
let mut res = FxHashMap::default();
let mut to_visit = vec![module];
let mut is_first = true;
while let Some(module) = to_visit.pop() {
let src = module.definition_source(db);
let file_id = src.file_id.original_file(db);
match src.value {
ModuleSource::Module(m) => {
if is_first {
let range = Some(m.syntax().text_range());
res.insert(file_id, range);
} else {
// We have already added the enclosing file to the search scope,
// so do nothing.
}
}
ModuleSource::BlockExpr(b) => {
if is_first {
let range = Some(b.syntax().text_range());
res.insert(file_id, range);
} else {
// We have already added the enclosing file to the search scope,
// so do nothing.
}
}
ModuleSource::SourceFile(_) => {
res.insert(file_id, None);
}
};
is_first = false;
to_visit.extend(module.children(db));
}
return SearchScope::new(res);
}
if let Some(Visibility::Public) = vis {
let mut res = FxHashMap::default();
let krate = module.krate();
for rev_dep in krate.transitive_reverse_dependencies(db) {
let root_file = rev_dep.root_file(db);
let source_root_id = db.file_source_root(root_file);
let source_root = db.source_root(source_root_id);
res.extend(source_root.iter().map(|id| (id, None)));
}
return SearchScope::new(res);
return SearchScope::reverse_dependencies(db, module.krate());
}
if let Some(Visibility::Module(module)) = vis {
return SearchScope::module(db, module.into());
}
let mut res = FxHashMap::default();
let range = match module_src.value {
let range = match module_source {
ModuleSource::Module(m) => Some(m.syntax().text_range()),
ModuleSource::BlockExpr(b) => Some(b.syntax().text_range()),
ModuleSource::SourceFile(_) => None,
};
res.insert(file_id, range);
SearchScope::new(res)
match range {
Some(range) => SearchScope::file_range(FileRange { file_id, range }),
None => SearchScope::single_file(file_id),
}
}
pub fn usages<'a>(&'a self, sema: &'a Semantics<RootDatabase>) -> FindUsages<'a> {