language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-10-28 10:39:45 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 5

Cleanup incremental tests

Browse source
This commit is contained in:
Lukas Wirth 2025-06-14 17:07:31 +02:00
parent fe5a925a74
commit f68512af65
2 changed files with 695 additions and 216 deletions
Download patch file Download diff file Expand all files Collapse all files

391
crates/hir-def/src/nameres/tests/incremental.rs
View file

@ -2,13 +2,13 @@ use base_db::{
CrateDisplayName, CrateGraphBuilder, CrateName, CrateOrigin, CrateWorkspaceData,
DependencyBuilder, Env, RootQueryDb, SourceDatabase,
};
use expect_test::{Expect, expect};
use intern::Symbol;
use span::Edition;
use test_fixture::WithFixture;
use triomphe::Arc;
use crate::{
AdtId, ModuleDefId,
db::DefDatabase,
nameres::{crate_def_map, tests::TestDB},
};
@ -16,29 +16,29 @@ use crate::{
fn check_def_map_is_not_recomputed(
#[rust_analyzer::rust_fixture] ra_fixture_initial: &str,
#[rust_analyzer::rust_fixture] ra_fixture_change: &str,
expecta: Expect,
expectb: Expect,
) {
let (mut db, pos) = TestDB::with_position(ra_fixture_initial);
let krate = db.fetch_test_crate();
{
let events = db.log_executed(|| {
execute_assert_events(
&db,
|| {
crate_def_map(&db, krate);
});
assert!(
format!("{events:?}").contains("crate_local_def_map"),
"no crate def map computed:\n{events:#?}",
)
}
},
&[],
expecta,
);
db.set_file_text(pos.file_id.file_id(&db), ra_fixture_change);
{
let events = db.log_executed(|| {
execute_assert_events(
&db,
|| {
crate_def_map(&db, krate);
});
assert!(
!format!("{events:?}").contains("crate_local_def_map"),
"crate def map invalidated:\n{events:#?}",
)
}
},
&[("crate_local_def_map", 0)],
expectb,
);
}
#[test]
@ -104,15 +104,20 @@ pub const BAZ: u32 = 0;
Arc::ptr_eq(&all_crates_before, &all_crates_after),
"the all_crates list should not have been invalidated"
);
let events = db.log_executed(|| {
for &krate in db.all_crates().iter() {
crate_def_map(&db, krate);
}
});
let invalidated_def_maps =
events.iter().filter(|event| event.contains("crate_local_def_map")).count();
assert_eq!(invalidated_def_maps, 1, "{events:#?}")
execute_assert_events(
&db,
|| {
for &krate in db.all_crates().iter() {
crate_def_map(&db, krate);
}
},
&[("crate_local_def_map", 1)],
expect![[r#"
[
"crate_local_def_map",
]
"#]],
);
}
#[test]
@ -152,6 +157,34 @@ fn foo() -> i32 { 92 }
#[cfg(never)]
fn no() {}
",
expect![[r#"
[
"crate_local_def_map",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"enum_variants_shim",
"enum_variants_with_diagnostics_shim",
]
"#]],
expect![[r#"
[
"parse_shim",
"ast_id_map_shim",
"file_item_tree_query",
"real_span_map_shim",
"enum_variants_with_diagnostics_shim",
]
"#]],
);
}
@ -183,6 +216,41 @@ m!(Y);
pub struct S {}
",
expect![[r#"
[
"crate_local_def_map",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"macro_def_shim",
"file_item_tree_query",
"ast_id_map_shim",
"parse_macro_expansion_shim",
"macro_arg_shim",
"decl_macro_expander_shim",
]
"#]],
expect![[r#"
[
"parse_shim",
"ast_id_map_shim",
"file_item_tree_query",
"real_span_map_shim",
"macro_arg_shim",
"parse_macro_expansion_shim",
"ast_id_map_shim",
"file_item_tree_query",
]
"#]],
);
}
@ -206,6 +274,49 @@ fn f() {}
#[proc_macros::identity]
fn f() { foo }
",
expect![[r#"
[
"crate_local_def_map",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"crate_local_def_map",
"proc_macros_for_crate_shim",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"macro_def_shim",
"file_item_tree_query",
"ast_id_map_shim",
"parse_macro_expansion_shim",
"expand_proc_macro_shim",
"macro_arg_shim",
"proc_macro_span_shim",
]
"#]],
expect![[r#"
[
"parse_shim",
"ast_id_map_shim",
"file_item_tree_query",
"real_span_map_shim",
"macro_arg_shim",
"expand_proc_macro_shim",
"parse_macro_expansion_shim",
"ast_id_map_shim",
"file_item_tree_query",
]
"#]],
);
}
@ -287,6 +398,61 @@ m2!(X);
#[derive(proc_macros::DeriveIdentity)]
pub struct S {}
",
expect![[r#"
[
"crate_local_def_map",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"macro_def_shim",
"file_item_tree_query",
"ast_id_map_shim",
"parse_macro_expansion_shim",
"macro_arg_shim",
"decl_macro_expander_shim",
"macro_def_shim",
"file_item_tree_query",
"ast_id_map_shim",
"parse_macro_expansion_shim",
"macro_arg_shim",
"decl_macro_expander_shim",
"crate_local_def_map",
"proc_macros_for_crate_shim",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"macro_def_shim",
"macro_def_shim",
"file_item_tree_query",
"ast_id_map_shim",
"parse_macro_expansion_shim",
"expand_proc_macro_shim",
"macro_arg_shim",
"proc_macro_span_shim",
]
"#]],
expect![[r#"
[
"parse_shim",
"ast_id_map_shim",
"file_item_tree_query",
"real_span_map_shim",
"macro_arg_shim",
"macro_arg_shim",
"decl_macro_expander_shim",
"macro_arg_shim",
]
"#]],
);
}
@ -341,19 +507,46 @@ m!(Z);
"#,
);
let krate = db.test_crate();
{
let events = db.log_executed(|| {
execute_assert_events(
&db,
|| {
let crate_def_map = crate_def_map(&db, krate);
let (_, module_data) = crate_def_map.modules.iter().last().unwrap();
assert_eq!(module_data.scope.resolutions().count(), 4);
});
let n_recalculated_item_trees =
events.iter().filter(|it| it.contains("file_item_tree_query")).count();
assert_eq!(n_recalculated_item_trees, 6);
let n_reparsed_macros =
events.iter().filter(|it| it.contains("parse_macro_expansion_shim")).count();
assert_eq!(n_reparsed_macros, 3);
}
},
&[("file_item_tree_query", 6), ("parse_macro_expansion_shim", 3)],
expect![[r#"
[
"crate_local_def_map",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"macro_def_shim",
"file_item_tree_query",
"ast_id_map_shim",
"parse_macro_expansion_shim",
"macro_arg_shim",
"decl_macro_expander_shim",
"file_item_tree_query",
"ast_id_map_shim",
"parse_macro_expansion_shim",
"macro_arg_shim",
"file_item_tree_query",
"ast_id_map_shim",
"parse_macro_expansion_shim",
"macro_arg_shim",
]
"#]],
);
let new_text = r#"
m!(X);
@ -363,28 +556,31 @@ m!(Z);
"#;
db.set_file_text(pos.file_id.file_id(&db), new_text);
{
let events = db.log_executed(|| {
execute_assert_events(
&db,
|| {
let crate_def_map = crate_def_map(&db, krate);
let (_, module_data) = crate_def_map.modules.iter().last().unwrap();
assert_eq!(module_data.scope.resolutions().count(), 4);
});
let n_recalculated_item_trees =
events.iter().filter(|it| it.contains("file_item_tree_query")).count();
assert_eq!(n_recalculated_item_trees, 1, "{events:#?}");
let n_reparsed_macros =
events.iter().filter(|it| it.contains("parse_macro_expansion_shim")).count();
assert_eq!(n_reparsed_macros, 0);
}
},
&[("file_item_tree_query", 1), ("parse_macro_expansion_shim", 0)],
expect![[r#"
[
"parse_shim",
"ast_id_map_shim",
"file_item_tree_query",
"real_span_map_shim",
"macro_arg_shim",
"macro_arg_shim",
"macro_arg_shim",
]
"#]],
);
}
#[test]
fn item_tree_prevents_reparsing() {
// The `ItemTree` is used by both name resolution and the various queries in `adt.rs` and
// `data.rs`. After computing the `ItemTree` and deleting the parse tree, we should be able to
// run those other queries without triggering a reparse.
let (db, pos) = TestDB::with_position(
let (mut db, pos) = TestDB::with_position(
r#"
pub struct S;
pub union U {}
@ -399,53 +595,54 @@ pub static ST: u8 = 0;
pub type Ty = ();
"#,
);
let krate = db.test_crate();
{
let events = db.log_executed(|| {
execute_assert_events(
&db,
|| {
db.file_item_tree(pos.file_id.into());
});
let n_calculated_item_trees =
events.iter().filter(|it| it.contains("file_item_tree_query")).count();
assert_eq!(n_calculated_item_trees, 1, "{events:#?}");
let n_parsed_files = events.iter().filter(|it| it.contains("parse")).count();
assert_eq!(n_parsed_files, 1, "{events:#?}");
}
},
&[("file_item_tree_query", 1), ("parse", 1)],
expect![[r#"
[
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
]
"#]],
);
// FIXME(salsa-transition): bring this back
// base_db::ParseQuery.in_db(&db).purge();
let file_id = pos.file_id.file_id(&db);
let file_text = db.file_text(file_id).text(&db);
db.set_file_text(file_id, &format!("{file_text}\n"));
{
let events = db.log_executed(|| {
let crate_def_map = crate_def_map(&db, krate);
let (_, module_data) = crate_def_map.modules.iter().last().unwrap();
assert_eq!(module_data.scope.resolutions().count(), 8);
assert_eq!(module_data.scope.impls().count(), 1);
for imp in module_data.scope.impls() {
db.impl_signature(imp);
}
for (_, res) in module_data.scope.resolutions() {
match res.values.map(|it| it.def).or(res.types.map(|it| it.def)).unwrap() {
ModuleDefId::FunctionId(f) => _ = db.function_signature(f),
ModuleDefId::AdtId(adt) => match adt {
AdtId::StructId(it) => _ = db.struct_signature(it),
AdtId::UnionId(it) => _ = db.union_signature(it),
AdtId::EnumId(it) => _ = db.enum_signature(it),
},
ModuleDefId::ConstId(it) => _ = db.const_signature(it),
ModuleDefId::StaticId(it) => _ = db.static_signature(it),
ModuleDefId::TraitId(it) => _ = db.trait_signature(it),
ModuleDefId::TraitAliasId(it) => _ = db.trait_alias_signature(it),
ModuleDefId::TypeAliasId(it) => _ = db.type_alias_signature(it),
ModuleDefId::EnumVariantId(_)
| ModuleDefId::ModuleId(_)
| ModuleDefId::MacroId(_)
| ModuleDefId::BuiltinType(_) => unreachable!(),
}
}
});
let n_reparsed_files = events.iter().filter(|it| it.contains("parse(")).count();
assert_eq!(n_reparsed_files, 0, "{events:?}");
}
execute_assert_events(
&db,
|| {
db.file_item_tree(pos.file_id.into());
},
&[("file_item_tree_query", 1), ("parse", 1)],
expect![[r#"
[
"parse_shim",
"ast_id_map_shim",
"file_item_tree_query",
"real_span_map_shim",
]
"#]],
);
}
fn execute_assert_events(
db: &TestDB,
f: impl FnOnce(),
required: &[(&str, usize)],
expect: Expect,
) {
let events = db.log_executed(f);
for (event, count) in required {
let n = events.iter().filter(|it| it.contains(event)).count();
assert_eq!(n, *count, "Expected {event} to be executed {count} times, but only got {n}");
}
expect.assert_debug_eq(&events);
}

520
crates/hir-ty/src/tests/incremental.rs
View file

@ -1,4 +1,5 @@
use base_db::SourceDatabase;
use expect_test::Expect;
use hir_def::{DefWithBodyId, ModuleDefId};
use test_fixture::WithFixture;
@ -15,8 +16,9 @@ fn foo() -> i32 {
$01 + 1
}",
);
{
let events = db.log_executed(|| {
execute_assert_events(
&db,
|| {
let module = db.module_for_file(pos.file_id.file_id(&db));
let crate_def_map = module.def_map(&db);
visit_module(&db, crate_def_map, module.local_id, &mut |def| {
@ -24,9 +26,31 @@ fn foo() -> i32 {
db.infer(it.into());
}
});
});
assert!(format!("{events:?}").contains("infer_shim"))
}
},
&[("infer_shim", 1)],
expect_test::expect![[r#"
[
"source_root_crates_shim",
"crate_local_def_map",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"infer_shim",
"function_signature_shim",
"function_signature_with_source_map_shim",
"attrs_shim",
"body_shim",
"body_with_source_map_shim",
"trait_environment_shim",
"return_type_impl_traits_shim",
"expr_scopes_shim",
"lang_item",
"crate_lang_items",
"lang_item",
]
"#]],
);
let new_text = "
fn foo() -> i32 {
@ -37,8 +61,9 @@ fn foo() -> i32 {
db.set_file_text(pos.file_id.file_id(&db), new_text);
{
let events = db.log_executed(|| {
execute_assert_events(
&db,
|| {
let module = db.module_for_file(pos.file_id.file_id(&db));
let crate_def_map = module.def_map(&db);
visit_module(&db, crate_def_map, module.local_id, &mut |def| {
@ -46,9 +71,22 @@ fn foo() -> i32 {
db.infer(it.into());
}
});
});
assert!(!format!("{events:?}").contains("infer_shim"), "{events:#?}")
}
},
&[("infer_shim", 0)],
expect_test::expect![[r#"
[
"parse_shim",
"ast_id_map_shim",
"file_item_tree_query",
"real_span_map_shim",
"attrs_shim",
"function_signature_with_source_map_shim",
"function_signature_shim",
"body_with_source_map_shim",
"body_shim",
]
"#]],
);
}
#[test]
@ -66,8 +104,9 @@ fn baz() -> i32 {
1 + 1
}",
);
{
let events = db.log_executed(|| {
execute_assert_events(
&db,
|| {
let module = db.module_for_file(pos.file_id.file_id(&db));
let crate_def_map = module.def_map(&db);
visit_module(&db, crate_def_map, module.local_id, &mut |def| {
@ -75,9 +114,49 @@ fn baz() -> i32 {
db.infer(it.into());
}
});
});
assert!(format!("{events:?}").contains("infer_shim"))
}
},
&[("infer_shim", 3)],
expect_test::expect![[r#"
[
"source_root_crates_shim",
"crate_local_def_map",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"infer_shim",
"function_signature_shim",
"function_signature_with_source_map_shim",
"attrs_shim",
"body_shim",
"body_with_source_map_shim",
"trait_environment_shim",
"return_type_impl_traits_shim",
"expr_scopes_shim",
"lang_item",
"crate_lang_items",
"attrs_shim",
"attrs_shim",
"lang_item",
"infer_shim",
"function_signature_shim",
"function_signature_with_source_map_shim",
"body_shim",
"body_with_source_map_shim",
"trait_environment_shim",
"return_type_impl_traits_shim",
"expr_scopes_shim",
"infer_shim",
"function_signature_shim",
"function_signature_with_source_map_shim",
"body_shim",
"body_with_source_map_shim",
"trait_environment_shim",
"return_type_impl_traits_shim",
"expr_scopes_shim",
]
"#]],
);
let new_text = "
fn foo() -> f32 {
@ -93,8 +172,9 @@ fn baz() -> i32 {
db.set_file_text(pos.file_id.file_id(&db), new_text);
{
let events = db.log_executed(|| {
execute_assert_events(
&db,
|| {
let module = db.module_for_file(pos.file_id.file_id(&db));
let crate_def_map = module.def_map(&db);
visit_module(&db, crate_def_map, module.local_id, &mut |def| {
@ -102,9 +182,34 @@ fn baz() -> i32 {
db.infer(it.into());
}
});
});
assert_eq!(format!("{events:?}").matches("infer_shim").count(), 1, "{events:#?}")
}
},
&[("infer_shim", 1)],
expect_test::expect![[r#"
[
"parse_shim",
"ast_id_map_shim",
"file_item_tree_query",
"real_span_map_shim",
"attrs_shim",
"function_signature_with_source_map_shim",
"function_signature_shim",
"body_with_source_map_shim",
"body_shim",
"attrs_shim",
"attrs_shim",
"function_signature_with_source_map_shim",
"function_signature_shim",
"body_with_source_map_shim",
"body_shim",
"infer_shim",
"expr_scopes_shim",
"function_signature_with_source_map_shim",
"function_signature_shim",
"body_with_source_map_shim",
"body_shim",
]
"#]],
);
}
#[test]
@ -121,14 +226,26 @@ fn bar() -> f32 {
}
$0",
);
{
let events = db.log_executed(|| {
execute_assert_events(
&db,
|| {
let module = db.module_for_file(pos.file_id.file_id(&db));
let _crate_def_map = module.def_map(&db);
db.trait_impls_in_crate(module.krate());
});
assert!(format!("{events:?}").contains("trait_impls_in_crate_shim"))
}
},
&[("trait_impls_in_crate_shim", 1)],
expect_test::expect![[r#"
[
"source_root_crates_shim",
"crate_local_def_map",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"trait_impls_in_crate_shim",
]
"#]],
);
let new_text = "
fn foo() -> i32 {
@ -146,24 +263,25 @@ pub struct NewStruct {
db.set_file_text(pos.file_id.file_id(&db), new_text);
{
let actual = db.log_executed(|| {
execute_assert_events(
&db,
|| {
let module = db.module_for_file(pos.file_id.file_id(&db));
let _crate_def_map = module.def_map(&db);
db.trait_impls_in_crate(module.krate());
});
let expected = vec![
"parse_shim".to_owned(),
"ast_id_map_shim".to_owned(),
"file_item_tree_query".to_owned(),
"real_span_map_shim".to_owned(),
"crate_local_def_map".to_owned(),
"trait_impls_in_crate_shim".to_owned(),
];
assert_eq!(expected, actual);
}
},
&[("trait_impls_in_crate_shim", 1)],
expect_test::expect![[r#"
[
"parse_shim",
"ast_id_map_shim",
"file_item_tree_query",
"real_span_map_shim",
"crate_local_def_map",
"trait_impls_in_crate_shim",
]
"#]],
);
}
#[test]
@ -180,14 +298,26 @@ fn bar() -> f32 {
}
$0",
);
{
let events = db.log_executed(|| {
execute_assert_events(
&db,
|| {
let module = db.module_for_file(pos.file_id.file_id(&db));
let _crate_def_map = module.def_map(&db);
db.trait_impls_in_crate(module.krate());
});
assert!(format!("{events:?}").contains("trait_impls_in_crate_shim"))
}
},
&[("trait_impls_in_crate_shim", 1)],
expect_test::expect![[r#"
[
"source_root_crates_shim",
"crate_local_def_map",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"trait_impls_in_crate_shim",
]
"#]],
);
let new_text = "
fn foo() -> i32 {
@ -206,24 +336,25 @@ pub enum SomeEnum {
db.set_file_text(pos.file_id.file_id(&db), new_text);
{
let actual = db.log_executed(|| {
execute_assert_events(
&db,
|| {
let module = db.module_for_file(pos.file_id.file_id(&db));
let _crate_def_map = module.def_map(&db);
db.trait_impls_in_crate(module.krate());
});
let expected = vec![
"parse_shim".to_owned(),
"ast_id_map_shim".to_owned(),
"file_item_tree_query".to_owned(),
"real_span_map_shim".to_owned(),
"crate_local_def_map".to_owned(),
"trait_impls_in_crate_shim".to_owned(),
];
assert_eq!(expected, actual);
}
},
&[("trait_impls_in_crate_shim", 1)],
expect_test::expect![[r#"
[
"parse_shim",
"ast_id_map_shim",
"file_item_tree_query",
"real_span_map_shim",
"crate_local_def_map",
"trait_impls_in_crate_shim",
]
"#]],
);
}
#[test]
@ -240,14 +371,26 @@ fn bar() -> f32 {
}
$0",
);
{
let events = db.log_executed(|| {
execute_assert_events(
&db,
|| {
let module = db.module_for_file(pos.file_id.file_id(&db));
let _crate_def_map = module.def_map(&db);
db.trait_impls_in_crate(module.krate());
});
assert!(format!("{events:?}").contains("trait_impls_in_crate_shim"))
}
},
&[("trait_impls_in_crate_shim", 1)],
expect_test::expect![[r#"
[
"source_root_crates_shim",
"crate_local_def_map",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"trait_impls_in_crate_shim",
]
"#]],
);
let new_text = "
use std::collections::HashMap;
@ -263,24 +406,25 @@ fn bar() -> f32 {
db.set_file_text(pos.file_id.file_id(&db), new_text);
{
let actual = db.log_executed(|| {
execute_assert_events(
&db,
|| {
let module = db.module_for_file(pos.file_id.file_id(&db));
let _crate_def_map = module.def_map(&db);
db.trait_impls_in_crate(module.krate());
});
let expected = vec![
"parse_shim".to_owned(),
"ast_id_map_shim".to_owned(),
"file_item_tree_query".to_owned(),
"real_span_map_shim".to_owned(),
"crate_local_def_map".to_owned(),
"trait_impls_in_crate_shim".to_owned(),
];
assert_eq!(expected, actual);
}
},
&[("trait_impls_in_crate_shim", 1)],
expect_test::expect![[r#"
[
"parse_shim",
"ast_id_map_shim",
"file_item_tree_query",
"real_span_map_shim",
"crate_local_def_map",
"trait_impls_in_crate_shim",
]
"#]],
);
}
#[test]
@ -301,14 +445,26 @@ pub struct SomeStruct {
}
$0",
);
{
let events = db.log_executed(|| {
execute_assert_events(
&db,
|| {
let module = db.module_for_file(pos.file_id.file_id(&db));
let _crate_def_map = module.def_map(&db);
db.trait_impls_in_crate(module.krate());
});
assert!(format!("{events:?}").contains("trait_impls_in_crate_shim"))
}
},
&[("trait_impls_in_crate_shim", 1)],
expect_test::expect![[r#"
[
"source_root_crates_shim",
"crate_local_def_map",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"trait_impls_in_crate_shim",
]
"#]],
);
let new_text = "
fn foo() -> i32 {
@ -332,33 +488,34 @@ impl SomeStruct {
db.set_file_text(pos.file_id.file_id(&db), new_text);
{
let actual = db.log_executed(|| {
execute_assert_events(
&db,
|| {
let module = db.module_for_file(pos.file_id.file_id(&db));
let _crate_def_map = module.def_map(&db);
db.trait_impls_in_crate(module.krate());
});
let expected = vec![
"parse_shim".to_owned(),
"ast_id_map_shim".to_owned(),
"file_item_tree_query".to_owned(),
"real_span_map_shim".to_owned(),
"crate_local_def_map".to_owned(),
"trait_impls_in_crate_shim".to_owned(),
"attrs_shim".to_owned(),
"impl_trait_with_diagnostics_shim".to_owned(),
"impl_signature_shim".to_owned(),
"impl_signature_with_source_map_shim".to_owned(),
"impl_self_ty_with_diagnostics_shim".to_owned(),
"struct_signature_shim".to_owned(),
"struct_signature_with_source_map_shim".to_owned(),
"attrs_shim".to_owned(),
"type_for_adt_tracked".to_owned(),
];
assert_eq!(expected, actual);
}
},
&[("trait_impls_in_crate_shim", 1)],
expect_test::expect![[r#"
[
"parse_shim",
"ast_id_map_shim",
"file_item_tree_query",
"real_span_map_shim",
"crate_local_def_map",
"trait_impls_in_crate_shim",
"attrs_shim",
"impl_trait_with_diagnostics_shim",
"impl_signature_shim",
"impl_signature_with_source_map_shim",
"impl_self_ty_with_diagnostics_shim",
"struct_signature_shim",
"struct_signature_with_source_map_shim",
"attrs_shim",
"type_for_adt_tracked",
]
"#]],
);
}
#[test]
@ -380,8 +537,9 @@ fn main() {
}",
);
{
let events = db.log_executed(|| {
execute_assert_events(
&db,
|| {
let module = db.module_for_file(file_id.file_id(&db));
let crate_def_map = module.def_map(&db);
let mut defs: Vec<DefWithBodyId> = vec![];
@ -399,9 +557,73 @@ fn main() {
for def in defs {
let _inference_result = db.infer(def);
}
});
assert!(format!("{events:?}").contains("trait_solve_shim"))
}
},
&[("trait_solve_shim", 2)],
expect_test::expect![[r#"
[
"source_root_crates_shim",
"crate_local_def_map",
"file_item_tree_query",
"ast_id_map_shim",
"parse_shim",
"real_span_map_shim",
"trait_items_with_diagnostics_shim",
"body_shim",
"body_with_source_map_shim",
"attrs_shim",
"impl_items_with_diagnostics_shim",
"infer_shim",
"trait_signature_shim",
"trait_signature_with_source_map_shim",
"attrs_shim",
"function_signature_shim",
"function_signature_with_source_map_shim",
"attrs_shim",
"body_shim",
"body_with_source_map_shim",
"trait_environment_shim",
"lang_item",
"crate_lang_items",
"attrs_shim",
"attrs_shim",
"return_type_impl_traits_shim",
"infer_shim",
"function_signature_shim",
"function_signature_with_source_map_shim",
"trait_environment_shim",
"expr_scopes_shim",
"struct_signature_shim",
"struct_signature_with_source_map_shim",
"generic_predicates_shim",
"value_ty_shim",
"variant_fields_shim",
"variant_fields_with_source_map_shim",
"lang_item",
"inherent_impls_in_crate_shim",
"impl_signature_shim",
"impl_signature_with_source_map_shim",
"callable_item_signature_shim",
"adt_variance_shim",
"variances_of_shim",
"trait_solve_shim",
"trait_datum_shim",
"generic_predicates_shim",
"adt_datum_shim",
"trait_impls_in_deps_shim",
"trait_impls_in_crate_shim",
"impl_trait_with_diagnostics_shim",
"impl_self_ty_with_diagnostics_shim",
"type_for_adt_tracked",
"impl_datum_shim",
"generic_predicates_shim",
"program_clauses_for_chalk_env_shim",
"value_ty_shim",
"generic_predicates_shim",
"trait_solve_shim",
"lang_item",
]
"#]],
);
let new_text = "
//- /main.rs crate:main
@ -422,8 +644,9 @@ fn main() {
db.set_file_text(file_id.file_id(&db), new_text);
{
let events = db.log_executed(|| {
execute_assert_events(
&db,
|| {
let module = db.module_for_file(file_id.file_id(&db));
let crate_def_map = module.def_map(&db);
let mut defs: Vec<DefWithBodyId> = vec![];
@ -442,7 +665,66 @@ fn main() {
for def in defs {
let _inference_result = db.infer(def);
}
});
assert!(!format!("{events:?}").contains("trait_solve_shim"))
}
},
&[("trait_solve_shim", 0)],
expect_test::expect![[r#"
[
"parse_shim",
"ast_id_map_shim",
"file_item_tree_query",
"real_span_map_shim",
"crate_local_def_map",
"trait_items_with_diagnostics_shim",
"body_with_source_map_shim",
"attrs_shim",
"body_shim",
"impl_items_with_diagnostics_shim",
"infer_shim",
"attrs_shim",
"trait_signature_with_source_map_shim",
"attrs_shim",
"function_signature_with_source_map_shim",
"function_signature_shim",
"body_with_source_map_shim",
"body_shim",
"trait_environment_shim",
"crate_lang_items",
"attrs_shim",
"attrs_shim",
"attrs_shim",
"return_type_impl_traits_shim",
"infer_shim",
"function_signature_with_source_map_shim",
"trait_environment_shim",
"expr_scopes_shim",
"struct_signature_with_source_map_shim",
"generic_predicates_shim",
"variant_fields_with_source_map_shim",
"inherent_impls_in_crate_shim",
"impl_signature_with_source_map_shim",
"impl_signature_shim",
"callable_item_signature_shim",
"generic_predicates_shim",
"trait_impls_in_crate_shim",
"impl_trait_with_diagnostics_shim",
"impl_self_ty_with_diagnostics_shim",
"generic_predicates_shim",
"generic_predicates_shim",
]
"#]],
);
}
fn execute_assert_events(
db: &TestDB,
f: impl FnOnce(),
required: &[(&str, usize)],
expect: Expect,
) {
let events = db.log_executed(f);
for (event, count) in required {
let n = events.iter().filter(|it| it.contains(event)).count();
assert_eq!(n, *count, "Expected {event} to be executed {count} times, but only got {n}");
}
expect.assert_debug_eq(&events);
}