From 973b5cf7e20842711d59a810b268796b26241382 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sat, 21 Dec 2019 15:04:33 +0100 Subject: [PATCH] Revert "Merge #2629" This reverts commit cdc9d682b066b110e0a44e5f8f1c574b38c16ba9, reversing changes made to 90ef070db3dce0a7acb9cd11d0b0d72de13c9d79. --- crates/ra_hir/src/code_model.rs | 18 ++--- crates/ra_hir/src/db.rs | 4 +- crates/ra_hir/src/has_source.rs | 16 ++++- crates/ra_hir/src/lib.rs | 4 +- crates/ra_hir_def/src/db.rs | 11 ++- crates/ra_hir_def/src/item_scope.rs | 35 +++++++--- crates/ra_hir_def/src/lib.rs | 4 ++ crates/ra_hir_def/src/nameres/collector.rs | 46 +++++++------ crates/ra_hir_def/src/nameres/raw.rs | 68 ++++++++++++++----- crates/ra_hir_def/src/trace.rs | 8 +++ crates/ra_ide/src/change.rs | 2 + crates/ra_ide/src/completion/complete_path.rs | 17 +++-- .../src/completion/completion_context.rs | 4 -- 13 files changed, 166 insertions(+), 71 deletions(-) diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs index e6768ea0bc0..fca3a295099 100644 --- a/crates/ra_hir/src/code_model.rs +++ b/crates/ra_hir/src/code_model.rs @@ -12,8 +12,8 @@ resolver::HasResolver, type_ref::{Mutability, TypeRef}, AdtId, ConstId, DefWithBodyId, EnumId, FunctionId, HasModule, ImplId, LocalEnumVariantId, - LocalModuleId, LocalStructFieldId, Lookup, ModuleId, StaticId, StructId, TraitId, TypeAliasId, - TypeParamId, UnionId, + LocalImportId, LocalModuleId, LocalStructFieldId, Lookup, ModuleId, StaticId, StructId, + TraitId, TypeAliasId, TypeParamId, UnionId, }; use hir_expand::{ diagnostics::DiagnosticSink, @@ -180,11 +180,13 @@ pub fn path_to_root(self, db: &impl HirDatabase) -> Vec { } /// Returns a `ModuleScope`: a set of items, visible in this module. - pub fn scope(self, db: &impl HirDatabase) -> Vec<(Name, ScopeDef)> { + pub fn scope(self, db: &impl HirDatabase) -> Vec<(Name, ScopeDef, Option)> { db.crate_def_map(self.id.krate)[self.id.local_id] .scope .entries() - .map(|(name, res)| (name.clone(), res.def.into())) + .map(|(name, res)| { + (name.clone(), res.def.into(), res.import.map(|id| Import { parent: self, id })) + }) .collect() } @@ -227,10 +229,10 @@ pub(crate) fn with_module_id(self, module_id: LocalModuleId) -> Module { } } -// pub struct Import { -// pub(crate) parent: Module, -// pub(crate) id: LocalImportId, -// } +pub struct Import { + pub(crate) parent: Module, + pub(crate) id: LocalImportId, +} #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct StructField { diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs index f5ffd64fa7b..bfae3660b41 100644 --- a/crates/ra_hir/src/db.rs +++ b/crates/ra_hir/src/db.rs @@ -4,8 +4,8 @@ BodyQuery, BodyWithSourceMapQuery, ConstDataQuery, CrateDefMapQuery, CrateLangItemsQuery, DefDatabase, DefDatabaseStorage, DocumentationQuery, EnumDataQuery, ExprScopesQuery, FunctionDataQuery, GenericParamsQuery, ImplDataQuery, InternDatabase, InternDatabaseStorage, - LangItemQuery, ModuleLangItemsQuery, RawItemsQuery, StaticDataQuery, StructDataQuery, - TraitDataQuery, TypeAliasDataQuery, + LangItemQuery, ModuleLangItemsQuery, RawItemsQuery, RawItemsWithSourceMapQuery, + StaticDataQuery, StructDataQuery, TraitDataQuery, TypeAliasDataQuery, }; pub use hir_expand::db::{ AstDatabase, AstDatabaseStorage, AstIdMapQuery, MacroArgQuery, MacroDefQuery, MacroExpandQuery, diff --git a/crates/ra_hir/src/has_source.rs b/crates/ra_hir/src/has_source.rs index 5541266e2b1..72afecf26c3 100644 --- a/crates/ra_hir/src/has_source.rs +++ b/crates/ra_hir/src/has_source.rs @@ -9,8 +9,8 @@ use ra_syntax::ast; use crate::{ - db::DefDatabase, Const, Enum, EnumVariant, FieldSource, Function, ImplBlock, MacroDef, Module, - Static, Struct, StructField, Trait, TypeAlias, TypeParam, Union, + db::DefDatabase, Const, Enum, EnumVariant, FieldSource, Function, ImplBlock, Import, MacroDef, + Module, Static, Struct, StructField, Trait, TypeAlias, TypeParam, Union, }; pub use hir_expand::InFile; @@ -117,6 +117,18 @@ fn source(self, db: &impl DefDatabase) -> InFile { self.id.lookup(db).source(db) } } +impl HasSource for Import { + type Ast = Either; + + /// Returns the syntax of the last path segment corresponding to this import + fn source(self, db: &impl DefDatabase) -> InFile { + let src = self.parent.definition_source(db); + let (_, source_map) = db.raw_items_with_source_map(src.file_id); + let root = db.parse_or_expand(src.file_id).unwrap(); + let ptr = source_map.get(self.id); + src.with_value(ptr.map_left(|it| it.to_node(&root)).map_right(|it| it.to_node(&root))) + } +} impl HasSource for TypeParam { type Ast = Either; diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs index 0008a8858fc..7f9aef77074 100644 --- a/crates/ra_hir/src/lib.rs +++ b/crates/ra_hir/src/lib.rs @@ -40,8 +40,8 @@ fn from(it: $sv) -> $e { pub use crate::{ code_model::{ Adt, AssocItem, AttrDef, Const, Crate, CrateDependency, DefWithBody, Docs, Enum, - EnumVariant, FieldSource, Function, GenericDef, HasAttrs, ImplBlock, Local, MacroDef, - Module, ModuleDef, ScopeDef, Static, Struct, StructField, Trait, Type, TypeAlias, + EnumVariant, FieldSource, Function, GenericDef, HasAttrs, ImplBlock, Import, Local, + MacroDef, Module, ModuleDef, ScopeDef, Static, Struct, StructField, Trait, Type, TypeAlias, TypeParam, Union, VariantDef, }, from_source::FromSource, diff --git a/crates/ra_hir_def/src/db.rs b/crates/ra_hir_def/src/db.rs index c55fd411107..98bff6cb783 100644 --- a/crates/ra_hir_def/src/db.rs +++ b/crates/ra_hir_def/src/db.rs @@ -13,7 +13,10 @@ docs::Documentation, generics::GenericParams, lang_item::{LangItemTarget, LangItems}, - nameres::{raw::RawItems, CrateDefMap}, + nameres::{ + raw::{ImportSourceMap, RawItems}, + CrateDefMap, + }, AttrDefId, ConstId, ConstLoc, DefWithBodyId, EnumId, EnumLoc, FunctionId, FunctionLoc, GenericDefId, ImplId, ImplLoc, ModuleId, StaticId, StaticLoc, StructId, StructLoc, TraitId, TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc, @@ -43,6 +46,12 @@ pub trait InternDatabase: SourceDatabase { #[salsa::query_group(DefDatabaseStorage)] pub trait DefDatabase: InternDatabase + AstDatabase { + #[salsa::invoke(RawItems::raw_items_with_source_map_query)] + fn raw_items_with_source_map( + &self, + file_id: HirFileId, + ) -> (Arc, Arc); + #[salsa::invoke(RawItems::raw_items_query)] fn raw_items(&self, file_id: HirFileId) -> Arc; diff --git a/crates/ra_hir_def/src/item_scope.rs b/crates/ra_hir_def/src/item_scope.rs index 5c14fefff43..6b9be8325d4 100644 --- a/crates/ra_hir_def/src/item_scope.rs +++ b/crates/ra_hir_def/src/item_scope.rs @@ -5,7 +5,7 @@ use once_cell::sync::Lazy; use rustc_hash::FxHashMap; -use crate::{per_ns::PerNs, BuiltinType, ImplId, MacroDefId, ModuleDefId, TraitId}; +use crate::{per_ns::PerNs, BuiltinType, ImplId, LocalImportId, MacroDefId, ModuleDefId, TraitId}; #[derive(Debug, Default, PartialEq, Eq)] pub struct ItemScope { @@ -30,7 +30,7 @@ pub struct ItemScope { BuiltinType::ALL .iter() .map(|(name, ty)| { - (name.clone(), Resolution { def: PerNs::types(ty.clone().into()), declaration: false }) + (name.clone(), Resolution { def: PerNs::types(ty.clone().into()), import: None }) }) .collect() }); @@ -53,9 +53,11 @@ pub fn entries<'a>(&'a self) -> impl Iterator } pub fn declarations(&self) -> impl Iterator + '_ { - self.entries().filter(|(_name, res)| res.declaration).flat_map(|(_name, res)| { - res.def.take_types().into_iter().chain(res.def.take_values().into_iter()) - }) + self.entries() + .filter_map(|(_name, res)| if res.import.is_none() { Some(res.def) } else { None }) + .flat_map(|per_ns| { + per_ns.take_types().into_iter().chain(per_ns.take_values().into_iter()) + }) } pub fn impls(&self) -> impl Iterator + ExactSizeIterator + '_ { @@ -110,26 +112,38 @@ pub(crate) fn define_legacy_macro(&mut self, name: Name, mac: MacroDefId) { self.legacy_macros.insert(name, mac); } - pub(crate) fn push_res(&mut self, name: Name, res: &Resolution, declaration: bool) -> bool { + pub(crate) fn push_res( + &mut self, + name: Name, + res: &Resolution, + import: Option, + ) -> bool { let mut changed = false; let existing = self.items.entry(name.clone()).or_default(); if existing.def.types.is_none() && res.def.types.is_some() { existing.def.types = res.def.types; - existing.declaration |= declaration; + existing.import = import.or(res.import); changed = true; } if existing.def.values.is_none() && res.def.values.is_some() { existing.def.values = res.def.values; - existing.declaration |= declaration; + existing.import = import.or(res.import); changed = true; } if existing.def.macros.is_none() && res.def.macros.is_some() { existing.def.macros = res.def.macros; - existing.declaration |= declaration; + existing.import = import.or(res.import); changed = true; } + if existing.def.is_none() + && res.def.is_none() + && existing.import.is_none() + && res.import.is_some() + { + existing.import = res.import; + } changed } @@ -146,5 +160,6 @@ pub(crate) fn collect_legacy_macros(&self) -> FxHashMap { pub struct Resolution { /// None for unresolved pub def: PerNs, - pub declaration: bool, + /// ident by which this is imported into local scope. + pub import: Option, } diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs index f6c7f38d171..acd4f4af17b 100644 --- a/crates/ra_hir_def/src/lib.rs +++ b/crates/ra_hir_def/src/lib.rs @@ -51,6 +51,10 @@ use crate::body::Expander; use crate::builtin_type::BuiltinType; +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct LocalImportId(RawId); +impl_arena_id!(LocalImportId); + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct ModuleId { pub krate: CrateId, diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs index 9419461a864..45199fa1149 100644 --- a/crates/ra_hir_def/src/nameres/collector.rs +++ b/crates/ra_hir_def/src/nameres/collector.rs @@ -26,7 +26,8 @@ path::{ModPath, PathKind}, per_ns::PerNs, AdtId, AstId, ConstLoc, ContainerId, EnumLoc, EnumVariantId, FunctionLoc, ImplLoc, Intern, - LocalModuleId, ModuleDefId, ModuleId, StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc, + LocalImportId, LocalModuleId, ModuleDefId, ModuleId, StaticLoc, StructLoc, TraitLoc, + TypeAliasLoc, UnionLoc, }; pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> CrateDefMap { @@ -92,7 +93,7 @@ fn namespaces(&self) -> PerNs { #[derive(Clone, Debug, Eq, PartialEq)] struct ImportDirective { module_id: LocalModuleId, - import_id: raw::LocalImportId, + import_id: LocalImportId, import: raw::ImportData, status: PartialResolvedImport, } @@ -109,7 +110,7 @@ struct MacroDirective { struct DefCollector<'a, DB> { db: &'a DB, def_map: CrateDefMap, - glob_imports: FxHashMap>, + glob_imports: FxHashMap>, unresolved_imports: Vec, resolved_imports: Vec, unexpanded_macros: Vec, @@ -217,7 +218,8 @@ fn define_macro( if export { self.update( self.def_map.root, - &[(name, Resolution { def: PerNs::macros(macro_), declaration: false })], + None, + &[(name, Resolution { def: PerNs::macros(macro_), import: None })], ); } } @@ -372,7 +374,7 @@ fn record_resolved_import(&mut self, directive: &ImportDirective) { // Module scoped macros is included let items = scope.collect_resolutions(); - self.update(module_id, &items); + self.update(module_id, Some(import_id), &items); } else { // glob import from same crate => we do an initial // import, and then need to propagate any further @@ -382,7 +384,7 @@ fn record_resolved_import(&mut self, directive: &ImportDirective) { // Module scoped macros is included let items = scope.collect_resolutions(); - self.update(module_id, &items); + self.update(module_id, Some(import_id), &items); // record the glob import in case we add further items let glob = self.glob_imports.entry(m.local_id).or_default(); if !glob.iter().any(|it| *it == (module_id, import_id)) { @@ -402,12 +404,12 @@ fn record_resolved_import(&mut self, directive: &ImportDirective) { let variant = EnumVariantId { parent: e, local_id }; let res = Resolution { def: PerNs::both(variant.into(), variant.into()), - declaration: false, + import: Some(import_id), }; (name, res) }) .collect::>(); - self.update(module_id, &resolutions); + self.update(module_id, Some(import_id), &resolutions); } Some(d) => { log::debug!("glob import {:?} from non-module/enum {:?}", import, d); @@ -429,21 +431,27 @@ fn record_resolved_import(&mut self, directive: &ImportDirective) { } } - let resolution = Resolution { def, declaration: false }; - self.update(module_id, &[(name, resolution)]); + let resolution = Resolution { def, import: Some(import_id) }; + self.update(module_id, Some(import_id), &[(name, resolution)]); } None => tested_by!(bogus_paths), } } } - fn update(&mut self, module_id: LocalModuleId, resolutions: &[(Name, Resolution)]) { - self.update_recursive(module_id, resolutions, 0) + fn update( + &mut self, + module_id: LocalModuleId, + import: Option, + resolutions: &[(Name, Resolution)], + ) { + self.update_recursive(module_id, import, resolutions, 0) } fn update_recursive( &mut self, module_id: LocalModuleId, + import: Option, resolutions: &[(Name, Resolution)], depth: usize, ) { @@ -454,7 +462,7 @@ fn update_recursive( let scope = &mut self.def_map.modules[module_id].scope; let mut changed = false; for (name, res) in resolutions { - changed |= scope.push_res(name.clone(), res, depth == 0 && res.declaration); + changed |= scope.push_res(name.clone(), res, import); } if !changed { @@ -467,9 +475,9 @@ fn update_recursive( .flat_map(|v| v.iter()) .cloned() .collect::>(); - for (glob_importing_module, _glob_import) in glob_imports { + for (glob_importing_module, glob_import) in glob_imports { // We pass the glob import so that the tracked import in those modules is that glob import - self.update_recursive(glob_importing_module, resolutions, depth + 1); + self.update_recursive(glob_importing_module, Some(glob_import), resolutions, depth + 1); } } @@ -711,9 +719,9 @@ fn push_child_module( def: PerNs::types( ModuleId { krate: self.def_collector.def_map.krate, local_id: res }.into(), ), - declaration: true, + import: None, }; - self.def_collector.update(self.module_id, &[(name, resolution)]); + self.def_collector.update(self.module_id, None, &[(name, resolution)]); res } @@ -783,8 +791,8 @@ fn define_def(&mut self, def: &raw::DefData, attrs: &Attrs) { PerNs::types(def.into()) } }; - let resolution = Resolution { def, declaration: true }; - self.def_collector.update(self.module_id, &[(name, resolution)]) + let resolution = Resolution { def, import: None }; + self.def_collector.update(self.module_id, None, &[(name, resolution)]) } fn collect_derives(&mut self, attrs: &Attrs, def: &raw::DefData) { diff --git a/crates/ra_hir_def/src/nameres/raw.rs b/crates/ra_hir_def/src/nameres/raw.rs index b10e458a207..ecb4d7c03d6 100644 --- a/crates/ra_hir_def/src/nameres/raw.rs +++ b/crates/ra_hir_def/src/nameres/raw.rs @@ -7,24 +7,24 @@ use std::{ops::Index, sync::Arc}; +use either::Either; use hir_expand::{ ast_id_map::AstIdMap, db::AstDatabase, hygiene::Hygiene, name::{AsName, Name}, }; -use ra_arena::{impl_arena_id, Arena, RawId}; +use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId}; use ra_syntax::{ ast::{self, AttrsOwner, NameOwner}, - AstNode, + AstNode, AstPtr, }; use test_utils::tested_by; -use crate::{attr::Attrs, db::DefDatabase, path::ModPath, FileAstId, HirFileId, InFile}; - -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -pub(super) struct LocalImportId(RawId); -impl_arena_id!(LocalImportId); +use crate::{ + attr::Attrs, db::DefDatabase, path::ModPath, trace::Trace, FileAstId, HirFileId, InFile, + LocalImportId, +}; /// `RawItems` is a set of top-level items in a file (except for impls). /// @@ -41,14 +41,35 @@ pub struct RawItems { items: Vec, } +#[derive(Debug, Default, PartialEq, Eq)] +pub struct ImportSourceMap { + map: ArenaMap, +} + +type ImportSourcePtr = Either, AstPtr>; + +impl ImportSourceMap { + pub fn get(&self, import: LocalImportId) -> ImportSourcePtr { + self.map[import].clone() + } +} + impl RawItems { pub(crate) fn raw_items_query( db: &(impl DefDatabase + AstDatabase), file_id: HirFileId, ) -> Arc { + 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, Arc) { let mut collector = RawItemsCollector { raw_items: RawItems::default(), source_ast_id_map: db.ast_id_map(file_id), + imports: Trace::new(), file_id, hygiene: Hygiene::new(db, file_id), }; @@ -59,8 +80,11 @@ pub(crate) fn raw_items_query( collector.process_module(None, item_list); } } - let raw_items = collector.raw_items; - Arc::new(raw_items) + let mut raw_items = collector.raw_items; + let (arena, map) = collector.imports.into_arena_and_map(); + raw_items.imports = arena; + let source_map = ImportSourceMap { map }; + (Arc::new(raw_items), Arc::new(source_map)) } pub(super) fn items(&self) -> &[RawItem] { @@ -199,6 +223,7 @@ pub(super) struct ImplData { struct RawItemsCollector { raw_items: RawItems, + imports: Trace, source_ast_id_map: Arc, file_id: HirFileId, hygiene: Hygiene, @@ -305,7 +330,7 @@ fn add_use_item(&mut self, current_module: Option, use_item: ast::UseIte ModPath::expand_use_item( InFile { value: use_item, file_id: self.file_id }, &self.hygiene, - |path, _use_tree, is_glob, alias| { + |path, use_tree, is_glob, alias| { let import_data = ImportData { path, alias, @@ -314,11 +339,11 @@ fn add_use_item(&mut self, current_module: Option, use_item: ast::UseIte is_extern_crate: false, is_macro_use: false, }; - buf.push(import_data); + buf.push((import_data, Either::Left(AstPtr::new(use_tree)))); }, ); - for import_data in buf { - self.push_import(current_module, attrs.clone(), import_data); + for (import_data, ptr) in buf { + self.push_import(current_module, attrs.clone(), import_data, ptr); } } @@ -341,7 +366,12 @@ fn add_extern_crate_item( is_extern_crate: true, is_macro_use, }; - self.push_import(current_module, attrs, import_data); + self.push_import( + current_module, + attrs, + import_data, + Either::Right(AstPtr::new(&extern_crate)), + ); } } @@ -372,8 +402,14 @@ fn add_impl(&mut self, current_module: Option, imp: ast::ImplBlock) { self.push_item(current_module, attrs, RawItemKind::Impl(imp)) } - fn push_import(&mut self, current_module: Option, attrs: Attrs, data: ImportData) { - let import = self.raw_items.imports.alloc(data); + fn push_import( + &mut self, + current_module: Option, + attrs: Attrs, + data: ImportData, + source: ImportSourcePtr, + ) { + let import = self.imports.alloc(|| source, || data); self.push_item(current_module, attrs, RawItemKind::Import(import)) } diff --git a/crates/ra_hir_def/src/trace.rs b/crates/ra_hir_def/src/trace.rs index 9769e88df58..2bcd707bcd3 100644 --- a/crates/ra_hir_def/src/trace.rs +++ b/crates/ra_hir_def/src/trace.rs @@ -18,6 +18,10 @@ pub(crate) struct Trace { } impl Trace { + pub(crate) fn new() -> Trace { + Trace { arena: Some(Arena::default()), map: Some(ArenaMap::default()), len: 0 } + } + pub(crate) fn new_for_arena() -> Trace { Trace { arena: Some(Arena::default()), map: None, len: 0 } } @@ -48,4 +52,8 @@ pub(crate) fn into_arena(mut self) -> Arena { pub(crate) fn into_map(mut self) -> ArenaMap { self.map.take().unwrap() } + + pub(crate) fn into_arena_and_map(mut self) -> (Arena, ArenaMap) { + (self.arena.take().unwrap(), self.map.take().unwrap()) + } } diff --git a/crates/ra_ide/src/change.rs b/crates/ra_ide/src/change.rs index 387a9cafb65..4a76d1dd83c 100644 --- a/crates/ra_ide/src/change.rs +++ b/crates/ra_ide/src/change.rs @@ -270,6 +270,7 @@ pub(crate) fn collect_garbage(&mut self) { self.query(hir::db::AstIdMapQuery).sweep(sweep); + self.query(hir::db::RawItemsWithSourceMapQuery).sweep(sweep); self.query(hir::db::BodyWithSourceMapQuery).sweep(sweep); self.query(hir::db::ExprScopesQuery).sweep(sweep); @@ -308,6 +309,7 @@ macro_rules! sweep_each_query { hir::db::StructDataQuery hir::db::EnumDataQuery hir::db::TraitDataQuery + hir::db::RawItemsWithSourceMapQuery hir::db::RawItemsQuery hir::db::CrateDefMapQuery hir::db::GenericParamsQuery diff --git a/crates/ra_ide/src/completion/complete_path.rs b/crates/ra_ide/src/completion/complete_path.rs index 8ce86ad7d21..28f94e0a776 100644 --- a/crates/ra_ide/src/completion/complete_path.rs +++ b/crates/ra_ide/src/completion/complete_path.rs @@ -1,6 +1,7 @@ //! FIXME: write short doc here -use hir::{Adt, PathResolution, ScopeDef}; +use either::Either; +use hir::{Adt, HasSource, PathResolution}; use ra_syntax::AstNode; use test_utils::tested_by; @@ -18,15 +19,17 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) { match def { hir::ModuleDef::Module(module) => { let module_scope = module.scope(ctx.db); - for (name, def) in module_scope { - if ctx.use_item_syntax.is_some() { - if let hir::ScopeDef::ModuleDef(hir::ModuleDef::BuiltinType(..)) = def { + for (name, def, import) in module_scope { + if let hir::ScopeDef::ModuleDef(hir::ModuleDef::BuiltinType(..)) = def { + if ctx.use_item_syntax.is_some() { tested_by!(dont_complete_primitive_in_use); continue; } - if let ScopeDef::Unknown = def { - if let Some(name_ref) = ctx.name_ref.as_ref() { - if &name_ref.syntax().text() == name.to_string().as_str() { + } + if Some(module) == ctx.module { + if let Some(import) = import { + if let Either::Left(use_tree) = import.source(ctx.db).value { + if use_tree.syntax().text_range().contains_inclusive(ctx.offset) { // for `use self::foo<|>`, don't suggest `foo` as a completion tested_by!(dont_complete_current_use); continue; diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs index 8f56ce7062a..4894ea2f6b7 100644 --- a/crates/ra_ide/src/completion/completion_context.rs +++ b/crates/ra_ide/src/completion/completion_context.rs @@ -18,7 +18,6 @@ pub(crate) struct CompletionContext<'a> { pub(super) analyzer: hir::SourceAnalyzer, pub(super) offset: TextUnit, pub(super) token: SyntaxToken, - pub(super) name_ref: Option, pub(super) module: Option, pub(super) function_syntax: Option, pub(super) use_item_syntax: Option, @@ -69,7 +68,6 @@ pub(super) fn new( analyzer, token, offset: position.offset, - name_ref: None, module, function_syntax: None, use_item_syntax: None, @@ -144,8 +142,6 @@ fn fill(&mut self, original_parse: &'a Parse, offset: TextUnit) } fn classify_name_ref(&mut self, original_file: SourceFile, name_ref: ast::NameRef) { - self.name_ref = - find_node_at_offset(original_file.syntax(), name_ref.syntax().text_range().start()); let name_range = name_ref.syntax().text_range(); if name_ref.syntax().parent().and_then(ast::RecordField::cast).is_some() { self.record_lit_syntax = find_node_at_offset(original_file.syntax(), self.offset); -- 2.44.0