2019-11-15 15:56:51 -06:00
|
|
|
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;
|
2019-11-15 15:56:51 -06:00
|
|
|
|
2019-07-04 15:05:17 -05:00
|
|
|
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;
|
2019-11-04 04:25:42 -06:00
|
|
|
use ra_db::{fixture::WithFixture, salsa::Database, FilePosition, SourceDatabase};
|
2019-07-04 15:05:17 -05:00
|
|
|
use ra_syntax::{
|
|
|
|
algo,
|
2020-04-09 16:35:05 -05:00
|
|
|
ast::{self, AstNode},
|
2020-04-23 14:23:36 -05:00
|
|
|
SyntaxNode,
|
2019-07-04 15:05:17 -05:00
|
|
|
};
|
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
|
|
|
|
2018-12-24 08:36:54 -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.
|
2018-12-24 08:36:54 -06:00
|
|
|
|
2019-11-04 13:21:15 -06:00
|
|
|
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);
|
2019-12-05 16:34:12 -06:00
|
|
|
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")
|
2019-02-23 05:32:25 -06:00
|
|
|
}
|
|
|
|
|
2019-04-14 09:08:10 -05:00
|
|
|
fn type_at(content: &str) -> String {
|
2019-11-04 13:21:15 -06:00
|
|
|
let (db, file_pos) = TestDB::with_position(content);
|
2019-04-14 09:08:10 -05:00
|
|
|
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)
|
2019-12-05 16:02:31 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
|
2019-11-04 13:21:15 -06:00
|
|
|
let (db, file_id) = TestDB::with_single_file(content);
|
2019-04-18 13:35:47 -05:00
|
|
|
|
2020-03-28 05:20:34 -05:00
|
|
|
let mut buf = String::new();
|
2019-03-30 06:17:31 -05:00
|
|
|
|
|
|
|
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-03-30 06:17:31 -05:00
|
|
|
|
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(),
|
|
|
|
)
|
|
|
|
})
|
2019-09-03 03:04:38 -05:00
|
|
|
}
|
2020-03-06 07:44:44 -06:00
|
|
|
Err(SyntheticSyntax) => continue,
|
2019-01-06 09:47:59 -06:00
|
|
|
};
|
2019-01-06 16:01:33 -06:00
|
|
|
types.push((syntax_ptr, ty));
|
2019-01-06 09:47:59 -06:00
|
|
|
}
|
2019-03-30 06:17:31 -05:00
|
|
|
|
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,
|
2019-01-06 09:47:59 -06:00
|
|
|
};
|
2020-04-23 14:23:36 -05:00
|
|
|
types.push((node.clone(), ty));
|
2019-12-05 16:02:31 -06:00
|
|
|
if let Some(mismatch) = inference_result.type_mismatch_for_expr(expr) {
|
2020-04-23 14:23:36 -05:00
|
|
|
mismatches.push((node, mismatch));
|
2019-12-05 16:02:31 -06:00
|
|
|
}
|
2019-01-06 09:47:59 -06:00
|
|
|
}
|
2019-04-18 13:35:47 -05:00
|
|
|
|
2019-01-06 16:01:33 -06:00
|
|
|
// 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",
|
2019-09-03 03:04:38 -05:00
|
|
|
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
|
|
|
}
|
2019-12-05 16:02:31 -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())
|
2019-12-05 16:02:31 -06:00
|
|
|
});
|
|
|
|
for (src_ptr, mismatch) in &mismatches {
|
2020-04-23 14:23:36 -05:00
|
|
|
let range = src_ptr.value.text_range();
|
2019-12-05 16:02:31 -06:00
|
|
|
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",
|
2019-12-05 16:02:31 -06:00
|
|
|
macro_prefix,
|
|
|
|
range,
|
|
|
|
mismatch.expected.display(&db),
|
|
|
|
mismatch.actual.display(&db),
|
2020-03-28 05:20:34 -05:00
|
|
|
);
|
2019-12-05 16:02:31 -06:00
|
|
|
}
|
|
|
|
}
|
2019-03-30 06:17:31 -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);
|
2019-03-30 06:17:31 -05:00
|
|
|
}
|
|
|
|
|
2020-03-28 05:20:34 -05:00
|
|
|
buf.truncate(buf.trim_end().len());
|
|
|
|
buf
|
2018-12-23 05:05:54 -06:00
|
|
|
}
|
|
|
|
|
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),
|
|
|
|
) {
|
2019-12-29 07:46:24 -06:00
|
|
|
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 {
|
2019-12-29 07:46:24 -06:00
|
|
|
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(_) => (),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-12-29 07:46:24 -06:00
|
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2018-12-23 05:05:54 -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
|
|
|
}
|
|
|
|
|
2019-01-05 06:42:47 -06:00
|
|
|
#[test]
|
|
|
|
fn typing_whitespace_inside_a_function_should_not_invalidate_types() {
|
2019-11-04 13:21:15 -06:00
|
|
|
let (mut db, pos) = TestDB::with_position(
|
2019-01-05 06:42:47 -06:00
|
|
|
"
|
|
|
|
//- /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);
|
|
|
|
});
|
2019-01-05 06:42:47 -06:00
|
|
|
});
|
|
|
|
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));
|
2019-01-05 06:42:47 -06:00
|
|
|
|
|
|
|
{
|
|
|
|
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);
|
|
|
|
});
|
2019-01-05 06:42:47 -06:00
|
|
|
});
|
|
|
|
assert!(!format!("{:?}", events).contains("infer"), "{:#?}", events)
|
|
|
|
}
|
|
|
|
}
|
2019-03-24 03:39:47 -05:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn no_such_field_diagnostics() {
|
2019-11-04 13:21:15 -06:00
|
|
|
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
|
2019-11-24 10:36:30 -06:00
|
|
|
"{\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
|
|
|
);
|
|
|
|
}
|
2020-04-07 10:58:05 -05:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn no_such_field_with_feature_flag_diagnostics() {
|
|
|
|
let diagnostics = TestDB::with_files(
|
|
|
|
r#"
|
2020-04-08 11:12:15 -05:00
|
|
|
//- /lib.rs crate:foo cfg:feature=foo
|
2020-04-07 10:58:05 -05:00
|
|
|
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 }
|
|
|
|
}
|
2020-04-09 02:39:17 -05:00
|
|
|
|
2020-04-07 10:58:05 -05:00
|
|
|
#[cfg(not(feature = "foo"))]
|
|
|
|
pub(crate) fn new(my_val: usize, _bar: bool) -> Self {
|
|
|
|
Self { my_val }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
"#,
|
|
|
|
)
|
2020-04-08 11:12:15 -05:00
|
|
|
.diagnostics()
|
|
|
|
.0;
|
2020-04-07 10:58:05 -05:00
|
|
|
|
2020-04-08 11:12:15 -05:00
|
|
|
assert_snapshot!(diagnostics, @r###""###);
|
2020-04-07 10:58:05 -05:00
|
|
|
}
|
2020-04-09 11:32:02 -05:00
|
|
|
|
|
|
|
#[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 }
|
|
|
|
}
|
2020-04-09 11:37:34 -05:00
|
|
|
#[cfg(not(feature = "foo"))]
|
2020-04-09 11:32:02 -05:00
|
|
|
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###""###);
|
|
|
|
}
|
2020-04-08 22:23:51 -05:00
|
|
|
|
|
|
|
#[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, @"");
|
|
|
|
}
|