14 files changed, 969 insertions, 1838 deletions

diff --git a/crates/ra_hir_ty/Cargo.toml b/crates/ra_hir_ty/Cargo.toml
index 90368220b..78f5e55bb 100644
--- a/crates/ra_hir_ty/Cargo.toml
+++ b/crates/ra_hir_ty/Cargo.toml
@@ -3,6 +3,7 @@ edition = "2018"
 name = "ra_hir_ty"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+license = "MIT OR Apache-2.0"
 
 [lib]
 doctest = false
diff --git a/crates/ra_hir_ty/src/diagnostics.rs b/crates/ra_hir_ty/src/diagnostics.rs
index 5b0dda634..d3ee9cf55 100644
--- a/crates/ra_hir_ty/src/diagnostics.rs
+++ b/crates/ra_hir_ty/src/diagnostics.rs
@@ -1,13 +1,30 @@
 //! FIXME: write short doc here
+mod expr;
+mod match_check;
+mod unsafe_check;
 
 use std::any::Any;
 
+use hir_def::DefWithBodyId;
+use hir_expand::diagnostics::{AstDiagnostic, Diagnostic, DiagnosticSink};
 use hir_expand::{db::AstDatabase, name::Name, HirFileId, InFile};
+use ra_prof::profile;
 use ra_syntax::{ast, AstNode, AstPtr, SyntaxNodePtr};
 use stdx::format_to;
 
-pub use hir_def::{diagnostics::UnresolvedModule, expr::MatchArm, path::Path};
-pub use hir_expand::diagnostics::{AstDiagnostic, Diagnostic, DiagnosticSink};
+use crate::db::HirDatabase;
+
+pub use crate::diagnostics::expr::{record_literal_missing_fields, record_pattern_missing_fields};
+
+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);
+}
 
 #[derive(Debug)]
 pub struct NoSuchField {
@@ -227,3 +244,235 @@ impl AstDiagnostic for MismatchedArgCount {
         ast::CallExpr::cast(node).unwrap()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use hir_def::{db::DefDatabase, AssocItemId, ModuleDefId};
+    use hir_expand::diagnostics::{Diagnostic, DiagnosticSink};
+    use ra_db::{fixture::WithFixture, FileId, SourceDatabase, SourceDatabaseExt};
+    use ra_syntax::{TextRange, TextSize};
+    use rustc_hash::FxHashMap;
+
+    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 {
+                    let mut sink = DiagnosticSink::new(&mut cb);
+                    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,
+        }
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn no_such_field_with_type_macro() {
+        check_diagnostics(
+            r#"
+macro_rules! Type { () => { u32 }; }
+struct Foo { bar: Type![] }
+
+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
+}
+"#,
+        );
+    }
+
+    #[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
+"#,
+        );
+    }
+}
diff --git a/crates/ra_hir_ty/src/expr.rs b/crates/ra_hir_ty/src/diagnostics/expr.rs
index d44562b22..557d01cdc 100644
--- a/crates/ra_hir_ty/src/expr.rs
+++ b/crates/ra_hir_ty/src/diagnostics/expr.rs
@@ -2,7 +2,7 @@
 
 use std::sync::Arc;
 
-use hir_def::{path::path, resolver::HasResolver, AdtId, FunctionId};
+use hir_def::{path::path, resolver::HasResolver, AdtId, DefWithBodyId};
 use hir_expand::diagnostics::DiagnosticSink;
 use ra_syntax::{ast, AstPtr};
 use rustc_hash::FxHashSet;
@@ -10,9 +10,9 @@ use rustc_hash::FxHashSet;
 use crate::{
     db::HirDatabase,
     diagnostics::{
+        match_check::{is_useful, MatchCheckCtx, Matrix, PatStack, Usefulness},
         MismatchedArgCount, MissingFields, MissingMatchArms, MissingOkInTailExpr, MissingPatFields,
     },
-    match_checking::{is_useful, MatchCheckCtx, Matrix, PatStack, Usefulness},
     utils::variant_data,
     ApplicationTy, InferenceResult, Ty, TypeCtor,
 };
@@ -30,23 +30,23 @@ pub use hir_def::{
     LocalFieldId, Lookup, VariantId,
 };
 
-pub struct ExprValidator<'a, 'b: 'a> {
-    func: FunctionId,
+pub(super) struct ExprValidator<'a, 'b: 'a> {
+    owner: DefWithBodyId,
     infer: Arc<InferenceResult>,
     sink: &'a mut DiagnosticSink<'b>,
 }
 
 impl<'a, 'b> ExprValidator<'a, 'b> {
-    pub fn new(
-        func: FunctionId,
+    pub(super) fn new(
+        owner: DefWithBodyId,
         infer: Arc<InferenceResult>,
         sink: &'a mut DiagnosticSink<'b>,
     ) -> ExprValidator<'a, 'b> {
-        ExprValidator { func, infer, sink }
+        ExprValidator { owner, infer, sink }
     }
 
-    pub fn validate_body(&mut self, db: &dyn HirDatabase) {
-        let body = db.body(self.func.into());
+    pub(super) fn validate_body(&mut self, db: &dyn HirDatabase) {
+        let body = db.body(self.owner.into());
 
         for (id, expr) in body.exprs.iter() {
             if let Some((variant_def, missed_fields, true)) =
@@ -96,7 +96,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
         missed_fields: Vec<LocalFieldId>,
     ) {
         // XXX: only look at source_map if we do have missing fields
-        let (_, source_map) = db.body_with_source_map(self.func.into());
+        let (_, source_map) = db.body_with_source_map(self.owner.into());
 
         if let Ok(source_ptr) = source_map.expr_syntax(id) {
             let root = source_ptr.file_syntax(db.upcast());
@@ -125,7 +125,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
         missed_fields: Vec<LocalFieldId>,
     ) {
         // XXX: only look at source_map if we do have missing fields
-        let (_, source_map) = db.body_with_source_map(self.func.into());
+        let (_, source_map) = db.body_with_source_map(self.owner.into());
 
         if let Ok(source_ptr) = source_map.pat_syntax(id) {
             if let Some(expr) = source_ptr.value.as_ref().left() {
@@ -175,13 +175,17 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
         };
 
         let sig = db.callable_item_signature(callee);
+        if sig.value.is_varargs {
+            return None;
+        }
+
         let params = sig.value.params();
 
         let mut param_count = params.len();
         let mut arg_count = args.len();
 
         if arg_count != param_count {
-            let (_, source_map) = db.body_with_source_map(self.func.into());
+            let (_, source_map) = db.body_with_source_map(self.owner.into());
             if let Ok(source_ptr) = source_map.expr_syntax(call_id) {
                 if is_method_call {
                     param_count -= 1;
@@ -208,7 +212,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
         infer: Arc<InferenceResult>,
     ) {
         let (body, source_map): (Arc<Body>, Arc<BodySourceMap>) =
-            db.body_with_source_map(self.func.into());
+            db.body_with_source_map(self.owner.into());
 
         let match_expr_ty = match infer.type_of_expr.get(match_expr) {
             Some(ty) => ty,
@@ -289,7 +293,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
 
         let core_result_path = path![core::result::Result];
 
-        let resolver = self.func.resolver(db.upcast());
+        let resolver = self.owner.resolver(db.upcast());
         let core_result_enum = match resolver.resolve_known_enum(db.upcast(), &core_result_path) {
             Some(it) => it,
             _ => return,
@@ -304,7 +308,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
         };
 
         if params.len() == 2 && params[0] == mismatch.actual {
-            let (_, source_map) = db.body_with_source_map(self.func.into());
+            let (_, source_map) = db.body_with_source_map(self.owner.into());
 
             if let Ok(source_ptr) = source_map.expr_syntax(id) {
                 self.sink
@@ -376,146 +380,166 @@ pub fn record_pattern_missing_fields(
 
 #[cfg(test)]
 mod tests {
-    use expect::{expect, Expect};
-    use ra_db::fixture::WithFixture;
-
-    use crate::{diagnostics::MismatchedArgCount, test_db::TestDB};
-
-    fn check_diagnostic(ra_fixture: &str, expect: Expect) {
-        let msg = TestDB::with_single_file(ra_fixture).0.diagnostic::<MismatchedArgCount>().0;
-        expect.assert_eq(&msg);
-    }
-
-    fn check_no_diagnostic(ra_fixture: &str) {
-        let (s, diagnostic_count) =
-            TestDB::with_single_file(ra_fixture).0.diagnostic::<MismatchedArgCount>();
-
-        assert_eq!(0, diagnostic_count, "expected no diagnostic, found one: {}", s);
-    }
+    use crate::diagnostics::tests::check_diagnostics;
 
     #[test]
     fn simple_free_fn_zero() {
-        check_diagnostic(
-            r"
-            fn zero() {}
-            fn f() { zero(1); }
-            ",
-            expect![["\"zero(1)\": Expected 0 arguments, found 1\n"]],
+        check_diagnostics(
+            r#"
+fn zero() {}
+fn f() { zero(1); }
+       //^^^^^^^ Expected 0 arguments, found 1
+"#,
         );
 
-        check_no_diagnostic(
-            r"
-            fn zero() {}
-            fn f() { zero(); }
-            ",
+        check_diagnostics(
+            r#"
+fn zero() {}
+fn f() { zero(); }
+"#,
         );
     }
 
     #[test]
     fn simple_free_fn_one() {
-        check_diagnostic(
-            r"
-            fn one(arg: u8) {}
-            fn f() { one(); }
-            ",
-            expect![["\"one()\": Expected 1 argument, found 0\n"]],
+        check_diagnostics(
+            r#"
+fn one(arg: u8) {}
+fn f() { one(); }
+       //^^^^^ Expected 1 argument, found 0
+"#,
         );
 
-        check_no_diagnostic(
-            r"
-            fn one(arg: u8) {}
-            fn f() { one(1); }
-            ",
+        check_diagnostics(
+            r#"
+fn one(arg: u8) {}
+fn f() { one(1); }
+"#,
         );
     }
 
     #[test]
     fn method_as_fn() {
-        check_diagnostic(
-            r"
-            struct S;
-            impl S {
-                fn method(&self) {}
-            }
-
-            fn f() {
-                S::method();
-            }
-            ",
-            expect![["\"S::method()\": Expected 1 argument, found 0\n"]],
+        check_diagnostics(
+            r#"
+struct S;
+impl S { fn method(&self) {} }
+
+fn f() {
+    S::method();
+} //^^^^^^^^^^^ Expected 1 argument, found 0
+"#,
         );
 
-        check_no_diagnostic(
-            r"
-            struct S;
-            impl S {
-                fn method(&self) {}
-            }
+        check_diagnostics(
+            r#"
+struct S;
+impl S { fn method(&self) {} }
 
-            fn f() {
-                S::method(&S);
-                S.method();
-            }
-            ",
+fn f() {
+    S::method(&S);
+    S.method();
+}
+"#,
         );
     }
 
     #[test]
     fn method_with_arg() {
-        check_diagnostic(
-            r"
-            struct S;
-            impl S {
-                fn method(&self, arg: u8) {}
-            }
+        check_diagnostics(
+            r#"
+struct S;
+impl S { fn method(&self, arg: u8) {} }
 
             fn f() {
                 S.method();
-            }
-            ",
-            expect![["\"S.method()\": Expected 1 argument, found 0\n"]],
+            } //^^^^^^^^^^ Expected 1 argument, found 0
+            "#,
         );
 
-        check_no_diagnostic(
-            r"
-            struct S;
-            impl S {
-                fn method(&self, arg: u8) {}
-            }
+        check_diagnostics(
+            r#"
+struct S;
+impl S { fn method(&self, arg: u8) {} }
 
-            fn f() {
-                S::method(&S, 0);
-                S.method(1);
-            }
-            ",
+fn f() {
+    S::method(&S, 0);
+    S.method(1);
+}
+"#,
         );
     }
 
     #[test]
     fn tuple_struct() {
-        check_diagnostic(
-            r"
-            struct Tup(u8, u16);
-            fn f() {
-                Tup(0);
-            }
-            ",
-            expect![["\"Tup(0)\": Expected 2 arguments, found 1\n"]],
+        check_diagnostics(
+            r#"
+struct Tup(u8, u16);
+fn f() {
+    Tup(0);
+} //^^^^^^ Expected 2 arguments, found 1
+"#,
         )
     }
 
     #[test]
     fn enum_variant() {
-        check_diagnostic(
-            r"
-            enum En {
-                Variant(u8, u16),
-            }
-            fn f() {
-                En::Variant(0);
-            }
-            ",
-            expect![["\"En::Variant(0)\": Expected 2 arguments, found 1\n"]],
+        check_diagnostics(
+            r#"
+enum En { Variant(u8, u16), }
+fn f() {
+    En::Variant(0);
+} //^^^^^^^^^^^^^^ Expected 2 arguments, found 1
+"#,
+        )
+    }
+
+    #[test]
+    fn enum_variant_type_macro() {
+        check_diagnostics(
+            r#"
+macro_rules! Type {
+    () => { u32 };
+}
+enum Foo {
+    Bar(Type![])
+}
+impl Foo {
+    fn new() {
+        Foo::Bar(0);
+        Foo::Bar(0, 1);
+      //^^^^^^^^^^^^^^ Expected 1 argument, found 2
+        Foo::Bar();
+      //^^^^^^^^^^ Expected 1 argument, found 0
+    }
+}
+        "#,
+        );
+    }
+
+    #[test]
+    fn varargs() {
+        check_diagnostics(
+            r#"
+extern "C" {
+    fn fixed(fixed: u8);
+    fn varargs(fixed: u8, ...);
+    fn varargs2(...);
+}
+
+fn f() {
+    unsafe {
+        fixed(0);
+        fixed(0, 1);
+      //^^^^^^^^^^^ Expected 1 argument, found 2
+        varargs(0);
+        varargs(0, 1);
+        varargs2();
+        varargs2(0);
+        varargs2(0, 1);
+    }
+}
+        "#,
         )
     }
 }
diff --git a/crates/ra_hir_ty/src/match_checking.rs b/crates/ra_hir_ty/src/diagnostics/match_check.rs
index 5495ce284..507edcb7d 100644
--- a/crates/ra_hir_ty/src/match_checking.rs
+++ b/crates/ra_hir_ty/src/diagnostics/match_check.rs
@@ -41,9 +41,9 @@
 //! ```ignore
 //! // x: (Option<bool>, Result<()>)
 //! match x {
-//!     (Some(true), _) => {}
-//!     (None, Err(())) => {}
-//!     (None, Err(_)) => {}
+//!     (Some(true), _) => (),
+//!     (None, Err(())) => (),
+//!     (None, Err(_)) => (),
 //! }
 //! ```
 //!
@@ -218,15 +218,16 @@
 //!   ```
 use std::sync::Arc;
 
-use smallvec::{smallvec, SmallVec};
-
-use crate::{
-    db::HirDatabase,
-    expr::{Body, Expr, Literal, Pat, PatId},
-    ApplicationTy, InferenceResult, Ty, TypeCtor,
+use hir_def::{
+    adt::VariantData,
+    body::Body,
+    expr::{Expr, Literal, Pat, PatId},
+    AdtId, EnumVariantId, VariantId,
 };
-use hir_def::{adt::VariantData, AdtId, EnumVariantId, VariantId};
 use ra_arena::Idx;
+use smallvec::{smallvec, SmallVec};
+
+use crate::{db::HirDatabase, ApplicationTy, InferenceResult, Ty, TypeCtor};
 
 #[derive(Debug, Clone, Copy)]
 /// Either a pattern from the source code being analyzed, represented as
@@ -271,7 +272,7 @@ impl From<&PatId> for PatIdOrWild {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq)]
-pub enum MatchCheckErr {
+pub(super) enum MatchCheckErr {
     NotImplemented,
     MalformedMatchArm,
     /// Used when type inference cannot resolve the type of
@@ -286,21 +287,21 @@ pub enum MatchCheckErr {
 ///
 /// The `std::result::Result` type is used here rather than a custom enum
 /// to allow the use of `?`.
-pub type MatchCheckResult<T> = Result<T, MatchCheckErr>;
+pub(super) type MatchCheckResult<T> = Result<T, MatchCheckErr>;
 
 #[derive(Debug)]
 /// A row in a Matrix.
 ///
 /// This type is modeled from the struct of the same name in `rustc`.
-pub(crate) struct PatStack(PatStackInner);
+pub(super) struct PatStack(PatStackInner);
 type PatStackInner = SmallVec<[PatIdOrWild; 2]>;
 
 impl PatStack {
-    pub(crate) fn from_pattern(pat_id: PatId) -> PatStack {
+    pub(super) fn from_pattern(pat_id: PatId) -> PatStack {
         Self(smallvec!(pat_id.into()))
     }
 
-    pub(crate) fn from_wild() -> PatStack {
+    pub(super) fn from_wild() -> PatStack {
         Self(smallvec!(PatIdOrWild::Wild))
     }
 
@@ -509,14 +510,14 @@ impl PatStack {
 /// A collection of PatStack.
 ///
 /// This type is modeled from the struct of the same name in `rustc`.
-pub(crate) struct Matrix(Vec<PatStack>);
+pub(super) struct Matrix(Vec<PatStack>);
 
 impl Matrix {
-    pub(crate) fn empty() -> Self {
+    pub(super) fn empty() -> Self {
         Self(vec![])
     }
 
-    pub(crate) fn push(&mut self, cx: &MatchCheckCtx, row: PatStack) {
+    pub(super) fn push(&mut self, cx: &MatchCheckCtx, row: PatStack) {
         if let Some(Pat::Or(pat_ids)) = row.get_head().map(|pat_id| pat_id.as_pat(cx)) {
             // Or patterns are expanded here
             for pat_id in pat_ids {
@@ -578,16 +579,16 @@ impl Matrix {
 /// not matched by an prior match arms.
 ///
 /// We may eventually need an `Unknown` variant here.
-pub enum Usefulness {
+pub(super) enum Usefulness {
     Useful,
     NotUseful,
 }
 
-pub struct MatchCheckCtx<'a> {
-    pub match_expr: Idx<Expr>,
-    pub body: Arc<Body>,
-    pub infer: Arc<InferenceResult>,
-    pub db: &'a dyn HirDatabase,
+pub(super) struct MatchCheckCtx<'a> {
+    pub(super) match_expr: Idx<Expr>,
+    pub(super) body: Arc<Body>,
+    pub(super) infer: Arc<InferenceResult>,
+    pub(super) db: &'a dyn HirDatabase,
 }
 
 /// Given a set of patterns `matrix`, and pattern to consider `v`, determines
@@ -598,7 +599,7 @@ pub struct MatchCheckCtx<'a> {
 /// expected that you have already type checked the match arms. All patterns in
 /// matrix should be the same type as v, as well as they should all be the same
 /// type as the match expression.
-pub(crate) fn is_useful(
+pub(super) fn is_useful(
     cx: &MatchCheckCtx,
     matrix: &Matrix,
     v: &PatStack,
@@ -836,685 +837,251 @@ fn enum_variant_matches(cx: &MatchCheckCtx, pat_id: PatId, enum_variant_id: Enum
 
 #[cfg(test)]
 mod tests {
-    pub(super) use insta::assert_snapshot;
-    pub(super) use ra_db::fixture::WithFixture;
-
-    pub(super) use crate::{diagnostics::MissingMatchArms, test_db::TestDB};
-
-    pub(super) fn check_diagnostic_message(ra_fixture: &str) -> String {
-        TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>().0
-    }
-
-    pub(super) fn check_diagnostic(ra_fixture: &str) {
-        let diagnostic_count =
-            TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>().1;
-
-        assert_eq!(1, diagnostic_count, "no diagnostic reported");
-    }
-
-    pub(super) fn check_no_diagnostic(ra_fixture: &str) {
-        let (s, diagnostic_count) =
-            TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>();
-
-        assert_eq!(0, diagnostic_count, "expected no diagnostic, found one: {}", s);
-    }
-
-    #[test]
-    fn empty_tuple_no_arms_diagnostic_message() {
-        assert_snapshot!(
-            check_diagnostic_message(r"
-                fn test_fn() {
-                    match () {
-                    }
-                }
-            "),
-            @"\"()\": Missing match arm\n"
-        );
-    }
-
-    #[test]
-    fn empty_tuple_no_arms() {
-        check_diagnostic(
-            r"
-            fn test_fn() {
-                match () {
-                }
-            }
-        ",
-        );
-    }
-
-    #[test]
-    fn empty_tuple_wild() {
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match () {
-                    _ => {}
-                }
-            }
-        ",
-        );
-    }
-
-    #[test]
-    fn empty_tuple_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match () {
-                    () => {}
-                }
-            }
-        ",
-        );
-    }
-
-    #[test]
-    fn tuple_of_empty_tuple_no_arms() {
-        check_diagnostic(
-            r"
-            fn test_fn() {
-                match (()) {
-                }
-            }
-        ",
-        );
-    }
-
-    #[test]
-    fn tuple_of_empty_tuple_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match (()) {
-                    (()) => {}
-                }
-            }
-        ",
-        );
-    }
+    use crate::diagnostics::tests::check_diagnostics;
 
     #[test]
-    fn tuple_of_two_empty_tuple_no_arms() {
-        check_diagnostic(
-            r"
-            fn test_fn() {
-                match ((), ()) {
-                }
-            }
-        ",
-        );
-    }
+    fn empty_tuple() {
+        check_diagnostics(
+            r#"
+fn main() {
+    match () { }
+        //^^ Missing match arm
+   match (()) { }
+       //^^^^ Missing match arm
 
-    #[test]
-    fn tuple_of_two_empty_tuple_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match ((), ()) {
-                    ((), ()) => {}
-                }
-            }
-        ",
-        );
-    }
-
-    #[test]
-    fn bool_no_arms() {
-        check_diagnostic(
-            r"
-            fn test_fn() {
-                match false {
-                }
-            }
-        ",
-        );
-    }
-
-    #[test]
-    fn bool_missing_arm() {
-        check_diagnostic(
-            r"
-            fn test_fn() {
-                match false {
-                    true => {}
-                }
-            }
-        ",
-        );
-    }
-
-    #[test]
-    fn bool_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match false {
-                    true => {}
-                    false => {}
-                }
-            }
-        ",
-        );
-    }
-
-    #[test]
-    fn tuple_of_bools_no_arms() {
-        check_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, true) {
-                }
-            }
-        ",
-        );
-    }
-
-    #[test]
-    fn tuple_of_bools_missing_arms() {
-        check_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, true) {
-                    (true, true) => {},
-                }
-            }
-        ",
-        );
-    }
-
-    #[test]
-    fn tuple_of_bools_missing_arm() {
-        check_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, true) {
-                    (false, true) => {},
-                    (false, false) => {},
-                    (true, false) => {},
-                }
-            }
-        ",
-        );
-    }
-
-    #[test]
-    fn tuple_of_bools_with_wilds() {
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, true) {
-                    (false, _) => {},
-                    (true, false) => {},
-                    (_, true) => {},
-                }
-            }
-        ",
+    match () { _ => (), }
+    match () { () => (), }
+    match (()) { (()) => (), }
+}
+"#,
         );
     }
 
     #[test]
-    fn tuple_of_bools_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, true) {
-                    (true, true) => {},
-                    (true, false) => {},
-                    (false, true) => {},
-                    (false, false) => {},
-                }
-            }
-        ",
-        );
-    }
+    fn tuple_of_two_empty_tuple() {
+        check_diagnostics(
+            r#"
+fn main() {
+    match ((), ()) { }
+        //^^^^^^^^ Missing match arm
 
-    #[test]
-    fn tuple_of_bools_binding_missing_arms() {
-        check_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, true) {
-                    (true, _x) => {},
-                }
-            }
-        ",
-        );
-    }
-
-    #[test]
-    fn tuple_of_bools_binding_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, true) {
-                    (true, _x) => {},
-                    (false, true) => {},
-                    (false, false) => {},
-                }
-            }
-        ",
+    match ((), ()) { ((), ()) => (), }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn boolean() {
+        check_diagnostics(
+            r#"
+fn test_main() {
+    match false { }
+        //^^^^^ Missing match arm
+    match false { true => (), }
+        //^^^^^ Missing match arm
+    match (false, true) {}
+        //^^^^^^^^^^^^^ Missing match arm
+    match (false, true) { (true, true) => (), }
+        //^^^^^^^^^^^^^ Missing match arm
+    match (false, true) {
+        //^^^^^^^^^^^^^ Missing match arm
+        (false, true) => (),
+        (false, false) => (),
+        (true, false) => (),
+    }
+    match (false, true) { (true, _x) => (), }
+        //^^^^^^^^^^^^^ Missing match arm
+
+    match false { true => (), false => (), }
+    match (false, true) {
+        (false, _) => (),
+        (true, false) => (),
+        (_, true) => (),
+    }
+    match (false, true) {
+        (true, true) => (),
+        (true, false) => (),
+        (false, true) => (),
+        (false, false) => (),
+    }
+    match (false, true) {
+        (true, _x) => (),
+        (false, true) => (),
+        (false, false) => (),
+    }
+    match (false, true, false) {
+        (false, ..) => (),
+        (true, ..) => (),
+    }
+    match (false, true, false) {
+        (.., false) => (),
+        (.., true) => (),
+    }
+    match (false, true, false) { (..) => (), }
+}
+"#,
         );
     }
 
     #[test]
-    fn tuple_of_bools_with_ellipsis_at_end_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, true, false) {
-                    (false, ..) => {},
-                    (true, ..) => {},
-                }
-            }
-        ",
-        );
-    }
+    fn tuple_of_tuple_and_bools() {
+        check_diagnostics(
+            r#"
+fn main() {
+    match (false, ((), false)) {}
+        //^^^^^^^^^^^^^^^^^^^^ Missing match arm
+    match (false, ((), false)) { (true, ((), true)) => (), }
+        //^^^^^^^^^^^^^^^^^^^^ Missing match arm
+    match (false, ((), false)) { (true, _) => (), }
+        //^^^^^^^^^^^^^^^^^^^^ Missing match arm
 
-    #[test]
-    fn tuple_of_bools_with_ellipsis_at_beginning_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, true, false) {
-                    (.., false) => {},
-                    (.., true) => {},
-                }
-            }
-        ",
-        );
+    match (false, ((), false)) {
+        (true, ((), true)) => (),
+        (true, ((), false)) => (),
+        (false, ((), true)) => (),
+        (false, ((), false)) => (),
     }
-
-    #[test]
-    fn tuple_of_bools_with_ellipsis_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, true, false) {
-                    (..) => {},
-                }
-            }
-        ",
-        );
+    match (false, ((), false)) {
+        (true, ((), true)) => (),
+        (true, ((), false)) => (),
+        (false, _) => (),
     }
-
-    #[test]
-    fn tuple_of_tuple_and_bools_no_arms() {
-        check_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, ((), false)) {
-                }
-            }
-        ",
+}
+"#,
         );
     }
 
     #[test]
-    fn tuple_of_tuple_and_bools_missing_arms() {
-        check_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, ((), false)) {
-                    (true, ((), true)) => {},
-                }
-            }
-        ",
-        );
-    }
+    fn enums() {
+        check_diagnostics(
+            r#"
+enum Either { A, B, }
 
-    #[test]
-    fn tuple_of_tuple_and_bools_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, ((), false)) {
-                    (true, ((), true)) => {},
-                    (true, ((), false)) => {},
-                    (false, ((), true)) => {},
-                    (false, ((), false)) => {},
-                }
-            }
-        ",
-        );
-    }
+fn main() {
+    match Either::A { }
+        //^^^^^^^^^ Missing match arm
+    match Either::B { Either::A => (), }
+        //^^^^^^^^^ Missing match arm
 
-    #[test]
-    fn tuple_of_tuple_and_bools_wildcard_missing_arms() {
-        check_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, ((), false)) {
-                    (true, _) => {},
-                }
-            }
-        ",
-        );
+    match &Either::B {
+        //^^^^^^^^^^ Missing match arm
+        Either::A => (),
     }
 
-    #[test]
-    fn tuple_of_tuple_and_bools_wildcard_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, ((), false)) {
-                    (true, ((), true)) => {},
-                    (true, ((), false)) => {},
-                    (false, _) => {},
-                }
-            }
-        ",
-        );
+    match Either::B {
+        Either::A => (), Either::B => (),
     }
-
-    #[test]
-    fn enum_no_arms() {
-        check_diagnostic(
-            r"
-            enum Either {
-                A,
-                B,
-            }
-            fn test_fn() {
-                match Either::A {
-                }
-            }
-        ",
-        );
+    match &Either::B {
+        Either::A => (), Either::B => (),
     }
-
-    #[test]
-    fn enum_missing_arms() {
-        check_diagnostic(
-            r"
-            enum Either {
-                A,
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::A => {},
-                }
-            }
-        ",
+}
+"#,
         );
     }
 
     #[test]
-    fn enum_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A,
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::A => {},
-                    Either::B => {},
-                }
-            }
-        ",
-        );
-    }
+    fn enum_containing_bool() {
+        check_diagnostics(
+            r#"
+enum Either { A(bool), B }
 
-    #[test]
-    fn enum_ref_missing_arms() {
-        check_diagnostic(
-            r"
-            enum Either {
-                A,
-                B,
-            }
-            fn test_fn() {
-                match &Either::B {
-                    Either::A => {},
-                }
-            }
-        ",
-        );
+fn main() {
+    match Either::B { }
+        //^^^^^^^^^ Missing match arm
+    match Either::B {
+        //^^^^^^^^^ Missing match arm
+        Either::A(true) => (), Either::B => ()
     }
 
-    #[test]
-    fn enum_ref_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A,
-                B,
-            }
-            fn test_fn() {
-                match &Either::B {
-                    Either::A => {},
-                    Either::B => {},
-                }
-            }
-        ",
-        );
+    match Either::B {
+        Either::A(true) => (),
+        Either::A(false) => (),
+        Either::B => (),
     }
-
-    #[test]
-    fn enum_containing_bool_no_arms() {
-        check_diagnostic(
-            r"
-            enum Either {
-                A(bool),
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                }
-            }
-        ",
-        );
+    match Either::B {
+        Either::B => (),
+        _ => (),
     }
-
-    #[test]
-    fn enum_containing_bool_missing_arms() {
-        check_diagnostic(
-            r"
-            enum Either {
-                A(bool),
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::A(true) => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
+    match Either::B {
+        Either::A(_) => (),
+        Either::B => (),
     }
 
-    #[test]
-    fn enum_containing_bool_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A(bool),
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::A(true) => (),
-                    Either::A(false) => (),
-                    Either::B => (),
-                }
-            }
-        ",
+}
+        "#,
         );
     }
 
     #[test]
-    fn enum_containing_bool_with_wild_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A(bool),
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::B => (),
-                    _ => (),
-                }
-            }
-        ",
-        );
-    }
+    fn enum_different_sizes() {
+        check_diagnostics(
+            r#"
+enum Either { A(bool), B(bool, bool) }
 
-    #[test]
-    fn enum_containing_bool_with_wild_2_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A(bool),
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::A(_) => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
+fn main() {
+    match Either::A(false) {
+        //^^^^^^^^^^^^^^^^ Missing match arm
+        Either::A(_) => (),
+        Either::B(false, _) => (),
     }
 
-    #[test]
-    fn enum_different_sizes_missing_arms() {
-        check_diagnostic(
-            r"
-            enum Either {
-                A(bool),
-                B(bool, bool),
-            }
-            fn test_fn() {
-                match Either::A(false) {
-                    Either::A(_) => (),
-                    Either::B(false, _) => (),
-                }
-            }
-        ",
-        );
+    match Either::A(false) {
+        Either::A(_) => (),
+        Either::B(true, _) => (),
+        Either::B(false, _) => (),
     }
-
-    #[test]
-    fn enum_different_sizes_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A(bool),
-                B(bool, bool),
-            }
-            fn test_fn() {
-                match Either::A(false) {
-                    Either::A(_) => (),
-                    Either::B(true, _) => (),
-                    Either::B(false, _) => (),
-                }
-            }
-        ",
-        );
+    match Either::A(false) {
+        Either::A(true) | Either::A(false) => (),
+        Either::B(true, _) => (),
+        Either::B(false, _) => (),
     }
-
-    #[test]
-    fn or_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A(bool),
-                B(bool, bool),
-            }
-            fn test_fn() {
-                match Either::A(false) {
-                    Either::A(true) | Either::A(false) => (),
-                    Either::B(true, _) => (),
-                    Either::B(false, _) => (),
-                }
-            }
-        ",
+}
+"#,
         );
     }
 
     #[test]
     fn tuple_of_enum_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A(bool),
-                B(bool, bool),
-            }
-            enum Either2 {
-                C,
-                D,
-            }
-            fn test_fn() {
-                match (Either::A(false), Either2::C) {
-                    (Either::A(true), _) | (Either::A(false), _) => (),
-                    (Either::B(true, _), Either2::C) => (),
-                    (Either::B(false, _), Either2::C) => (),
-                    (Either::B(_, _), Either2::D) => (),
-                }
-            }
-        ",
-        );
-    }
-
-    #[test]
-    fn mismatched_types() {
-        // Match statements with arms that don't match the
-        // expression pattern do not fire this diagnostic.
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A,
-                B,
-            }
-            enum Either2 {
-                C,
-                D,
-            }
-            fn test_fn() {
-                match Either::A {
-                    Either2::C => (),
-                    Either2::D => (),
-                }
-            }
-        ",
-        );
+        check_diagnostics(
+            r#"
+enum Either { A(bool), B(bool, bool) }
+enum Either2 { C, D }
+
+fn main() {
+    match (Either::A(false), Either2::C) {
+        (Either::A(true), _) | (Either::A(false), _) => (),
+        (Either::B(true, _), Either2::C) => (),
+        (Either::B(false, _), Either2::C) => (),
+        (Either::B(_, _), Either2::D) => (),
     }
-
-    #[test]
-    fn mismatched_types_with_different_arity() {
-        // Match statements with arms that don't match the
-        // expression pattern do not fire this diagnostic.
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match (true, false) {
-                    (true, false, true) => (),
-                    (true) => (),
-                }
-            }
-        ",
+}
+"#,
         );
     }
 
     #[test]
-    fn malformed_match_arm_tuple_missing_pattern() {
+    fn mismatched_types() {
         // Match statements with arms that don't match the
         // expression pattern do not fire this diagnostic.
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match (0) {
-                    () => (),
-                }
-            }
-        ",
+        check_diagnostics(
+            r#"
+enum Either { A, B }
+enum Either2 { C, D }
+
+fn main() {
+    match Either::A {
+        Either2::C => (),
+        Either2::D => (),
+    }
+    match (true, false) {
+        (true, false, true) => (),
+        (true) => (),
+    }
+    match (0) { () => () }
+    match Unresolved::Bar { Unresolved::Baz => () }
+}
+        "#,
         );
     }
 
@@ -1522,636 +1089,333 @@ mod tests {
     fn malformed_match_arm_tuple_enum_missing_pattern() {
         // We are testing to be sure we don't panic here when the match
         // arm `Either::B` is missing its pattern.
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A,
-                B(u32),
-            }
-            fn test_fn() {
-                match Either::A {
-                    Either::A => (),
-                    Either::B() => (),
-                }
-            }
-        ",
-        );
-    }
+        check_diagnostics(
+            r#"
+enum Either { A, B(u32) }
 
-    #[test]
-    fn enum_not_in_scope() {
-        // The enum is not in scope so we don't perform exhaustiveness
-        // checking, but we want to be sure we don't panic here (and
-        // we don't create a diagnostic).
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match Foo::Bar {
-                    Foo::Baz => (),
-                }
-            }
-        ",
+fn main() {
+    match Either::A {
+        Either::A => (),
+        Either::B() => (),
+    }
+}
+"#,
         );
     }
 
     #[test]
     fn expr_diverges() {
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A,
-                B,
-            }
-            fn test_fn() {
-                match loop {} {
-                    Either::A => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
-    }
+        check_diagnostics(
+            r#"
+enum Either { A, B }
 
-    #[test]
-    fn expr_loop_with_break() {
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A,
-                B,
-            }
-            fn test_fn() {
-                match loop { break Foo::A } {
-                    Either::A => (),
-                    Either::B => (),
-                }
-            }
-        ",
+fn main() {
+    match loop {} {
+        Either::A => (),
+        Either::B => (),
+    }
+    match loop {} {
+        Either::A => (),
+    }
+    match loop { break Foo::A } {
+        //^^^^^^^^^^^^^^^^^^^^^ Missing match arm
+        Either::A => (),
+    }
+    match loop { break Foo::A } {
+        Either::A => (),
+        Either::B => (),
+    }
+}
+"#,
         );
     }
 
     #[test]
     fn expr_partially_diverges() {
-        check_no_diagnostic(
-            r"
-            enum Either<T> {
-                A(T),
-                B,
-            }
-            fn foo() -> Either<!> {
-                Either::B
-            }
-            fn test_fn() -> u32 {
-                match foo() {
-                    Either::A(val) => val,
-                    Either::B => 0,
-                }
-            }
-        ",
-        );
-    }
+        check_diagnostics(
+            r#"
+enum Either<T> { A(T), B }
 
-    #[test]
-    fn enum_record_no_arms() {
-        check_diagnostic(
-            r"
-            enum Either {
-                A { foo: bool },
-                B,
-            }
-            fn test_fn() {
-                let a = Either::A { foo: true };
-                match a {
-                }
-            }
-        ",
-        );
+fn foo() -> Either<!> { Either::B }
+fn main() -> u32 {
+    match foo() {
+        Either::A(val) => val,
+        Either::B => 0,
     }
-
-    #[test]
-    fn enum_record_missing_arms() {
-        check_diagnostic(
-            r"
-            enum Either {
-                A { foo: bool },
-                B,
-            }
-            fn test_fn() {
-                let a = Either::A { foo: true };
-                match a {
-                    Either::A { foo: true } => (),
-                }
-            }
-        ",
+}
+"#,
         );
     }
 
     #[test]
-    fn enum_record_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A { foo: bool },
-                B,
-            }
-            fn test_fn() {
-                let a = Either::A { foo: true };
-                match a {
-                    Either::A { foo: true } => (),
-                    Either::A { foo: false } => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
-    }
+    fn enum_record() {
+        check_diagnostics(
+            r#"
+enum Either { A { foo: bool }, B }
 
-    #[test]
-    fn enum_record_missing_field_no_diagnostic() {
-        // When `Either::A` is missing a struct member, we don't want
-        // to fire the missing match arm diagnostic. This should fire
-        // some other diagnostic.
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A { foo: bool },
-                B,
-            }
-            fn test_fn() {
-                let a = Either::B;
-                match a {
-                    Either::A { } => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
+fn main() {
+    let a = Either::A { foo: true };
+    match a { }
+        //^ Missing match arm
+    match a { Either::A { foo: true } => () }
+        //^ Missing match arm
+    match a {
+        Either::A { } => (),
+                //^^^ Missing structure fields:
+                //  | - foo
+        Either::B => (),
     }
+    match a {
+        //^ Missing match arm
+        Either::A { } => (),
+    }           //^^^ Missing structure fields:
+                //  | - foo
 
-    #[test]
-    fn enum_record_missing_field_missing_match_arm() {
-        // Even though `Either::A` is missing fields, we still want to fire
-        // the missing arm diagnostic here, since we know `Either::B` is missing.
-        check_diagnostic(
-            r"
-            enum Either {
-                A { foo: bool },
-                B,
-            }
-            fn test_fn() {
-                let a = Either::B;
-                match a {
-                    Either::A { } => (),
-                }
-            }
-        ",
-        );
+    match a {
+        Either::A { foo: true } => (),
+        Either::A { foo: false } => (),
+        Either::B => (),
     }
-
-    #[test]
-    fn enum_record_no_diagnostic_wild() {
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A { foo: bool },
-                B,
-            }
-            fn test_fn() {
-                let a = Either::A { foo: true };
-                match a {
-                    Either::A { foo: _ } => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
+    match a {
+        Either::A { foo: _ } => (),
+        Either::B => (),
     }
-
-    #[test]
-    fn enum_record_fields_out_of_order_missing_arm() {
-        check_diagnostic(
-            r"
-            enum Either {
-                A { foo: bool, bar: () },
-                B,
-            }
-            fn test_fn() {
-                let a = Either::A { foo: true };
-                match a {
-                    Either::A { bar: (), foo: false } => (),
-                    Either::A { foo: true, bar: () } => (),
-                }
-            }
-        ",
+}
+"#,
         );
     }
 
     #[test]
-    fn enum_record_fields_out_of_order_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A { foo: bool, bar: () },
-                B,
-            }
-            fn test_fn() {
-                let a = Either::A { foo: true };
-                match a {
-                    Either::A { bar: (), foo: false } => (),
-                    Either::A { foo: true, bar: () } => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
-    }
+    fn enum_record_fields_out_of_order() {
+        check_diagnostics(
+            r#"
+enum Either {
+    A { foo: bool, bar: () },
+    B,
+}
 
-    #[test]
-    fn enum_record_ellipsis_missing_arm() {
-        check_diagnostic(
-            r"
-            enum Either {
-                A { foo: bool, bar: bool },
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::A { foo: true, .. } => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
+fn main() {
+    let a = Either::A { foo: true, bar: () };
+    match a {
+        //^ Missing match arm
+        Either::A { bar: (), foo: false } => (),
+        Either::A { foo: true, bar: () } => (),
     }
 
-    #[test]
-    fn enum_record_ellipsis_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A { foo: bool, bar: bool },
-                B,
-            }
-            fn test_fn() {
-                let a = Either::A { foo: true };
-                match a {
-                    Either::A { foo: true, .. } => (),
-                    Either::A { foo: false, .. } => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
+    match a {
+        Either::A { bar: (), foo: false } => (),
+        Either::A { foo: true, bar: () } => (),
+        Either::B => (),
     }
-
-    #[test]
-    fn enum_record_ellipsis_all_fields_missing_arm() {
-        check_diagnostic(
-            r"
-            enum Either {
-                A { foo: bool, bar: bool },
-                B,
-            }
-            fn test_fn() {
-                let a = Either::B;
-                match a {
-                    Either::A { .. } => (),
-                }
-            }
-        ",
+}
+"#,
         );
     }
 
     #[test]
-    fn enum_record_ellipsis_all_fields_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A { foo: bool, bar: bool },
-                B,
-            }
-            fn test_fn() {
-                let a = Either::B;
-                match a {
-                    Either::A { .. } => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
-    }
+    fn enum_record_ellipsis() {
+        check_diagnostics(
+            r#"
+enum Either {
+    A { foo: bool, bar: bool },
+    B,
+}
 
-    #[test]
-    fn enum_tuple_partial_ellipsis_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A(bool, bool, bool, bool),
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::A(true, .., true) => {},
-                    Either::A(true, .., false) => {},
-                    Either::A(false, .., true) => {},
-                    Either::A(false, .., false) => {},
-                    Either::B => {},
-                }
-            }
-        ",
-        );
+fn main() {
+    let a = Either::B;
+    match a {
+        //^ Missing match arm
+        Either::A { foo: true, .. } => (),
+        Either::B => (),
     }
-
-    #[test]
-    fn enum_tuple_partial_ellipsis_2_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A(bool, bool, bool, bool),
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::A(true, .., true) => {},
-                    Either::A(true, .., false) => {},
-                    Either::A(.., true) => {},
-                    Either::A(.., false) => {},
-                    Either::B => {},
-                }
-            }
-        ",
-        );
+    match a {
+        //^ Missing match arm
+        Either::A { .. } => (),
     }
 
-    #[test]
-    fn enum_tuple_partial_ellipsis_missing_arm() {
-        check_diagnostic(
-            r"
-            enum Either {
-                A(bool, bool, bool, bool),
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::A(true, .., true) => {},
-                    Either::A(true, .., false) => {},
-                    Either::A(false, .., false) => {},
-                    Either::B => {},
-                }
-            }
-        ",
-        );
+    match a {
+        Either::A { foo: true, .. } => (),
+        Either::A { foo: false, .. } => (),
+        Either::B => (),
     }
 
-    #[test]
-    fn enum_tuple_partial_ellipsis_2_missing_arm() {
-        check_diagnostic(
-            r"
-            enum Either {
-                A(bool, bool, bool, bool),
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::A(true, .., true) => {},
-                    Either::A(true, .., false) => {},
-                    Either::A(.., true) => {},
-                    Either::B => {},
-                }
-            }
-        ",
-        );
+    match a {
+        Either::A { .. } => (),
+        Either::B => (),
     }
-
-    #[test]
-    fn enum_tuple_ellipsis_no_diagnostic() {
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A(bool, bool, bool, bool),
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::A(..) => {},
-                    Either::B => {},
-                }
-            }
-        ",
+}
+"#,
         );
     }
 
     #[test]
-    fn enum_never() {
-        check_no_diagnostic(
-            r"
-            enum Never {}
+    fn enum_tuple_partial_ellipsis() {
+        check_diagnostics(
+            r#"
+enum Either {
+    A(bool, bool, bool, bool),
+    B,
+}
 
-            fn test_fn(never: Never) {
-                match never {}
-            }
-        ",
-        );
+fn main() {
+    match Either::B {
+        //^^^^^^^^^ Missing match arm
+        Either::A(true, .., true) => (),
+        Either::A(true, .., false) => (),
+        Either::A(false, .., false) => (),
+        Either::B => (),
+    }
+    match Either::B {
+        //^^^^^^^^^ Missing match arm
+        Either::A(true, .., true) => (),
+        Either::A(true, .., false) => (),
+        Either::A(.., true) => (),
+        Either::B => (),
+    }
+
+    match Either::B {
+        Either::A(true, .., true) => (),
+        Either::A(true, .., false) => (),
+        Either::A(false, .., true) => (),
+        Either::A(false, .., false) => (),
+        Either::B => (),
+    }
+    match Either::B {
+        Either::A(true, .., true) => (),
+        Either::A(true, .., false) => (),
+        Either::A(.., true) => (),
+        Either::A(.., false) => (),
+        Either::B => (),
     }
-
-    #[test]
-    fn type_never() {
-        check_no_diagnostic(
-            r"
-            fn test_fn(never: !) {
-                match never {}
-            }
-        ",
+}
+"#,
         );
     }
 
     #[test]
-    fn enum_never_ref() {
-        check_no_diagnostic(
-            r"
-            enum Never {}
+    fn never() {
+        check_diagnostics(
+            r#"
+enum Never {}
 
-            fn test_fn(never: &Never) {
-                match never {}
-            }
-        ",
-        );
-    }
-
-    #[test]
-    fn expr_diverges_missing_arm() {
-        check_no_diagnostic(
-            r"
-            enum Either {
-                A,
-                B,
-            }
-            fn test_fn() {
-                match loop {} {
-                    Either::A => (),
-                }
-            }
-        ",
+fn enum_(never: Never) {
+    match never {}
+}
+fn enum_ref(never: &Never) {
+    match never {}
+}
+fn bang(never: !) {
+    match never {}
+}
+"#,
         );
     }
 
     #[test]
     fn or_pattern_panic() {
-        check_no_diagnostic(
-            r"
-            pub enum Category {
-                Infinity,
-                Zero,
-            }
+        check_diagnostics(
+            r#"
+pub enum Category { Infinity, Zero }
 
-            fn panic(a: Category, b: Category) {
-                match (a, b) {
-                    (Category::Zero | Category::Infinity, _) => {}
-                    (_, Category::Zero | Category::Infinity) => {}
-                }
-            }
-        ",
-        );
+fn panic(a: Category, b: Category) {
+    match (a, b) {
+        (Category::Zero | Category::Infinity, _) => (),
+        (_, Category::Zero | Category::Infinity) => (),
     }
 
-    #[test]
-    fn or_pattern_panic_2() {
-        // FIXME: This is a false positive, but the code used to cause a panic in the match checker,
-        // so this acts as a regression test for that.
-        check_diagnostic(
-            r"
-            pub enum Category {
-                Infinity,
-                Zero,
-            }
-
-            fn panic(a: Category, b: Category) {
-                match (a, b) {
-                    (Category::Infinity, Category::Infinity) | (Category::Zero, Category::Zero) => {}
-
-                    (Category::Infinity | Category::Zero, _) => {}
-                }
-            }
-        ",
-        );
+    // FIXME: This is a false positive, but the code used to cause a panic in the match checker,
+    // so this acts as a regression test for that.
+    match (a, b) {
+        //^^^^^^ Missing match arm
+        (Category::Infinity, Category::Infinity) | (Category::Zero, Category::Zero) => (),
+        (Category::Infinity | Category::Zero, _) => (),
     }
 }
-
-#[cfg(test)]
-mod false_negatives {
-    //! The implementation of match checking here is a work in progress. As we roll this out, we
-    //! prefer false negatives to false positives (ideally there would be no false positives). This
-    //! test module should document known false negatives. Eventually we will have a complete
-    //! implementation of match checking and this module will be empty.
-    //!
-    //! The reasons for documenting known false negatives:
-    //!
-    //!   1. It acts as a backlog of work that can be done to improve the behavior of the system.
-    //!   2. It ensures the code doesn't panic when handling these cases.
-
-    use super::tests::*;
-
-    #[test]
-    fn integers() {
-        // This is a false negative.
-        // We don't currently check integer exhaustiveness.
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match 5 {
-                    10 => (),
-                    11..20 => (),
-                }
-            }
-        ",
-        );
-    }
-
-    #[test]
-    fn internal_or() {
-        // This is a false negative.
-        // We do not currently handle patterns with internal `or`s.
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                enum Either {
-                    A(bool),
-                    B,
-                }
-                match Either::B {
-                    Either::A(true | false) => (),
-                }
-            }
-        ",
-        );
+"#,
+        );
+    }
+
+    mod false_negatives {
+        //! The implementation of match checking here is a work in progress. As we roll this out, we
+        //! prefer false negatives to false positives (ideally there would be no false positives). This
+        //! test module should document known false negatives. Eventually we will have a complete
+        //! implementation of match checking and this module will be empty.
+        //!
+        //! The reasons for documenting known false negatives:
+        //!
+        //!   1. It acts as a backlog of work that can be done to improve the behavior of the system.
+        //!   2. It ensures the code doesn't panic when handling these cases.
+        use super::*;
+
+        #[test]
+        fn integers() {
+            // We don't currently check integer exhaustiveness.
+            check_diagnostics(
+                r#"
+fn main() {
+    match 5 {
+        10 => (),
+        11..20 => (),
     }
+}
+"#,
+            );
+        }
 
-    #[test]
-    fn expr_loop_missing_arm() {
-        // This is a false negative.
-        // We currently infer the type of `loop { break Foo::A }` to `!`, which
-        // causes us to skip the diagnostic since `Either::A` doesn't type check
-        // with `!`.
-        check_diagnostic(
-            r"
-            enum Either {
-                A,
-                B,
-            }
-            fn test_fn() {
-                match loop { break Foo::A } {
-                    Either::A => (),
-                }
-            }
-        ",
-        );
+        #[test]
+        fn internal_or() {
+            // We do not currently handle patterns with internal `or`s.
+            check_diagnostics(
+                r#"
+fn main() {
+    enum Either { A(bool), B }
+    match Either::B {
+        Either::A(true | false) => (),
     }
+}
+"#,
+            );
+        }
 
-    #[test]
-    fn tuple_of_bools_with_ellipsis_at_end_missing_arm() {
-        // This is a false negative.
-        // We don't currently handle tuple patterns with ellipsis.
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, true, false) {
-                    (false, ..) => {},
-                }
-            }
-        ",
-        );
+        #[test]
+        fn tuple_of_bools_with_ellipsis_at_end_missing_arm() {
+            // We don't currently handle tuple patterns with ellipsis.
+            check_diagnostics(
+                r#"
+fn main() {
+    match (false, true, false) {
+        (false, ..) => (),
     }
+}
+"#,
+            );
+        }
 
-    #[test]
-    fn tuple_of_bools_with_ellipsis_at_beginning_missing_arm() {
-        // This is a false negative.
-        // We don't currently handle tuple patterns with ellipsis.
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, true, false) {
-                    (.., false) => {},
-                }
-            }
-        ",
-        );
+        #[test]
+        fn tuple_of_bools_with_ellipsis_at_beginning_missing_arm() {
+            // We don't currently handle tuple patterns with ellipsis.
+            check_diagnostics(
+                r#"
+fn main() {
+    match (false, true, false) {
+        (.., false) => (),
     }
+}
+"#,
+            );
+        }
 
-    #[test]
-    fn struct_missing_arm() {
-        // This is a false negative.
-        // We don't currently handle structs.
-        check_no_diagnostic(
-            r"
-            struct Foo {
-                a: bool,
-            }
-            fn test_fn(f: Foo) {
-                match f {
-                    Foo { a: true } => {},
-                }
-            }
-        ",
-        );
+        #[test]
+        fn struct_missing_arm() {
+            // We don't currently handle structs.
+            check_diagnostics(
+                r#"
+struct Foo { a: bool }
+fn main(f: Foo) {
+    match f { Foo { a: true } => () }
+}
+"#,
+            );
+        }
     }
 }
diff --git a/crates/ra_hir_ty/src/unsafe_validation.rs b/crates/ra_hir_ty/src/diagnostics/unsafe_check.rs
index c512c4f8e..9e4ed9a8b 100644
--- a/crates/ra_hir_ty/src/unsafe_validation.rs
+++ b/crates/ra_hir_ty/src/diagnostics/unsafe_check.rs
@@ -6,7 +6,7 @@ use std::sync::Arc;
 use hir_def::{
     body::Body,
     expr::{Expr, ExprId, UnaryOp},
-    DefWithBodyId, FunctionId,
+    DefWithBodyId,
 };
 use hir_expand::diagnostics::DiagnosticSink;
 
@@ -15,26 +15,29 @@ use crate::{
     InferenceResult, Ty, TypeCtor,
 };
 
-pub struct UnsafeValidator<'a, 'b: 'a> {
-    func: FunctionId,
+pub(super) struct UnsafeValidator<'a, 'b: 'a> {
+    owner: DefWithBodyId,
     infer: Arc<InferenceResult>,
     sink: &'a mut DiagnosticSink<'b>,
 }
 
 impl<'a, 'b> UnsafeValidator<'a, 'b> {
-    pub fn new(
-        func: FunctionId,
+    pub(super) fn new(
+        owner: DefWithBodyId,
         infer: Arc<InferenceResult>,
         sink: &'a mut DiagnosticSink<'b>,
     ) -> UnsafeValidator<'a, 'b> {
-        UnsafeValidator { func, infer, sink }
+        UnsafeValidator { owner, infer, sink }
     }
 
-    pub fn validate_body(&mut self, db: &dyn HirDatabase) {
-        let def = self.func.into();
+    pub(super) fn validate_body(&mut self, db: &dyn HirDatabase) {
+        let def = self.owner.into();
         let unsafe_expressions = unsafe_expressions(db, self.infer.as_ref(), def);
-        let func_data = db.function_data(self.func);
-        if func_data.is_unsafe
+        let is_unsafe = match self.owner {
+            DefWithBodyId::FunctionId(it) => db.function_data(it).is_unsafe,
+            DefWithBodyId::StaticId(_) | DefWithBodyId::ConstId(_) => false,
+        };
+        if is_unsafe
             || unsafe_expressions
                 .iter()
                 .filter(|unsafe_expr| !unsafe_expr.inside_unsafe_block)
@@ -118,3 +121,53 @@ fn walk_unsafe(
         walk_unsafe(unsafe_exprs, db, infer, body, child, inside_unsafe_block);
     });
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::diagnostics::tests::check_diagnostics;
+
+    #[test]
+    fn missing_unsafe_diagnostic_with_raw_ptr() {
+        check_diagnostics(
+            r#"
+fn main() {
+    let x = &5 as *const usize;
+    unsafe { let y = *x; }
+    let z = *x;
+}         //^^ This operation is unsafe and requires an unsafe function or block
+"#,
+        )
+    }
+
+    #[test]
+    fn missing_unsafe_diagnostic_with_unsafe_call() {
+        check_diagnostics(
+            r#"
+struct HasUnsafe;
+
+impl HasUnsafe {
+    unsafe fn unsafe_fn(&self) {
+        let x = &5 as *const usize;
+        let y = *x;
+    }
+}
+
+unsafe fn unsafe_fn() {
+    let x = &5 as *const usize;
+    let y = *x;
+}
+
+fn main() {
+    unsafe_fn();
+  //^^^^^^^^^^^ This operation is unsafe and requires an unsafe function or block
+    HasUnsafe.unsafe_fn();
+  //^^^^^^^^^^^^^^^^^^^^^ This operation is unsafe and requires an unsafe function or block
+    unsafe {
+        unsafe_fn();
+        HasUnsafe.unsafe_fn();
+    }
+}
+"#,
+        );
+    }
+}
diff --git a/crates/ra_hir_ty/src/display.rs b/crates/ra_hir_ty/src/display.rs
index ac68c5661..c860c254c 100644
--- a/crates/ra_hir_ty/src/display.rs
+++ b/crates/ra_hir_ty/src/display.rs
@@ -243,10 +243,17 @@ impl HirDisplay for ApplicationTy {
                     write!(f, ")")?;
                 }
             }
-            TypeCtor::FnPtr { .. } => {
-                let sig = FnSig::from_fn_ptr_substs(&self.parameters);
+            TypeCtor::FnPtr { is_varargs, .. } => {
+                let sig = FnSig::from_fn_ptr_substs(&self.parameters, is_varargs);
                 write!(f, "fn(")?;
                 f.write_joined(sig.params(), ", ")?;
+                if is_varargs {
+                    if sig.params().is_empty() {
+                        write!(f, "...")?;
+                    } else {
+                        write!(f, ", ...")?;
+                    }
+                }
                 write!(f, ")")?;
                 let ret = sig.ret();
                 if *ret != Ty::unit() {
diff --git a/crates/ra_hir_ty/src/infer.rs b/crates/ra_hir_ty/src/infer.rs
index 2ce4f65cc..28f32a0a4 100644
--- a/crates/ra_hir_ty/src/infer.rs
+++ b/crates/ra_hir_ty/src/infer.rs
@@ -168,7 +168,7 @@ impl InferenceResult {
     pub fn add_diagnostics(
         &self,
         db: &dyn HirDatabase,
-        owner: FunctionId,
+        owner: DefWithBodyId,
         sink: &mut DiagnosticSink,
     ) {
         self.diagnostics.iter().for_each(|it| it.add_to(db, owner, sink))
@@ -760,7 +760,7 @@ impl std::ops::BitOrAssign for Diverges {
 }
 
 mod diagnostics {
-    use hir_def::{expr::ExprId, FunctionId};
+    use hir_def::{expr::ExprId, DefWithBodyId};
     use hir_expand::diagnostics::DiagnosticSink;
 
     use crate::{
@@ -778,17 +778,17 @@ mod diagnostics {
         pub(super) fn add_to(
             &self,
             db: &dyn HirDatabase,
-            owner: FunctionId,
+            owner: DefWithBodyId,
             sink: &mut DiagnosticSink,
         ) {
             match self {
                 InferenceDiagnostic::NoSuchField { expr, field } => {
-                    let (_, source_map) = db.body_with_source_map(owner.into());
+                    let (_, source_map) = db.body_with_source_map(owner);
                     let field = source_map.field_syntax(*expr, *field);
                     sink.push(NoSuchField { file: field.file_id, field: field.value })
                 }
                 InferenceDiagnostic::BreakOutsideOfLoop { expr } => {
-                    let (_, source_map) = db.body_with_source_map(owner.into());
+                    let (_, source_map) = db.body_with_source_map(owner);
                     let ptr = source_map
                         .expr_syntax(*expr)
                         .expect("break outside of loop in synthetic syntax");
diff --git a/crates/ra_hir_ty/src/infer/expr.rs b/crates/ra_hir_ty/src/infer/expr.rs
index bd9a387f5..ab586b018 100644
--- a/crates/ra_hir_ty/src/infer/expr.rs
+++ b/crates/ra_hir_ty/src/infer/expr.rs
@@ -220,7 +220,7 @@ impl<'a> InferenceContext<'a> {
                 };
                 sig_tys.push(ret_ty.clone());
                 let sig_ty = Ty::apply(
-                    TypeCtor::FnPtr { num_args: sig_tys.len() as u16 - 1 },
+                    TypeCtor::FnPtr { num_args: sig_tys.len() as u16 - 1, is_varargs: false },
                     Substs(sig_tys.clone().into()),
                 );
                 let closure_ty =
diff --git a/crates/ra_hir_ty/src/lib.rs b/crates/ra_hir_ty/src/lib.rs
index 2652d200f..c4c24a83b 100644
--- a/crates/ra_hir_ty/src/lib.rs
+++ b/crates/ra_hir_ty/src/lib.rs
@@ -12,15 +12,12 @@ pub mod traits;
 pub mod method_resolution;
 mod op;
 mod lower;
-mod match_checking;
 pub(crate) mod infer;
 pub(crate) mod utils;
 
 pub mod display;
 pub mod db;
 pub mod diagnostics;
-pub mod expr;
-pub mod unsafe_validation;
 
 #[cfg(test)]
 mod tests;
@@ -115,7 +112,7 @@ pub enum TypeCtor {
     /// fn foo() -> i32 { 1 }
     /// let bar: fn() -> i32 = foo;
     /// ```
-    FnPtr { num_args: u16 },
+    FnPtr { num_args: u16, is_varargs: bool },
 
     /// The never type `!`.
     Never,
@@ -190,7 +187,7 @@ impl TypeCtor {
                     }
                 }
             }
-            TypeCtor::FnPtr { num_args } => num_args as usize + 1,
+            TypeCtor::FnPtr { num_args, is_varargs: _ } => num_args as usize + 1,
             TypeCtor::Tuple { cardinality } => cardinality as usize,
         }
     }
@@ -670,19 +667,20 @@ pub enum TyKind {
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct FnSig {
     params_and_return: Arc<[Ty]>,
+    is_varargs: bool,
 }
 
 /// A polymorphic function signature.
 pub type PolyFnSig = Binders<FnSig>;
 
 impl FnSig {
-    pub fn from_params_and_return(mut params: Vec<Ty>, ret: Ty) -> FnSig {
+    pub fn from_params_and_return(mut params: Vec<Ty>, ret: Ty, is_varargs: bool) -> FnSig {
         params.push(ret);
-        FnSig { params_and_return: params.into() }
+        FnSig { params_and_return: params.into(), is_varargs }
     }
 
-    pub fn from_fn_ptr_substs(substs: &Substs) -> FnSig {
-        FnSig { params_and_return: Arc::clone(&substs.0) }
+    pub fn from_fn_ptr_substs(substs: &Substs, is_varargs: bool) -> FnSig {
+        FnSig { params_and_return: Arc::clone(&substs.0), is_varargs }
     }
 
     pub fn params(&self) -> &[Ty] {
@@ -727,7 +725,7 @@ impl Ty {
     }
     pub fn fn_ptr(sig: FnSig) -> Self {
         Ty::apply(
-            TypeCtor::FnPtr { num_args: sig.params().len() as u16 },
+            TypeCtor::FnPtr { num_args: sig.params().len() as u16, is_varargs: sig.is_varargs },
             Substs(sig.params_and_return),
         )
     }
@@ -824,7 +822,9 @@ impl Ty {
     fn callable_sig(&self, db: &dyn HirDatabase) -> Option<FnSig> {
         match self {
             Ty::Apply(a_ty) => match a_ty.ctor {
-                TypeCtor::FnPtr { .. } => Some(FnSig::from_fn_ptr_substs(&a_ty.parameters)),
+                TypeCtor::FnPtr { is_varargs, .. } => {
+                    Some(FnSig::from_fn_ptr_substs(&a_ty.parameters, is_varargs))
+                }
                 TypeCtor::FnDef(def) => {
                     let sig = db.callable_item_signature(def);
                     Some(sig.subst(&a_ty.parameters))
diff --git a/crates/ra_hir_ty/src/lower.rs b/crates/ra_hir_ty/src/lower.rs
index 101b8aebe..6f4398e84 100644
--- a/crates/ra_hir_ty/src/lower.rs
+++ b/crates/ra_hir_ty/src/lower.rs
@@ -176,9 +176,12 @@ impl Ty {
                 Ty::apply_one(TypeCtor::Ref(*mutability), inner_ty)
             }
             TypeRef::Placeholder => Ty::Unknown,
-            TypeRef::Fn(params) => {
+            TypeRef::Fn(params, is_varargs) => {
                 let sig = Substs(params.iter().map(|tr| Ty::from_hir(ctx, tr)).collect());
-                Ty::apply(TypeCtor::FnPtr { num_args: sig.len() as u16 - 1 }, sig)
+                Ty::apply(
+                    TypeCtor::FnPtr { num_args: sig.len() as u16 - 1, is_varargs: *is_varargs },
+                    sig,
+                )
             }
             TypeRef::DynTrait(bounds) => {
                 let self_ty = Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, 0));
@@ -996,7 +999,7 @@ fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> PolyFnSig {
     let ret = Ty::from_hir(&ctx_ret, &data.ret_type);
     let generics = generics(db.upcast(), def.into());
     let num_binders = generics.len();
-    Binders::new(num_binders, FnSig::from_params_and_return(params, ret))
+    Binders::new(num_binders, FnSig::from_params_and_return(params, ret, data.is_varargs))
 }
 
 /// Build the declared type of a function. This should not need to look at the
@@ -1047,7 +1050,7 @@ fn fn_sig_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> PolyFnS
     let params =
         fields.iter().map(|(_, field)| Ty::from_hir(&ctx, &field.type_ref)).collect::<Vec<_>>();
     let ret = type_for_adt(db, def.into());
-    Binders::new(ret.num_binders, FnSig::from_params_and_return(params, ret.value))
+    Binders::new(ret.num_binders, FnSig::from_params_and_return(params, ret.value, false))
 }
 
 /// Build the type of a tuple struct constructor.
@@ -1071,7 +1074,7 @@ fn fn_sig_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId)
     let params =
         fields.iter().map(|(_, field)| Ty::from_hir(&ctx, &field.type_ref)).collect::<Vec<_>>();
     let ret = type_for_adt(db, def.parent.into());
-    Binders::new(ret.num_binders, FnSig::from_params_and_return(params, ret.value))
+    Binders::new(ret.num_binders, FnSig::from_params_and_return(params, ret.value, false))
 }
 
 /// Build the type of a tuple enum variant constructor.
diff --git a/crates/ra_hir_ty/src/test_db.rs b/crates/ra_hir_ty/src/test_db.rs
index dc447955f..a1714ff0f 100644
--- a/crates/ra_hir_ty/src/test_db.rs
+++ b/crates/ra_hir_ty/src/test_db.rs
@@ -5,19 +5,13 @@ use std::{
     sync::{Arc, Mutex},
 };
 
-use hir_def::{db::DefDatabase, AssocItemId, ModuleDefId, ModuleId};
-use hir_expand::{db::AstDatabase, diagnostics::DiagnosticSink};
+use hir_def::{db::DefDatabase, ModuleId};
+use hir_expand::db::AstDatabase;
 use ra_db::{salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, SourceDatabase, Upcast};
 use ra_syntax::TextRange;
 use rustc_hash::{FxHashMap, FxHashSet};
-use stdx::format_to;
 use test_utils::extract_annotations;
 
-use crate::{
-    db::HirDatabase, diagnostics::Diagnostic, expr::ExprValidator,
-    unsafe_validation::UnsafeValidator,
-};
-
 #[salsa::database(
     ra_db::SourceDatabaseExtStorage,
     ra_db::SourceDatabaseStorage,
@@ -82,7 +76,7 @@ impl FileLoader for TestDB {
 }
 
 impl TestDB {
-    pub fn module_for_file(&self, file_id: FileId) -> ModuleId {
+    pub(crate) fn module_for_file(&self, file_id: FileId) -> ModuleId {
         for &krate in self.relevant_crates(file_id).iter() {
             let crate_def_map = self.crate_def_map(krate);
             for (local_id, data) in crate_def_map.modules.iter() {
@@ -94,67 +88,7 @@ impl TestDB {
         panic!("Can't find module for file")
     }
 
-    fn diag<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 {
-                let infer = self.infer(f.into());
-                let mut sink = DiagnosticSink::new(&mut cb);
-                infer.add_diagnostics(self, f, &mut sink);
-                let mut validator = ExprValidator::new(f, infer.clone(), &mut sink);
-                validator.validate_body(self);
-                let mut validator = UnsafeValidator::new(f, infer, &mut sink);
-                validator.validate_body(self);
-            }
-        }
-    }
-
-    pub fn diagnostics(&self) -> (String, u32) {
-        let mut buf = String::new();
-        let mut count = 0;
-        self.diag(|d| {
-            format_to!(buf, "{:?}: {}\n", d.syntax_node(self).text(), d.message());
-            count += 1;
-        });
-        (buf, count)
-    }
-
-    /// Like `diagnostics`, but filtered for a single diagnostic.
-    pub fn diagnostic<D: Diagnostic>(&self) -> (String, u32) {
-        let mut buf = String::new();
-        let mut count = 0;
-        self.diag(|d| {
-            // We want to filter diagnostics by the particular one we are testing for, to
-            // avoid surprising results in tests.
-            if d.downcast_ref::<D>().is_some() {
-                format_to!(buf, "{:?}: {}\n", d.syntax_node(self).text(), d.message());
-                count += 1;
-            };
-        });
-        (buf, count)
-    }
-
-    pub fn extract_annotations(&self) -> FxHashMap<FileId, Vec<(TextRange, String)>> {
+    pub(crate) fn extract_annotations(&self) -> FxHashMap<FileId, Vec<(TextRange, String)>> {
         let mut files = Vec::new();
         let crate_graph = self.crate_graph();
         for krate in crate_graph.iter() {
diff --git a/crates/ra_hir_ty/src/tests.rs b/crates/ra_hir_ty/src/tests.rs
index 27f5a60bf..d57b3f288 100644
--- a/crates/ra_hir_ty/src/tests.rs
+++ b/crates/ra_hir_ty/src/tests.rs
@@ -20,7 +20,6 @@ use hir_def::{
     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,
@@ -341,410 +340,3 @@ fn typing_whitespace_inside_a_function_should_not_invalidate_types() {
         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
-    "###
-    );
-}
diff --git a/crates/ra_hir_ty/src/traits/builtin.rs b/crates/ra_hir_ty/src/traits/builtin.rs
index 86e22e459..60cc9a9f5 100644
--- a/crates/ra_hir_ty/src/traits/builtin.rs
+++ b/crates/ra_hir_ty/src/traits/builtin.rs
@@ -121,7 +121,7 @@ fn closure_fn_trait_impl_datum(
             .build(),
     );
     let sig_ty = Ty::apply(
-        TypeCtor::FnPtr { num_args },
+        TypeCtor::FnPtr { num_args, is_varargs: false },
         Substs::builder(num_args as usize + 1)
             .fill_with_bound_vars(DebruijnIndex::INNERMOST, 0)
             .build(),
diff --git a/crates/ra_hir_ty/src/traits/chalk/mapping.rs b/crates/ra_hir_ty/src/traits/chalk/mapping.rs
index 06453ef82..3ebb55f77 100644
--- a/crates/ra_hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/ra_hir_ty/src/traits/chalk/mapping.rs
@@ -30,7 +30,8 @@ impl ToChalk for Ty {
             Ty::Apply(apply_ty) => match apply_ty.ctor {
                 TypeCtor::Ref(m) => ref_to_chalk(db, m, apply_ty.parameters),
                 TypeCtor::Array => array_to_chalk(db, apply_ty.parameters),
-                TypeCtor::FnPtr { num_args: _ } => {
+                TypeCtor::FnPtr { num_args: _, is_varargs: _ } => {
+                    // FIXME: handle is_varargs
                     let substitution = apply_ty.parameters.to_chalk(db).shifted_in(&Interner);
                     chalk_ir::TyData::Function(chalk_ir::Fn { num_binders: 0, substitution })
                         .intern(&Interner)
@@ -124,7 +125,10 @@ impl ToChalk for Ty {
                     substitution.shifted_out(&Interner).expect("fn ptr should have no binders"),
                 );
                 Ty::Apply(ApplicationTy {
-                    ctor: TypeCtor::FnPtr { num_args: (parameters.len() - 1) as u16 },
+                    ctor: TypeCtor::FnPtr {
+                        num_args: (parameters.len() - 1) as u16,
+                        is_varargs: false,
+                    },
                     parameters,
                 })
             }