language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-10-27 10:17:15 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Split assoc items out of trait_data/impl_data queries

Browse source
This commit is contained in:
Lukas Wirth 2025-02-26 07:40:42 +01:00
parent 185f9deb45
commit 12f54eec27
34 changed files with 446 additions and 397 deletions
Download patch file Download diff file Expand all files Collapse all files

321
crates/hir-def/src/data.rs
View file

@ -3,33 +3,21 @@
pub mod adt; pub mod adt;
use base_db::Crate; use base_db::Crate;
use hir_expand::{ use hir_expand::name::Name;
name::Name, AstId, ExpandResult, HirFileId, InFile, MacroCallId, MacroCallKind, MacroDefKind,
};
use intern::{sym, Symbol}; use intern::{sym, Symbol};
use la_arena::{Idx, RawIdx}; use la_arena::{Idx, RawIdx};
use smallvec::SmallVec;
use syntax::{ast, Parse};
use triomphe::Arc; use triomphe::Arc;
use tt::iter::TtElement; use tt::iter::TtElement;
use crate::{ use crate::{
db::DefDatabase, db::DefDatabase,
expander::{Expander, Mark}, item_tree::{self, FnFlags, ModItem},
item_tree::{self, AssocItem, FnFlags, ItemTree, ItemTreeId, MacroCall, ModItem, TreeId}, nameres::proc_macro::{parse_macro_name_and_helper_attrs, ProcMacroKind},
macro_call_as_call_id,
nameres::{
attr_resolution::ResolvedAttr,
diagnostics::{DefDiagnostic, DefDiagnostics},
proc_macro::{parse_macro_name_and_helper_attrs, ProcMacroKind},
DefMap, LocalDefMap, MacroSubNs,
},
path::ImportAlias, path::ImportAlias,
type_ref::{TraitRef, TypeBound, TypeRefId, TypesMap}, type_ref::{TraitRef, TypeBound, TypeRefId, TypesMap},
visibility::RawVisibility, visibility::RawVisibility,
AssocItemId, AstIdWithPath, ConstId, ConstLoc, ExternCrateId, FunctionId, FunctionLoc, ConstId, ExternCrateId, FunctionId, HasModule, ImplId, ItemContainerId, ItemLoc, Lookup,
HasModule, ImplId, Intern, ItemContainerId, ItemLoc, Lookup, Macro2Id, MacroRulesId, ModuleId, Macro2Id, MacroRulesId, ProcMacroId, StaticId, TraitAliasId, TraitId, TypeAliasId,
ProcMacroId, StaticId, TraitAliasId, TraitId, TypeAliasId, TypeAliasLoc,
}; };
#[derive(Debug, Clone, PartialEq, Eq)] #[derive(Debug, Clone, PartialEq, Eq)]
@ -256,23 +244,13 @@ bitflags::bitflags! {
#[derive(Debug, Clone, PartialEq, Eq)] #[derive(Debug, Clone, PartialEq, Eq)]
pub struct TraitData { pub struct TraitData {
pub name: Name, pub name: Name,
pub items: Box<[(Name, AssocItemId)]>,
pub flags: TraitFlags, pub flags: TraitFlags,
pub visibility: RawVisibility, pub visibility: RawVisibility,
// box it as the vec is usually empty anyways
pub macro_calls: Option<Box<Vec<(AstId<ast::Item>, MacroCallId)>>>,
} }
impl TraitData { impl TraitData {
#[inline] #[inline]
pub(crate) fn trait_data_query(db: &dyn DefDatabase, tr: TraitId) -> Arc<TraitData> { pub(crate) fn trait_data_query(db: &dyn DefDatabase, tr: TraitId) -> Arc<TraitData> {
db.trait_data_with_diagnostics(tr).0
}
pub(crate) fn trait_data_with_diagnostics_query(
db: &dyn DefDatabase,
tr: TraitId,
) -> (Arc<TraitData>, DefDiagnostics) {
let ItemLoc { container: module_id, id: tree_id } = tr.lookup(db); let ItemLoc { container: module_id, id: tree_id } = tr.lookup(db);
let item_tree = tree_id.item_tree(db); let item_tree = tree_id.item_tree(db);
let tr_def = &item_tree[tree_id.value]; let tr_def = &item_tree[tree_id.value];
@ -317,40 +295,7 @@ impl TraitData {
flags |= TraitFlags::SKIP_BOXED_SLICE_DURING_METHOD_DISPATCH; flags |= TraitFlags::SKIP_BOXED_SLICE_DURING_METHOD_DISPATCH;
} }
let mut collector = Arc::new(TraitData { name, visibility, flags })
AssocItemCollector::new(db, module_id, tree_id.file_id(), ItemContainerId::TraitId(tr));
collector.collect(&item_tree, tree_id.tree_id(), &tr_def.items);
let (items, macro_calls, diagnostics) = collector.finish();
(
Arc::new(TraitData { name, macro_calls, items, visibility, flags }),
DefDiagnostics::new(diagnostics),
)
}
pub fn associated_types(&self) -> impl Iterator<Item = TypeAliasId> + '_ {
self.items.iter().filter_map(|(_name, item)| match item {
AssocItemId::TypeAliasId(t) => Some(*t),
_ => None,
})
}
pub fn associated_type_by_name(&self, name: &Name) -> Option<TypeAliasId> {
self.items.iter().find_map(|(item_name, item)| match item {
AssocItemId::TypeAliasId(t) if item_name == name => Some(*t),
_ => None,
})
}
pub fn method_by_name(&self, name: &Name) -> Option<FunctionId> {
self.items.iter().find_map(|(item_name, item)| match item {
AssocItemId::FunctionId(t) if item_name == name => Some(*t),
_ => None,
})
}
pub fn attribute_calls(&self) -> impl Iterator<Item = (AstId<ast::Item>, MacroCallId)> + '_ {
self.macro_calls.iter().flat_map(|it| it.iter()).copied()
} }
} }
@ -375,26 +320,16 @@ impl TraitAliasData {
pub struct ImplData { pub struct ImplData {
pub target_trait: Option<TraitRef>, pub target_trait: Option<TraitRef>,
pub self_ty: TypeRefId, pub self_ty: TypeRefId,
pub items: Box<[(Name, AssocItemId)]>,
pub is_negative: bool, pub is_negative: bool,
pub is_unsafe: bool, pub is_unsafe: bool,
// box it as the vec is usually empty anyways
pub macro_calls: Option<Box<Vec<(AstId<ast::Item>, MacroCallId)>>>,
pub types_map: Arc<TypesMap>, pub types_map: Arc<TypesMap>,
} }
impl ImplData { impl ImplData {
#[inline] #[inline]
pub(crate) fn impl_data_query(db: &dyn DefDatabase, id: ImplId) -> Arc<ImplData> { pub(crate) fn impl_data_query(db: &dyn DefDatabase, id: ImplId) -> Arc<ImplData> {
db.impl_data_with_diagnostics(id).0 let _p = tracing::info_span!("impl_data_query").entered();
} let ItemLoc { id: tree_id, .. } = id.lookup(db);
pub(crate) fn impl_data_with_diagnostics_query(
db: &dyn DefDatabase,
id: ImplId,
) -> (Arc<ImplData>, DefDiagnostics) {
let _p = tracing::info_span!("impl_data_with_diagnostics_query").entered();
let ItemLoc { container: module_id, id: tree_id } = id.lookup(db);
let item_tree = tree_id.item_tree(db); let item_tree = tree_id.item_tree(db);
let impl_def = &item_tree[tree_id.value]; let impl_def = &item_tree[tree_id.value];
@ -403,28 +338,13 @@ impl ImplData {
let is_negative = impl_def.is_negative; let is_negative = impl_def.is_negative;
let is_unsafe = impl_def.is_unsafe; let is_unsafe = impl_def.is_unsafe;
let mut collector = Arc::new(ImplData {
AssocItemCollector::new(db, module_id, tree_id.file_id(), ItemContainerId::ImplId(id)); target_trait,
collector.collect(&item_tree, tree_id.tree_id(), &impl_def.items); self_ty,
is_negative,
let (items, macro_calls, diagnostics) = collector.finish(); is_unsafe,
types_map: impl_def.types_map.clone(),
( })
Arc::new(ImplData {
target_trait,
self_ty,
items,
is_negative,
is_unsafe,
macro_calls,
types_map: impl_def.types_map.clone(),
}),
DefDiagnostics::new(diagnostics),
)
}
pub fn attribute_calls(&self) -> impl Iterator<Item = (AstId<ast::Item>, MacroCallId)> + '_ {
self.macro_calls.iter().flat_map(|it| it.iter()).copied()
} }
} }
@ -628,217 +548,6 @@ impl StaticData {
} }
} }
struct AssocItemCollector<'a> {
db: &'a dyn DefDatabase,
module_id: ModuleId,
def_map: Arc<DefMap>,
local_def_map: Arc<LocalDefMap>,
diagnostics: Vec<DefDiagnostic>,
container: ItemContainerId,
expander: Expander,
items: Vec<(Name, AssocItemId)>,
macro_calls: Vec<(AstId<ast::Item>, MacroCallId)>,
}
impl<'a> AssocItemCollector<'a> {
fn new(
db: &'a dyn DefDatabase,
module_id: ModuleId,
file_id: HirFileId,
container: ItemContainerId,
) -> Self {
let (def_map, local_def_map) = module_id.local_def_map(db);
Self {
db,
module_id,
def_map,
local_def_map,
container,
expander: Expander::new(db, file_id, module_id),
items: Vec::new(),
macro_calls: Vec::new(),
diagnostics: Vec::new(),
}
}
fn finish(
self,
) -> (
Box<[(Name, AssocItemId)]>,
Option<Box<Vec<(AstId<ast::Item>, MacroCallId)>>>,
Vec<DefDiagnostic>,
) {
(
self.items.into_boxed_slice(),
if self.macro_calls.is_empty() { None } else { Some(Box::new(self.macro_calls)) },
self.diagnostics,
)
}
fn collect(&mut self, item_tree: &ItemTree, tree_id: TreeId, assoc_items: &[AssocItem]) {
let container = self.container;
self.items.reserve(assoc_items.len());
'items: for &item in assoc_items {
let attrs = item_tree.attrs(self.db, self.module_id.krate, ModItem::from(item).into());
if !attrs.is_cfg_enabled(self.expander.cfg_options()) {
self.diagnostics.push(DefDiagnostic::unconfigured_code(
self.module_id.local_id,
tree_id,
ModItem::from(item).into(),
attrs.cfg().unwrap(),
self.expander.cfg_options().clone(),
));
continue;
}
'attrs: for attr in &*attrs {
let ast_id =
AstId::new(self.expander.current_file_id(), item.ast_id(item_tree).upcast());
let ast_id_with_path = AstIdWithPath { path: attr.path.clone(), ast_id };
match self.def_map.resolve_attr_macro(
&self.local_def_map,
self.db,
self.module_id.local_id,
ast_id_with_path,
attr,
) {
Ok(ResolvedAttr::Macro(call_id)) => {
let loc = self.db.lookup_intern_macro_call(call_id);
if let MacroDefKind::ProcMacro(_, exp, _) = loc.def.kind {
// If there's no expander for the proc macro (e.g. the
// proc macro is ignored, or building the proc macro
// crate failed), skip expansion like we would if it was
// disabled. This is analogous to the handling in
// `DefCollector::collect_macros`.
if let Some(err) = exp.as_expand_error(self.module_id.krate) {
self.diagnostics.push(DefDiagnostic::macro_error(
self.module_id.local_id,
ast_id,
(*attr.path).clone(),
err,
));
continue 'attrs;
}
}
self.macro_calls.push((ast_id, call_id));
let res =
self.expander.enter_expand_id::<ast::MacroItems>(self.db, call_id);
self.collect_macro_items(res);
continue 'items;
}
Ok(_) => (),
Err(_) => {
self.diagnostics.push(DefDiagnostic::unresolved_macro_call(
self.module_id.local_id,
MacroCallKind::Attr {
ast_id,
attr_args: None,
invoc_attr_index: attr.id,
},
attr.path().clone(),
));
}
}
}
self.collect_item(item_tree, tree_id, container, item);
}
}
fn collect_item(
&mut self,
item_tree: &ItemTree,
tree_id: TreeId,
container: ItemContainerId,
item: AssocItem,
) {
match item {
AssocItem::Function(id) => {
let item = &item_tree[id];
let def =
FunctionLoc { container, id: ItemTreeId::new(tree_id, id) }.intern(self.db);
self.items.push((item.name.clone(), def.into()));
}
AssocItem::TypeAlias(id) => {
let item = &item_tree[id];
let def =
TypeAliasLoc { container, id: ItemTreeId::new(tree_id, id) }.intern(self.db);
self.items.push((item.name.clone(), def.into()));
}
AssocItem::Const(id) => {
let item = &item_tree[id];
let Some(name) = item.name.clone() else { return };
let def = ConstLoc { container, id: ItemTreeId::new(tree_id, id) }.intern(self.db);
self.items.push((name, def.into()));
}
AssocItem::MacroCall(call) => {
let file_id = self.expander.current_file_id();
let MacroCall { ast_id, expand_to, ctxt, ref path } = item_tree[call];
let module = self.expander.module.local_id;
let resolver = |path: &_| {
self.def_map
.resolve_path(
&self.local_def_map,
self.db,
module,
path,
crate::item_scope::BuiltinShadowMode::Other,
Some(MacroSubNs::Bang),
)
.0
.take_macros()
.map(|it| self.db.macro_def(it))
};
match macro_call_as_call_id(
self.db.upcast(),
&AstIdWithPath::new(file_id, ast_id, Clone::clone(path)),
ctxt,
expand_to,
self.expander.krate(),
resolver,
) {
Ok(Some(call_id)) => {
let res =
self.expander.enter_expand_id::<ast::MacroItems>(self.db, call_id);
self.macro_calls.push((InFile::new(file_id, ast_id.upcast()), call_id));
self.collect_macro_items(res);
}
Ok(None) => (),
Err(_) => {
self.diagnostics.push(DefDiagnostic::unresolved_macro_call(
self.module_id.local_id,
MacroCallKind::FnLike {
ast_id: InFile::new(file_id, ast_id),
expand_to,
eager: None,
},
Clone::clone(path),
));
}
}
}
}
}
fn collect_macro_items(&mut self, res: ExpandResult<Option<(Mark, Parse<ast::MacroItems>)>>) {
let Some((mark, _parse)) = res.value else { return };
let tree_id = item_tree::TreeId::new(self.expander.current_file_id(), None);
let item_tree = tree_id.item_tree(self.db);
let iter: SmallVec<[_; 2]> =
item_tree.top_level_items().iter().filter_map(ModItem::as_assoc_item).collect();
self.collect(&item_tree, tree_id, &iter);
self.expander.exit(mark);
}
}
fn trait_vis(db: &dyn DefDatabase, trait_id: TraitId) -> RawVisibility { fn trait_vis(db: &dyn DefDatabase, trait_id: TraitId) -> RawVisibility {
let ItemLoc { id: tree_id, .. } = trait_id.lookup(db); let ItemLoc { id: tree_id, .. } = trait_id.lookup(db);
let item_tree = tree_id.item_tree(db); let item_tree = tree_id.item_tree(db);

25
crates/hir-def/src/db.rs
View file

@ -20,7 +20,11 @@ use crate::{
import_map::ImportMap, import_map::ImportMap,
item_tree::{AttrOwner, ItemTree, ItemTreeSourceMaps}, item_tree::{AttrOwner, ItemTree, ItemTreeSourceMaps},
lang_item::{self, LangItem, LangItemTarget, LangItems}, lang_item::{self, LangItem, LangItemTarget, LangItems},
nameres::{diagnostics::DefDiagnostics, DefMap, LocalDefMap}, nameres::{
assoc::{ImplItems, TraitItems},
diagnostics::DefDiagnostics,
DefMap, LocalDefMap,
},
tt, tt,
type_ref::TypesSourceMap, type_ref::TypesSourceMap,
visibility::{self, Visibility}, visibility::{self, Visibility},
@ -176,19 +180,26 @@ pub trait DefDatabase:
#[salsa::transparent] #[salsa::transparent]
#[salsa::invoke_actual(VariantData::variant_data)] #[salsa::invoke_actual(VariantData::variant_data)]
fn variant_data(&self, id: VariantId) -> Arc<VariantData>; fn variant_data(&self, id: VariantId) -> Arc<VariantData>;
#[salsa::transparent]
#[salsa::invoke_actual(ImplData::impl_data_query)] #[salsa::invoke_actual(ImplData::impl_data_query)]
fn impl_data(&self, e: ImplId) -> Arc<ImplData>; fn impl_data(&self, e: ImplId) -> Arc<ImplData>;
#[salsa::invoke_actual(ImplData::impl_data_with_diagnostics_query)]
fn impl_data_with_diagnostics(&self, e: ImplId) -> (Arc<ImplData>, DefDiagnostics);
#[salsa::transparent] #[salsa::transparent]
#[salsa::invoke_actual(ImplItems::impl_items_query)]
fn impl_items(&self, e: ImplId) -> Arc<ImplItems>;
#[salsa::invoke_actual(ImplItems::impl_items_with_diagnostics_query)]
fn impl_items_with_diagnostics(&self, e: ImplId) -> (Arc<ImplItems>, DefDiagnostics);
#[salsa::invoke_actual(TraitData::trait_data_query)] #[salsa::invoke_actual(TraitData::trait_data_query)]
fn trait_data(&self, e: TraitId) -> Arc<TraitData>; fn trait_data(&self, e: TraitId) -> Arc<TraitData>;
#[salsa::invoke_actual(TraitData::trait_data_with_diagnostics_query)] #[salsa::transparent]
fn trait_data_with_diagnostics(&self, tr: TraitId) -> (Arc<TraitData>, DefDiagnostics); #[salsa::invoke_actual(TraitItems::trait_items_query)]
fn trait_items(&self, e: TraitId) -> Arc<TraitItems>;
#[salsa::invoke_actual(TraitItems::trait_items_with_diagnostics_query)]
fn trait_items_with_diagnostics(&self, tr: TraitId) -> (Arc<TraitItems>, DefDiagnostics);
#[salsa::invoke_actual(TraitAliasData::trait_alias_query)] #[salsa::invoke_actual(TraitAliasData::trait_alias_query)]
fn trait_alias_data(&self, e: TraitAliasId) -> Arc<TraitAliasData>; fn trait_alias_data(&self, e: TraitAliasId) -> Arc<TraitAliasData>;

2
crates/hir-def/src/expr_store/pretty.rs
View file

@ -82,7 +82,7 @@ pub(super) fn print_body_hir(
p.buf.push_str(", "); p.buf.push_str(", ");
}); });
// remove the last ", " in param list // remove the last ", " in param list
if body.params.len() > 0 { if !body.params.is_empty() {
p.buf.truncate(p.buf.len() - 2); p.buf.truncate(p.buf.len() - 2);
} }
p.buf.push(')'); p.buf.push(')');

6
crates/hir-def/src/import_map.rs
View file

@ -222,7 +222,7 @@ impl ImportMap {
trait_import_info: &ImportInfo, trait_import_info: &ImportInfo,
) { ) {
let _p = tracing::info_span!("collect_trait_assoc_items").entered(); let _p = tracing::info_span!("collect_trait_assoc_items").entered();
for &(ref assoc_item_name, item) in &db.trait_data(tr).items { for &(ref assoc_item_name, item) in &db.trait_items(tr).items {
let module_def_id = match item { let module_def_id = match item {
AssocItemId::FunctionId(f) => ModuleDefId::from(f), AssocItemId::FunctionId(f) => ModuleDefId::from(f),
AssocItemId::ConstId(c) => ModuleDefId::from(c), AssocItemId::ConstId(c) => ModuleDefId::from(c),
@ -575,8 +575,8 @@ mod tests {
let trait_info = dependency_imports.import_info_for(ItemInNs::Types(trait_id.into()))?; let trait_info = dependency_imports.import_info_for(ItemInNs::Types(trait_id.into()))?;
let trait_data = db.trait_data(trait_id); let trait_items = db.trait_items(trait_id);
let (assoc_item_name, _) = trait_data let (assoc_item_name, _) = trait_items
.items .items
.iter() .iter()
.find(|(_, assoc_item_id)| &dependency_assoc_item_id == assoc_item_id)?; .find(|(_, assoc_item_id)| &dependency_assoc_item_id == assoc_item_id)?;

4
crates/hir-def/src/lang_item.rs
View file

@ -107,7 +107,7 @@ impl LangItems {
for (_, module_data) in crate_def_map.modules() { for (_, module_data) in crate_def_map.modules() {
for impl_def in module_data.scope.impls() { for impl_def in module_data.scope.impls() {
lang_items.collect_lang_item(db, impl_def, LangItemTarget::ImplDef); lang_items.collect_lang_item(db, impl_def, LangItemTarget::ImplDef);
for &(_, assoc) in db.impl_data(impl_def).items.iter() { for &(_, assoc) in db.impl_items(impl_def).items.iter() {
match assoc { match assoc {
AssocItemId::FunctionId(f) => { AssocItemId::FunctionId(f) => {
lang_items.collect_lang_item(db, f, LangItemTarget::Function) lang_items.collect_lang_item(db, f, LangItemTarget::Function)
@ -124,7 +124,7 @@ impl LangItems {
match def { match def {
ModuleDefId::TraitId(trait_) => { ModuleDefId::TraitId(trait_) => {
lang_items.collect_lang_item(db, trait_, LangItemTarget::Trait); lang_items.collect_lang_item(db, trait_, LangItemTarget::Trait);
db.trait_data(trait_).items.iter().for_each( db.trait_items(trait_).items.iter().for_each(
|&(_, assoc_id)| match assoc_id { |&(_, assoc_id)| match assoc_id {
AssocItemId::FunctionId(f) => { AssocItemId::FunctionId(f) => {
lang_items.collect_lang_item(db, f, LangItemTarget::Function); lang_items.collect_lang_item(db, f, LangItemTarget::Function);

1
crates/hir-def/src/nameres.rs
View file

@ -47,6 +47,7 @@
//! path and, upon success, we run macro expansion and "collect module" phase on //! path and, upon success, we run macro expansion and "collect module" phase on
//! the result //! the result
pub mod assoc;
pub mod attr_resolution; pub mod attr_resolution;
mod collector; mod collector;
pub mod diagnostics; pub mod diagnostics;

325
crates/hir-def/src/nameres/assoc.rs Normal file
View file

@ -0,0 +1,325 @@
//! Expansion of associated items
use hir_expand::{
name::Name, AstId, ExpandResult, InFile, Intern, Lookup, MacroCallKind, MacroDefKind,
};
use smallvec::SmallVec;
use span::{HirFileId, MacroCallId};
use syntax::{ast, Parse};
use triomphe::Arc;
use crate::{
db::DefDatabase,
expander::{Expander, Mark},
item_tree::{self, AssocItem, ItemTree, ItemTreeId, MacroCall, ModItem, TreeId},
macro_call_as_call_id,
nameres::{
attr_resolution::ResolvedAttr,
diagnostics::{DefDiagnostic, DefDiagnostics},
DefMap, LocalDefMap, MacroSubNs,
},
AssocItemId, AstIdWithPath, ConstLoc, FunctionId, FunctionLoc, ImplId, ItemContainerId,
ItemLoc, ModuleId, TraitId, TypeAliasId, TypeAliasLoc,
};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TraitItems {
pub items: Box<[(Name, AssocItemId)]>,
// box it as the vec is usually empty anyways
pub macro_calls: Option<Box<Vec<(AstId<ast::Item>, MacroCallId)>>>,
}
impl TraitItems {
#[inline]
pub(crate) fn trait_items_query(db: &dyn DefDatabase, tr: TraitId) -> Arc<TraitItems> {
db.trait_items_with_diagnostics(tr).0
}
pub(crate) fn trait_items_with_diagnostics_query(
db: &dyn DefDatabase,
tr: TraitId,
) -> (Arc<TraitItems>, DefDiagnostics) {
let ItemLoc { container: module_id, id: tree_id } = tr.lookup(db);
let item_tree = tree_id.item_tree(db);
let tr_def = &item_tree[tree_id.value];
let mut collector =
AssocItemCollector::new(db, module_id, tree_id.file_id(), ItemContainerId::TraitId(tr));
collector.collect(&item_tree, tree_id.tree_id(), &tr_def.items);
let (items, macro_calls, diagnostics) = collector.finish();
(Arc::new(TraitItems { macro_calls, items }), DefDiagnostics::new(diagnostics))
}
pub fn associated_types(&self) -> impl Iterator<Item = TypeAliasId> + '_ {
self.items.iter().filter_map(|(_name, item)| match item {
AssocItemId::TypeAliasId(t) => Some(*t),
_ => None,
})
}
pub fn associated_type_by_name(&self, name: &Name) -> Option<TypeAliasId> {
self.items.iter().find_map(|(item_name, item)| match item {
AssocItemId::TypeAliasId(t) if item_name == name => Some(*t),
_ => None,
})
}
pub fn method_by_name(&self, name: &Name) -> Option<FunctionId> {
self.items.iter().find_map(|(item_name, item)| match item {
AssocItemId::FunctionId(t) if item_name == name => Some(*t),
_ => None,
})
}
pub fn attribute_calls(&self) -> impl Iterator<Item = (AstId<ast::Item>, MacroCallId)> + '_ {
self.macro_calls.iter().flat_map(|it| it.iter()).copied()
}
}
#[derive(Debug, PartialEq, Eq)]
pub struct ImplItems {
pub items: Box<[(Name, AssocItemId)]>,
// box it as the vec is usually empty anyways
pub macro_calls: Option<Box<Vec<(AstId<ast::Item>, MacroCallId)>>>,
}
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) {
let _p = tracing::info_span!("impl_items_with_diagnostics_query").entered();
let ItemLoc { container: module_id, id: tree_id } = id.lookup(db);
let item_tree = tree_id.item_tree(db);
let impl_def = &item_tree[tree_id.value];
let mut collector =
AssocItemCollector::new(db, module_id, tree_id.file_id(), ItemContainerId::ImplId(id));
collector.collect(&item_tree, tree_id.tree_id(), &impl_def.items);
let (items, macro_calls, diagnostics) = collector.finish();
(Arc::new(ImplItems { items, macro_calls }), DefDiagnostics::new(diagnostics))
}
pub fn attribute_calls(&self) -> impl Iterator<Item = (AstId<ast::Item>, MacroCallId)> + '_ {
self.macro_calls.iter().flat_map(|it| it.iter()).copied()
}
}
struct AssocItemCollector<'a> {
db: &'a dyn DefDatabase,
module_id: ModuleId,
def_map: Arc<DefMap>,
local_def_map: Arc<LocalDefMap>,
diagnostics: Vec<DefDiagnostic>,
container: ItemContainerId,
expander: Expander,
items: Vec<(Name, AssocItemId)>,
macro_calls: Vec<(AstId<ast::Item>, MacroCallId)>,
}
impl<'a> AssocItemCollector<'a> {
fn new(
db: &'a dyn DefDatabase,
module_id: ModuleId,
file_id: HirFileId,
container: ItemContainerId,
) -> Self {
let (def_map, local_def_map) = module_id.local_def_map(db);
Self {
db,
module_id,
def_map,
local_def_map,
container,
expander: Expander::new(db, file_id, module_id),
items: Vec::new(),
macro_calls: Vec::new(),
diagnostics: Vec::new(),
}
}
fn finish(
self,
) -> (
Box<[(Name, AssocItemId)]>,
Option<Box<Vec<(AstId<ast::Item>, MacroCallId)>>>,
Vec<DefDiagnostic>,
) {
(
self.items.into_boxed_slice(),
if self.macro_calls.is_empty() { None } else { Some(Box::new(self.macro_calls)) },
self.diagnostics,
)
}
fn collect(&mut self, item_tree: &ItemTree, tree_id: TreeId, assoc_items: &[AssocItem]) {
let container = self.container;
self.items.reserve(assoc_items.len());
'items: for &item in assoc_items {
let attrs = item_tree.attrs(self.db, self.module_id.krate, ModItem::from(item).into());
if !attrs.is_cfg_enabled(self.expander.cfg_options()) {
self.diagnostics.push(DefDiagnostic::unconfigured_code(
self.module_id.local_id,
tree_id,
ModItem::from(item).into(),
attrs.cfg().unwrap(),
self.expander.cfg_options().clone(),
));
continue;
}
'attrs: for attr in &*attrs {
let ast_id =
AstId::new(self.expander.current_file_id(), item.ast_id(item_tree).upcast());
let ast_id_with_path = AstIdWithPath { path: attr.path.clone(), ast_id };
match self.def_map.resolve_attr_macro(
&self.local_def_map,
self.db,
self.module_id.local_id,
ast_id_with_path,
attr,
) {
Ok(ResolvedAttr::Macro(call_id)) => {
let loc = self.db.lookup_intern_macro_call(call_id);
if let MacroDefKind::ProcMacro(_, exp, _) = loc.def.kind {
// If there's no expander for the proc macro (e.g. the
// proc macro is ignored, or building the proc macro
// crate failed), skip expansion like we would if it was
// disabled. This is analogous to the handling in
// `DefCollector::collect_macros`.
if let Some(err) = exp.as_expand_error(self.module_id.krate) {
self.diagnostics.push(DefDiagnostic::macro_error(
self.module_id.local_id,
ast_id,
(*attr.path).clone(),
err,
));
continue 'attrs;
}
}
self.macro_calls.push((ast_id, call_id));
let res =
self.expander.enter_expand_id::<ast::MacroItems>(self.db, call_id);
self.collect_macro_items(res);
continue 'items;
}
Ok(_) => (),
Err(_) => {
self.diagnostics.push(DefDiagnostic::unresolved_macro_call(
self.module_id.local_id,
MacroCallKind::Attr {
ast_id,
attr_args: None,
invoc_attr_index: attr.id,
},
attr.path().clone(),
));
}
}
}
self.collect_item(item_tree, tree_id, container, item);
}
}
fn collect_item(
&mut self,
item_tree: &ItemTree,
tree_id: TreeId,
container: ItemContainerId,
item: AssocItem,
) {
match item {
AssocItem::Function(id) => {
let item = &item_tree[id];
let def =
FunctionLoc { container, id: ItemTreeId::new(tree_id, id) }.intern(self.db);
self.items.push((item.name.clone(), def.into()));
}
AssocItem::TypeAlias(id) => {
let item = &item_tree[id];
let def =
TypeAliasLoc { container, id: ItemTreeId::new(tree_id, id) }.intern(self.db);
self.items.push((item.name.clone(), def.into()));
}
AssocItem::Const(id) => {
let item = &item_tree[id];
let Some(name) = item.name.clone() else { return };
let def = ConstLoc { container, id: ItemTreeId::new(tree_id, id) }.intern(self.db);
self.items.push((name, def.into()));
}
AssocItem::MacroCall(call) => {
let file_id = self.expander.current_file_id();
let MacroCall { ast_id, expand_to, ctxt, ref path } = item_tree[call];
let module = self.expander.module.local_id;
let resolver = |path: &_| {
self.def_map
.resolve_path(
&self.local_def_map,
self.db,
module,
path,
crate::item_scope::BuiltinShadowMode::Other,
Some(MacroSubNs::Bang),
)
.0
.take_macros()
.map(|it| self.db.macro_def(it))
};
match macro_call_as_call_id(
self.db.upcast(),
&AstIdWithPath::new(file_id, ast_id, Clone::clone(path)),
ctxt,
expand_to,
self.expander.krate(),
resolver,
) {
Ok(Some(call_id)) => {
let res =
self.expander.enter_expand_id::<ast::MacroItems>(self.db, call_id);
self.macro_calls.push((InFile::new(file_id, ast_id.upcast()), call_id));
self.collect_macro_items(res);
}
Ok(None) => (),
Err(_) => {
self.diagnostics.push(DefDiagnostic::unresolved_macro_call(
self.module_id.local_id,
MacroCallKind::FnLike {
ast_id: InFile::new(file_id, ast_id),
expand_to,
eager: None,
},
Clone::clone(path),
));
}
}
}
}
}
fn collect_macro_items(&mut self, res: ExpandResult<Option<(Mark, Parse<ast::MacroItems>)>>) {
let Some((mark, _parse)) = res.value else { return };
let tree_id = item_tree::TreeId::new(self.expander.current_file_id(), None);
let item_tree = tree_id.item_tree(self.db);
let iter: SmallVec<[_; 2]> =
item_tree.top_level_items().iter().filter_map(ModItem::as_assoc_item).collect();
self.collect(&item_tree, tree_id, &iter);
self.expander.exit(mark);
}
}

2
crates/hir-ty/src/autoderef.rs
View file

@ -210,7 +210,7 @@ pub(crate) fn deref_by_trait(
}; };
let trait_id = trait_id()?; let trait_id = trait_id()?;
let target = db let target = db
.trait_data(trait_id) .trait_items(trait_id)
.associated_type_by_name(&Name::new_symbol_root(sym::Target.clone()))?; .associated_type_by_name(&Name::new_symbol_root(sym::Target.clone()))?;
let projection = { let projection = {

12
crates/hir-ty/src/chalk_db.rs
View file

@ -294,7 +294,7 @@ impl chalk_solve::RustIrDatabase<Interner> for ChalkContext<'_> {
.lang_item(self.krate, LangItem::Future) .lang_item(self.krate, LangItem::Future)
.and_then(|item| item.as_trait()) .and_then(|item| item.as_trait())
.and_then(|trait_| { .and_then(|trait_| {
let alias = self.db.trait_data(trait_).associated_type_by_name( let alias = self.db.trait_items(trait_).associated_type_by_name(
&Name::new_symbol_root(sym::Output.clone()), &Name::new_symbol_root(sym::Output.clone()),
)?; )?;
Some((trait_, alias)) Some((trait_, alias))
@ -684,7 +684,8 @@ pub(crate) fn trait_datum_query(
fundamental: trait_data.flags.contains(TraitFlags::IS_FUNDAMENTAL), fundamental: trait_data.flags.contains(TraitFlags::IS_FUNDAMENTAL),
}; };
let where_clauses = convert_where_clauses(db, trait_.into(), &bound_vars); let where_clauses = convert_where_clauses(db, trait_.into(), &bound_vars);
let associated_ty_ids = trait_data.associated_types().map(to_assoc_type_id).collect(); let associated_ty_ids =
db.trait_items(trait_).associated_types().map(to_assoc_type_id).collect();
let trait_datum_bound = rust_ir::TraitDatumBound { where_clauses }; let trait_datum_bound = rust_ir::TraitDatumBound { where_clauses };
let well_known = db.lang_attr(trait_.into()).and_then(well_known_trait_from_lang_item); let well_known = db.lang_attr(trait_.into()).and_then(well_known_trait_from_lang_item);
let trait_datum = TraitDatum { let trait_datum = TraitDatum {
@ -856,8 +857,9 @@ fn impl_def_datum(db: &dyn HirDatabase, krate: Crate, impl_id: hir_def::ImplId)
let polarity = if negative { rust_ir::Polarity::Negative } else { rust_ir::Polarity::Positive }; let polarity = if negative { rust_ir::Polarity::Negative } else { rust_ir::Polarity::Positive };
let impl_datum_bound = rust_ir::ImplDatumBound { trait_ref, where_clauses }; let impl_datum_bound = rust_ir::ImplDatumBound { trait_ref, where_clauses };
let trait_data = db.trait_data(trait_); let trait_data = db.trait_items(trait_);
let associated_ty_value_ids = impl_data let associated_ty_value_ids = db
.impl_items(impl_id)
.items .items
.iter() .iter()
.filter_map(|(_, item)| match item { .filter_map(|(_, item)| match item {
@ -908,7 +910,7 @@ fn type_alias_associated_ty_value(
.0; // we don't return any assoc ty values if the impl'd trait can't be resolved .0; // we don't return any assoc ty values if the impl'd trait can't be resolved
let assoc_ty = db let assoc_ty = db
.trait_data(trait_ref.hir_trait_id()) .trait_items(trait_ref.hir_trait_id())
.associated_type_by_name(&type_alias_data.name) .associated_type_by_name(&type_alias_data.name)
.expect("assoc ty value should not exist"); // validated when building the impl data as well .expect("assoc ty value should not exist"); // validated when building the impl data as well
let (ty, binders) = db.ty(type_alias.into()).into_value_and_skipped_binders(); let (ty, binders) = db.ty(type_alias.into()).into_value_and_skipped_binders();

2
crates/hir-ty/src/diagnostics/expr.rs
View file

@ -492,7 +492,7 @@ impl FilterMapNextChecker {
Some(next_function_id), Some(next_function_id),
match next_function_id.lookup(db.upcast()).container { match next_function_id.lookup(db.upcast()).container {
ItemContainerId::TraitId(iterator_trait_id) => { ItemContainerId::TraitId(iterator_trait_id) => {
let iterator_trait_items = &db.trait_data(iterator_trait_id).items; let iterator_trait_items = &db.trait_items(iterator_trait_id).items;
iterator_trait_items.iter().find_map(|(name, it)| match it { iterator_trait_items.iter().find_map(|(name, it)| match it {
&AssocItemId::FunctionId(id) if *name == sym::filter_map.clone() => { &AssocItemId::FunctionId(id) if *name == sym::filter_map.clone() => {
Some(id) Some(id)

2
crates/hir-ty/src/display.rs
View file

@ -1342,7 +1342,7 @@ impl HirDisplay for Ty {
.lang_item(body.module(db.upcast()).krate(), LangItem::Future) .lang_item(body.module(db.upcast()).krate(), LangItem::Future)
.and_then(LangItemTarget::as_trait); .and_then(LangItemTarget::as_trait);
let output = future_trait.and_then(|t| { let output = future_trait.and_then(|t| {
db.trait_data(t).associated_type_by_name(&Name::new_symbol_root( db.trait_items(t).associated_type_by_name(&Name::new_symbol_root(
sym::Output.clone(), sym::Output.clone(),
)) ))
}); });

4
crates/hir-ty/src/dyn_compatibility.rs
View file

@ -103,7 +103,7 @@ where
// rustc checks for non-lifetime binders here, but we don't support HRTB yet // rustc checks for non-lifetime binders here, but we don't support HRTB yet
let trait_data = db.trait_data(trait_); let trait_data = db.trait_items(trait_);
for (_, assoc_item) in &trait_data.items { for (_, assoc_item) in &trait_data.items {
dyn_compatibility_violation_for_assoc_item(db, trait_, *assoc_item, cb)?; dyn_compatibility_violation_for_assoc_item(db, trait_, *assoc_item, cb)?;
} }
@ -166,7 +166,7 @@ fn predicates_reference_self(db: &dyn HirDatabase, trait_: TraitId) -> bool {
// Same as the above, `predicates_reference_self` // Same as the above, `predicates_reference_self`
fn bounds_reference_self(db: &dyn HirDatabase, trait_: TraitId) -> bool { fn bounds_reference_self(db: &dyn HirDatabase, trait_: TraitId) -> bool {
let trait_data = db.trait_data(trait_); let trait_data = db.trait_items(trait_);
trait_data trait_data
.items .items
.iter() .iter()

2
crates/hir-ty/src/infer.rs
View file

@ -1723,7 +1723,7 @@ impl<'a> InferenceContext<'a> {
fn resolve_output_on(&self, trait_: TraitId) -> Option<TypeAliasId> { fn resolve_output_on(&self, trait_: TraitId) -> Option<TypeAliasId> {
self.db self.db
.trait_data(trait_) .trait_items(trait_)
.associated_type_by_name(&Name::new_symbol_root(sym::Output.clone())) .associated_type_by_name(&Name::new_symbol_root(sym::Output.clone()))
} }

2
crates/hir-ty/src/infer/closure.rs
View file

@ -815,7 +815,7 @@ impl InferenceContext<'_> {
{ {
if let Some(deref_fn) = self if let Some(deref_fn) = self
.db .db
.trait_data(deref_trait) .trait_items(deref_trait)
.method_by_name(&Name::new_symbol_root(sym::deref_mut.clone())) .method_by_name(&Name::new_symbol_root(sym::deref_mut.clone()))
{ {
break 'b deref_fn == f; break 'b deref_fn == f;

8
crates/hir-ty/src/infer/expr.rs
View file

@ -772,7 +772,7 @@ impl InferenceContext<'_> {
if let Some(deref_trait) = self.resolve_lang_trait(LangItem::Deref) { if let Some(deref_trait) = self.resolve_lang_trait(LangItem::Deref) {
if let Some(deref_fn) = self if let Some(deref_fn) = self
.db .db
.trait_data(deref_trait) .trait_items(deref_trait)
.method_by_name(&Name::new_symbol_root(sym::deref.clone())) .method_by_name(&Name::new_symbol_root(sym::deref.clone()))
{ {
// FIXME: this is wrong in multiple ways, subst is empty, and we emit it even for builtin deref (note that // FIXME: this is wrong in multiple ways, subst is empty, and we emit it even for builtin deref (note that
@ -930,7 +930,7 @@ impl InferenceContext<'_> {
self.write_expr_adj(*base, adj); self.write_expr_adj(*base, adj);
if let Some(func) = self if let Some(func) = self
.db .db
.trait_data(index_trait) .trait_items(index_trait)
.method_by_name(&Name::new_symbol_root(sym::index.clone())) .method_by_name(&Name::new_symbol_root(sym::index.clone()))
{ {
let subst = TyBuilder::subst_for_def(self.db, index_trait, None); let subst = TyBuilder::subst_for_def(self.db, index_trait, None);
@ -1258,7 +1258,7 @@ impl InferenceContext<'_> {
let Some(trait_) = fn_x.get_id(self.db, self.table.trait_env.krate) else { let Some(trait_) = fn_x.get_id(self.db, self.table.trait_env.krate) else {
return; return;
}; };
let trait_data = self.db.trait_data(trait_); let trait_data = self.db.trait_items(trait_);
if let Some(func) = trait_data.method_by_name(&fn_x.method_name()) { if let Some(func) = trait_data.method_by_name(&fn_x.method_name()) {
let subst = TyBuilder::subst_for_def(self.db, trait_, None) let subst = TyBuilder::subst_for_def(self.db, trait_, None)
.push(callee_ty.clone()) .push(callee_ty.clone())
@ -1426,7 +1426,7 @@ impl InferenceContext<'_> {
let trait_func = lang_items_for_bin_op(op).and_then(|(name, lang_item)| { let trait_func = lang_items_for_bin_op(op).and_then(|(name, lang_item)| {
let trait_id = self.resolve_lang_item(lang_item)?.as_trait()?; let trait_id = self.resolve_lang_item(lang_item)?.as_trait()?;
let func = self.db.trait_data(trait_id).method_by_name(&name)?; let func = self.db.trait_items(trait_id).method_by_name(&name)?;
Some((trait_id, func)) Some((trait_id, func))
}); });
let (trait_, func) = match trait_func { let (trait_, func) = match trait_func {

4
crates/hir-ty/src/infer/mutability.rs
View file

@ -134,7 +134,7 @@ impl InferenceContext<'_> {
{ {
if let Some(index_fn) = self if let Some(index_fn) = self
.db .db
.trait_data(index_trait) .trait_items(index_trait)
.method_by_name(&Name::new_symbol_root(sym::index_mut.clone())) .method_by_name(&Name::new_symbol_root(sym::index_mut.clone()))
{ {
*f = index_fn; *f = index_fn;
@ -201,7 +201,7 @@ impl InferenceContext<'_> {
mutability = Mutability::Not; mutability = Mutability::Not;
} else if let Some(deref_fn) = self } else if let Some(deref_fn) = self
.db .db
.trait_data(deref_trait) .trait_items(deref_trait)
.method_by_name(&Name::new_symbol_root(sym::deref_mut.clone())) .method_by_name(&Name::new_symbol_root(sym::deref_mut.clone()))
{ {
*f = deref_fn; *f = deref_fn;

2
crates/hir-ty/src/infer/path.rs
View file

@ -277,7 +277,7 @@ impl InferenceContext<'_> {
) -> Option<(ValueNs, Substitution)> { ) -> Option<(ValueNs, Substitution)> {
let trait_ = trait_ref.hir_trait_id(); let trait_ = trait_ref.hir_trait_id();
let item = let item =
self.db.trait_data(trait_).items.iter().map(|(_name, id)| *id).find_map(|item| { self.db.trait_items(trait_).items.iter().map(|(_name, id)| *id).find_map(|item| {
match item { match item {
AssocItemId::FunctionId(func) => { AssocItemId::FunctionId(func) => {
if segment.name == &self.db.function_data(func).name { if segment.name == &self.db.function_data(func).name {

2
crates/hir-ty/src/infer/unify.rs
View file

@ -801,7 +801,7 @@ impl<'a> InferenceTable<'a> {
] { ] {
let krate = self.trait_env.krate; let krate = self.trait_env.krate;
let fn_trait = fn_trait_name.get_id(self.db, krate)?; let fn_trait = fn_trait_name.get_id(self.db, krate)?;
let trait_data = self.db.trait_data(fn_trait); let trait_data = self.db.trait_items(fn_trait);
let output_assoc_type = let output_assoc_type =
trait_data.associated_type_by_name(&Name::new_symbol_root(output_assoc_name))?; trait_data.associated_type_by_name(&Name::new_symbol_root(output_assoc_name))?;

2
crates/hir-ty/src/lib.rs
View file

@ -906,7 +906,7 @@ pub fn callable_sig_from_fn_trait(
let krate = trait_env.krate; let krate = trait_env.krate;
let fn_once_trait = FnTrait::FnOnce.get_id(db, krate)?; let fn_once_trait = FnTrait::FnOnce.get_id(db, krate)?;
let output_assoc_type = db let output_assoc_type = db
.trait_data(fn_once_trait) .trait_items(fn_once_trait)
.associated_type_by_name(&Name::new_symbol_root(sym::Output.clone()))?; .associated_type_by_name(&Name::new_symbol_root(sym::Output.clone()))?;
let mut table = InferenceTable::new(db, trait_env.clone()); let mut table = InferenceTable::new(db, trait_env.clone());

4
crates/hir-ty/src/lower.rs
View file

@ -898,7 +898,7 @@ fn named_associated_type_shorthand_candidates<R>(
) -> Option<R> { ) -> Option<R> {
let mut search = |t| { let mut search = |t| {
all_super_trait_refs(db, t, |t| { all_super_trait_refs(db, t, |t| {
let data = db.trait_data(t.hir_trait_id()); let data = db.trait_items(t.hir_trait_id());
for (name, assoc_id) in &data.items { for (name, assoc_id) in &data.items {
if let AssocItemId::TypeAliasId(alias) = assoc_id { if let AssocItemId::TypeAliasId(alias) = assoc_id {
@ -1068,7 +1068,7 @@ pub(crate) fn generic_predicates_for_param_query(
}; };
all_super_traits(db.upcast(), tr).iter().any(|tr| { all_super_traits(db.upcast(), tr).iter().any(|tr| {
db.trait_data(*tr).items.iter().any(|(name, item)| { db.trait_items(*tr).items.iter().any(|(name, item)| {
matches!(item, AssocItemId::TypeAliasId(_)) && name == assoc_name matches!(item, AssocItemId::TypeAliasId(_)) && name == assoc_name
}) })
}) })

2
crates/hir-ty/src/lower/path.rs
View file

@ -169,7 +169,7 @@ impl<'a, 'b> PathLoweringContext<'a, 'b> {
self.skip_resolved_segment(); self.skip_resolved_segment();
let segment = self.current_or_prev_segment; let segment = self.current_or_prev_segment;
let found = let found =
self.ctx.db.trait_data(trait_).associated_type_by_name(segment.name); self.ctx.db.trait_items(trait_).associated_type_by_name(segment.name);
match found { match found {
Some(associated_ty) => { Some(associated_ty) => {

24
crates/hir-ty/src/method_resolution.rs
View file

@ -8,8 +8,8 @@ use arrayvec::ArrayVec;
use base_db::Crate; use base_db::Crate;
use chalk_ir::{cast::Cast, UniverseIndex, WithKind}; use chalk_ir::{cast::Cast, UniverseIndex, WithKind};
use hir_def::{ use hir_def::{
data::{adt::StructFlags, ImplData, TraitFlags}, data::{adt::StructFlags, TraitFlags},
nameres::DefMap, nameres::{assoc::ImplItems, DefMap},
AssocItemId, BlockId, ConstId, FunctionId, HasModule, ImplId, ItemContainerId, Lookup, AssocItemId, BlockId, ConstId, FunctionId, HasModule, ImplId, ItemContainerId, Lookup,
ModuleId, TraitId, ModuleId, TraitId,
}; };
@ -325,7 +325,7 @@ impl InherentImpls {
let self_ty = db.impl_self_ty(impl_id); let self_ty = db.impl_self_ty(impl_id);
let self_ty = self_ty.skip_binders(); let self_ty = self_ty.skip_binders();
match is_inherent_impl_coherent(db, def_map, &data, self_ty) { match is_inherent_impl_coherent(db, def_map, impl_id, self_ty) {
true => { true => {
// `fp` should only be `None` in error cases (either erroneous code or incomplete name resolution) // `fp` should only be `None` in error cases (either erroneous code or incomplete name resolution)
if let Some(fp) = TyFingerprint::for_inherent_impl(self_ty) { if let Some(fp) = TyFingerprint::for_inherent_impl(self_ty) {
@ -765,11 +765,10 @@ fn find_matching_impl(
mut impls: impl Iterator<Item = ImplId>, mut impls: impl Iterator<Item = ImplId>,
mut table: InferenceTable<'_>, mut table: InferenceTable<'_>,
actual_trait_ref: TraitRef, actual_trait_ref: TraitRef,
) -> Option<(Arc<ImplData>, Substitution)> { ) -> Option<(Arc<ImplItems>, Substitution)> {
let db = table.db; let db = table.db;
impls.find_map(|impl_| { impls.find_map(|impl_| {
table.run_in_snapshot(|table| { table.run_in_snapshot(|table| {
let impl_data = db.impl_data(impl_);
let impl_substs = let impl_substs =
TyBuilder::subst_for_def(db, impl_, None).fill_with_inference_vars(table).build(); TyBuilder::subst_for_def(db, impl_, None).fill_with_inference_vars(table).build();
let trait_ref = db let trait_ref = db
@ -787,7 +786,7 @@ fn find_matching_impl(
let goal = crate::Goal::all(Interner, wcs); let goal = crate::Goal::all(Interner, wcs);
table.try_obligation(goal.clone())?; table.try_obligation(goal.clone())?;
table.register_obligation(goal); table.register_obligation(goal);
Some((impl_data, table.resolve_completely(impl_substs))) Some((db.impl_items(impl_), table.resolve_completely(impl_substs)))
}) })
}) })
} }
@ -795,7 +794,7 @@ fn find_matching_impl(
fn is_inherent_impl_coherent( fn is_inherent_impl_coherent(
db: &dyn HirDatabase, db: &dyn HirDatabase,
def_map: &DefMap, def_map: &DefMap,
impl_data: &ImplData, impl_id: ImplId,
self_ty: &Ty, self_ty: &Ty,
) -> bool { ) -> bool {
let self_ty = self_ty.kind(Interner); let self_ty = self_ty.kind(Interner);
@ -848,9 +847,10 @@ fn is_inherent_impl_coherent(
_ => false, _ => false,
}; };
let items = db.impl_items(impl_id);
rustc_has_incoherent_inherent_impls rustc_has_incoherent_inherent_impls
&& !impl_data.items.is_empty() && !items.items.is_empty()
&& impl_data.items.iter().all(|&(_, assoc)| match assoc { && items.items.iter().all(|&(_, assoc)| match assoc {
AssocItemId::FunctionId(it) => db.function_data(it).rustc_allow_incoherent_impl, AssocItemId::FunctionId(it) => db.function_data(it).rustc_allow_incoherent_impl,
AssocItemId::ConstId(it) => db.const_data(it).rustc_allow_incoherent_impl, AssocItemId::ConstId(it) => db.const_data(it).rustc_allow_incoherent_impl,
AssocItemId::TypeAliasId(it) => db.type_alias_data(it).rustc_allow_incoherent_impl, AssocItemId::TypeAliasId(it) => db.type_alias_data(it).rustc_allow_incoherent_impl,
@ -1241,7 +1241,7 @@ fn iterate_trait_method_candidates(
// trait, but if we find out it doesn't, we'll skip the rest of the // trait, but if we find out it doesn't, we'll skip the rest of the
// iteration // iteration
let mut known_implemented = false; let mut known_implemented = false;
for &(_, item) in data.items.iter() { for &(_, item) in db.trait_items(t).items.iter() {
// Don't pass a `visible_from_module` down to `is_valid_candidate`, // Don't pass a `visible_from_module` down to `is_valid_candidate`,
// since only inherent methods should be included into visibility checking. // since only inherent methods should be included into visibility checking.
let visible = let visible =
@ -1368,7 +1368,7 @@ fn iterate_inherent_methods(
) -> ControlFlow<()> { ) -> ControlFlow<()> {
let db = table.db; let db = table.db;
for t in traits { for t in traits {
let data = db.trait_data(t); let data = db.trait_items(t);
for &(_, item) in data.items.iter() { for &(_, item) in data.items.iter() {
// We don't pass `visible_from_module` as all trait items should be visible. // We don't pass `visible_from_module` as all trait items should be visible.
let visible = match is_valid_trait_method_candidate( let visible = match is_valid_trait_method_candidate(
@ -1401,7 +1401,7 @@ fn iterate_inherent_methods(
callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>, callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
) -> ControlFlow<()> { ) -> ControlFlow<()> {
for &impl_id in impls.for_self_ty(self_ty) { for &impl_id in impls.for_self_ty(self_ty) {
for &(ref item_name, item) in table.db.impl_data(impl_id).items.iter() { for &(ref item_name, item) in table.db.impl_items(impl_id).items.iter() {
let visible = match is_valid_impl_method_candidate( let visible = match is_valid_impl_method_candidate(
table, table,
self_ty, self_ty,

12
crates/hir-ty/src/mir/eval.rs
View file

@ -661,19 +661,19 @@ impl Evaluator<'_> {
.lang_item(crate_id, LangItem::Fn) .lang_item(crate_id, LangItem::Fn)
.and_then(|x| x.as_trait()) .and_then(|x| x.as_trait())
.and_then(|x| { .and_then(|x| {
db.trait_data(x).method_by_name(&Name::new_symbol_root(sym::call.clone())) db.trait_items(x).method_by_name(&Name::new_symbol_root(sym::call.clone()))
}), }),
cached_fn_mut_trait_func: db cached_fn_mut_trait_func: db
.lang_item(crate_id, LangItem::FnMut) .lang_item(crate_id, LangItem::FnMut)
.and_then(|x| x.as_trait()) .and_then(|x| x.as_trait())
.and_then(|x| { .and_then(|x| {
db.trait_data(x).method_by_name(&Name::new_symbol_root(sym::call_mut.clone())) db.trait_items(x).method_by_name(&Name::new_symbol_root(sym::call_mut.clone()))
}), }),
cached_fn_once_trait_func: db cached_fn_once_trait_func: db
.lang_item(crate_id, LangItem::FnOnce) .lang_item(crate_id, LangItem::FnOnce)
.and_then(|x| x.as_trait()) .and_then(|x| x.as_trait())
.and_then(|x| { .and_then(|x| {
db.trait_data(x).method_by_name(&Name::new_symbol_root(sym::call_once.clone())) db.trait_items(x).method_by_name(&Name::new_symbol_root(sym::call_once.clone()))
}), }),
}) })
} }
@ -2818,7 +2818,9 @@ impl Evaluator<'_> {
) -> Result<()> { ) -> Result<()> {
let Some(drop_fn) = (|| { let Some(drop_fn) = (|| {
let drop_trait = self.db.lang_item(self.crate_id, LangItem::Drop)?.as_trait()?; let drop_trait = self.db.lang_item(self.crate_id, LangItem::Drop)?.as_trait()?;
self.db.trait_data(drop_trait).method_by_name(&Name::new_symbol_root(sym::drop.clone())) self.db
.trait_items(drop_trait)
.method_by_name(&Name::new_symbol_root(sym::drop.clone()))
})() else { })() else {
// in some tests we don't have drop trait in minicore, and // in some tests we don't have drop trait in minicore, and
// we can ignore drop in them. // we can ignore drop in them.
@ -2928,7 +2930,7 @@ pub fn render_const_using_debug_impl(
not_supported!("core::fmt::Debug not found"); not_supported!("core::fmt::Debug not found");
}; };
let Some(debug_fmt_fn) = let Some(debug_fmt_fn) =
db.trait_data(debug_trait).method_by_name(&Name::new_symbol_root(sym::fmt.clone())) db.trait_items(debug_trait).method_by_name(&Name::new_symbol_root(sym::fmt.clone()))
else { else {
not_supported!("core::fmt::Debug::fmt not found"); not_supported!("core::fmt::Debug::fmt not found");
}; };

2
crates/hir-ty/src/mir/eval/shim.rs
View file

@ -1261,7 +1261,7 @@ impl Evaluator<'_> {
if let Some(target) = self.db.lang_item(self.crate_id, LangItem::FnOnce) { if let Some(target) = self.db.lang_item(self.crate_id, LangItem::FnOnce) {
if let Some(def) = target.as_trait().and_then(|it| { if let Some(def) = target.as_trait().and_then(|it| {
self.db self.db
.trait_data(it) .trait_items(it)
.method_by_name(&Name::new_symbol_root(sym::call_once.clone())) .method_by_name(&Name::new_symbol_root(sym::call_once.clone()))
}) { }) {
self.exec_fn_trait( self.exec_fn_trait(

4
crates/hir-ty/src/mir/lower/as_place.rs
View file

@ -195,7 +195,7 @@ impl MirLowerCtx<'_> {
self.resolve_lang_item(LangItem::DerefMut)?.as_trait() self.resolve_lang_item(LangItem::DerefMut)?.as_trait()
{ {
if let Some(deref_fn) = if let Some(deref_fn) =
self.db.trait_data(deref_trait).method_by_name( self.db.trait_items(deref_trait).method_by_name(
&Name::new_symbol_root(sym::deref_mut.clone()), &Name::new_symbol_root(sym::deref_mut.clone()),
) )
{ {
@ -353,7 +353,7 @@ impl MirLowerCtx<'_> {
.ok_or(MirLowerError::LangItemNotFound(trait_lang_item))?; .ok_or(MirLowerError::LangItemNotFound(trait_lang_item))?;
let deref_fn = self let deref_fn = self
.db .db
.trait_data(deref_trait) .trait_items(deref_trait)
.method_by_name(&trait_method_name) .method_by_name(&trait_method_name)
.ok_or(MirLowerError::LangItemNotFound(trait_lang_item))?; .ok_or(MirLowerError::LangItemNotFound(trait_lang_item))?;
let deref_fn_op = Operand::const_zst( let deref_fn_op = Operand::const_zst(

4
crates/hir-ty/src/tests.rs
View file

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

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

@ -226,7 +226,7 @@ pub(super) fn associated_type_by_name_including_super_traits(
name: &Name, name: &Name,
) -> Option<(TraitRef, TypeAliasId)> { ) -> Option<(TraitRef, TypeAliasId)> {
all_super_trait_refs(db, trait_ref, |t| { all_super_trait_refs(db, trait_ref, |t| {
let assoc_type = db.trait_data(t.hir_trait_id()).associated_type_by_name(name)?; let assoc_type = db.trait_items(t.hir_trait_id()).associated_type_by_name(name)?;
Some((t, assoc_type)) Some((t, assoc_type))
}) })
} }

2
crates/hir/src/attrs.rs
View file

@ -194,7 +194,7 @@ fn resolve_assoc_or_field(
// Doc paths in this context may only resolve to an item of this trait // Doc paths in this context may only resolve to an item of this trait
// (i.e. no items of its supertraits), so we need to handle them here // (i.e. no items of its supertraits), so we need to handle them here
// independently of others. // independently of others.
return db.trait_data(id).items.iter().find(|it| it.0 == name).map(|(_, assoc_id)| { return db.trait_items(id).items.iter().find(|it| it.0 == name).map(|(_, assoc_id)| {
let def = match *assoc_id { let def = match *assoc_id {
AssocItemId::FunctionId(it) => ModuleDef::Function(it.into()), AssocItemId::FunctionId(it) => ModuleDef::Function(it.into()),
AssocItemId::ConstId(it) => ModuleDef::Const(it.into()), AssocItemId::ConstId(it) => ModuleDef::Const(it.into()),

4
crates/hir/src/db.rs
View file

@ -11,7 +11,7 @@ pub use hir_def::db::DefDatabase;
// ExpandProcAttrMacrosQuery, ExprScopesQuery, ExternCrateDeclDataQuery, FieldVisibilitiesQuery, // ExpandProcAttrMacrosQuery, ExprScopesQuery, ExternCrateDeclDataQuery, FieldVisibilitiesQuery,
// FieldsAttrsQuery, FieldsAttrsSourceMapQuery, FileItemTreeQuery, FileItemTreeWithSourceMapQuery, // FieldsAttrsQuery, FieldsAttrsSourceMapQuery, FileItemTreeQuery, FileItemTreeWithSourceMapQuery,
// FunctionDataQuery, FunctionVisibilityQuery, GenericParamsQuery, // FunctionDataQuery, FunctionVisibilityQuery, GenericParamsQuery,
// GenericParamsWithSourceMapQuery, ImplDataWithDiagnosticsQuery, ImportMapQuery, // GenericParamsWithSourceMapQuery, ImplItemsWithDiagnosticsQuery, ImportMapQuery,
// IncludeMacroInvocQuery, InternAnonymousConstQuery, InternBlockQuery, InternConstQuery, // IncludeMacroInvocQuery, InternAnonymousConstQuery, InternBlockQuery, InternConstQuery,
// InternDatabase, InternDatabaseStorage, InternEnumQuery, InternExternBlockQuery, // InternDatabase, InternDatabaseStorage, InternEnumQuery, InternExternBlockQuery,
// InternExternCrateQuery, InternFunctionQuery, InternImplQuery, InternInTypeConstQuery, // InternExternCrateQuery, InternFunctionQuery, InternImplQuery, InternInTypeConstQuery,
@ -19,7 +19,7 @@ pub use hir_def::db::DefDatabase;
// InternStructQuery, InternTraitAliasQuery, InternTraitQuery, InternTypeAliasQuery, // InternStructQuery, InternTraitAliasQuery, InternTraitQuery, InternTypeAliasQuery,
// InternUnionQuery, InternUseQuery, LangItemQuery, Macro2DataQuery, MacroDefQuery, // InternUnionQuery, InternUseQuery, LangItemQuery, Macro2DataQuery, MacroDefQuery,
// MacroRulesDataQuery, NotableTraitsInDepsQuery, ProcMacroDataQuery, StaticDataQuery, // MacroRulesDataQuery, NotableTraitsInDepsQuery, ProcMacroDataQuery, StaticDataQuery,
// StructDataWithDiagnosticsQuery, TraitAliasDataQuery, TraitDataWithDiagnosticsQuery, // StructDataWithDiagnosticsQuery, TraitAliasDataQuery, TraitItemsWithDiagnosticsQuery,
// TypeAliasDataQuery, UnionDataWithDiagnosticsQuery, // TypeAliasDataQuery, UnionDataWithDiagnosticsQuery,
// }; // };
pub use hir_expand::db::ExpandDatabase; pub use hir_expand::db::ExpandDatabase;

37
crates/hir/src/lib.rs
View file

@ -636,7 +636,7 @@ impl Module {
acc.extend(def.diagnostics(db, style_lints)) acc.extend(def.diagnostics(db, style_lints))
} }
ModuleDef::Trait(t) => { ModuleDef::Trait(t) => {
for diag in db.trait_data_with_diagnostics(t.id).1.iter() { for diag in db.trait_items_with_diagnostics(t.id).1.iter() {
emit_def_diagnostic(db, acc, diag, edition); emit_def_diagnostic(db, acc, diag, edition);
} }
@ -743,7 +743,7 @@ impl Module {
let ast_id_map = db.ast_id_map(file_id); let ast_id_map = db.ast_id_map(file_id);
for diag in db.impl_data_with_diagnostics(impl_def.id).1.iter() { for diag in db.impl_items_with_diagnostics(impl_def.id).1.iter() {
emit_def_diagnostic(db, acc, diag, edition); emit_def_diagnostic(db, acc, diag, edition);
} }
@ -801,13 +801,13 @@ impl Module {
// Negative impls can't have items, don't emit missing items diagnostic for them // Negative impls can't have items, don't emit missing items diagnostic for them
if let (false, Some(trait_)) = (impl_is_negative, trait_) { if let (false, Some(trait_)) = (impl_is_negative, trait_) {
let items = &db.trait_data(trait_.into()).items; let items = &db.trait_items(trait_.into()).items;
let required_items = items.iter().filter(|&(_, assoc)| match *assoc { let required_items = items.iter().filter(|&(_, assoc)| match *assoc {
AssocItemId::FunctionId(it) => !db.function_data(it).has_body(), AssocItemId::FunctionId(it) => !db.function_data(it).has_body(),
AssocItemId::ConstId(id) => !db.const_data(id).has_body, AssocItemId::ConstId(id) => !db.const_data(id).has_body,
AssocItemId::TypeAliasId(it) => db.type_alias_data(it).type_ref.is_none(), AssocItemId::TypeAliasId(it) => db.type_alias_data(it).type_ref.is_none(),
}); });
impl_assoc_items_scratch.extend(db.impl_data(impl_def.id).items.iter().cloned()); impl_assoc_items_scratch.extend(db.impl_items(impl_def.id).items.iter().cloned());
let redundant = impl_assoc_items_scratch let redundant = impl_assoc_items_scratch
.iter() .iter()
@ -863,7 +863,7 @@ impl Module {
source_map, source_map,
); );
for &(_, item) in db.impl_data(impl_def.id).items.iter() { for &(_, item) in db.impl_items(impl_def.id).items.iter() {
AssocItem::from(item).diagnostics(db, acc, style_lints); AssocItem::from(item).diagnostics(db, acc, style_lints);
} }
} }
@ -2868,16 +2868,15 @@ impl Trait {
} }
pub fn function(self, db: &dyn HirDatabase, name: impl PartialEq<Name>) -> Option<Function> { pub fn function(self, db: &dyn HirDatabase, name: impl PartialEq<Name>) -> Option<Function> {
db.trait_data(self.id).items.iter().find(|(n, _)| name == *n).and_then( db.trait_items(self.id).items.iter().find(|(n, _)| name == *n).and_then(|&(_, it)| match it
|&(_, it)| match it { {
AssocItemId::FunctionId(id) => Some(Function { id }), AssocItemId::FunctionId(id) => Some(Function { id }),
_ => None, _ => None,
}, })
)
} }
pub fn items(self, db: &dyn HirDatabase) -> Vec<AssocItem> { pub fn items(self, db: &dyn HirDatabase) -> Vec<AssocItem> {
db.trait_data(self.id).items.iter().map(|(_name, it)| (*it).into()).collect() db.trait_items(self.id).items.iter().map(|(_name, it)| (*it).into()).collect()
} }
pub fn items_with_supertraits(self, db: &dyn HirDatabase) -> Vec<AssocItem> { pub fn items_with_supertraits(self, db: &dyn HirDatabase) -> Vec<AssocItem> {
@ -2921,7 +2920,7 @@ impl Trait {
} }
fn all_macro_calls(&self, db: &dyn HirDatabase) -> Box<[(AstId<ast::Item>, MacroCallId)]> { fn all_macro_calls(&self, db: &dyn HirDatabase) -> Box<[(AstId<ast::Item>, MacroCallId)]> {
db.trait_data(self.id) db.trait_items(self.id)
.macro_calls .macro_calls
.as_ref() .as_ref()
.map(|it| it.as_ref().clone().into_boxed_slice()) .map(|it| it.as_ref().clone().into_boxed_slice())
@ -4428,7 +4427,7 @@ impl Impl {
} }
pub fn items(self, db: &dyn HirDatabase) -> Vec<AssocItem> { pub fn items(self, db: &dyn HirDatabase) -> Vec<AssocItem> {
db.impl_data(self.id).items.iter().map(|&(_, it)| it.into()).collect() db.impl_items(self.id).items.iter().map(|&(_, it)| it.into()).collect()
} }
pub fn is_negative(self, db: &dyn HirDatabase) -> bool { pub fn is_negative(self, db: &dyn HirDatabase) -> bool {
@ -4478,7 +4477,7 @@ impl Impl {
} }
fn all_macro_calls(&self, db: &dyn HirDatabase) -> Box<[(AstId<ast::Item>, MacroCallId)]> { fn all_macro_calls(&self, db: &dyn HirDatabase) -> Box<[(AstId<ast::Item>, MacroCallId)]> {
db.impl_data(self.id) db.impl_items(self.id)
.macro_calls .macro_calls
.as_ref() .as_ref()
.map(|it| it.as_ref().clone().into_boxed_slice()) .map(|it| it.as_ref().clone().into_boxed_slice())
@ -4959,7 +4958,7 @@ impl Type {
} }
let output_assoc_type = db let output_assoc_type = db
.trait_data(trait_) .trait_items(trait_)
.associated_type_by_name(&Name::new_symbol_root(sym::Output.clone()))?; .associated_type_by_name(&Name::new_symbol_root(sym::Output.clone()))?;
self.normalize_trait_assoc_type(db, &[], output_assoc_type.into()) self.normalize_trait_assoc_type(db, &[], output_assoc_type.into())
} }
@ -4975,7 +4974,7 @@ impl Type {
pub fn iterator_item(self, db: &dyn HirDatabase) -> Option<Type> { pub fn iterator_item(self, db: &dyn HirDatabase) -> Option<Type> {
let iterator_trait = db.lang_item(self.env.krate, LangItem::Iterator)?.as_trait()?; let iterator_trait = db.lang_item(self.env.krate, LangItem::Iterator)?.as_trait()?;
let iterator_item = db let iterator_item = db
.trait_data(iterator_trait) .trait_items(iterator_trait)
.associated_type_by_name(&Name::new_symbol_root(sym::Item.clone()))?; .associated_type_by_name(&Name::new_symbol_root(sym::Item.clone()))?;
self.normalize_trait_assoc_type(db, &[], iterator_item.into()) self.normalize_trait_assoc_type(db, &[], iterator_item.into())
} }
@ -5007,7 +5006,7 @@ impl Type {
} }
let into_iter_assoc_type = db let into_iter_assoc_type = db
.trait_data(trait_) .trait_items(trait_)
.associated_type_by_name(&Name::new_symbol_root(sym::IntoIter.clone()))?; .associated_type_by_name(&Name::new_symbol_root(sym::IntoIter.clone()))?;
self.normalize_trait_assoc_type(db, &[], into_iter_assoc_type.into()) self.normalize_trait_assoc_type(db, &[], into_iter_assoc_type.into())
} }
@ -5301,7 +5300,7 @@ impl Type {
let impls = db.inherent_impls_in_crate(krate); let impls = db.inherent_impls_in_crate(krate);
for impl_def in impls.for_self_ty(&self.ty) { for impl_def in impls.for_self_ty(&self.ty) {
for &(_, item) in db.impl_data(*impl_def).items.iter() { for &(_, item) in db.impl_items(*impl_def).items.iter() {
if callback(item) { if callback(item) {
return; return;
} }

4
crates/hir/src/semantics/child_by_source.rs
View file

@ -34,7 +34,7 @@ pub(crate) trait ChildBySource {
impl ChildBySource for TraitId { impl ChildBySource for TraitId {
fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) { fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) {
let data = db.trait_data(*self); let data = db.trait_items(*self);
data.attribute_calls().filter(|(ast_id, _)| ast_id.file_id == file_id).for_each( data.attribute_calls().filter(|(ast_id, _)| ast_id.file_id == file_id).for_each(
|(ast_id, call_id)| { |(ast_id, call_id)| {
@ -49,7 +49,7 @@ impl ChildBySource for TraitId {
impl ChildBySource for ImplId { impl ChildBySource for ImplId {
fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) { fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) {
let data = db.impl_data(*self); let data = db.impl_items(*self);
// FIXME: Macro calls // FIXME: Macro calls
data.attribute_calls().filter(|(ast_id, _)| ast_id.file_id == file_id).for_each( data.attribute_calls().filter(|(ast_id, _)| ast_id.file_id == file_id).for_each(
|(ast_id, call_id)| { |(ast_id, call_id)| {

6
crates/hir/src/source_analyzer.rs
View file

@ -1291,7 +1291,7 @@ impl SourceAnalyzer {
method_name: &Name, method_name: &Name,
) -> Option<(TraitId, FunctionId)> { ) -> Option<(TraitId, FunctionId)> {
let trait_id = db.lang_item(self.resolver.krate(), lang_trait)?.as_trait()?; let trait_id = db.lang_item(self.resolver.krate(), lang_trait)?.as_trait()?;
let fn_id = db.trait_data(trait_id).method_by_name(method_name)?; let fn_id = db.trait_items(trait_id).method_by_name(method_name)?;
Some((trait_id, fn_id)) Some((trait_id, fn_id))
} }
@ -1453,7 +1453,7 @@ fn resolve_hir_path_(
// within the trait's associated types. // within the trait's associated types.
if let (Some(unresolved), &TypeNs::TraitId(trait_id)) = (&unresolved, &ty) { if let (Some(unresolved), &TypeNs::TraitId(trait_id)) = (&unresolved, &ty) {
if let Some(type_alias_id) = if let Some(type_alias_id) =
db.trait_data(trait_id).associated_type_by_name(unresolved.name) db.trait_items(trait_id).associated_type_by_name(unresolved.name)
{ {
return Some(PathResolution::Def(ModuleDefId::from(type_alias_id).into())); return Some(PathResolution::Def(ModuleDefId::from(type_alias_id).into()));
} }
@ -1586,7 +1586,7 @@ fn resolve_hir_path_qualifier(
// within the trait's associated types. // within the trait's associated types.
if let (Some(unresolved), &TypeNs::TraitId(trait_id)) = (&unresolved, &ty) { if let (Some(unresolved), &TypeNs::TraitId(trait_id)) = (&unresolved, &ty) {
if let Some(type_alias_id) = if let Some(type_alias_id) =
db.trait_data(trait_id).associated_type_by_name(unresolved.name) db.trait_items(trait_id).associated_type_by_name(unresolved.name)
{ {
return Some(PathResolution::Def(ModuleDefId::from(type_alias_id).into())); return Some(PathResolution::Def(ModuleDefId::from(type_alias_id).into()));
} }

4
crates/hir/src/symbols.rs
View file

@ -313,7 +313,7 @@ impl<'a> SymbolCollector<'a> {
.to_smolstr(), .to_smolstr(),
); );
self.with_container_name(impl_name, |s| { self.with_container_name(impl_name, |s| {
for &(ref name, assoc_item_id) in &impl_data.items { for &(ref name, assoc_item_id) in &self.db.impl_items(impl_id).items {
s.push_assoc_item(assoc_item_id, name) s.push_assoc_item(assoc_item_id, name)
} }
}) })
@ -322,7 +322,7 @@ impl<'a> SymbolCollector<'a> {
fn collect_from_trait(&mut self, trait_id: TraitId) { fn collect_from_trait(&mut self, trait_id: TraitId) {
let trait_data = self.db.trait_data(trait_id); let trait_data = self.db.trait_data(trait_id);
self.with_container_name(Some(trait_data.name.as_str().into()), |s| { self.with_container_name(Some(trait_data.name.as_str().into()), |s| {
for &(ref name, assoc_item_id) in &trait_data.items { for &(ref name, assoc_item_id) in &self.db.trait_items(trait_id).items {
s.push_assoc_item(assoc_item_id, name); s.push_assoc_item(assoc_item_id, name);
} }
}); });

4
crates/ide-db/src/apply_change.rs
View file

@ -162,7 +162,7 @@ impl RootDatabase {
// hir::db::FunctionVisibilityQuery // hir::db::FunctionVisibilityQuery
// hir::db::GenericParamsQuery // hir::db::GenericParamsQuery
// hir::db::GenericParamsWithSourceMapQuery // hir::db::GenericParamsWithSourceMapQuery
// hir::db::ImplDataWithDiagnosticsQuery // hir::db::ImplItemsWithDiagnosticsQuery
// hir::db::ImportMapQuery // hir::db::ImportMapQuery
// hir::db::IncludeMacroInvocQuery // hir::db::IncludeMacroInvocQuery
// hir::db::InternAnonymousConstQuery // hir::db::InternAnonymousConstQuery
@ -193,7 +193,7 @@ impl RootDatabase {
// hir::db::StaticDataQuery // hir::db::StaticDataQuery
// hir::db::StructDataWithDiagnosticsQuery // hir::db::StructDataWithDiagnosticsQuery
// hir::db::TraitAliasDataQuery // hir::db::TraitAliasDataQuery
// hir::db::TraitDataWithDiagnosticsQuery // hir::db::TraitItemsWithDiagnosticsQuery
// hir::db::TypeAliasDataQuery // hir::db::TypeAliasDataQuery
// hir::db::UnionDataWithDiagnosticsQuery // hir::db::UnionDataWithDiagnosticsQuery