rust-analyzer

diff --git a/crates/hir-def/src/db.rs b/crates/hir-def/src/db.rs
index 2fc79c3809..c618e4bdce 100644
--- a/crates/hir-def/src/db.rs
+++ b/crates/hir-def/src/db.rs

@@ -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,

@@ -121,13 +117,6 @@ pub trait DefDatabase: InternDatabase + ExpandDatabase + SourceDatabase {

) -> (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

diff --git a/crates/hir-def/src/lang_item.rs b/crates/hir-def/src/lang_item.rs
index c0e30ac795..faff7d036a 100644
--- a/crates/hir-def/src/lang_item.rs
+++ b/crates/hir-def/src/lang_item.rs

@@ -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)

diff --git a/crates/hir-def/src/lib.rs b/crates/hir-def/src/lib.rs
index be5bb57ade..0cd7e89432 100644
--- a/crates/hir-def/src/lib.rs
+++ b/crates/hir-def/src/lib.rs

@@ -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),

diff --git a/crates/hir-def/src/nameres.rs b/crates/hir-def/src/nameres.rs
index 610bb6b00b..0837308d5b 100644
--- a/crates/hir-def/src/nameres.rs
+++ b/crates/hir-def/src/nameres.rs

@@ -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]`.

diff --git a/crates/hir-def/src/nameres/assoc.rs b/crates/hir-def/src/nameres/assoc.rs
index cf123d14f5..7aaa918d1c 100644
--- a/crates/hir-def/src/nameres/assoc.rs
+++ b/crates/hir-def/src/nameres/assoc.rs

@@ -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()

}

diff --git a/crates/hir-def/src/nameres/collector.rs b/crates/hir-def/src/nameres/collector.rs
index 3a2faae366..508fcc2fa5 100644
--- a/crates/hir-def/src/nameres/collector.rs
+++ b/crates/hir-def/src/nameres/collector.rs

@@ -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);

}

diff --git a/crates/hir-def/src/nameres/tests/incremental.rs b/crates/hir-def/src/nameres/tests/incremental.rs
index 77e706caed..ba75dca3d3 100644
--- a/crates/hir-def/src/nameres/tests/incremental.rs
+++ b/crates/hir-def/src/nameres/tests/incremental.rs

@@ -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",

diff --git a/crates/hir-def/src/signatures.rs b/crates/hir-def/src/signatures.rs
index c808079011..377a545ebf 100644
--- a/crates/hir-def/src/signatures.rs
+++ b/crates/hir-def/src/signatures.rs

@@ -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> {

diff --git a/crates/hir-def/src/visibility.rs b/crates/hir-def/src/visibility.rs
index 14d67ea804..aea2ac550e 100644
--- a/crates/hir-def/src/visibility.rs
+++ b/crates/hir-def/src/visibility.rs

@@ -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)

-fn trait_item_visibility(

- db: &dyn DefDatabase,

- resolver: &Resolver<'_>,

- container: ItemContainerId,

-) -> Option<Visibility> {

- match container {

- ItemContainerId::TraitId(trait_) => Some(trait_visibility(db, resolver, trait_)),

- _ => None,

+ if raw_vis == RawVisibility::Public {

+ return Visibility::Public;

}

-/// 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()))

- })

+ Visibility::resolve(db, &has_resolver.resolver(db), &raw_vis)

}

-/// 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 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()))

+ })

+ }

}

-/// 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()))

- })

+fn trait_item_visibility(db: &dyn DefDatabase, container: ItemContainerId) -> Option<Visibility> {

+ match container {

+ ItemContainerId::TraitId(trait_) => Some(trait_visibility(db, trait_)),

+ _ => None,

+ }

}

-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()))

}

diff --git a/crates/hir-ty/src/chalk_db.rs b/crates/hir-ty/src/chalk_db.rs
index cf43924513..7945442811 100644
--- a/crates/hir-ty/src/chalk_db.rs
+++ b/crates/hir-ty/src/chalk_db.rs

@@ -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 {

diff --git a/crates/hir-ty/src/method_resolution.rs b/crates/hir-ty/src/method_resolution.rs
index 3b295d41e6..25f1782bdd 100644
--- a/crates/hir-ty/src/method_resolution.rs
+++ b/crates/hir-ty/src/method_resolution.rs

@@ -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;

}

diff --git a/crates/hir-ty/src/mir/eval/shim.rs b/crates/hir-ty/src/mir/eval/shim.rs
index 8d428dd6d0..6ebde01334 100644
--- a/crates/hir-ty/src/mir/eval/shim.rs
+++ b/crates/hir-ty/src/mir/eval/shim.rs

@@ -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 {

diff --git a/crates/hir-ty/src/tests.rs b/crates/hir-ty/src/tests.rs
index f2812570ed..9ca6ee476c 100644
--- a/crates/hir-ty/src/tests.rs
+++ b/crates/hir-ty/src/tests.rs

@@ -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) => {

diff --git a/crates/hir-ty/src/tests/incremental.rs b/crates/hir-ty/src/tests/incremental.rs
index b45d8babd4..905fd8a3bc 100644
--- a/crates/hir-ty/src/tests/incremental.rs
+++ b/crates/hir-ty/src/tests/incremental.rs

@@ -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",

diff --git a/crates/hir-ty/src/utils.rs b/crates/hir-ty/src/utils.rs
index 867c7ea087..4c8e635eff 100644
--- a/crates/hir-ty/src/utils.rs
+++ b/crates/hir-ty/src/utils.rs

@@ -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

diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 597da0a3cb..adae335627 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs

@@ -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;

}

diff --git a/crates/hir/src/semantics/child_by_source.rs b/crates/hir/src/semantics/child_by_source.rs
index 0d0bbe367e..fedd8239d0 100644
--- a/crates/hir/src/semantics/child_by_source.rs
+++ b/crates/hir/src/semantics/child_by_source.rs

@@ -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);

diff --git a/crates/hir/src/symbols.rs b/crates/hir/src/symbols.rs
index 4b295fe9ec..cb9901ab11 100644
--- a/crates/hir/src/symbols.rs
+++ b/crates/hir/src/symbols.rs

@@ -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)

}

})