itsscb/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-10-01 11:31:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #19412 from Veykril/push-krktmvxmlxmt

Browse Source 
chore: Remove some unnecessary usage of `Semantics`
This commit is contained in:
Lukas Wirth 2025-03-21 19:25:41 +00:00 committed by GitHub
commit 32fa60f3a6
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
6 changed files with 46 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -599,6 +599,18 @@ impl Module {
.collect()
}
pub fn resolve_mod_path(
&self,
db: &dyn HirDatabase,
segments: impl IntoIterator<Item = Name>,
) -> Option<impl Iterator<Item = ItemInNs>> {
let items = self.id.resolver(db.upcast()).resolve_module_path_in_items(
db.upcast(),
&ModPath::from_segments(hir_def::path::PathKind::Plain, segments),
);
Some(items.iter_items().map(|(item, _)| item.into()))
}
/// Fills `acc` with the module's diagnostics.
pub fn diagnostics(
self,

12
crates/hir/src/semantics.rs
View File

@ -1651,18 +1651,6 @@ impl<'db> SemanticsImpl<'db> {
Some(items.iter_items().map(|(item, _)| item.into()))
}
pub fn resolve_mod_path_relative(
&self,
to: Module,
segments: impl IntoIterator<Item = Name>,
) -> Option<impl Iterator<Item = ItemInNs>> {
let items = to.id.resolver(self.db.upcast()).resolve_module_path_in_items(
self.db.upcast(),
&ModPath::from_segments(hir_def::path::PathKind::Plain, segments),
);
Some(items.iter_items().map(|(item, _)| item.into()))
}
fn resolve_variant(&self, record_lit: ast::RecordExpr) -> Option<VariantId> {
self.analyze(record_lit.syntax())?.resolve_variant(record_lit)
}

2
crates/ide-assists/src/handlers/replace_derive_with_manual_impl.rs
View File

@ -73,7 +73,7 @@ pub(crate) fn replace_derive_with_manual_impl(
let current_edition = current_crate.edition(ctx.db());
let found_traits = items_locator::items_with_name(
&ctx.sema,
ctx.db(),
current_crate,
NameToImport::exact_case_sensitive(path.segments().last()?.to_string()),
items_locator::AssocSearchMode::Exclude,

1
crates/ide-completion/src/context.rs
View File

@ -823,6 +823,7 @@ impl<'a> CompletionContext<'a> {
exclude_flyimport
.extend(exclude_traits.iter().map(|&t| (t.into(), AutoImportExclusionType::Always)));
// FIXME: This should be part of `CompletionAnalysis` / `expand_and_analyze`
let complete_semicolon = if config.add_semicolon_to_unit {
let inside_closure_ret = token.parent_ancestors().try_for_each(|ancestor| {
match_ast! {

43
crates/ide-db/src/imports/import_assets.rs
View File

@ -273,12 +273,13 @@ impl ImportAssets {
Some(it) => it,
None => return <FxIndexSet<_>>::default().into_iter(),
};
let db = sema.db;
let krate = self.module_with_candidate.krate();
let scope_definitions = self.scope_definitions(sema);
let mod_path = |item| {
get_mod_path(
sema.db,
item_for_path_search(sema.db, item)?,
db,
item_for_path_search(db, item)?,
&self.module_with_candidate,
prefixed,
cfg,
@ -288,7 +289,7 @@ impl ImportAssets {
match &self.import_candidate {
ImportCandidate::Path(path_candidate) => path_applicable_imports(
sema,
db,
&scope,
krate,
path_candidate,
@ -297,7 +298,7 @@ impl ImportAssets {
),
ImportCandidate::TraitAssocItem(trait_candidate)
| ImportCandidate::TraitMethod(trait_candidate) => trait_applicable_items(
sema,
db,
krate,
&scope,
trait_candidate,
@ -325,7 +326,7 @@ impl ImportAssets {
}
fn path_applicable_imports(
sema: &Semantics<'_, RootDatabase>,
db: &RootDatabase,
scope: &SemanticsScope<'_>,
current_crate: Crate,
path_candidate: &PathImportCandidate,
@ -337,7 +338,7 @@ fn path_applicable_imports(
match &*path_candidate.qualifier {
[] => {
items_locator::items_with_name(
sema,
db,
current_crate,
path_candidate.name.clone(),
// FIXME: we could look up assoc items by the input and propose those in completion,
@ -365,7 +366,7 @@ fn path_applicable_imports(
// what follows
// FIXME: This doesn't handle visibility
[first_qsegment, qualifier_rest @ ..] => items_locator::items_with_name(
sema,
db,
current_crate,
NameToImport::Exact(first_qsegment.as_str().to_owned(), true),
AssocSearchMode::Exclude,
@ -374,7 +375,7 @@ fn path_applicable_imports(
// we found imports for `first_qsegment`, now we need to filter these imports by whether
// they result in resolving the rest of the path successfully
validate_resolvable(
sema,
db,
scope,
mod_path,
scope_filter,
@ -391,7 +392,7 @@ fn path_applicable_imports(
/// Validates and builds an import for `resolved_qualifier` if the `unresolved_qualifier` appended
/// to it resolves and there is a validate `candidate` after that.
fn validate_resolvable(
sema: &Semantics<'_, RootDatabase>,
db: &RootDatabase,
scope: &SemanticsScope<'_>,
mod_path: impl Fn(ItemInNs) -> Option<ModPath>,
scope_filter: impl Fn(ItemInNs) -> bool,
@ -406,8 +407,8 @@ fn validate_resolvable(
if !unresolved_qualifier.is_empty() {
match resolved_qualifier {
ItemInNs::Types(ModuleDef::Module(module)) => {
adjusted_resolved_qualifier = sema
.resolve_mod_path_relative(module, unresolved_qualifier.iter().cloned())?
adjusted_resolved_qualifier = module
.resolve_mod_path(db, unresolved_qualifier.iter().cloned())?
.next()?;
}
// can't resolve multiple segments for non-module item path bases
@ -424,7 +425,7 @@ fn validate_resolvable(
let ty = match qualifier {
ModuleDef::Module(module) => {
return items_locator::items_with_name_in_module(
sema,
db,
module,
candidate.clone(),
AssocSearchMode::Exclude,
@ -439,17 +440,17 @@ fn validate_resolvable(
ModuleDef::Trait(_) => return None,
// FIXME
ModuleDef::TraitAlias(_) => return None,
ModuleDef::TypeAlias(alias) => alias.ty(sema.db),
ModuleDef::BuiltinType(builtin) => builtin.ty(sema.db),
ModuleDef::Adt(adt) => adt.ty(sema.db),
ModuleDef::TypeAlias(alias) => alias.ty(db),
ModuleDef::BuiltinType(builtin) => builtin.ty(db),
ModuleDef::Adt(adt) => adt.ty(db),
_ => return None,
};
ty.iterate_path_candidates(sema.db, scope, &FxHashSet::default(), None, None, |assoc| {
ty.iterate_path_candidates(db, scope, &FxHashSet::default(), None, None, |assoc| {
// FIXME: Support extra trait imports
if assoc.container_or_implemented_trait(sema.db).is_some() {
if assoc.container_or_implemented_trait(db).is_some() {
return None;
}
let name = assoc.name(sema.db)?;
let name = assoc.name(db)?;
let is_match = match candidate {
NameToImport::Prefix(text, true) => name.as_str().starts_with(text),
NameToImport::Prefix(text, false) => {
@ -495,7 +496,7 @@ fn item_for_path_search_assoc(db: &RootDatabase, assoc_item: AssocItem) -> Optio
}
fn trait_applicable_items(
sema: &Semantics<'_, RootDatabase>,
db: &RootDatabase,
current_crate: Crate,
scope: &SemanticsScope<'_>,
trait_candidate: &TraitImportCandidate,
@ -505,15 +506,13 @@ fn trait_applicable_items(
) -> FxIndexSet<LocatedImport> {
let _p = tracing::info_span!("ImportAssets::trait_applicable_items").entered();
let db = sema.db;
let inherent_traits = trait_candidate.receiver_ty.applicable_inherent_traits(db);
let env_traits = trait_candidate.receiver_ty.env_traits(db);
let related_traits = inherent_traits.chain(env_traits).collect::<FxHashSet<_>>();
let mut required_assoc_items = FxHashSet::default();
let mut trait_candidates: FxHashSet<_> = items_locator::items_with_name(
sema,
db,
current_crate,
trait_candidate.assoc_item_name.clone(),
AssocSearchMode::AssocItemsOnly,

23
crates/ide-db/src/items_locator.rs
View File

@ -5,7 +5,7 @@
use std::ops::ControlFlow;
use either::Either;
use hir::{Crate, ItemInNs, Module, Semantics, import_map};
use hir::{Crate, ItemInNs, Module, import_map};
use crate::{
RootDatabase,
@ -20,13 +20,13 @@ pub use import_map::AssocSearchMode;
// FIXME: Do callbacks instead to avoid allocations.
/// Searches for importable items with the given name in the crate and its dependencies.
pub fn items_with_name<'a>(
sema: &'a Semantics<'_, RootDatabase>,
pub fn items_with_name(
db: &RootDatabase,
krate: Crate,
name: NameToImport,
assoc_item_search: AssocSearchMode,
) -> impl Iterator<Item = ItemInNs> + 'a {
let _p = tracing::info_span!("items_with_name", name = name.text(), assoc_item_search = ?assoc_item_search, crate = ?krate.display_name(sema.db).map(|name| name.to_string()))
) -> impl Iterator<Item = ItemInNs> {
let _p = tracing::info_span!("items_with_name", name = name.text(), assoc_item_search = ?assoc_item_search, crate = ?krate.display_name(db).map(|name| name.to_string()))
.entered();
let prefix = matches!(name, NameToImport::Prefix(..));
@ -68,12 +68,12 @@ pub fn items_with_name<'a>(
}
};
find_items(sema, krate, local_query, external_query)
find_items(db, krate, local_query, external_query)
}
/// Searches for importable items with the given name in the crate and its dependencies.
pub fn items_with_name_in_module<T>(
sema: &Semantics<'_, RootDatabase>,
db: &RootDatabase,
module: Module,
name: NameToImport,
assoc_item_search: AssocSearchMode,
@ -110,7 +110,7 @@ pub fn items_with_name_in_module<T>(
local_query
}
};
local_query.search(&[sema.db.module_symbols(module)], |local_candidate| {
local_query.search(&[db.module_symbols(module)], |local_candidate| {
cb(match local_candidate.def {
hir::ModuleDef::Macro(macro_def) => ItemInNs::Macros(macro_def),
def => ItemInNs::from(def),
@ -118,14 +118,13 @@ pub fn items_with_name_in_module<T>(
})
}
fn find_items<'a>(
sema: &'a Semantics<'_, RootDatabase>,
fn find_items(
db: &RootDatabase,
krate: Crate,
local_query: symbol_index::Query,
external_query: import_map::Query,
) -> impl Iterator<Item = ItemInNs> + 'a {
) -> impl Iterator<Item = ItemInNs> {
let _p = tracing::info_span!("find_items").entered();
let db = sema.db;
// NOTE: `external_query` includes `assoc_item_search`, so we don't need to
// filter on our own.