Skip to content

Commit 01c3303

Browse files
bors[bot]Veykril
bors[bot]
and
Veykril
authored
Merge #11236
11236: internal: Remove `InFile` wrapping from `DynMap` keys r=Veykril a=Veykril We already store a `DynMap` per `(Container, HirFileId)` pair, so the `InFile` keys are already guruanteed to always be of the same file id bors r+ Co-authored-by: Lukas Wirth <[email protected]>
2 parents 926ba99 + 47591f0 commit 01c3303

File tree

4 files changed

+82
-138
lines changed

4 files changed

+82
-138
lines changed

‎crates/hir/src/semantics/source_to_def.rs

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -242,7 +242,7 @@ impl SourceToDefCtx<'_, '_> {
242242

243243
pub(super) fn item_to_macro_call(&mut self, src: InFile<ast::Item>) -> Option<MacroCallId> {
244244
let map = self.dyn_map(src.as_ref())?;
245-
map[keys::ATTR_MACRO_CALL].get(&src).copied()
245+
map[keys::ATTR_MACRO_CALL].get(&src.value).copied()
246246
}
247247

248248
pub(super) fn attr_to_derive_macro_call(
@@ -251,15 +251,15 @@ impl SourceToDefCtx<'_, '_> {
251251
src: InFile<ast::Attr>,
252252
) -> Option<(AttrId, &[Option<MacroCallId>])> {
253253
let map = self.dyn_map(item)?;
254-
map[keys::DERIVE_MACRO_CALL].get(&src).map(|(id, ids)| (*id, &**ids))
254+
map[keys::DERIVE_MACRO_CALL].get(&src.value).map(|(id, ids)| (*id, &**ids))
255255
}
256256

257257
fn to_def<Ast: AstNode + 'static, ID: Copy + 'static>(
258258
&mut self,
259259
src: InFile<Ast>,
260260
key: Key<Ast, ID>,
261261
) -> Option<ID> {
262-
self.dyn_map(src.as_ref())?[key].get(&src).copied()
262+
self.dyn_map(src.as_ref())?[key].get(&src.value).copied()
263263
}
264264

265265
fn dyn_map<Ast: AstNode + 'static>(&mut self, src: InFile<&Ast>) -> Option<&DynMap> {
@@ -277,7 +277,7 @@ impl SourceToDefCtx<'_, '_> {
277277
pub(super) fn type_param_to_def(&mut self, src: InFile<ast::TypeParam>) -> Option<TypeParamId> {
278278
let container: ChildContainer = self.find_generic_param_container(src.syntax())?.into();
279279
let dyn_map = self.cache_for(container, src.file_id);
280-
dyn_map[keys::TYPE_PARAM].get(&src).copied()
280+
dyn_map[keys::TYPE_PARAM].get(&src.value).copied()
281281
}
282282

283283
pub(super) fn lifetime_param_to_def(
@@ -286,7 +286,7 @@ impl SourceToDefCtx<'_, '_> {
286286
) -> Option<LifetimeParamId> {
287287
let container: ChildContainer = self.find_generic_param_container(src.syntax())?.into();
288288
let dyn_map = self.cache_for(container, src.file_id);
289-
dyn_map[keys::LIFETIME_PARAM].get(&src).copied()
289+
dyn_map[keys::LIFETIME_PARAM].get(&src.value).copied()
290290
}
291291

292292
pub(super) fn const_param_to_def(
@@ -295,7 +295,7 @@ impl SourceToDefCtx<'_, '_> {
295295
) -> Option<ConstParamId> {
296296
let container: ChildContainer = self.find_generic_param_container(src.syntax())?.into();
297297
let dyn_map = self.cache_for(container, src.file_id);
298-
dyn_map[keys::CONST_PARAM].get(&src).copied()
298+
dyn_map[keys::CONST_PARAM].get(&src.value).copied()
299299
}
300300

301301
pub(super) fn generic_param_to_def(
@@ -316,9 +316,9 @@ impl SourceToDefCtx<'_, '_> {
316316
}
317317

318318
pub(super) fn macro_to_def(&mut self, src: InFile<ast::Macro>) -> Option<MacroDefId> {
319-
let makro = self.dyn_map(src.as_ref()).and_then(|it| it[keys::MACRO].get(&src).copied());
320-
if let res @ Some(_) = makro {
321-
return res;
319+
let makro = self.dyn_map(src.as_ref()).and_then(|it| it[keys::MACRO].get(&src.value));
320+
if let Some(&makro) = makro {
321+
return Some(makro);
322322
}
323323

324324
// Not all macros are recorded in the dyn map, only the ones behaving like items, so fall back

‎crates/hir_def/src/child_by_source.rs

Lines changed: 55 additions & 114 deletions
Original file line numberDiff line numberDiff line change
@@ -33,12 +33,11 @@ impl ChildBySource for TraitId {
3333

3434
data.attribute_calls().filter(|(ast_id, _)| ast_id.file_id == file_id).for_each(
3535
|(ast_id, call_id)| {
36-
let item = ast_id.with_value(ast_id.to_node(db.upcast()));
37-
res[keys::ATTR_MACRO_CALL].insert(item, call_id);
36+
res[keys::ATTR_MACRO_CALL].insert(ast_id.to_node(db.upcast()), call_id);
3837
},
3938
);
4039
data.items.iter().for_each(|&(_, item)| {
41-
child_by_source_assoc_items(db, res, file_id, item);
40+
add_assoc_item(db, res, file_id, item);
4241
});
4342
}
4443
}
@@ -48,42 +47,33 @@ impl ChildBySource for ImplId {
4847
let data = db.impl_data(*self);
4948
data.attribute_calls().filter(|(ast_id, _)| ast_id.file_id == file_id).for_each(
5049
|(ast_id, call_id)| {
51-
let item = ast_id.with_value(ast_id.to_node(db.upcast()));
52-
res[keys::ATTR_MACRO_CALL].insert(item, call_id);
50+
res[keys::ATTR_MACRO_CALL].insert(ast_id.to_node(db.upcast()), call_id);
5351
},
5452
);
5553
data.items.iter().for_each(|&item| {
56-
child_by_source_assoc_items(db, res, file_id, item);
54+
add_assoc_item(db, res, file_id, item);
5755
});
5856
}
5957
}
6058

61-
fn child_by_source_assoc_items(
62-
db: &dyn DefDatabase,
63-
res: &mut DynMap,
64-
file_id: HirFileId,
65-
item: AssocItemId,
66-
) {
59+
fn add_assoc_item(db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId, item: AssocItemId) {
6760
match item {
6861
AssocItemId::FunctionId(func) => {
6962
let loc = func.lookup(db);
7063
if loc.id.file_id() == file_id {
71-
let src = loc.source(db);
72-
res[keys::FUNCTION].insert(src, func)
64+
res[keys::FUNCTION].insert(loc.source(db).value, func)
7365
}
7466
}
7567
AssocItemId::ConstId(konst) => {
7668
let loc = konst.lookup(db);
7769
if loc.id.file_id() == file_id {
78-
let src = loc.source(db);
79-
res[keys::CONST].insert(src, konst)
70+
res[keys::CONST].insert(loc.source(db).value, konst)
8071
}
8172
}
8273
AssocItemId::TypeAliasId(ty) => {
8374
let loc = ty.lookup(db);
8475
if loc.id.file_id() == file_id {
85-
let src = loc.source(db);
86-
res[keys::TYPE_ALIAS].insert(src, ty)
76+
res[keys::TYPE_ALIAS].insert(loc.source(db).value, ty)
8777
}
8878
}
8979
}
@@ -99,120 +89,75 @@ impl ChildBySource for ModuleId {
9989

10090
impl ChildBySource for ItemScope {
10191
fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) {
102-
self.declarations().for_each(|item| add_module_def(db, file_id, res, item));
92+
self.declarations().for_each(|item| add_module_def(db, res, file_id, item));
93+
self.impls().for_each(|imp| add_impl(db, res, file_id, imp));
94+
self.unnamed_consts().for_each(|konst| {
95+
let loc = konst.lookup(db);
96+
if loc.id.file_id() == file_id {
97+
res[keys::CONST].insert(loc.source(db).value, konst);
98+
}
99+
});
103100
self.macros().for_each(|(_, makro)| {
104101
let ast_id = makro.ast_id();
105102
if ast_id.either(|it| it.file_id, |it| it.file_id) == file_id {
106103
let src = match ast_id {
107-
Either::Left(ast_id) => ast_id.with_value(ast_id.to_node(db.upcast())),
104+
Either::Left(ast_id) => ast_id.to_node(db.upcast()),
108105
// FIXME: Do we need to add proc-macros into a PROCMACRO dynmap here?
109106
Either::Right(_fn) => return,
110107
};
111108
res[keys::MACRO].insert(src, makro);
112109
}
113110
});
114-
self.unnamed_consts().for_each(|konst| {
115-
let loc = konst.lookup(db);
116-
if loc.id.file_id() == file_id {
117-
let src = loc.source(db);
118-
res[keys::CONST].insert(src, konst);
119-
}
120-
});
121-
self.impls().for_each(|imp| add_impl(db, file_id, res, imp));
122-
self.attr_macro_invocs().for_each(|(ast_id, call_id)| {
123-
if ast_id.file_id == file_id {
124-
let item = ast_id.with_value(ast_id.to_node(db.upcast()));
125-
res[keys::ATTR_MACRO_CALL].insert(item, call_id);
126-
}
127-
});
128-
self.derive_macro_invocs().for_each(|(ast_id, calls)| {
129-
if ast_id.file_id != file_id {
130-
return;
131-
}
132-
let adt = ast_id.to_node(db.upcast());
133-
for (attr_id, calls) in calls {
134-
if let Some(Either::Right(attr)) =
135-
adt.doc_comments_and_attrs().nth(attr_id.ast_index as usize)
136-
{
137-
res[keys::DERIVE_MACRO_CALL]
138-
.insert(ast_id.with_value(attr), (attr_id, calls.into()));
139-
}
140-
}
141-
});
111+
self.attr_macro_invocs().filter(|(id, _)| id.file_id == file_id).for_each(
112+
|(ast_id, call_id)| {
113+
res[keys::ATTR_MACRO_CALL].insert(ast_id.to_node(db.upcast()), call_id);
114+
},
115+
);
116+
self.derive_macro_invocs().filter(|(id, _)| id.file_id == file_id).for_each(
117+
|(ast_id, calls)| {
118+
let adt = ast_id.to_node(db.upcast());
119+
calls.for_each(|(attr_id, calls)| {
120+
if let Some(Either::Right(attr)) =
121+
adt.doc_comments_and_attrs().nth(attr_id.ast_index as usize)
122+
{
123+
res[keys::DERIVE_MACRO_CALL].insert(attr, (attr_id, calls.into()));
124+
}
125+
});
126+
},
127+
);
142128

143129
fn add_module_def(
144130
db: &dyn DefDatabase,
145-
file_id: HirFileId,
146131
map: &mut DynMap,
132+
file_id: HirFileId,
147133
item: ModuleDefId,
148134
) {
149-
match item {
150-
ModuleDefId::FunctionId(func) => {
151-
let loc = func.lookup(db);
152-
if loc.id.file_id() == file_id {
153-
let src = loc.source(db);
154-
map[keys::FUNCTION].insert(src, func)
155-
}
156-
}
157-
ModuleDefId::ConstId(konst) => {
158-
let loc = konst.lookup(db);
159-
if loc.id.file_id() == file_id {
160-
let src = loc.source(db);
161-
map[keys::CONST].insert(src, konst)
162-
}
163-
}
164-
ModuleDefId::StaticId(statik) => {
165-
let loc = statik.lookup(db);
135+
macro_rules! insert {
136+
($map:ident[$key:path].$insert:ident($id:ident)) => {{
137+
let loc = $id.lookup(db);
166138
if loc.id.file_id() == file_id {
167-
let src = loc.source(db);
168-
map[keys::STATIC].insert(src, statik)
139+
$map[$key].$insert(loc.source(db).value, $id)
169140
}
170-
}
171-
ModuleDefId::TypeAliasId(ty) => {
172-
let loc = ty.lookup(db);
173-
if loc.id.file_id() == file_id {
174-
let src = loc.source(db);
175-
map[keys::TYPE_ALIAS].insert(src, ty)
176-
}
177-
}
178-
ModuleDefId::TraitId(trait_) => {
179-
let loc = trait_.lookup(db);
180-
if loc.id.file_id() == file_id {
181-
let src = loc.source(db);
182-
map[keys::TRAIT].insert(src, trait_)
183-
}
184-
}
141+
}};
142+
}
143+
match item {
144+
ModuleDefId::FunctionId(id) => insert!(map[keys::FUNCTION].insert(id)),
145+
ModuleDefId::ConstId(id) => insert!(map[keys::CONST].insert(id)),
146+
ModuleDefId::StaticId(id) => insert!(map[keys::STATIC].insert(id)),
147+
ModuleDefId::TypeAliasId(id) => insert!(map[keys::TYPE_ALIAS].insert(id)),
148+
ModuleDefId::TraitId(id) => insert!(map[keys::TRAIT].insert(id)),
185149
ModuleDefId::AdtId(adt) => match adt {
186-
AdtId::StructId(strukt) => {
187-
let loc = strukt.lookup(db);
188-
if loc.id.file_id() == file_id {
189-
let src = loc.source(db);
190-
map[keys::STRUCT].insert(src, strukt)
191-
}
192-
}
193-
AdtId::UnionId(union_) => {
194-
let loc = union_.lookup(db);
195-
if loc.id.file_id() == file_id {
196-
let src = loc.source(db);
197-
map[keys::UNION].insert(src, union_)
198-
}
199-
}
200-
AdtId::EnumId(enum_) => {
201-
let loc = enum_.lookup(db);
202-
if loc.id.file_id() == file_id {
203-
let src = loc.source(db);
204-
map[keys::ENUM].insert(src, enum_)
205-
}
206-
}
150+
AdtId::StructId(id) => insert!(map[keys::STRUCT].insert(id)),
151+
AdtId::UnionId(id) => insert!(map[keys::UNION].insert(id)),
152+
AdtId::EnumId(id) => insert!(map[keys::ENUM].insert(id)),
207153
},
208154
_ => (),
209155
}
210156
}
211-
fn add_impl(db: &dyn DefDatabase, file_id: HirFileId, map: &mut DynMap, imp: ImplId) {
157+
fn add_impl(db: &dyn DefDatabase, map: &mut DynMap, file_id: HirFileId, imp: ImplId) {
212158
let loc = imp.lookup(db);
213159
if loc.id.file_id() == file_id {
214-
let src = loc.source(db);
215-
map[keys::IMPL].insert(src, imp)
160+
map[keys::IMPL].insert(loc.source(db).value, imp)
216161
}
217162
}
218163
}
@@ -226,12 +171,8 @@ impl ChildBySource for VariantId {
226171
for (local_id, source) in arena_map.value.iter() {
227172
let id = FieldId { parent, local_id };
228173
match source.clone() {
229-
Either::Left(source) => {
230-
res[keys::TUPLE_FIELD].insert(arena_map.with_value(source), id)
231-
}
232-
Either::Right(source) => {
233-
res[keys::RECORD_FIELD].insert(arena_map.with_value(source), id)
234-
}
174+
Either::Left(source) => res[keys::TUPLE_FIELD].insert(source, id),
175+
Either::Right(source) => res[keys::RECORD_FIELD].insert(source, id),
235176
}
236177
}
237178
}
@@ -243,7 +184,7 @@ impl ChildBySource for EnumId {
243184
let arena_map = arena_map.as_ref();
244185
for (local_id, source) in arena_map.value.iter() {
245186
let id = EnumVariantId { parent: *self, local_id };
246-
res[keys::VARIANT].insert(arena_map.with_value(source.clone()), id)
187+
res[keys::VARIANT].insert(source.clone(), id)
247188
}
248189
}
249190
}

‎crates/hir_def/src/generics.rs

Lines changed: 9 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -454,14 +454,17 @@ impl HasChildSource<LocalConstParamId> for GenericDefId {
454454
}
455455

456456
impl ChildBySource for GenericDefId {
457-
fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, _: HirFileId) {
457+
fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) {
458+
let (gfile_id, generic_params_list) = file_id_and_params_of(*self, db);
459+
if gfile_id != file_id {
460+
return;
461+
}
462+
458463
let generic_params = db.generic_params(*self);
459464
let mut types_idx_iter = generic_params.types.iter().map(|(idx, _)| idx);
460465
let lts_idx_iter = generic_params.lifetimes.iter().map(|(idx, _)| idx);
461466
let consts_idx_iter = generic_params.consts.iter().map(|(idx, _)| idx);
462467

463-
let (file_id, generic_params_list) = file_id_and_params_of(*self, db);
464-
465468
// For traits the first type index is `Self`, skip it.
466469
if let GenericDefId::TraitId(_) = *self {
467470
types_idx_iter.next().unwrap(); // advance_by(1);
@@ -470,15 +473,15 @@ impl ChildBySource for GenericDefId {
470473
if let Some(generic_params_list) = generic_params_list {
471474
for (local_id, ast_param) in types_idx_iter.zip(generic_params_list.type_params()) {
472475
let id = TypeParamId { parent: *self, local_id };
473-
res[keys::TYPE_PARAM].insert(InFile::new(file_id, ast_param), id);
476+
res[keys::TYPE_PARAM].insert(ast_param, id);
474477
}
475478
for (local_id, ast_param) in lts_idx_iter.zip(generic_params_list.lifetime_params()) {
476479
let id = LifetimeParamId { parent: *self, local_id };
477-
res[keys::LIFETIME_PARAM].insert(InFile::new(file_id, ast_param), id);
480+
res[keys::LIFETIME_PARAM].insert(ast_param, id);
478481
}
479482
for (local_id, ast_param) in consts_idx_iter.zip(generic_params_list.const_params()) {
480483
let id = ConstParamId { parent: *self, local_id };
481-
res[keys::CONST_PARAM].insert(InFile::new(file_id, ast_param), id);
484+
res[keys::CONST_PARAM].insert(ast_param, id);
482485
}
483486
}
484487
}

0 commit comments

Comments
 (0)