2019-11-27 14:46:02 +00:00
|
|
|
//! FIXME: write short doc here
|
2020-07-14 08:52:18 +00:00
|
|
|
mod expr;
|
2020-07-14 08:18:08 +00:00
|
|
|
mod match_check;
|
2020-07-14 08:52:18 +00:00
|
|
|
mod unsafe_check;
|
2019-11-27 14:46:02 +00:00
|
|
|
|
|
|
|
use std::any::Any;
|
|
|
|
|
2020-07-14 08:52:18 +00:00
|
|
|
use hir_def::DefWithBodyId;
|
|
|
|
use hir_expand::diagnostics::{AstDiagnostic, Diagnostic, DiagnosticSink};
|
2019-11-28 09:50:26 +00:00
|
|
|
use hir_expand::{db::AstDatabase, name::Name, HirFileId, InFile};
|
2020-07-14 08:28:55 +00:00
|
|
|
use ra_prof::profile;
|
2020-05-27 12:51:08 +00:00
|
|
|
use ra_syntax::{ast, AstNode, AstPtr, SyntaxNodePtr};
|
2020-03-28 10:20:34 +00:00
|
|
|
use stdx::format_to;
|
2019-11-27 14:46:02 +00:00
|
|
|
|
2020-07-14 08:28:55 +00:00
|
|
|
use crate::db::HirDatabase;
|
|
|
|
|
2020-07-14 08:52:18 +00:00
|
|
|
pub use crate::diagnostics::expr::{record_literal_missing_fields, record_pattern_missing_fields};
|
|
|
|
|
2020-07-14 08:28:55 +00:00
|
|
|
pub fn validate_body(db: &dyn HirDatabase, owner: DefWithBodyId, sink: &mut DiagnosticSink<'_>) {
|
|
|
|
let _p = profile("validate_body");
|
|
|
|
let infer = db.infer(owner);
|
|
|
|
infer.add_diagnostics(db, owner, sink);
|
|
|
|
let mut validator = expr::ExprValidator::new(owner, infer.clone(), sink);
|
|
|
|
validator.validate_body(db);
|
|
|
|
let mut validator = unsafe_check::UnsafeValidator::new(owner, infer, sink);
|
|
|
|
validator.validate_body(db);
|
|
|
|
}
|
|
|
|
|
2019-11-27 14:46:02 +00:00
|
|
|
#[derive(Debug)]
|
|
|
|
pub struct NoSuchField {
|
|
|
|
pub file: HirFileId,
|
|
|
|
pub field: AstPtr<ast::RecordField>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Diagnostic for NoSuchField {
|
|
|
|
fn message(&self) -> String {
|
|
|
|
"no such field".to_string()
|
|
|
|
}
|
|
|
|
|
2019-11-28 09:50:26 +00:00
|
|
|
fn source(&self) -> InFile<SyntaxNodePtr> {
|
2020-04-17 11:06:02 +00:00
|
|
|
InFile::new(self.file, self.field.clone().into())
|
2019-11-27 14:46:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn as_any(&self) -> &(dyn Any + Send + 'static) {
|
|
|
|
self
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-09 21:11:16 +00:00
|
|
|
impl AstDiagnostic for NoSuchField {
|
|
|
|
type AST = ast::RecordField;
|
|
|
|
|
2020-07-01 07:46:27 +00:00
|
|
|
fn ast(&self, db: &dyn AstDatabase) -> Self::AST {
|
2020-06-09 21:11:16 +00:00
|
|
|
let root = db.parse_or_expand(self.source().file_id).unwrap();
|
|
|
|
let node = self.source().value.to_node(&root);
|
|
|
|
ast::RecordField::cast(node).unwrap()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-27 14:46:02 +00:00
|
|
|
#[derive(Debug)]
|
|
|
|
pub struct MissingFields {
|
|
|
|
pub file: HirFileId,
|
|
|
|
pub field_list: AstPtr<ast::RecordFieldList>,
|
|
|
|
pub missed_fields: Vec<Name>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Diagnostic for MissingFields {
|
|
|
|
fn message(&self) -> String {
|
2020-03-28 10:20:34 +00:00
|
|
|
let mut buf = String::from("Missing structure fields:\n");
|
2019-11-27 14:46:02 +00:00
|
|
|
for field in &self.missed_fields {
|
2020-05-27 16:15:19 +00:00
|
|
|
format_to!(buf, "- {}\n", field);
|
2019-11-27 14:46:02 +00:00
|
|
|
}
|
2020-03-28 10:20:34 +00:00
|
|
|
buf
|
2019-11-27 14:46:02 +00:00
|
|
|
}
|
2019-11-28 09:50:26 +00:00
|
|
|
fn source(&self) -> InFile<SyntaxNodePtr> {
|
2020-04-10 22:27:00 +00:00
|
|
|
InFile { file_id: self.file, value: self.field_list.clone().into() }
|
2019-11-27 14:46:02 +00:00
|
|
|
}
|
|
|
|
fn as_any(&self) -> &(dyn Any + Send + 'static) {
|
|
|
|
self
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl AstDiagnostic for MissingFields {
|
|
|
|
type AST = ast::RecordFieldList;
|
|
|
|
|
2020-07-01 07:46:27 +00:00
|
|
|
fn ast(&self, db: &dyn AstDatabase) -> Self::AST {
|
2019-11-27 14:46:02 +00:00
|
|
|
let root = db.parse_or_expand(self.source().file_id).unwrap();
|
|
|
|
let node = self.source().value.to_node(&root);
|
|
|
|
ast::RecordFieldList::cast(node).unwrap()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-09 03:23:51 +00:00
|
|
|
#[derive(Debug)]
|
|
|
|
pub struct MissingPatFields {
|
|
|
|
pub file: HirFileId,
|
|
|
|
pub field_list: AstPtr<ast::RecordFieldPatList>,
|
|
|
|
pub missed_fields: Vec<Name>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Diagnostic for MissingPatFields {
|
|
|
|
fn message(&self) -> String {
|
|
|
|
let mut buf = String::from("Missing structure fields:\n");
|
|
|
|
for field in &self.missed_fields {
|
2020-05-27 16:15:19 +00:00
|
|
|
format_to!(buf, "- {}\n", field);
|
2020-04-09 03:23:51 +00:00
|
|
|
}
|
|
|
|
buf
|
|
|
|
}
|
|
|
|
fn source(&self) -> InFile<SyntaxNodePtr> {
|
2020-04-10 22:27:00 +00:00
|
|
|
InFile { file_id: self.file, value: self.field_list.clone().into() }
|
2020-04-09 03:23:51 +00:00
|
|
|
}
|
|
|
|
fn as_any(&self) -> &(dyn Any + Send + 'static) {
|
|
|
|
self
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-24 11:40:58 +00:00
|
|
|
#[derive(Debug)]
|
|
|
|
pub struct MissingMatchArms {
|
|
|
|
pub file: HirFileId,
|
2020-04-06 13:55:25 +00:00
|
|
|
pub match_expr: AstPtr<ast::Expr>,
|
2020-03-24 11:40:58 +00:00
|
|
|
pub arms: AstPtr<ast::MatchArmList>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Diagnostic for MissingMatchArms {
|
|
|
|
fn message(&self) -> String {
|
|
|
|
String::from("Missing match arm")
|
|
|
|
}
|
|
|
|
fn source(&self) -> InFile<SyntaxNodePtr> {
|
2020-04-10 22:27:00 +00:00
|
|
|
InFile { file_id: self.file, value: self.match_expr.clone().into() }
|
2020-03-24 11:40:58 +00:00
|
|
|
}
|
|
|
|
fn as_any(&self) -> &(dyn Any + Send + 'static) {
|
|
|
|
self
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-27 14:46:02 +00:00
|
|
|
#[derive(Debug)]
|
|
|
|
pub struct MissingOkInTailExpr {
|
|
|
|
pub file: HirFileId,
|
|
|
|
pub expr: AstPtr<ast::Expr>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Diagnostic for MissingOkInTailExpr {
|
|
|
|
fn message(&self) -> String {
|
|
|
|
"wrap return expression in Ok".to_string()
|
|
|
|
}
|
2019-11-28 09:50:26 +00:00
|
|
|
fn source(&self) -> InFile<SyntaxNodePtr> {
|
2020-04-10 22:27:00 +00:00
|
|
|
InFile { file_id: self.file, value: self.expr.clone().into() }
|
2019-11-27 14:46:02 +00:00
|
|
|
}
|
|
|
|
fn as_any(&self) -> &(dyn Any + Send + 'static) {
|
|
|
|
self
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl AstDiagnostic for MissingOkInTailExpr {
|
|
|
|
type AST = ast::Expr;
|
|
|
|
|
2020-07-01 07:46:27 +00:00
|
|
|
fn ast(&self, db: &dyn AstDatabase) -> Self::AST {
|
2019-11-27 14:46:02 +00:00
|
|
|
let root = db.parse_or_expand(self.file).unwrap();
|
|
|
|
let node = self.source().value.to_node(&root);
|
|
|
|
ast::Expr::cast(node).unwrap()
|
|
|
|
}
|
|
|
|
}
|
2020-05-08 17:48:03 +00:00
|
|
|
|
|
|
|
#[derive(Debug)]
|
|
|
|
pub struct BreakOutsideOfLoop {
|
|
|
|
pub file: HirFileId,
|
|
|
|
pub expr: AstPtr<ast::Expr>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Diagnostic for BreakOutsideOfLoop {
|
|
|
|
fn message(&self) -> String {
|
|
|
|
"break outside of loop".to_string()
|
|
|
|
}
|
|
|
|
fn source(&self) -> InFile<SyntaxNodePtr> {
|
|
|
|
InFile { file_id: self.file, value: self.expr.clone().into() }
|
|
|
|
}
|
|
|
|
fn as_any(&self) -> &(dyn Any + Send + 'static) {
|
|
|
|
self
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl AstDiagnostic for BreakOutsideOfLoop {
|
|
|
|
type AST = ast::Expr;
|
|
|
|
|
2020-07-01 07:46:27 +00:00
|
|
|
fn ast(&self, db: &dyn AstDatabase) -> Self::AST {
|
2020-05-08 17:48:03 +00:00
|
|
|
let root = db.parse_or_expand(self.file).unwrap();
|
|
|
|
let node = self.source().value.to_node(&root);
|
|
|
|
ast::Expr::cast(node).unwrap()
|
|
|
|
}
|
|
|
|
}
|
2020-05-23 21:49:53 +00:00
|
|
|
|
|
|
|
#[derive(Debug)]
|
|
|
|
pub struct MissingUnsafe {
|
|
|
|
pub file: HirFileId,
|
2020-05-27 12:51:08 +00:00
|
|
|
pub expr: AstPtr<ast::Expr>,
|
2020-05-23 21:49:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Diagnostic for MissingUnsafe {
|
|
|
|
fn message(&self) -> String {
|
2020-05-27 12:51:08 +00:00
|
|
|
format!("This operation is unsafe and requires an unsafe function or block")
|
2020-05-23 21:49:53 +00:00
|
|
|
}
|
|
|
|
fn source(&self) -> InFile<SyntaxNodePtr> {
|
2020-05-27 12:51:08 +00:00
|
|
|
InFile { file_id: self.file, value: self.expr.clone().into() }
|
2020-05-23 21:49:53 +00:00
|
|
|
}
|
|
|
|
fn as_any(&self) -> &(dyn Any + Send + 'static) {
|
|
|
|
self
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl AstDiagnostic for MissingUnsafe {
|
2020-05-27 12:51:08 +00:00
|
|
|
type AST = ast::Expr;
|
2020-05-23 21:49:53 +00:00
|
|
|
|
2020-07-01 07:46:27 +00:00
|
|
|
fn ast(&self, db: &dyn AstDatabase) -> Self::AST {
|
2020-05-23 21:49:53 +00:00
|
|
|
let root = db.parse_or_expand(self.source().file_id).unwrap();
|
|
|
|
let node = self.source().value.to_node(&root);
|
2020-05-27 12:51:08 +00:00
|
|
|
ast::Expr::cast(node).unwrap()
|
2020-05-23 21:49:53 +00:00
|
|
|
}
|
|
|
|
}
|
2020-07-08 17:58:45 +00:00
|
|
|
|
|
|
|
#[derive(Debug)]
|
|
|
|
pub struct MismatchedArgCount {
|
|
|
|
pub file: HirFileId,
|
|
|
|
pub call_expr: AstPtr<ast::Expr>,
|
|
|
|
pub expected: usize,
|
|
|
|
pub found: usize,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Diagnostic for MismatchedArgCount {
|
|
|
|
fn message(&self) -> String {
|
2020-07-09 13:50:53 +00:00
|
|
|
let s = if self.expected == 1 { "" } else { "s" };
|
|
|
|
format!("Expected {} argument{}, found {}", self.expected, s, self.found)
|
2020-07-08 17:58:45 +00:00
|
|
|
}
|
|
|
|
fn source(&self) -> InFile<SyntaxNodePtr> {
|
|
|
|
InFile { file_id: self.file, value: self.call_expr.clone().into() }
|
|
|
|
}
|
|
|
|
fn as_any(&self) -> &(dyn Any + Send + 'static) {
|
|
|
|
self
|
|
|
|
}
|
2020-07-24 15:38:33 +00:00
|
|
|
fn is_experimental(&self) -> bool {
|
|
|
|
true
|
|
|
|
}
|
2020-07-08 17:58:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl AstDiagnostic for MismatchedArgCount {
|
|
|
|
type AST = ast::CallExpr;
|
|
|
|
fn ast(&self, db: &dyn AstDatabase) -> Self::AST {
|
|
|
|
let root = db.parse_or_expand(self.source().file_id).unwrap();
|
|
|
|
let node = self.source().value.to_node(&root);
|
|
|
|
ast::CallExpr::cast(node).unwrap()
|
|
|
|
}
|
|
|
|
}
|
2020-07-14 10:05:50 +00:00
|
|
|
|
|
|
|
#[cfg(test)]
|
2020-07-14 14:43:39 +00:00
|
|
|
mod tests {
|
|
|
|
use hir_def::{db::DefDatabase, AssocItemId, ModuleDefId};
|
2020-07-24 14:30:12 +00:00
|
|
|
use hir_expand::diagnostics::{Diagnostic, DiagnosticSinkBuilder};
|
2020-07-14 14:43:39 +00:00
|
|
|
use ra_db::{fixture::WithFixture, FileId, SourceDatabase, SourceDatabaseExt};
|
|
|
|
use ra_syntax::{TextRange, TextSize};
|
2020-07-14 10:05:50 +00:00
|
|
|
use rustc_hash::FxHashMap;
|
|
|
|
|
2020-07-14 14:43:39 +00:00
|
|
|
use crate::{diagnostics::validate_body, test_db::TestDB};
|
|
|
|
|
|
|
|
impl TestDB {
|
|
|
|
fn diagnostics<F: FnMut(&dyn Diagnostic)>(&self, mut cb: F) {
|
|
|
|
let crate_graph = self.crate_graph();
|
|
|
|
for krate in crate_graph.iter() {
|
|
|
|
let crate_def_map = self.crate_def_map(krate);
|
|
|
|
|
|
|
|
let mut fns = Vec::new();
|
|
|
|
for (module_id, _) in crate_def_map.modules.iter() {
|
|
|
|
for decl in crate_def_map[module_id].scope.declarations() {
|
|
|
|
if let ModuleDefId::FunctionId(f) = decl {
|
|
|
|
fns.push(f)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for impl_id in crate_def_map[module_id].scope.impls() {
|
|
|
|
let impl_data = self.impl_data(impl_id);
|
|
|
|
for item in impl_data.items.iter() {
|
|
|
|
if let AssocItemId::FunctionId(f) = item {
|
|
|
|
fns.push(*f)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for f in fns {
|
2020-07-24 14:30:12 +00:00
|
|
|
let mut sink = DiagnosticSinkBuilder::new().build(&mut cb);
|
2020-07-14 14:43:39 +00:00
|
|
|
validate_body(self, f.into(), &mut sink);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn check_diagnostics(ra_fixture: &str) {
|
|
|
|
let db = TestDB::with_files(ra_fixture);
|
|
|
|
let annotations = db.extract_annotations();
|
|
|
|
|
|
|
|
let mut actual: FxHashMap<FileId, Vec<(TextRange, String)>> = FxHashMap::default();
|
|
|
|
db.diagnostics(|d| {
|
|
|
|
// FXIME: macros...
|
|
|
|
let file_id = d.source().file_id.original_file(&db);
|
|
|
|
let range = d.syntax_node(&db).text_range();
|
|
|
|
let message = d.message().to_owned();
|
|
|
|
actual.entry(file_id).or_default().push((range, message));
|
|
|
|
});
|
|
|
|
|
|
|
|
for (file_id, diags) in actual.iter_mut() {
|
|
|
|
diags.sort_by_key(|it| it.0.start());
|
|
|
|
let text = db.file_text(*file_id);
|
|
|
|
// For multiline spans, place them on line start
|
|
|
|
for (range, content) in diags {
|
|
|
|
if text[*range].contains('\n') {
|
|
|
|
*range = TextRange::new(range.start(), range.start() + TextSize::from(1));
|
|
|
|
*content = format!("... {}", content);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
assert_eq!(annotations, actual);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn no_such_field_diagnostics() {
|
|
|
|
check_diagnostics(
|
|
|
|
r#"
|
|
|
|
struct S { foo: i32, bar: () }
|
|
|
|
impl S {
|
|
|
|
fn new() -> S {
|
|
|
|
S {
|
|
|
|
//^... Missing structure fields:
|
|
|
|
//| - bar
|
|
|
|
foo: 92,
|
|
|
|
baz: 62,
|
|
|
|
//^^^^^^^ no such field
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
"#,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
#[test]
|
|
|
|
fn no_such_field_with_feature_flag_diagnostics() {
|
|
|
|
check_diagnostics(
|
|
|
|
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 }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
"#,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn no_such_field_enum_with_feature_flag_diagnostics() {
|
|
|
|
check_diagnostics(
|
|
|
|
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 => {},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
"#,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn no_such_field_with_feature_flag_diagnostics_on_struct_lit() {
|
|
|
|
check_diagnostics(
|
|
|
|
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 }
|
|
|
|
}
|
|
|
|
fn new2(bar: u32) -> Self {
|
|
|
|
#[cfg(feature = "foo")]
|
|
|
|
{ Self { foo: bar } }
|
|
|
|
#[cfg(not(feature = "foo"))]
|
|
|
|
{ Self { bar } }
|
|
|
|
}
|
|
|
|
fn new2(val: u32) -> Self {
|
|
|
|
Self {
|
|
|
|
#[cfg(feature = "foo")]
|
|
|
|
foo: val,
|
|
|
|
#[cfg(not(feature = "foo"))]
|
|
|
|
bar: val,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
"#,
|
|
|
|
);
|
|
|
|
}
|
2020-07-14 10:05:50 +00:00
|
|
|
|
2020-07-14 14:43:39 +00:00
|
|
|
#[test]
|
|
|
|
fn no_such_field_with_type_macro() {
|
|
|
|
check_diagnostics(
|
|
|
|
r#"
|
|
|
|
macro_rules! Type { () => { u32 }; }
|
|
|
|
struct Foo { bar: Type![] }
|
2020-07-14 10:05:50 +00:00
|
|
|
|
2020-07-14 14:43:39 +00:00
|
|
|
impl Foo {
|
|
|
|
fn new() -> Self {
|
|
|
|
Foo { bar: 0 }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
"#,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn missing_record_pat_field_diagnostic() {
|
|
|
|
check_diagnostics(
|
|
|
|
r#"
|
|
|
|
struct S { foo: i32, bar: () }
|
|
|
|
fn baz(s: S) {
|
|
|
|
let S { foo: _ } = s;
|
|
|
|
//^^^^^^^^^^ Missing structure fields:
|
|
|
|
// | - bar
|
|
|
|
}
|
|
|
|
"#,
|
|
|
|
);
|
|
|
|
}
|
2020-07-14 10:05:50 +00:00
|
|
|
|
2020-07-14 14:43:39 +00:00
|
|
|
#[test]
|
|
|
|
fn missing_record_pat_field_no_diagnostic_if_not_exhaustive() {
|
|
|
|
check_diagnostics(
|
|
|
|
r"
|
|
|
|
struct S { foo: i32, bar: () }
|
|
|
|
fn baz(s: S) -> i32 {
|
|
|
|
match s {
|
|
|
|
S { foo, .. } => foo,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
",
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn break_outside_of_loop() {
|
|
|
|
check_diagnostics(
|
|
|
|
r#"
|
|
|
|
fn foo() { break; }
|
|
|
|
//^^^^^ break outside of loop
|
|
|
|
"#,
|
|
|
|
);
|
|
|
|
}
|
2020-07-14 10:05:50 +00:00
|
|
|
}
|