rust/crates/ra_hir_ty/src/tests.rs

462 lines
14 KiB
Rust
Raw Normal View History

mod never_type;
mod coercion;
2019-12-03 06:38:54 -06:00
mod regression;
mod simple;
mod patterns;
mod traits;
mod method_resolution;
mod macros;
use std::sync::Arc;
2018-12-20 14:56:28 -06:00
2019-11-27 08:46:02 -06:00
use hir_def::{
2020-03-06 07:44:44 -06:00
body::{BodySourceMap, SyntheticSyntax},
child_by_source::ChildBySource,
db::DefDatabase,
item_scope::ItemScope,
keys,
nameres::CrateDefMap,
AssocItemId, DefWithBodyId, LocalModuleId, Lookup, ModuleDefId,
2019-11-27 08:46:02 -06:00
};
2020-04-23 14:23:36 -05:00
use hir_expand::{db::AstDatabase, InFile};
2019-08-29 08:49:10 -05:00
use insta::assert_snapshot;
use ra_db::{fixture::WithFixture, salsa::Database, FilePosition, SourceDatabase};
use ra_syntax::{
algo,
2020-04-09 16:35:05 -05:00
ast::{self, AstNode},
2020-04-23 14:23:36 -05:00
SyntaxNode,
};
2020-03-28 05:20:34 -05:00
use stdx::format_to;
2018-12-20 14:56:28 -06:00
2020-04-23 14:23:36 -05:00
use crate::{
db::HirDatabase, display::HirDisplay, infer::TypeMismatch, test_db::TestDB, InferenceResult, Ty,
};
2018-12-20 14:56:28 -06:00
// These tests compare the inference results for all expressions in a file
2019-03-03 05:40:36 -06:00
// against snapshots of the expected results using insta. Use cargo-insta to
// update the snapshots.
fn type_at_pos(db: &TestDB, pos: FilePosition) -> String {
2019-05-28 10:07:39 -05:00
let file = db.parse(pos.file_id).ok().unwrap();
2019-04-12 17:32:43 -05:00
let expr = algo::find_node_at_offset::<ast::Expr>(file.syntax(), pos.offset).unwrap();
2019-12-05 14:17:17 -06:00
let fn_def = expr.syntax().ancestors().find_map(ast::FnDef::cast).unwrap();
2019-11-27 08:46:02 -06:00
let module = db.module_for_file(pos.file_id);
let func = *module.child_by_source(db)[keys::FUNCTION]
.get(&InFile::new(pos.file_id.into(), fn_def))
.unwrap();
2019-12-05 14:17:17 -06:00
let (_body, source_map) = db.body_with_source_map(func.into());
if let Some(expr_id) = source_map.node_expr(InFile::new(pos.file_id.into(), &expr)) {
let infer = db.infer(func.into());
let ty = &infer[expr_id];
return ty.display(db).to_string();
2019-11-27 08:46:02 -06:00
}
panic!("Can't find expression")
}
fn type_at(content: &str) -> String {
let (db, file_pos) = TestDB::with_position(content);
type_at_pos(&db, file_pos)
}
2020-02-27 09:05:35 -06:00
fn infer(ra_fixture: &str) -> String {
infer_with_mismatches(ra_fixture, false)
}
fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
let (db, file_id) = TestDB::with_single_file(content);
2020-03-28 05:20:34 -05:00
let mut buf = String::new();
let mut infer_def = |inference_result: Arc<InferenceResult>,
body_source_map: Arc<BodySourceMap>| {
2020-04-23 14:23:36 -05:00
let mut types: Vec<(InFile<SyntaxNode>, &Ty)> = Vec::new();
let mut mismatches: Vec<(InFile<SyntaxNode>, &TypeMismatch)> = Vec::new();
2019-01-06 16:57:39 -06:00
for (pat, ty) in inference_result.type_of_pat.iter() {
2019-03-02 06:14:37 -06:00
let syntax_ptr = match body_source_map.pat_syntax(pat) {
2020-03-06 07:44:44 -06:00
Ok(sp) => {
2020-04-23 14:23:36 -05:00
let root = db.parse_or_expand(sp.file_id).unwrap();
sp.map(|ptr| {
ptr.either(
|it| it.to_node(&root).syntax().clone(),
|it| it.to_node(&root).syntax().clone(),
)
})
}
2020-03-06 07:44:44 -06:00
Err(SyntheticSyntax) => continue,
};
types.push((syntax_ptr, ty));
}
2019-01-06 16:57:39 -06:00
for (expr, ty) in inference_result.type_of_expr.iter() {
2020-04-23 14:23:36 -05:00
let node = match body_source_map.expr_syntax(expr) {
Ok(sp) => {
let root = db.parse_or_expand(sp.file_id).unwrap();
sp.map(|ptr| ptr.to_node(&root).syntax().clone())
}
2020-03-06 07:44:44 -06:00
Err(SyntheticSyntax) => continue,
};
2020-04-23 14:23:36 -05:00
types.push((node.clone(), ty));
if let Some(mismatch) = inference_result.type_mismatch_for_expr(expr) {
2020-04-23 14:23:36 -05:00
mismatches.push((node, mismatch));
}
}
// sort ranges for consistency
2020-04-23 14:23:36 -05:00
types.sort_by_key(|(node, _)| {
let range = node.value.text_range();
(range.start(), range.end())
2019-11-20 00:40:36 -06:00
});
2020-04-23 14:23:36 -05:00
for (node, ty) in &types {
let (range, text) = if let Some(self_param) = ast::SelfParam::cast(node.value.clone()) {
2020-04-09 16:35:05 -05:00
(self_param.self_token().unwrap().text_range(), "self".to_string())
2019-03-30 05:25:53 -05:00
} else {
2020-04-23 14:23:36 -05:00
(node.value.text_range(), node.value.text().to_string().replace("\n", " "))
2019-03-30 05:25:53 -05:00
};
2020-04-23 14:23:36 -05:00
let macro_prefix = if node.file_id != file_id.into() { "!" } else { "" };
2020-03-28 05:20:34 -05:00
format_to!(
buf,
"{}{} '{}': {}\n",
macro_prefix,
range,
ellipsize(text, 15),
ty.display(&db)
2020-03-28 05:20:34 -05:00
);
2018-12-20 14:56:28 -06:00
}
if include_mismatches {
2020-04-23 14:23:36 -05:00
mismatches.sort_by_key(|(node, _)| {
let range = node.value.text_range();
(range.start(), range.end())
});
for (src_ptr, mismatch) in &mismatches {
2020-04-23 14:23:36 -05:00
let range = src_ptr.value.text_range();
let macro_prefix = if src_ptr.file_id != file_id.into() { "!" } else { "" };
2020-03-28 05:20:34 -05:00
format_to!(
buf,
"{}{}: expected {}, got {}\n",
macro_prefix,
range,
mismatch.expected.display(&db),
mismatch.actual.display(&db),
2020-03-28 05:20:34 -05:00
);
}
}
};
2019-11-27 08:46:02 -06:00
let module = db.module_for_file(file_id);
let crate_def_map = db.crate_def_map(module.krate);
let mut defs: Vec<DefWithBodyId> = Vec::new();
2019-11-27 12:31:51 -06:00
visit_module(&db, &crate_def_map, module.local_id, &mut |it| defs.push(it));
2019-11-27 08:46:02 -06:00
defs.sort_by_key(|def| match def {
DefWithBodyId::FunctionId(it) => {
it.lookup(&db).ast_id.to_node(&db).syntax().text_range().start()
}
DefWithBodyId::ConstId(it) => {
it.lookup(&db).ast_id.to_node(&db).syntax().text_range().start()
}
DefWithBodyId::StaticId(it) => {
it.lookup(&db).ast_id.to_node(&db).syntax().text_range().start()
2019-04-12 16:56:57 -05:00
}
2019-11-27 08:46:02 -06:00
});
for def in defs {
let (_body, source_map) = db.body_with_source_map(def);
let infer = db.infer(def);
infer_def(infer, source_map);
}
2020-03-28 05:20:34 -05:00
buf.truncate(buf.trim_end().len());
buf
}
2019-11-27 08:46:02 -06:00
fn visit_module(
db: &TestDB,
crate_def_map: &CrateDefMap,
module_id: LocalModuleId,
cb: &mut dyn FnMut(DefWithBodyId),
) {
visit_scope(db, crate_def_map, &crate_def_map[module_id].scope, cb);
2019-12-20 08:58:20 -06:00
for impl_id in crate_def_map[module_id].scope.impls() {
2019-11-27 08:46:02 -06:00
let impl_data = db.impl_data(impl_id);
for &item in impl_data.items.iter() {
match item {
AssocItemId::FunctionId(it) => {
let def = it.into();
cb(def);
let body = db.body(def);
visit_scope(db, crate_def_map, &body.item_scope, cb);
}
AssocItemId::ConstId(it) => {
let def = it.into();
cb(def);
let body = db.body(def);
visit_scope(db, crate_def_map, &body.item_scope, cb);
}
2019-11-27 08:46:02 -06:00
AssocItemId::TypeAliasId(_) => (),
}
}
}
fn visit_scope(
db: &TestDB,
crate_def_map: &CrateDefMap,
scope: &ItemScope,
cb: &mut dyn FnMut(DefWithBodyId),
) {
for decl in scope.declarations() {
match decl {
ModuleDefId::FunctionId(it) => {
let def = it.into();
cb(def);
let body = db.body(def);
visit_scope(db, crate_def_map, &body.item_scope, cb);
}
ModuleDefId::ConstId(it) => {
let def = it.into();
cb(def);
let body = db.body(def);
visit_scope(db, crate_def_map, &body.item_scope, cb);
}
ModuleDefId::StaticId(it) => {
let def = it.into();
cb(def);
let body = db.body(def);
visit_scope(db, crate_def_map, &body.item_scope, cb);
}
ModuleDefId::TraitId(it) => {
let trait_data = db.trait_data(it);
for &(_, item) in trait_data.items.iter() {
match item {
AssocItemId::FunctionId(it) => cb(it.into()),
AssocItemId::ConstId(it) => cb(it.into()),
AssocItemId::TypeAliasId(_) => (),
}
}
}
ModuleDefId::ModuleId(it) => visit_module(db, crate_def_map, it.local_id, cb),
_ => (),
}
}
}
2019-11-27 08:46:02 -06:00
}
fn ellipsize(mut text: String, max_len: usize) -> String {
if text.len() <= max_len {
return text;
}
let ellipsis = "...";
let e_len = ellipsis.len();
let mut prefix_len = (max_len - e_len) / 2;
while !text.is_char_boundary(prefix_len) {
prefix_len += 1;
}
let mut suffix_len = max_len - e_len - prefix_len;
while !text.is_char_boundary(text.len() - suffix_len) {
suffix_len += 1;
}
text.replace_range(prefix_len..text.len() - suffix_len, ellipsis);
text
2018-12-20 14:56:28 -06:00
}
#[test]
fn typing_whitespace_inside_a_function_should_not_invalidate_types() {
let (mut db, pos) = TestDB::with_position(
"
//- /lib.rs
fn foo() -> i32 {
<|>1 + 1
}
",
);
{
let events = db.log_executed(|| {
2019-11-27 08:46:02 -06:00
let module = db.module_for_file(pos.file_id);
let crate_def_map = db.crate_def_map(module.krate);
2019-11-27 12:31:51 -06:00
visit_module(&db, &crate_def_map, module.local_id, &mut |def| {
2019-11-27 08:46:02 -06:00
db.infer(def);
});
});
assert!(format!("{:?}", events).contains("infer"))
}
let new_text = "
fn foo() -> i32 {
1
+
1
}
"
.to_string();
2019-02-08 05:49:43 -06:00
db.query_mut(ra_db::FileTextQuery).set(pos.file_id, Arc::new(new_text));
{
let events = db.log_executed(|| {
2019-11-27 08:46:02 -06:00
let module = db.module_for_file(pos.file_id);
let crate_def_map = db.crate_def_map(module.krate);
2019-11-27 12:31:51 -06:00
visit_module(&db, &crate_def_map, module.local_id, &mut |def| {
2019-11-27 08:46:02 -06:00
db.infer(def);
});
});
assert!(!format!("{:?}", events).contains("infer"), "{:#?}", events)
}
}
2019-03-24 03:39:47 -05:00
#[test]
fn no_such_field_diagnostics() {
let diagnostics = TestDB::with_files(
2019-03-24 03:39:47 -05:00
r"
//- /lib.rs
struct S { foo: i32, bar: () }
impl S {
fn new() -> S {
S {
foo: 92,
baz: 62,
}
}
}
",
)
2020-03-24 06:40:58 -05:00
.diagnostics()
.0;
2019-03-24 03:39:47 -05:00
2019-08-29 08:49:10 -05:00
assert_snapshot!(diagnostics, @r###"
"baz: 62": no such field
"{\n foo: 92,\n baz: 62,\n }": Missing structure fields:
- bar
2019-08-29 08:49:10 -05:00
"###
2019-03-24 03:39:47 -05:00
);
}
#[test]
fn no_such_field_with_feature_flag_diagnostics() {
let diagnostics = TestDB::with_files(
r#"
//- /lib.rs crate:foo cfg:feature=foo
struct MyStruct {
my_val: usize,
#[cfg(feature = "foo")]
bar: bool,
}
impl MyStruct {
#[cfg(feature = "foo")]
pub(crate) fn new(my_val: usize, bar: bool) -> Self {
Self { my_val, bar }
}
#[cfg(not(feature = "foo"))]
pub(crate) fn new(my_val: usize, _bar: bool) -> Self {
Self { my_val }
}
}
"#,
)
.diagnostics()
.0;
assert_snapshot!(diagnostics, @r###""###);
}
#[test]
fn no_such_field_with_feature_flag_diagnostics_on_struct_lit() {
let diagnostics = TestDB::with_files(
r#"
//- /lib.rs crate:foo cfg:feature=foo
struct S {
#[cfg(feature = "foo")]
foo: u32,
#[cfg(not(feature = "foo"))]
bar: u32,
}
impl S {
#[cfg(feature = "foo")]
fn new(foo: u32) -> Self {
Self { foo }
}
#[cfg(not(feature = "foo"))]
fn new(bar: u32) -> Self {
Self { bar }
}
}
"#,
)
.diagnostics()
.0;
assert_snapshot!(diagnostics, @r###""###);
}
#[test]
fn no_such_field_with_feature_flag_diagnostics_on_struct_fields() {
let diagnostics = TestDB::with_files(
r#"
//- /lib.rs crate:foo cfg:feature=foo
struct S {
#[cfg(feature = "foo")]
foo: u32,
#[cfg(not(feature = "foo"))]
bar: u32,
}
impl S {
fn new(val: u32) -> Self {
Self {
#[cfg(feature = "foo")]
foo: val,
#[cfg(not(feature = "foo"))]
bar: val,
}
}
}
"#,
)
.diagnostics()
.0;
assert_snapshot!(diagnostics, @r###""###);
}
#[test]
fn missing_record_pat_field_diagnostic() {
let diagnostics = TestDB::with_files(
r"
//- /lib.rs
struct S { foo: i32, bar: () }
fn baz(s: S) {
let S { foo: _ } = s;
}
",
)
.diagnostics()
.0;
assert_snapshot!(diagnostics, @r###"
"{ foo: _ }": Missing structure fields:
- bar
"###
);
}
#[test]
fn missing_record_pat_field_no_diagnostic_if_not_exhaustive() {
let diagnostics = TestDB::with_files(
r"
//- /lib.rs
struct S { foo: i32, bar: () }
fn baz(s: S) -> i32 {
match s {
S { foo, .. } => foo,
}
}
",
)
.diagnostics()
.0;
assert_snapshot!(diagnostics, @"");
}