mod never_type; mod coercion; mod regression; mod simple; mod patterns; mod traits; mod method_resolution; mod macros; mod display_source_code; use std::sync::Arc; use hir_def::{ body::{BodySourceMap, SyntheticSyntax}, child_by_source::ChildBySource, db::DefDatabase, item_scope::ItemScope, keys, nameres::CrateDefMap, AssocItemId, DefWithBodyId, LocalModuleId, Lookup, ModuleDefId, }; use hir_expand::{db::AstDatabase, InFile}; use insta::assert_snapshot; use ra_db::{fixture::WithFixture, FileRange, SourceDatabase, SourceDatabaseExt}; use ra_syntax::{ algo, ast::{self, AstNode}, SyntaxNode, }; use stdx::format_to; use crate::{ db::HirDatabase, display::HirDisplay, infer::TypeMismatch, test_db::TestDB, InferenceResult, Ty, }; // These tests compare the inference results for all expressions in a file // against snapshots of the expected results using insta. Use cargo-insta to // update the snapshots. fn setup_tracing() -> tracing::subscriber::DefaultGuard { use tracing_subscriber::{layer::SubscriberExt, EnvFilter, Registry}; use tracing_tree::HierarchicalLayer; let filter = EnvFilter::from_env("CHALK_DEBUG"); let layer = HierarchicalLayer::default().with_indent_amount(2).with_writer(std::io::stderr); let subscriber = Registry::default().with(filter).with(layer); tracing::subscriber::set_default(subscriber) } fn check_types(ra_fixture: &str) { check_types_impl(ra_fixture, false) } fn check_types_source_code(ra_fixture: &str) { check_types_impl(ra_fixture, true) } fn check_types_impl(ra_fixture: &str, display_source: bool) { let _tracing = setup_tracing(); let db = TestDB::with_files(ra_fixture); let mut checked_one = false; for (file_id, annotations) in db.extract_annotations() { for (range, expected) in annotations { let ty = type_at_range(&db, FileRange { file_id, range }); let actual = if display_source { let module = db.module_for_file(file_id); ty.display_source_code(&db, module).unwrap() } else { ty.display(&db).to_string() }; assert_eq!(expected, actual); checked_one = true; } } assert!(checked_one, "no `//^` annotations found"); } fn type_at_range(db: &TestDB, pos: FileRange) -> Ty { let file = db.parse(pos.file_id).ok().unwrap(); let expr = algo::find_node_at_range::(file.syntax(), pos.range).unwrap(); let fn_def = expr.syntax().ancestors().find_map(ast::FnDef::cast).unwrap(); 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(); 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()); return infer[expr_id].clone(); } panic!("Can't find expression") } fn infer(ra_fixture: &str) -> String { infer_with_mismatches(ra_fixture, false) } fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String { let _tracing = setup_tracing(); let (db, file_id) = TestDB::with_single_file(content); let mut buf = String::new(); let mut infer_def = |inference_result: Arc, body_source_map: Arc| { let mut types: Vec<(InFile, &Ty)> = Vec::new(); let mut mismatches: Vec<(InFile, &TypeMismatch)> = Vec::new(); for (pat, ty) in inference_result.type_of_pat.iter() { let syntax_ptr = match body_source_map.pat_syntax(pat) { Ok(sp) => { 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(), ) }) } Err(SyntheticSyntax) => continue, }; types.push((syntax_ptr, ty)); } for (expr, ty) in inference_result.type_of_expr.iter() { 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()) } Err(SyntheticSyntax) => continue, }; types.push((node.clone(), ty)); if let Some(mismatch) = inference_result.type_mismatch_for_expr(expr) { mismatches.push((node, mismatch)); } } // sort ranges for consistency types.sort_by_key(|(node, _)| { let range = node.value.text_range(); (range.start(), range.end()) }); for (node, ty) in &types { let (range, text) = if let Some(self_param) = ast::SelfParam::cast(node.value.clone()) { (self_param.self_token().unwrap().text_range(), "self".to_string()) } else { (node.value.text_range(), node.value.text().to_string().replace("\n", " ")) }; let macro_prefix = if node.file_id != file_id.into() { "!" } else { "" }; format_to!( buf, "{}{:?} '{}': {}\n", macro_prefix, range, ellipsize(text, 15), ty.display(&db) ); } if include_mismatches { mismatches.sort_by_key(|(node, _)| { let range = node.value.text_range(); (range.start(), range.end()) }); for (src_ptr, mismatch) in &mismatches { let range = src_ptr.value.text_range(); let macro_prefix = if src_ptr.file_id != file_id.into() { "!" } else { "" }; format_to!( buf, "{}{:?}: expected {}, got {}\n", macro_prefix, range, mismatch.expected.display(&db), mismatch.actual.display(&db), ); } } }; let module = db.module_for_file(file_id); let crate_def_map = db.crate_def_map(module.krate); let mut defs: Vec = Vec::new(); visit_module(&db, &crate_def_map, module.local_id, &mut |it| defs.push(it)); defs.sort_by_key(|def| match def { DefWithBodyId::FunctionId(it) => { let loc = it.lookup(&db); let tree = db.item_tree(loc.id.file_id); tree.source(&db, loc.id).syntax().text_range().start() } DefWithBodyId::ConstId(it) => { let loc = it.lookup(&db); let tree = db.item_tree(loc.id.file_id); tree.source(&db, loc.id).syntax().text_range().start() } DefWithBodyId::StaticId(it) => { let loc = it.lookup(&db); let tree = db.item_tree(loc.id.file_id); tree.source(&db, loc.id).syntax().text_range().start() } }); for def in defs { let (_body, source_map) = db.body_with_source_map(def); let infer = db.infer(def); infer_def(infer, source_map); } buf.truncate(buf.trim_end().len()); buf } 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); for impl_id in crate_def_map[module_id].scope.impls() { 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); } 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), _ => (), } } } } 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 } #[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(|| { let module = db.module_for_file(pos.file_id); let crate_def_map = db.crate_def_map(module.krate); visit_module(&db, &crate_def_map, module.local_id, &mut |def| { db.infer(def); }); }); assert!(format!("{:?}", events).contains("infer")) } let new_text = " fn foo() -> i32 { 1 + 1 } " .to_string(); db.set_file_text(pos.file_id, Arc::new(new_text)); { let events = db.log_executed(|| { let module = db.module_for_file(pos.file_id); let crate_def_map = db.crate_def_map(module.krate); visit_module(&db, &crate_def_map, module.local_id, &mut |def| { db.infer(def); }); }); assert!(!format!("{:?}", events).contains("infer"), "{:#?}", events) } } #[test] fn no_such_field_diagnostics() { let diagnostics = TestDB::with_files( r" //- /lib.rs struct S { foo: i32, bar: () } impl S { fn new() -> S { S { foo: 92, baz: 62, } } } ", ) .diagnostics() .0; assert_snapshot!(diagnostics, @r###" "baz: 62": no such field "{\n foo: 92,\n baz: 62,\n }": Missing structure fields: - bar "### ); } #[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_enum_with_feature_flag_diagnostics() { let diagnostics = TestDB::with_files( r#" //- /lib.rs crate:foo cfg:feature=foo enum Foo { #[cfg(not(feature = "foo"))] Buz, #[cfg(feature = "foo")] Bar, Baz } fn test_fn(f: Foo) { match f { Foo::Bar => {}, Foo::Baz => {}, } } "#, ) .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_block_expr() { 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(bar: u32) -> Self { #[cfg(feature = "foo")] { Self { foo: bar } } #[cfg(not(feature = "foo"))] { 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 no_such_field_with_type_macro() { let diagnostics = TestDB::with_files( r" macro_rules! Type { () => { u32 }; } struct Foo { bar: Type![], } impl Foo { fn new() -> Self { Foo { bar: 0 } } } ", ) .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, @""); } #[test] fn missing_unsafe_diagnostic_with_raw_ptr() { let diagnostics = TestDB::with_files( r" //- /lib.rs fn missing_unsafe() { let x = &5 as *const usize; let y = *x; } ", ) .diagnostics() .0; assert_snapshot!(diagnostics, @r#""*x": This operation is unsafe and requires an unsafe function or block"#); } #[test] fn missing_unsafe_diagnostic_with_unsafe_call() { let diagnostics = TestDB::with_files( r" //- /lib.rs unsafe fn unsafe_fn() { let x = &5 as *const usize; let y = *x; } fn missing_unsafe() { unsafe_fn(); } ", ) .diagnostics() .0; assert_snapshot!(diagnostics, @r#""unsafe_fn()": This operation is unsafe and requires an unsafe function or block"#); } #[test] fn missing_unsafe_diagnostic_with_unsafe_method_call() { let diagnostics = TestDB::with_files( r" struct HasUnsafe; impl HasUnsafe { unsafe fn unsafe_fn(&self) { let x = &5 as *const usize; let y = *x; } } fn missing_unsafe() { HasUnsafe.unsafe_fn(); } ", ) .diagnostics() .0; assert_snapshot!(diagnostics, @r#""HasUnsafe.unsafe_fn()": This operation is unsafe and requires an unsafe function or block"#); } #[test] fn no_missing_unsafe_diagnostic_with_raw_ptr_in_unsafe_block() { let diagnostics = TestDB::with_files( r" fn nothing_to_see_move_along() { let x = &5 as *const usize; unsafe { let y = *x; } } ", ) .diagnostics() .0; assert_snapshot!(diagnostics, @""); } #[test] fn missing_unsafe_diagnostic_with_raw_ptr_outside_unsafe_block() { let diagnostics = TestDB::with_files( r" fn nothing_to_see_move_along() { let x = &5 as *const usize; unsafe { let y = *x; } let z = *x; } ", ) .diagnostics() .0; assert_snapshot!(diagnostics, @r#""*x": This operation is unsafe and requires an unsafe function or block"#); } #[test] fn no_missing_unsafe_diagnostic_with_unsafe_call_in_unsafe_block() { let diagnostics = TestDB::with_files( r" unsafe fn unsafe_fn() { let x = &5 as *const usize; let y = *x; } fn nothing_to_see_move_along() { unsafe { unsafe_fn(); } } ", ) .diagnostics() .0; assert_snapshot!(diagnostics, @""); } #[test] fn no_missing_unsafe_diagnostic_with_unsafe_method_call_in_unsafe_block() { let diagnostics = TestDB::with_files( r" struct HasUnsafe; impl HasUnsafe { unsafe fn unsafe_fn() { let x = &5 as *const usize; let y = *x; } } fn nothing_to_see_move_along() { unsafe { HasUnsafe.unsafe_fn(); } } ", ) .diagnostics() .0; assert_snapshot!(diagnostics, @""); } #[test] fn break_outside_of_loop() { let diagnostics = TestDB::with_files( r" //- /lib.rs fn foo() { break; } ", ) .diagnostics() .0; assert_snapshot!(diagnostics, @r###""break": break outside of loop "### ); }