mirror of
https://github.com/rust-lang/rust.git
synced 2024-12-11 08:05:12 +00:00
switched to lowerd module
This commit is contained in:
parent
b93c6bc557
commit
c0aeb5204c
@ -7,7 +7,7 @@ use ra_syntax::{ast, TreeArc, SyntaxNode};
|
||||
use crate::{
|
||||
Name, DefId, Path, PerNs, ScopesWithSyntaxMapping, Ty, HirFileId,
|
||||
type_ref::TypeRef,
|
||||
nameres::ModuleScope,
|
||||
nameres::{ModuleScope, lower::LoweredImport},
|
||||
db::HirDatabase,
|
||||
expr::BodySyntaxMapping,
|
||||
ty::InferenceResult,
|
||||
@ -96,6 +96,15 @@ impl Module {
|
||||
self.declaration_source_impl(db)
|
||||
}
|
||||
|
||||
/// Returns the syntax of the last path segment corresponding to this import
|
||||
pub fn import_source(
|
||||
&self,
|
||||
db: &impl HirDatabase,
|
||||
import: LoweredImport,
|
||||
) -> TreeArc<ast::PathSegment> {
|
||||
self.import_source_impl(db, import)
|
||||
}
|
||||
|
||||
/// Returns the crate this module is part of.
|
||||
pub fn krate(&self, db: &impl HirDatabase) -> Option<Crate> {
|
||||
self.krate_impl(db)
|
||||
|
@ -5,7 +5,7 @@ use crate::{
|
||||
Module, ModuleSource, Problem,
|
||||
Crate, DefId, DefLoc, DefKind, Name, Path, PathKind, PerNs, Def,
|
||||
module_tree::ModuleId,
|
||||
nameres::ModuleScope,
|
||||
nameres::{ModuleScope, lower::LoweredImport},
|
||||
db::HirDatabase,
|
||||
};
|
||||
|
||||
@ -37,7 +37,7 @@ impl Module {
|
||||
Some(link.name(&module_tree).clone())
|
||||
}
|
||||
|
||||
pub fn definition_source_impl(&self, db: &impl HirDatabase) -> (FileId, ModuleSource) {
|
||||
pub(crate) fn definition_source_impl(&self, db: &impl HirDatabase) -> (FileId, ModuleSource) {
|
||||
let loc = self.def_id.loc(db);
|
||||
let file_id = loc.source_item_id.file_id.as_original_file();
|
||||
let syntax_node = db.file_item(loc.source_item_id);
|
||||
@ -50,7 +50,7 @@ impl Module {
|
||||
(file_id, module_source)
|
||||
}
|
||||
|
||||
pub fn declaration_source_impl(
|
||||
pub(crate) fn declaration_source_impl(
|
||||
&self,
|
||||
db: &impl HirDatabase,
|
||||
) -> Option<(FileId, TreeArc<ast::Module>)> {
|
||||
@ -66,6 +66,17 @@ impl Module {
|
||||
Some((file_id, src))
|
||||
}
|
||||
|
||||
pub(crate) fn import_source_impl(
|
||||
&self,
|
||||
db: &impl HirDatabase,
|
||||
import: LoweredImport,
|
||||
) -> TreeArc<ast::PathSegment> {
|
||||
let loc = self.def_id.loc(db);
|
||||
let source_map = db.lower_module_source_map(loc.source_root_id, loc.module_id);
|
||||
let (_, source) = self.definition_source(db);
|
||||
source_map.get(&source, import)
|
||||
}
|
||||
|
||||
pub(crate) fn krate_impl(&self, db: &impl HirDatabase) -> Option<Crate> {
|
||||
let root = self.crate_root(db);
|
||||
let loc = root.def_id.loc(db);
|
||||
|
@ -10,7 +10,7 @@ use crate::{
|
||||
FnSignature, FnScopes,
|
||||
macros::MacroExpansion,
|
||||
module_tree::{ModuleId, ModuleTree},
|
||||
nameres::{ItemMap, lower::InputModuleItems},
|
||||
nameres::{ItemMap, lower::{InputModuleItems, LoweredModule, ImportSourceMap}},
|
||||
ty::{InferenceResult, Ty, method_resolution::CrateImplBlocks},
|
||||
adt::{StructData, EnumData, EnumVariantData},
|
||||
impl_block::ModuleImplBlocks,
|
||||
@ -65,6 +65,27 @@ pub trait HirDatabase:
|
||||
module_id: ModuleId,
|
||||
) -> Arc<InputModuleItems>;
|
||||
|
||||
#[salsa::invoke(crate::nameres::lower::LoweredModule::lower_module_query)]
|
||||
fn lower_module(
|
||||
&self,
|
||||
source_root_id: SourceRootId,
|
||||
module_id: ModuleId,
|
||||
) -> (Arc<LoweredModule>, Arc<ImportSourceMap>);
|
||||
|
||||
#[salsa::invoke(crate::nameres::lower::LoweredModule::lower_module_module_query)]
|
||||
fn lower_module_module(
|
||||
&self,
|
||||
source_root_id: SourceRootId,
|
||||
module_id: ModuleId,
|
||||
) -> Arc<LoweredModule>;
|
||||
|
||||
#[salsa::invoke(crate::nameres::lower::LoweredModule::lower_module_source_map_query)]
|
||||
fn lower_module_source_map(
|
||||
&self,
|
||||
source_root_id: SourceRootId,
|
||||
module_id: ModuleId,
|
||||
) -> Arc<ImportSourceMap>;
|
||||
|
||||
#[salsa::invoke(query_definitions::item_map)]
|
||||
fn item_map(&self, source_root_id: SourceRootId) -> Arc<ItemMap>;
|
||||
|
||||
|
@ -60,7 +60,7 @@ pub struct Resolution {
|
||||
/// None for unresolved
|
||||
pub def_id: PerNs<DefId>,
|
||||
/// ident by whitch this is imported into local scope.
|
||||
pub import: Option<NamedImport>,
|
||||
pub import: Option<LoweredImport>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
@ -151,10 +151,10 @@ impl<T> PerNs<T> {
|
||||
|
||||
pub(crate) struct Resolver<'a, DB> {
|
||||
db: &'a DB,
|
||||
input: &'a FxHashMap<ModuleId, Arc<InputModuleItems>>,
|
||||
input: &'a FxHashMap<ModuleId, Arc<LoweredModule>>,
|
||||
source_root: SourceRootId,
|
||||
module_tree: Arc<ModuleTree>,
|
||||
processed_imports: FxHashSet<(ModuleId, usize)>,
|
||||
processed_imports: FxHashSet<(ModuleId, LoweredImport)>,
|
||||
result: ItemMap,
|
||||
}
|
||||
|
||||
@ -164,7 +164,7 @@ where
|
||||
{
|
||||
pub(crate) fn new(
|
||||
db: &'a DB,
|
||||
input: &'a FxHashMap<ModuleId, Arc<InputModuleItems>>,
|
||||
input: &'a FxHashMap<ModuleId, Arc<LoweredModule>>,
|
||||
source_root: SourceRootId,
|
||||
module_tree: Arc<ModuleTree>,
|
||||
) -> Resolver<'a, DB> {
|
||||
@ -197,7 +197,7 @@ where
|
||||
self.result
|
||||
}
|
||||
|
||||
fn populate_module(&mut self, module_id: ModuleId, input: Arc<InputModuleItems>) {
|
||||
fn populate_module(&mut self, module_id: ModuleId, input: Arc<LoweredModule>) {
|
||||
let mut module_items = ModuleScope::default();
|
||||
|
||||
// Populate extern crates prelude
|
||||
@ -220,14 +220,14 @@ where
|
||||
}
|
||||
};
|
||||
}
|
||||
for import in input.imports.iter() {
|
||||
if let Some(name) = import.path.segments.iter().last() {
|
||||
if let ImportKind::Named(import) = import.kind {
|
||||
for (import_id, import_data) in input.imports.iter() {
|
||||
if let Some(name) = import_data.path.segments.iter().last() {
|
||||
if !import_data.is_glob {
|
||||
module_items.items.insert(
|
||||
name.clone(),
|
||||
Resolution {
|
||||
def_id: PerNs::none(),
|
||||
import: Some(import),
|
||||
import: Some(import_id),
|
||||
},
|
||||
);
|
||||
}
|
||||
@ -281,23 +281,27 @@ where
|
||||
}
|
||||
|
||||
fn resolve_imports(&mut self, module_id: ModuleId) {
|
||||
for (i, import) in self.input[&module_id].imports.iter().enumerate() {
|
||||
if self.processed_imports.contains(&(module_id, i)) {
|
||||
for (import_id, import_data) in self.input[&module_id].imports.iter() {
|
||||
if self.processed_imports.contains(&(module_id, import_id)) {
|
||||
// already done
|
||||
continue;
|
||||
}
|
||||
if self.resolve_import(module_id, import) {
|
||||
log::debug!("import {:?} resolved (or definite error)", import);
|
||||
self.processed_imports.insert((module_id, i));
|
||||
if self.resolve_import(module_id, import_id, import_data) {
|
||||
log::debug!("import {:?} resolved (or definite error)", import_id);
|
||||
self.processed_imports.insert((module_id, import_id));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn resolve_import(&mut self, module_id: ModuleId, import: &Import) -> bool {
|
||||
fn resolve_import(
|
||||
&mut self,
|
||||
module_id: ModuleId,
|
||||
import_id: LoweredImport,
|
||||
import: &ImportData,
|
||||
) -> bool {
|
||||
log::debug!("resolving import: {:?}", import);
|
||||
let ptr = match import.kind {
|
||||
ImportKind::Glob => return false,
|
||||
ImportKind::Named(ptr) => ptr,
|
||||
if import.is_glob {
|
||||
return false;
|
||||
};
|
||||
|
||||
let mut curr: ModuleId = match import.path.kind {
|
||||
@ -358,7 +362,7 @@ where
|
||||
self.update(module_id, |items| {
|
||||
let res = Resolution {
|
||||
def_id,
|
||||
import: Some(ptr),
|
||||
import: Some(import_id),
|
||||
};
|
||||
items.items.insert(name.clone(), res);
|
||||
});
|
||||
@ -394,7 +398,7 @@ where
|
||||
self.update(module_id, |items| {
|
||||
let res = Resolution {
|
||||
def_id,
|
||||
import: Some(ptr),
|
||||
import: Some(import_id),
|
||||
};
|
||||
items.items.insert(name.clone(), res);
|
||||
})
|
||||
|
@ -1,10 +1,11 @@
|
||||
use std::sync::Arc;
|
||||
|
||||
use ra_syntax::{
|
||||
TextRange, SyntaxKind, AstNode,
|
||||
TextRange, SyntaxKind, AstNode, SourceFile, TreeArc,
|
||||
ast::{self, ModuleItemOwner},
|
||||
};
|
||||
use ra_db::{FileId, SourceRootId};
|
||||
use ra_db::{SourceRootId, LocalSyntaxPtr};
|
||||
use ra_arena::{Arena, RawId, impl_arena_id, map::ArenaMap};
|
||||
|
||||
use crate::{
|
||||
SourceItemId, SourceFileItemId, Path, ModuleSource, HirDatabase, Name, SourceFileItems,
|
||||
@ -139,12 +140,12 @@ impl InputModuleItems {
|
||||
fn add_use_item(&mut self, file_items: &SourceFileItems, item: &ast::UseItem) {
|
||||
let file_item_id = file_items.id_of_unchecked(item.syntax());
|
||||
let start_offset = item.syntax().range().start();
|
||||
Path::expand_use_item(item, |path, range| {
|
||||
let kind = match range {
|
||||
Path::expand_use_item(item, |path, segment| {
|
||||
let kind = match segment {
|
||||
None => ImportKind::Glob,
|
||||
Some(range) => ImportKind::Named(NamedImport {
|
||||
Some(segment) => ImportKind::Named(NamedImport {
|
||||
file_item_id,
|
||||
relative_range: range - start_offset,
|
||||
relative_range: segment.syntax().range() - start_offset,
|
||||
}),
|
||||
};
|
||||
self.imports.push(Import { kind, path })
|
||||
@ -199,22 +200,194 @@ pub struct NamedImport {
|
||||
pub relative_range: TextRange,
|
||||
}
|
||||
|
||||
impl NamedImport {
|
||||
// FIXME: this is only here for one use-case in completion. Seems like a
|
||||
// pretty gross special case.
|
||||
pub fn range(&self, db: &impl HirDatabase, file_id: FileId) -> TextRange {
|
||||
let source_item_id = SourceItemId {
|
||||
file_id: file_id.into(),
|
||||
item_id: Some(self.file_item_id),
|
||||
};
|
||||
let syntax = db.file_item(source_item_id);
|
||||
let offset = syntax.range().start();
|
||||
self.relative_range + offset
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub(super) enum ImportKind {
|
||||
Glob,
|
||||
Named(NamedImport),
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
||||
pub struct LoweredImport(RawId);
|
||||
impl_arena_id!(LoweredImport);
|
||||
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
pub(super) struct ImportData {
|
||||
pub(super) path: Path,
|
||||
pub(super) is_glob: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug, Default, PartialEq, Eq)]
|
||||
pub struct LoweredModule {
|
||||
pub(super) items: Vec<ModuleItem>,
|
||||
pub(super) imports: Arena<LoweredImport, ImportData>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Default, PartialEq, Eq)]
|
||||
pub struct ImportSourceMap {
|
||||
map: ArenaMap<LoweredImport, LocalSyntaxPtr>,
|
||||
}
|
||||
|
||||
impl ImportSourceMap {
|
||||
fn insert(&mut self, import: LoweredImport, segment: &ast::PathSegment) {
|
||||
self.map
|
||||
.insert(import, LocalSyntaxPtr::new(segment.syntax()))
|
||||
}
|
||||
|
||||
pub fn get(&self, source: &ModuleSource, import: LoweredImport) -> TreeArc<ast::PathSegment> {
|
||||
let file = match source {
|
||||
ModuleSource::SourceFile(file) => &*file,
|
||||
ModuleSource::Module(m) => m.syntax().ancestors().find_map(SourceFile::cast).unwrap(),
|
||||
};
|
||||
|
||||
ast::PathSegment::cast(&self.map[import].resolve(file))
|
||||
.unwrap()
|
||||
.to_owned()
|
||||
}
|
||||
}
|
||||
|
||||
impl LoweredModule {
|
||||
pub(crate) fn lower_module_module_query(
|
||||
db: &impl HirDatabase,
|
||||
source_root_id: SourceRootId,
|
||||
module_id: ModuleId,
|
||||
) -> Arc<LoweredModule> {
|
||||
db.lower_module(source_root_id, module_id).0
|
||||
}
|
||||
|
||||
pub(crate) fn lower_module_source_map_query(
|
||||
db: &impl HirDatabase,
|
||||
source_root_id: SourceRootId,
|
||||
module_id: ModuleId,
|
||||
) -> Arc<ImportSourceMap> {
|
||||
db.lower_module(source_root_id, module_id).1
|
||||
}
|
||||
|
||||
pub(crate) fn lower_module_query(
|
||||
db: &impl HirDatabase,
|
||||
source_root_id: SourceRootId,
|
||||
module_id: ModuleId,
|
||||
) -> (Arc<LoweredModule>, Arc<ImportSourceMap>) {
|
||||
let module_tree = db.module_tree(source_root_id);
|
||||
let source = module_id.source(&module_tree);
|
||||
let file_id = source.file_id;
|
||||
let source = ModuleSource::from_source_item_id(db, source);
|
||||
let mut source_map = ImportSourceMap::default();
|
||||
let mut res = LoweredModule::default();
|
||||
match source {
|
||||
ModuleSource::SourceFile(it) => res.fill(
|
||||
&mut source_map,
|
||||
db,
|
||||
source_root_id,
|
||||
module_id,
|
||||
file_id,
|
||||
&mut it.items_with_macros(),
|
||||
),
|
||||
ModuleSource::Module(it) => {
|
||||
if let Some(item_list) = it.item_list() {
|
||||
res.fill(
|
||||
&mut source_map,
|
||||
db,
|
||||
source_root_id,
|
||||
module_id,
|
||||
file_id,
|
||||
&mut item_list.items_with_macros(),
|
||||
)
|
||||
}
|
||||
}
|
||||
};
|
||||
(Arc::new(res), Arc::new(source_map))
|
||||
}
|
||||
|
||||
fn fill(
|
||||
&mut self,
|
||||
source_map: &mut ImportSourceMap,
|
||||
db: &impl HirDatabase,
|
||||
source_root_id: SourceRootId,
|
||||
module_id: ModuleId,
|
||||
file_id: HirFileId,
|
||||
items: &mut Iterator<Item = ast::ItemOrMacro>,
|
||||
) {
|
||||
let file_items = db.file_items(file_id);
|
||||
|
||||
for item in items {
|
||||
match item {
|
||||
ast::ItemOrMacro::Item(it) => {
|
||||
self.add_item(source_map, file_id, &file_items, it);
|
||||
}
|
||||
ast::ItemOrMacro::Macro(macro_call) => {
|
||||
let item_id = file_items.id_of_unchecked(macro_call.syntax());
|
||||
let loc = MacroCallLoc {
|
||||
source_root_id,
|
||||
module_id,
|
||||
source_item_id: SourceItemId {
|
||||
file_id,
|
||||
item_id: Some(item_id),
|
||||
},
|
||||
};
|
||||
let id = loc.id(db);
|
||||
let file_id = HirFileId::from(id);
|
||||
let file_items = db.file_items(file_id);
|
||||
//FIXME: expand recursively
|
||||
for item in db.hir_source_file(file_id).items() {
|
||||
self.add_item(source_map, file_id, &file_items, item);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn add_item(
|
||||
&mut self,
|
||||
source_map: &mut ImportSourceMap,
|
||||
file_id: HirFileId,
|
||||
file_items: &SourceFileItems,
|
||||
item: &ast::ModuleItem,
|
||||
) -> Option<()> {
|
||||
match item.kind() {
|
||||
ast::ModuleItemKind::StructDef(it) => {
|
||||
self.items.push(ModuleItem::new(file_id, file_items, it)?)
|
||||
}
|
||||
ast::ModuleItemKind::EnumDef(it) => {
|
||||
self.items.push(ModuleItem::new(file_id, file_items, it)?)
|
||||
}
|
||||
ast::ModuleItemKind::FnDef(it) => {
|
||||
self.items.push(ModuleItem::new(file_id, file_items, it)?)
|
||||
}
|
||||
ast::ModuleItemKind::TraitDef(it) => {
|
||||
self.items.push(ModuleItem::new(file_id, file_items, it)?)
|
||||
}
|
||||
ast::ModuleItemKind::TypeDef(it) => {
|
||||
self.items.push(ModuleItem::new(file_id, file_items, it)?)
|
||||
}
|
||||
ast::ModuleItemKind::ImplBlock(_) => {
|
||||
// impls don't define items
|
||||
}
|
||||
ast::ModuleItemKind::UseItem(it) => self.add_use_item(source_map, it),
|
||||
ast::ModuleItemKind::ExternCrateItem(_) => {
|
||||
// TODO
|
||||
}
|
||||
ast::ModuleItemKind::ConstDef(it) => {
|
||||
self.items.push(ModuleItem::new(file_id, file_items, it)?)
|
||||
}
|
||||
ast::ModuleItemKind::StaticDef(it) => {
|
||||
self.items.push(ModuleItem::new(file_id, file_items, it)?)
|
||||
}
|
||||
ast::ModuleItemKind::Module(it) => {
|
||||
self.items.push(ModuleItem::new(file_id, file_items, it)?)
|
||||
}
|
||||
}
|
||||
Some(())
|
||||
}
|
||||
|
||||
fn add_use_item(&mut self, source_map: &mut ImportSourceMap, item: &ast::UseItem) {
|
||||
Path::expand_use_item(item, |path, segment| {
|
||||
let import = self.imports.alloc(ImportData {
|
||||
path,
|
||||
is_glob: segment.is_none(),
|
||||
});
|
||||
if let Some(segment) = segment {
|
||||
source_map.insert(import, segment)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
@ -1,4 +1,4 @@
|
||||
use ra_syntax::{ast, AstNode, TextRange};
|
||||
use ra_syntax::{ast, AstNode};
|
||||
|
||||
use crate::{Name, AsName};
|
||||
|
||||
@ -18,7 +18,10 @@ pub enum PathKind {
|
||||
|
||||
impl Path {
|
||||
/// Calls `cb` with all paths, represented by this use item.
|
||||
pub fn expand_use_item(item: &ast::UseItem, mut cb: impl FnMut(Path, Option<TextRange>)) {
|
||||
pub fn expand_use_item<'a>(
|
||||
item: &'a ast::UseItem,
|
||||
mut cb: impl FnMut(Path, Option<&'a ast::PathSegment>),
|
||||
) {
|
||||
if let Some(tree) = item.use_tree() {
|
||||
expand_use_tree(None, tree, &mut cb);
|
||||
}
|
||||
@ -98,10 +101,10 @@ impl From<Name> for Path {
|
||||
}
|
||||
}
|
||||
|
||||
fn expand_use_tree(
|
||||
fn expand_use_tree<'a>(
|
||||
prefix: Option<Path>,
|
||||
tree: &ast::UseTree,
|
||||
cb: &mut impl FnMut(Path, Option<TextRange>),
|
||||
tree: &'a ast::UseTree,
|
||||
cb: &mut impl FnMut(Path, Option<&'a ast::PathSegment>),
|
||||
) {
|
||||
if let Some(use_tree_list) = tree.use_tree_list() {
|
||||
let prefix = match tree.path() {
|
||||
@ -125,20 +128,18 @@ fn expand_use_tree(
|
||||
if let Some(segment) = ast_path.segment() {
|
||||
if segment.kind() == Some(ast::PathSegmentKind::SelfKw) {
|
||||
if let Some(prefix) = prefix {
|
||||
cb(prefix, Some(segment.syntax().range()));
|
||||
cb(prefix, Some(segment));
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Some(path) = convert_path(prefix, ast_path) {
|
||||
let range = if tree.has_star() {
|
||||
None
|
||||
} else {
|
||||
let range = ast_path.segment().unwrap().syntax().range();
|
||||
Some(range)
|
||||
if tree.has_star() {
|
||||
cb(path, None)
|
||||
} else if let Some(segment) = ast_path.segment() {
|
||||
cb(path, Some(segment))
|
||||
};
|
||||
cb(path, range)
|
||||
}
|
||||
// TODO: report errors somewhere
|
||||
// We get here if we do
|
||||
|
@ -46,7 +46,7 @@ pub(super) fn item_map(db: &impl HirDatabase, source_root: SourceRootId) -> Arc<
|
||||
let module_tree = db.module_tree(source_root);
|
||||
let input = module_tree
|
||||
.modules()
|
||||
.map(|id| (id, db.input_module_items(source_root, id)))
|
||||
.map(|id| (id, db.lower_module_module(source_root, id)))
|
||||
.collect::<FxHashMap<_, _>>();
|
||||
|
||||
let resolver = Resolver::new(db, &input, source_root, module_tree);
|
||||
|
@ -1,5 +1,5 @@
|
||||
use rustc_hash::FxHashSet;
|
||||
use ra_syntax::TextUnit;
|
||||
use ra_syntax::{AstNode, TextUnit};
|
||||
|
||||
use crate::completion::{CompletionItem, CompletionItemKind, Completions, CompletionKind, CompletionContext};
|
||||
|
||||
@ -17,18 +17,15 @@ pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) {
|
||||
}
|
||||
|
||||
let module_scope = module.scope(ctx.db);
|
||||
let (file_id, _) = module.definition_source(ctx.db);
|
||||
module_scope
|
||||
.entries()
|
||||
.filter(|(_name, res)| {
|
||||
// Don't expose this item
|
||||
// FIXME: this penetrates through all kinds of abstractions,
|
||||
// we need to figura out the way to do it less ugly.
|
||||
// For cases like `use self::foo<|>` don't suggest foo itself.
|
||||
match res.import {
|
||||
None => true,
|
||||
Some(import) => {
|
||||
let range = import.range(ctx.db, file_id);
|
||||
!range.is_subrange(&ctx.leaf.range())
|
||||
let source = module.import_source(ctx.db, import);
|
||||
!source.syntax().range().is_subrange(&ctx.leaf.range())
|
||||
}
|
||||
}
|
||||
})
|
||||
|
@ -114,6 +114,9 @@ salsa::database_storage! {
|
||||
fn file_items() for hir::db::FileItemsQuery;
|
||||
fn file_item() for hir::db::FileItemQuery;
|
||||
fn input_module_items() for hir::db::InputModuleItemsQuery;
|
||||
fn lower_module() for hir::db::LowerModuleQuery;
|
||||
fn lower_module_module() for hir::db::LowerModuleModuleQuery;
|
||||
fn lower_module_source_map() for hir::db::LowerModuleSourceMapQuery;
|
||||
fn item_map() for hir::db::ItemMapQuery;
|
||||
fn submodules() for hir::db::SubmodulesQuery;
|
||||
fn infer() for hir::db::InferQuery;
|
||||
|
Loading…
Reference in New Issue
Block a user