itsscb/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-09-25 11:17:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #20008 from Veykril/push-rsnkrwyplmwr

Browse Source 
More idiomatic salsa use
This commit is contained in:
Lukas Wirth 2025-06-15 08:12:11 +00:00 committed by GitHub
commit d822f6a0ed
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
18 changed files with 121 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
crates/hir-def/src/db.rs
View File

@ -5,16 +5,16 @@ use hir_expand::{
EditionedFileId, HirFileId, InFile, Lookup, MacroCallId, MacroDefId, MacroDefKind,
db::ExpandDatabase,
};
use intern::{Symbol, sym};
use intern::sym;
use la_arena::ArenaMap;
use syntax::{AstPtr, ast};
use triomphe::Arc;
use crate::{
AttrDefId, ConstId, ConstLoc, DefWithBodyId, EnumId, EnumLoc, EnumVariantId, EnumVariantLoc,
ExternBlockId, ExternBlockLoc, ExternCrateId, ExternCrateLoc, FunctionId, FunctionLoc,
GenericDefId, ImplId, ImplLoc, LocalFieldId, Macro2Id, Macro2Loc, MacroExpander, MacroId,
MacroRulesId, MacroRulesLoc, MacroRulesLocFlags, ProcMacroId, ProcMacroLoc, StaticId,
AssocItemId, AttrDefId, ConstId, ConstLoc, DefWithBodyId, EnumId, EnumLoc, EnumVariantId,
EnumVariantLoc, ExternBlockId, ExternBlockLoc, ExternCrateId, ExternCrateLoc, FunctionId,
FunctionLoc, GenericDefId, ImplId, ImplLoc, LocalFieldId, Macro2Id, Macro2Loc, MacroExpander,
MacroId, MacroRulesId, MacroRulesLoc, MacroRulesLocFlags, ProcMacroId, ProcMacroLoc, StaticId,
StaticLoc, StructId, StructLoc, TraitAliasId, TraitAliasLoc, TraitId, TraitLoc, TypeAliasId,
TypeAliasLoc, UnionId, UnionLoc, UseId, UseLoc, VariantId,
attr::{Attrs, AttrsWithOwner},
@ -25,11 +25,7 @@ use crate::{
import_map::ImportMap,
item_tree::{ItemTree, file_item_tree_query},
lang_item::{self, LangItem},
nameres::{
assoc::{ImplItems, TraitItems},
crate_def_map,
diagnostics::DefDiagnostics,
},
nameres::{assoc::TraitItems, crate_def_map, diagnostics::DefDiagnostics},
signatures::{
ConstSignature, EnumSignature, FunctionSignature, ImplSignature, StaticSignature,
StructSignature, TraitAliasSignature, TraitSignature, TypeAliasSignature, UnionSignature,
@ -120,13 +116,6 @@ pub trait DefDatabase: InternDatabase + ExpandDatabase + SourceDatabase {
id: VariantId,
) -> (Arc<VariantFields>, Arc<ExpressionStoreSourceMap>);
#[salsa::transparent]
#[salsa::invoke(ImplItems::impl_items_query)]
fn impl_items(&self, e: ImplId) -> Arc<ImplItems>;
#[salsa::invoke(ImplItems::impl_items_with_diagnostics_query)]
fn impl_items_with_diagnostics(&self, e: ImplId) -> (Arc<ImplItems>, DefDiagnostics);
#[salsa::transparent]
#[salsa::invoke(TraitItems::trait_items_query)]
fn trait_items(&self, e: TraitId) -> Arc<TraitItems>;
@ -249,9 +238,6 @@ pub trait DefDatabase: InternDatabase + ExpandDatabase + SourceDatabase {
e: TypeAliasId,
) -> (Arc<TypeAliasSignature>, Arc<ExpressionStoreSourceMap>);
#[salsa::invoke(crate::signatures::extern_block_abi_query)]
fn extern_block_abi(&self, extern_block: ExternBlockId) -> Option<Symbol>;
// endregion:data
#[salsa::invoke(Body::body_with_source_map_query)]
@ -312,16 +298,8 @@ pub trait DefDatabase: InternDatabase + ExpandDatabase + SourceDatabase {
#[salsa::invoke(visibility::field_visibilities_query)]
fn field_visibilities(&self, var: VariantId) -> Arc<ArenaMap<LocalFieldId, Visibility>>;
// FIXME: unify function_visibility and const_visibility?
#[salsa::invoke(visibility::function_visibility_query)]
fn function_visibility(&self, def: FunctionId) -> Visibility;
#[salsa::invoke(visibility::const_visibility_query)]
fn const_visibility(&self, def: ConstId) -> Visibility;
#[salsa::invoke(visibility::type_alias_visibility_query)]
fn type_alias_visibility(&self, def: TypeAliasId) -> Visibility;
#[salsa::invoke(visibility::assoc_visibility_query)]
fn assoc_visibility(&self, def: AssocItemId) -> Visibility;
// endregion:visibilities

2
crates/hir-def/src/lang_item.rs
View File

@ -96,7 +96,7 @@ pub fn crate_lang_items(db: &dyn DefDatabase, krate: Crate) -> Option<Box<LangIt
for (_, module_data) in crate_def_map.modules() {
for impl_def in module_data.scope.impls() {
lang_items.collect_lang_item(db, impl_def, LangItemTarget::ImplDef);
for &(_, assoc) in db.impl_items(impl_def).items.iter() {
for &(_, assoc) in impl_def.impl_items(db).items.iter() {
match assoc {
AssocItemId::FunctionId(f) => {
lang_items.collect_lang_item(db, f, LangItemTarget::Function)

29
crates/hir-def/src/lib.rs
View File

@ -49,7 +49,7 @@ pub mod find_path;
pub mod import_map;
pub mod visibility;
use intern::{Interned, sym};
use intern::{Interned, Symbol, sym};
pub use rustc_abi as layout;
use thin_vec::ThinVec;
use triomphe::Arc;
@ -88,7 +88,10 @@ use crate::{
builtin_type::BuiltinType,
db::DefDatabase,
hir::generics::{LocalLifetimeParamId, LocalTypeOrConstParamId},
nameres::{LocalDefMap, block_def_map, crate_def_map, crate_local_def_map},
nameres::{
LocalDefMap, assoc::ImplItems, block_def_map, crate_def_map, crate_local_def_map,
diagnostics::DefDiagnostics,
},
signatures::{EnumVariants, InactiveEnumVariantCode, VariantFields},
};
@ -287,6 +290,18 @@ impl_intern!(TypeAliasId, TypeAliasLoc, intern_type_alias, lookup_intern_type_al
type ImplLoc = ItemLoc<ast::Impl>;
impl_intern!(ImplId, ImplLoc, intern_impl, lookup_intern_impl);
impl ImplId {
#[inline]
pub fn impl_items(self, db: &dyn DefDatabase) -> &ImplItems {
&self.impl_items_with_diagnostics(db).0
}
#[inline]
pub fn impl_items_with_diagnostics(self, db: &dyn DefDatabase) -> &(ImplItems, DefDiagnostics) {
ImplItems::of(db, self)
}
}
type UseLoc = ItemLoc<ast::Use>;
impl_intern!(UseId, UseLoc, intern_use, lookup_intern_use);
@ -296,6 +311,14 @@ impl_intern!(ExternCrateId, ExternCrateLoc, intern_extern_crate, lookup_intern_e
type ExternBlockLoc = ItemLoc<ast::ExternBlock>;
impl_intern!(ExternBlockId, ExternBlockLoc, intern_extern_block, lookup_intern_extern_block);
#[salsa::tracked]
impl ExternBlockId {
#[salsa::tracked]
pub fn abi(self, db: &dyn DefDatabase) -> Option<Symbol> {
signatures::extern_block_abi(db, self)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct EnumVariantLoc {
pub id: AstId<ast::Variant>,
@ -770,7 +793,7 @@ impl DefWithBodyId {
}
}
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, salsa_macros::Supertype)]
pub enum AssocItemId {
FunctionId(FunctionId),
ConstId(ConstId),

6
crates/hir-def/src/nameres.rs
View File

@ -62,8 +62,8 @@ use std::ops::Deref;
use base_db::Crate;
use hir_expand::{
EditionedFileId, ErasedAstId, HirFileId, InFile, MacroCallId, MacroDefId, mod_path::ModPath,
name::Name, proc_macro::ProcMacroKind,
EditionedFileId, ErasedAstId, HirFileId, InFile, MacroCallId, mod_path::ModPath, name::Name,
proc_macro::ProcMacroKind,
};
use intern::Symbol;
use itertools::Itertools;
@ -189,7 +189,7 @@ pub struct DefMap {
#[derive(Clone, Debug, PartialEq, Eq)]
struct DefMapCrateData {
/// Side table for resolving derive helpers.
exported_derives: FxHashMap<MacroDefId, Box<[Name]>>,
exported_derives: FxHashMap<MacroId, Box<[Name]>>,
fn_proc_macro_mapping: FxHashMap<FunctionId, ProcMacroId>,
/// Custom attributes registered with `#![register_attr]`.

16
crates/hir-def/src/nameres/assoc.rs
View File

@ -100,16 +100,10 @@ pub struct ImplItems {
pub macro_calls: ThinVec<(AstId<ast::Item>, MacroCallId)>,
}
#[salsa::tracked]
impl ImplItems {
#[inline]
pub(crate) fn impl_items_query(db: &dyn DefDatabase, id: ImplId) -> Arc<ImplItems> {
db.impl_items_with_diagnostics(id).0
}
pub(crate) fn impl_items_with_diagnostics_query(
db: &dyn DefDatabase,
id: ImplId,
) -> (Arc<ImplItems>, DefDiagnostics) {
#[salsa::tracked(returns(ref))]
pub fn of(db: &dyn DefDatabase, id: ImplId) -> (ImplItems, DefDiagnostics) {
let _p = tracing::info_span!("impl_items_with_diagnostics_query").entered();
let ItemLoc { container: module_id, id: ast_id } = id.lookup(db);
@ -118,9 +112,11 @@ impl ImplItems {
let source = ast_id.with_value(collector.ast_id_map.get(ast_id.value)).to_node(db);
let (items, macro_calls, diagnostics) = collector.collect(source.assoc_item_list());
(Arc::new(ImplItems { items, macro_calls }), DefDiagnostics::new(diagnostics))
(ImplItems { items, macro_calls }, DefDiagnostics::new(diagnostics))
}
}
impl ImplItems {
pub fn macro_calls(&self) -> impl Iterator<Item = (AstId<ast::Item>, MacroCallId)> + '_ {
self.macro_calls.iter().copied()
}

6
crates/hir-def/src/nameres/collector.rs
View File

@ -609,7 +609,7 @@ impl<'db> DefCollector<'db> {
self.define_proc_macro(def.name.clone(), proc_macro_id);
let crate_data = Arc::get_mut(&mut self.def_map.data).unwrap();
if let ProcMacroKind::Derive { helpers } = def.kind {
crate_data.exported_derives.insert(self.db.macro_def(proc_macro_id.into()), helpers);
crate_data.exported_derives.insert(proc_macro_id.into(), helpers);
}
crate_data.fn_proc_macro_mapping.insert(fn_id, proc_macro_id);
}
@ -1345,7 +1345,7 @@ impl<'db> DefCollector<'db> {
// Record its helper attributes.
if def_id.krate != self.def_map.krate {
let def_map = crate_def_map(self.db, def_id.krate);
if let Some(helpers) = def_map.data.exported_derives.get(&def_id) {
if let Some(helpers) = def_map.data.exported_derives.get(&macro_id) {
self.def_map
.derive_helpers_in_scope
.entry(ast_id.ast_id.map(|it| it.upcast()))
@ -2425,7 +2425,7 @@ impl ModCollector<'_, '_> {
Arc::get_mut(&mut self.def_collector.def_map.data)
.unwrap()
.exported_derives
.insert(self.def_collector.db.macro_def(macro_id.into()), helpers);
.insert(macro_id.into(), helpers);
}
}
}

1
crates/hir-def/src/nameres/tests/incremental.rs
View File

@ -431,7 +431,6 @@ pub struct S {}
"parse_shim",
"real_span_map_shim",
"macro_def_shim",
"macro_def_shim",
"file_item_tree_query",
"ast_id_map_shim",
"parse_macro_expansion_shim",

2
crates/hir-def/src/signatures.rs
View File

@ -965,7 +965,7 @@ impl EnumVariants {
}
}
pub(crate) fn extern_block_abi_query(
pub(crate) fn extern_block_abi(
db: &dyn DefDatabase,
extern_block: ExternBlockId,
) -> Option<Symbol> {

89
crates/hir-def/src/visibility.rs
View File

@ -8,12 +8,8 @@ use syntax::ast::{self, HasVisibility};
use triomphe::Arc;
use crate::{
ConstId, FunctionId, HasModule, ItemContainerId, LocalFieldId, LocalModuleId, ModuleId,
TraitId, TypeAliasId, VariantId,
db::DefDatabase,
nameres::DefMap,
resolver::{HasResolver, Resolver},
src::HasSource,
AssocItemId, HasModule, ItemContainerId, LocalFieldId, LocalModuleId, ModuleId, TraitId,
VariantId, db::DefDatabase, nameres::DefMap, resolver::HasResolver, src::HasSource,
};
pub use crate::item_tree::{RawVisibility, VisibilityExplicitness};
@ -225,63 +221,56 @@ pub(crate) fn field_visibilities_query(
pub fn visibility_from_ast(
db: &dyn DefDatabase,
resolver: &Resolver<'_>,
has_resolver: impl HasResolver,
ast_vis: InFile<Option<ast::Visibility>>,
) -> Visibility {
let mut span_map = None;
let raw_vis = crate::item_tree::visibility_from_ast(db, ast_vis.value, &mut |range| {
span_map.get_or_insert_with(|| db.span_map(ast_vis.file_id)).span_for_range(range).ctx
});
Visibility::resolve(db, resolver, &raw_vis)
if raw_vis == RawVisibility::Public {
return Visibility::Public;
}
Visibility::resolve(db, &has_resolver.resolver(db), &raw_vis)
}
fn trait_item_visibility(
db: &dyn DefDatabase,
resolver: &Resolver<'_>,
container: ItemContainerId,
) -> Option<Visibility> {
/// Resolve visibility of a type alias.
pub(crate) fn assoc_visibility_query(db: &dyn DefDatabase, def: AssocItemId) -> Visibility {
match def {
AssocItemId::FunctionId(function_id) => {
let loc = function_id.lookup(db);
trait_item_visibility(db, loc.container).unwrap_or_else(|| {
let source = loc.source(db);
visibility_from_ast(db, function_id, source.map(|src| src.visibility()))
})
}
AssocItemId::ConstId(const_id) => {
let loc = const_id.lookup(db);
trait_item_visibility(db, loc.container).unwrap_or_else(|| {
let source = loc.source(db);
visibility_from_ast(db, const_id, source.map(|src| src.visibility()))
})
}
AssocItemId::TypeAliasId(type_alias_id) => {
let loc = type_alias_id.lookup(db);
trait_item_visibility(db, loc.container).unwrap_or_else(|| {
let source = loc.source(db);
visibility_from_ast(db, type_alias_id, source.map(|src| src.visibility()))
})
}
}
}
fn trait_item_visibility(db: &dyn DefDatabase, container: ItemContainerId) -> Option<Visibility> {
match container {
ItemContainerId::TraitId(trait_) => Some(trait_visibility(db, resolver, trait_)),
ItemContainerId::TraitId(trait_) => Some(trait_visibility(db, trait_)),
_ => None,
}
}
/// Resolve visibility of a function.
pub(crate) fn function_visibility_query(db: &dyn DefDatabase, def: FunctionId) -> Visibility {
let loc = def.lookup(db);
let resolver = def.resolver(db);
trait_item_visibility(db, &resolver, loc.container).unwrap_or_else(|| {
let source = loc.source(db);
visibility_from_ast(db, &resolver, source.map(|src| src.visibility()))
})
}
/// Resolve visibility of a const.
pub(crate) fn const_visibility_query(db: &dyn DefDatabase, def: ConstId) -> Visibility {
let loc = def.lookup(db);
let resolver = def.resolver(db);
trait_item_visibility(db, &resolver, loc.container).unwrap_or_else(|| {
let source = loc.source(db);
visibility_from_ast(db, &resolver, source.map(|src| src.visibility()))
})
}
/// Resolve visibility of a type alias.
pub(crate) fn type_alias_visibility_query(db: &dyn DefDatabase, def: TypeAliasId) -> Visibility {
let loc = def.lookup(db);
let resolver = def.resolver(db);
trait_item_visibility(db, &resolver, loc.container).unwrap_or_else(|| {
let source = loc.source(db);
visibility_from_ast(db, &resolver, source.map(|src| src.visibility()))
})
}
pub(crate) fn trait_visibility(
db: &dyn DefDatabase,
resolver: &Resolver<'_>,
def: TraitId,
) -> Visibility {
fn trait_visibility(db: &dyn DefDatabase, def: TraitId) -> Visibility {
let loc = def.lookup(db);
let source = loc.source(db);
visibility_from_ast(db, resolver, source.map(|src| src.visibility()))
visibility_from_ast(db, def, source.map(|src| src.visibility()))
}

6
crates/hir-ty/src/chalk_db.rs
View File

@ -63,7 +63,7 @@ impl chalk_solve::RustIrDatabase<Interner> for ChalkContext<'_> {
) -> Option<rust_ir::AssociatedTyValueId<Interner>> {
let alias_id = from_assoc_type_id(assoc_type_id);
let trait_sig = self.db.type_alias_signature(alias_id);
self.db.impl_items(hir_def::ImplId::from_chalk(self.db, impl_id)).items.iter().find_map(
hir_def::ImplId::from_chalk(self.db, impl_id).impl_items(self.db).items.iter().find_map(
|(name, item)| match item {
AssocItemId::TypeAliasId(alias) if &trait_sig.name == name => {
Some(TypeAliasAsValue(*alias).to_chalk(self.db))
@ -880,8 +880,8 @@ fn impl_def_datum(db: &dyn HirDatabase, krate: Crate, impl_id: hir_def::ImplId)
let impl_datum_bound = rust_ir::ImplDatumBound { trait_ref, where_clauses };
let trait_data = db.trait_items(trait_);
let associated_ty_value_ids = db
.impl_items(impl_id)
let associated_ty_value_ids = impl_id
.impl_items(db)
.items
.iter()
.filter_map(|(_, item)| match item {

12
crates/hir-ty/src/method_resolution.rs
View File

@ -790,7 +790,7 @@ fn find_matching_impl(
mut impls: impl Iterator<Item = ImplId>,
mut table: InferenceTable<'_>,
actual_trait_ref: TraitRef,
) -> Option<(Arc<ImplItems>, Substitution)> {
) -> Option<(&ImplItems, Substitution)> {
let db = table.db;
impls.find_map(|impl_| {
table.run_in_snapshot(|table| {
@ -811,7 +811,7 @@ fn find_matching_impl(
let goal = crate::Goal::all(Interner, wcs);
table.try_obligation(goal.clone())?;
table.register_obligation(goal);
Some((db.impl_items(impl_), table.resolve_completely(impl_substs)))
Some((impl_.impl_items(db), table.resolve_completely(impl_substs)))
})
})
}
@ -875,7 +875,7 @@ fn is_inherent_impl_coherent(
_ => false,
};
let items = db.impl_items(impl_id);
let items = impl_id.impl_items(db);
rustc_has_incoherent_inherent_impls
&& !items.items.is_empty()
&& items.items.iter().all(|&(_, assoc)| match assoc {
@ -1462,7 +1462,7 @@ fn iterate_inherent_methods(
callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
) -> ControlFlow<()> {
for &impl_id in impls.for_self_ty(self_ty) {
for &(ref item_name, item) in table.db.impl_items(impl_id).items.iter() {
for &(ref item_name, item) in impl_id.impl_items(table.db).items.iter() {
let visible = match is_valid_impl_method_candidate(
table,
self_ty,
@ -1550,7 +1550,7 @@ fn is_valid_impl_method_candidate(
check_that!(name.is_none_or(|n| n == item_name));
if let Some(from_module) = visible_from_module {
if !db.const_visibility(c).is_visible_from(db, from_module) {
if !db.assoc_visibility(c.into()).is_visible_from(db, from_module) {
cov_mark::hit!(const_candidate_not_visible);
return IsValidCandidate::NotVisible;
}
@ -1639,7 +1639,7 @@ fn is_valid_impl_fn_candidate(
let data = db.function_signature(fn_id);
if let Some(from_module) = visible_from_module {
if !db.function_visibility(fn_id).is_visible_from(db, from_module) {
if !db.assoc_visibility(fn_id.into()).is_visible_from(db, from_module) {
cov_mark::hit!(autoderef_candidate_not_visible);
return IsValidCandidate::NotVisible;
}

6
crates/hir-ty/src/mir/eval/shim.rs
View File

@ -65,7 +65,7 @@ impl Evaluator<'_> {
Some(abi) => *abi == sym::rust_dash_intrinsic,
None => match def.lookup(self.db).container {
hir_def::ItemContainerId::ExternBlockId(block) => {
self.db.extern_block_abi(block) == Some(sym::rust_dash_intrinsic)
block.abi(self.db) == Some(sym::rust_dash_intrinsic)
}
_ => false,
},
@ -84,9 +84,7 @@ impl Evaluator<'_> {
);
}
let is_extern_c = match def.lookup(self.db).container {
hir_def::ItemContainerId::ExternBlockId(block) => {
self.db.extern_block_abi(block) == Some(sym::C)
}
hir_def::ItemContainerId::ExternBlockId(block) => block.abi(self.db) == Some(sym::C),
_ => false,
};
if is_extern_c {

2
crates/hir-ty/src/tests.rs
View File

@ -437,7 +437,7 @@ pub(crate) fn visit_module(
) {
visit_scope(db, crate_def_map, &crate_def_map[module_id].scope, cb);
for impl_id in crate_def_map[module_id].scope.impls() {
let impl_data = db.impl_items(impl_id);
let impl_data = impl_id.impl_items(db);
for &(_, item) in impl_data.items.iter() {
match item {
AssocItemId::FunctionId(it) => {

4
crates/hir-ty/src/tests/incremental.rs
View File

@ -571,7 +571,7 @@ fn main() {
"body_shim",
"body_with_source_map_shim",
"attrs_shim",
"impl_items_with_diagnostics_shim",
"of_",
"infer_shim",
"trait_signature_shim",
"trait_signature_with_source_map_shim",
@ -678,7 +678,7 @@ fn main() {
"body_with_source_map_shim",
"attrs_shim",
"body_shim",
"impl_items_with_diagnostics_shim",
"of_",
"infer_shim",
"attrs_shim",
"trait_signature_with_source_map_shim",

2
crates/hir-ty/src/utils.rs
View File

@ -293,7 +293,7 @@ pub fn is_fn_unsafe_to_call(
let loc = func.lookup(db);
match loc.container {
hir_def::ItemContainerId::ExternBlockId(block) => {
let is_intrinsic_block = db.extern_block_abi(block) == Some(sym::rust_dash_intrinsic);
let is_intrinsic_block = block.abi(db) == Some(sym::rust_dash_intrinsic);
if is_intrinsic_block {
// legacy intrinsics
// extern "rust-intrinsic" intrinsics are unsafe unless they have the rustc_safe_intrinsic attribute

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

@ -760,7 +760,7 @@ impl Module {
let ast_id_map = db.ast_id_map(file_id);
for diag in db.impl_items_with_diagnostics(impl_def.id).1.iter() {
for diag in impl_def.id.impl_items_with_diagnostics(db).1.iter() {
emit_def_diagnostic(db, acc, diag, edition);
}
@ -824,7 +824,7 @@ impl Module {
AssocItemId::ConstId(id) => !db.const_signature(id).has_body(),
AssocItemId::TypeAliasId(it) => db.type_alias_signature(it).ty.is_none(),
});
impl_assoc_items_scratch.extend(db.impl_items(impl_def.id).items.iter().cloned());
impl_assoc_items_scratch.extend(impl_def.id.impl_items(db).items.iter().cloned());
let redundant = impl_assoc_items_scratch
.iter()
@ -912,7 +912,7 @@ impl Module {
&source_map,
);
for &(_, item) in db.impl_items(impl_def.id).items.iter() {
for &(_, item) in impl_def.id.impl_items(db).items.iter() {
AssocItem::from(item).diagnostics(db, acc, style_lints);
}
}
@ -1431,7 +1431,7 @@ impl HasVisibility for Struct {
fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
let loc = self.id.lookup(db);
let source = loc.source(db);
visibility_from_ast(db, &self.id.resolver(db), source.map(|src| src.visibility()))
visibility_from_ast(db, self.id, source.map(|src| src.visibility()))
}
}
@ -1485,7 +1485,7 @@ impl HasVisibility for Union {
fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
let loc = self.id.lookup(db);
let source = loc.source(db);
visibility_from_ast(db, &self.id.resolver(db), source.map(|src| src.visibility()))
visibility_from_ast(db, self.id, source.map(|src| src.visibility()))
}
}
@ -1574,7 +1574,7 @@ impl HasVisibility for Enum {
fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
let loc = self.id.lookup(db);
let source = loc.source(db);
visibility_from_ast(db, &self.id.resolver(db), source.map(|src| src.visibility()))
visibility_from_ast(db, self.id, source.map(|src| src.visibility()))
}
}
@ -2632,7 +2632,7 @@ impl SelfParam {
impl HasVisibility for Function {
fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
db.function_visibility(self.id)
db.assoc_visibility(self.id.into())
}
}
@ -2692,7 +2692,7 @@ impl HasVisibility for ExternCrateDecl {
fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
let loc = self.id.lookup(db);
let source = loc.source(db);
visibility_from_ast(db, &self.id.resolver(db), source.map(|src| src.visibility()))
visibility_from_ast(db, self.id, source.map(|src| src.visibility()))
}
}
@ -2727,7 +2727,7 @@ impl Const {
impl HasVisibility for Const {
fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
db.const_visibility(self.id)
db.assoc_visibility(self.id.into())
}
}
@ -2813,7 +2813,7 @@ impl HasVisibility for Static {
fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
let loc = self.id.lookup(db);
let source = loc.source(db);
visibility_from_ast(db, &self.id.resolver(db), source.map(|src| src.visibility()))
visibility_from_ast(db, self.id, source.map(|src| src.visibility()))
}
}
@ -2915,7 +2915,7 @@ impl HasVisibility for Trait {
fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
let loc = self.id.lookup(db);
let source = loc.source(db);
visibility_from_ast(db, &self.id.resolver(db), source.map(|src| src.visibility()))
visibility_from_ast(db, self.id, source.map(|src| src.visibility()))
}
}
@ -2938,7 +2938,7 @@ impl HasVisibility for TraitAlias {
fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
let loc = self.id.lookup(db);
let source = loc.source(db);
visibility_from_ast(db, &self.id.resolver(db), source.map(|src| src.visibility()))
visibility_from_ast(db, self.id, source.map(|src| src.visibility()))
}
}
@ -2976,7 +2976,7 @@ impl TypeAlias {
impl HasVisibility for TypeAlias {
fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
db.type_alias_visibility(self.id)
db.assoc_visibility(self.id.into())
}
}
@ -3200,7 +3200,7 @@ impl HasVisibility for Macro {
MacroId::Macro2Id(id) => {
let loc = id.lookup(db);
let source = loc.source(db);
visibility_from_ast(db, &id.resolver(db), source.map(|src| src.visibility()))
visibility_from_ast(db, id, source.map(|src| src.visibility()))
}
MacroId::MacroRulesId(_) => Visibility::Public,
MacroId::ProcMacroId(_) => Visibility::Public,
@ -4413,7 +4413,7 @@ impl Impl {
}
pub fn items(self, db: &dyn HirDatabase) -> Vec<AssocItem> {
db.impl_items(self.id).items.iter().map(|&(_, it)| it.into()).collect()
self.id.impl_items(db).items.iter().map(|&(_, it)| it.into()).collect()
}
pub fn is_negative(self, db: &dyn HirDatabase) -> bool {
@ -4462,7 +4462,7 @@ impl Impl {
}
fn all_macro_calls(&self, db: &dyn HirDatabase) -> Box<[(AstId<ast::Item>, MacroCallId)]> {
db.impl_items(self.id).macro_calls.to_vec().into_boxed_slice()
self.id.impl_items(db).macro_calls.to_vec().into_boxed_slice()
}
}
@ -5271,7 +5271,7 @@ impl Type {
let impls = db.inherent_impls_in_crate(krate);
for impl_def in impls.for_self_ty(&self.ty) {
for &(_, item) in db.impl_items(*impl_def).items.iter() {
for &(_, item) in impl_def.impl_items(db).items.iter() {
if callback(item) {
return;
}

2
crates/hir/src/semantics/child_by_source.rs
View File

@ -61,7 +61,7 @@ impl ChildBySource for TraitId {
impl ChildBySource for ImplId {
fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) {
let data = db.impl_items(*self);
let data = self.impl_items(db);
data.macro_calls().filter(|(ast_id, _)| ast_id.file_id == file_id).for_each(
|(ast_id, call_id)| {
let ptr = ast_id.to_ptr(db);

2
crates/hir/src/symbols.rs
View File

@ -324,7 +324,7 @@ impl<'a> SymbolCollector<'a> {
.to_smolstr(),
);
self.with_container_name(impl_name, |s| {
for &(ref name, assoc_item_id) in &self.db.impl_items(impl_id).items {
for &(ref name, assoc_item_id) in &impl_id.impl_items(self.db).items {
s.push_assoc_item(assoc_item_id, name, None)
}
})