30 files changed, 8270 insertions, 8867 deletions
diff --git a/crates/ra_hir_ty/src/autoderef.rs b/crates/ra_hir_ty/src/autoderef.rs
index 1b0f84c5c..c727012c6 100644
--- a/crates/ra_hir_ty/src/autoderef.rs
+++ b/crates/ra_hir_ty/src/autoderef.rs
@@ -37,7 +37,7 @@ pub(crate) fn deref(
    ty: InEnvironment<&Canonical<Ty>>,
 ) -> Option<Canonical<Ty>> {
    if let Some(derefed) = ty.value.value.builtin_deref() {
-        Some(Canonical { value: derefed, num_vars: ty.value.num_vars })
+        Some(Canonical { value: derefed, kinds: ty.value.kinds.clone() })
    } else {
        deref_by_trait(db, krate, ty)
    }
@@ -68,8 +68,8 @@ fn deref_by_trait(
    // Check that the type implements Deref at all
    let trait_ref = TraitRef { trait_: deref_trait, substs: parameters.clone() };
-    let implements_goal = super::Canonical {
+    let implements_goal = Canonical {
-        num_vars: ty.value.num_vars,
+        kinds: ty.value.kinds.clone(),
        value: InEnvironment {
            value: Obligation::Trait(trait_ref),
            environment: ty.environment.clone(),
@@ -81,7 +81,7 @@ fn deref_by_trait(
    // Now do the assoc type projection
    let projection = super::traits::ProjectionPredicate {
-        ty: Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, ty.value.num_vars)),
+        ty: Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, ty.value.kinds.len())),
        projection_ty: super::ProjectionTy { associated_ty: target, parameters },
    };
@@ -89,7 +89,8 @@ fn deref_by_trait(
    let in_env = InEnvironment { value: obligation, environment: ty.environment };
-    let canonical = super::Canonical { num_vars: 1 + ty.value.num_vars, value: in_env };
+    let canonical =
+        Canonical::new(in_env, ty.value.kinds.iter().copied().chain(Some(super::TyKind::General)));
    let solution = db.trait_solve(krate, canonical)?;
@@ -110,7 +111,7 @@ fn deref_by_trait(
            // assumptions will be broken. We would need to properly introduce
            // new variables in that case
-            for i in 1..vars.0.num_vars {
+            for i in 1..vars.0.kinds.len() {
                if vars.0.value[i - 1] != Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, i - 1))
                {
                    warn!("complex solution for derefing {:?}: {:?}, ignoring", ty.value, solution);
@@ -119,7 +120,7 @@ fn deref_by_trait(
            }
            Some(Canonical {
                value: vars.0.value[vars.0.value.len() - 1].clone(),
-                num_vars: vars.0.num_vars,
+                kinds: vars.0.kinds.clone(),
            })
        }
        Solution::Ambig(_) => {
diff --git a/crates/ra_hir_ty/src/db.rs b/crates/ra_hir_ty/src/db.rs
index cad553273..c773adc67 100644
--- a/crates/ra_hir_ty/src/db.rs
+++ b/crates/ra_hir_ty/src/db.rs
@@ -3,23 +3,22 @@
 use std::sync::Arc;
 use hir_def::{
-    db::DefDatabase, DefWithBodyId, FunctionId, GenericDefId, ImplId, LocalFieldId, TypeParamId,
+    db::DefDatabase, expr::ExprId, DefWithBodyId, FunctionId, GenericDefId, ImplId, LocalFieldId,
-    VariantId,
+    TypeParamId, VariantId,
 };
 use ra_arena::map::ArenaMap;
 use ra_db::{impl_intern_key, salsa, CrateId, Upcast};
 use ra_prof::profile;
 use crate::{
-    method_resolution::CrateImplDefs,
+    method_resolution::{InherentImpls, TraitImpls},
-    traits::{chalk, AssocTyValue, Impl},
+    traits::chalk,
-    Binders, CallableDef, GenericPredicate, InferenceResult, OpaqueTyId, PolyFnSig,
+    Binders, CallableDefId, GenericPredicate, InferenceResult, OpaqueTyId, PolyFnSig,
-    ReturnTypeImplTraits, TraitRef, Ty, TyDefId, TypeCtor, ValueTyDefId,
+    ReturnTypeImplTraits, TraitRef, Ty, TyDefId, ValueTyDefId,
 };
 use hir_expand::name::Name;
 #[salsa::query_group(HirDatabaseStorage)]
-#[salsa::requires(salsa::Database)]
 pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
    #[salsa::invoke(infer_wait)]
    #[salsa::transparent]
@@ -46,7 +45,7 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
    fn field_types(&self, var: VariantId) -> Arc<ArenaMap<LocalFieldId, Binders<Ty>>>;
    #[salsa::invoke(crate::callable_item_sig)]
-    fn callable_item_signature(&self, def: CallableDef) -> PolyFnSig;
+    fn callable_item_signature(&self, def: CallableDefId) -> PolyFnSig;
    #[salsa::invoke(crate::lower::return_type_impl_traits)]
    fn return_type_impl_traits(
@@ -67,25 +66,24 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
    #[salsa::invoke(crate::lower::generic_defaults_query)]
    fn generic_defaults(&self, def: GenericDefId) -> Arc<[Binders<Ty>]>;
-    #[salsa::invoke(crate::method_resolution::CrateImplDefs::impls_in_crate_query)]
+    #[salsa::invoke(InherentImpls::inherent_impls_in_crate_query)]
-    fn impls_in_crate(&self, krate: CrateId) -> Arc<CrateImplDefs>;
+    fn inherent_impls_in_crate(&self, krate: CrateId) -> Arc<InherentImpls>;
-    #[salsa::invoke(crate::method_resolution::CrateImplDefs::impls_from_deps_query)]
+    #[salsa::invoke(TraitImpls::trait_impls_in_crate_query)]
-    fn impls_from_deps(&self, krate: CrateId) -> Arc<CrateImplDefs>;
+    fn trait_impls_in_crate(&self, krate: CrateId) -> Arc<TraitImpls>;
+    #[salsa::invoke(TraitImpls::trait_impls_in_deps_query)]
+    fn trait_impls_in_deps(&self, krate: CrateId) -> Arc<TraitImpls>;
    // Interned IDs for Chalk integration
    #[salsa::interned]
-    fn intern_type_ctor(&self, type_ctor: TypeCtor) -> crate::TypeCtorId;
+    fn intern_callable_def(&self, callable_def: CallableDefId) -> InternedCallableDefId;
-    #[salsa::interned]
-    fn intern_callable_def(&self, callable_def: CallableDef) -> crate::CallableDefId;
    #[salsa::interned]
    fn intern_type_param_id(&self, param_id: TypeParamId) -> GlobalTypeParamId;
    #[salsa::interned]
    fn intern_impl_trait_id(&self, id: OpaqueTyId) -> InternedOpaqueTyId;
    #[salsa::interned]
-    fn intern_chalk_impl(&self, impl_: Impl) -> crate::traits::GlobalImplId;
+    fn intern_closure(&self, id: (DefWithBodyId, ExprId)) -> ClosureId;
-    #[salsa::interned]
-    fn intern_assoc_ty_value(&self, assoc_ty_value: AssocTyValue) -> crate::traits::AssocTyValueId;
    #[salsa::invoke(chalk::associated_ty_data_query)]
    fn associated_ty_data(&self, id: chalk::AssocTypeId) -> Arc<chalk::AssociatedTyDatum>;
@@ -149,3 +147,13 @@ impl_intern_key!(GlobalTypeParamId);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct InternedOpaqueTyId(salsa::InternId);
 impl_intern_key!(InternedOpaqueTyId);
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct ClosureId(salsa::InternId);
+impl_intern_key!(ClosureId);
+/// This exists just for Chalk, because Chalk just has a single `FnDefId` where
+/// we have different IDs for struct and enum variant constructors.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub struct InternedCallableDefId(salsa::InternId);
+impl_intern_key!(InternedCallableDefId);
diff --git a/crates/ra_hir_ty/src/diagnostics.rs b/crates/ra_hir_ty/src/diagnostics.rs
index a59efb347..f210c305a 100644
--- a/crates/ra_hir_ty/src/diagnostics.rs
+++ b/crates/ra_hir_ty/src/diagnostics.rs
@@ -1,18 +1,35 @@
 //! 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};
+use crate::db::HirDatabase;
-pub use hir_expand::diagnostics::{AstDiagnostic, Diagnostic, DiagnosticSink};
+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 {
    pub file: HirFileId,
-    pub field: AstPtr<ast::RecordField>,
+    pub field: AstPtr<ast::RecordExprField>,
 }
 impl Diagnostic for NoSuchField {
@@ -30,19 +47,19 @@ impl Diagnostic for NoSuchField {
 }
 impl AstDiagnostic for NoSuchField {
-    type AST = ast::RecordField;
+    type AST = ast::RecordExprField;
-    fn ast(&self, db: &impl AstDatabase) -> Self::AST {
+    fn ast(&self, db: &dyn AstDatabase) -> Self::AST {
        let root = db.parse_or_expand(self.source().file_id).unwrap();
        let node = self.source().value.to_node(&root);
-        ast::RecordField::cast(node).unwrap()
+        ast::RecordExprField::cast(node).unwrap()
    }
 }
 #[derive(Debug)]
 pub struct MissingFields {
    pub file: HirFileId,
-    pub field_list: AstPtr<ast::RecordFieldList>,
+    pub field_list: AstPtr<ast::RecordExprFieldList>,
    pub missed_fields: Vec<Name>,
 }
@@ -63,12 +80,12 @@ impl Diagnostic for MissingFields {
 }
 impl AstDiagnostic for MissingFields {
-    type AST = ast::RecordFieldList;
+    type AST = ast::RecordExprFieldList;
-    fn ast(&self, db: &impl AstDatabase) -> Self::AST {
+    fn ast(&self, db: &dyn AstDatabase) -> Self::AST {
        let root = db.parse_or_expand(self.source().file_id).unwrap();
        let node = self.source().value.to_node(&root);
-        ast::RecordFieldList::cast(node).unwrap()
+        ast::RecordExprFieldList::cast(node).unwrap()
    }
 }
@@ -135,7 +152,7 @@ impl Diagnostic for MissingOkInTailExpr {
 impl AstDiagnostic for MissingOkInTailExpr {
    type AST = ast::Expr;
-    fn ast(&self, db: &impl AstDatabase) -> Self::AST {
+    fn ast(&self, db: &dyn AstDatabase) -> Self::AST {
        let root = db.parse_or_expand(self.file).unwrap();
        let node = self.source().value.to_node(&root);
        ast::Expr::cast(node).unwrap()
@@ -163,7 +180,7 @@ impl Diagnostic for BreakOutsideOfLoop {
 impl AstDiagnostic for BreakOutsideOfLoop {
    type AST = ast::Expr;
-    fn ast(&self, db: &impl AstDatabase) -> Self::AST {
+    fn ast(&self, db: &dyn AstDatabase) -> Self::AST {
        let root = db.parse_or_expand(self.file).unwrap();
        let node = self.source().value.to_node(&root);
        ast::Expr::cast(node).unwrap()
@@ -191,9 +208,274 @@ impl Diagnostic for MissingUnsafe {
 impl AstDiagnostic for MissingUnsafe {
    type AST = ast::Expr;
-    fn ast(&self, db: &impl AstDatabase) -> Self::AST {
+    fn ast(&self, db: &dyn AstDatabase) -> Self::AST {
        let root = db.parse_or_expand(self.source().file_id).unwrap();
        let node = self.source().value.to_node(&root);
        ast::Expr::cast(node).unwrap()
    }
 }
+#[derive(Debug)]
+pub struct MismatchedArgCount {
+    pub file: HirFileId,
+    pub call_expr: AstPtr<ast::Expr>,
+    pub expected: usize,
+    pub found: usize,
+}
+impl Diagnostic for MismatchedArgCount {
+    fn message(&self) -> String {
+        let s = if self.expected == 1 { "" } else { "s" };
+        format!("Expected {} argument{}, found {}", self.expected, s, self.found)
+    }
+    fn source(&self) -> InFile<SyntaxNodePtr> {
+        InFile { file_id: self.file, value: self.call_expr.clone().into() }
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+    fn is_experimental(&self) -> bool {
+        true
+    }
+}
+impl AstDiagnostic for MismatchedArgCount {
+    type AST = ast::CallExpr;
+    fn ast(&self, db: &dyn AstDatabase) -> Self::AST {
+        let root = db.parse_or_expand(self.source().file_id).unwrap();
+        let node = self.source().value.to_node(&root);
+        ast::CallExpr::cast(node).unwrap()
+    }
+}
+#[cfg(test)]
+mod tests {
+    use hir_def::{db::DefDatabase, AssocItemId, ModuleDefId};
+    use hir_expand::diagnostics::{Diagnostic, DiagnosticSinkBuilder};
+    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 = DiagnosticSinkBuilder::new().build(&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 7db928dde..f0e0f2988 100644
--- a/crates/ra_hir_ty/src/expr.rs
+++ b/crates/ra_hir_ty/src/diagnostics/expr.rs
@@ -2,17 +2,19 @@
 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;
 use crate::{
    db::HirDatabase,
-    diagnostics::{MissingFields, MissingMatchArms, MissingOkInTailExpr, MissingPatFields},
+    diagnostics::{
+        match_check::{is_useful, MatchCheckCtx, Matrix, PatStack, Usefulness},
+        MismatchedArgCount, MissingFields, MissingMatchArms, MissingOkInTailExpr, MissingPatFields,
+    },
    utils::variant_data,
    ApplicationTy, InferenceResult, Ty, TypeCtor,
-    _match::{is_useful, MatchCheckCtx, Matrix, PatStack, Usefulness},
 };
 pub use hir_def::{
@@ -24,26 +26,27 @@ pub use hir_def::{
        ArithOp, Array, BinaryOp, BindingAnnotation, CmpOp, Expr, ExprId, Literal, LogicOp,
        MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField, Statement, UnaryOp,
    },
-    LocalFieldId, VariantId,
+    src::HasSource,
+    LocalFieldId, Lookup, VariantId,
 };
-pub struct ExprValidator<'a, 'b: 'a> {
+pub(super) struct ExprValidator<'a, 'b: 'a> {
-    func: FunctionId,
+    owner: DefWithBodyId,
    infer: Arc<InferenceResult>,
    sink: &'a mut DiagnosticSink<'b>,
 }
 impl<'a, 'b> ExprValidator<'a, 'b> {
-    pub fn new(
+    pub(super) fn new(
-        func: FunctionId,
+        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) {
+    pub(super) fn validate_body(&mut self, db: &dyn HirDatabase) {
-        let body = db.body(self.func.into());
+        let body = db.body(self.owner.into());
        for (id, expr) in body.exprs.iter() {
            if let Some((variant_def, missed_fields, true)) =
@@ -56,8 +59,15 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
                    missed_fields,
                );
            }
-            if let Expr::Match { expr, arms } = expr {
-                self.validate_match(id, *expr, arms, db, self.infer.clone());
+            match expr {
+                Expr::Match { expr, arms } => {
+                    self.validate_match(id, *expr, arms, db, self.infer.clone());
+                }
+                Expr::Call { .. } | Expr::MethodCall { .. } => {
+                    self.validate_call(db, id, expr);
+                }
+                _ => {}
            }
        }
        for (id, pat) in body.pats.iter() {
@@ -86,12 +96,12 @@ 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());
-            if let ast::Expr::RecordLit(record_lit) = &source_ptr.value.to_node(&root) {
+            if let ast::Expr::RecordExpr(record_lit) = &source_ptr.value.to_node(&root) {
-                if let Some(field_list) = record_lit.record_field_list() {
+                if let Some(field_list) = record_lit.record_expr_field_list() {
                    let variant_data = variant_data(db.upcast(), variant_def);
                    let missed_fields = missed_fields
                        .into_iter()
@@ -115,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() {
@@ -138,6 +148,65 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        }
    }
+    fn validate_call(&mut self, db: &dyn HirDatabase, call_id: ExprId, expr: &Expr) -> Option<()> {
+        // Check that the number of arguments matches the number of parameters.
+        // FIXME: Due to shortcomings in the current type system implementation, only emit this
+        // diagnostic if there are no type mismatches in the containing function.
+        if self.infer.type_mismatches.iter().next().is_some() {
+            return Some(());
+        }
+        let is_method_call = matches!(expr, Expr::MethodCall { .. });
+        let (sig, args) = match expr {
+            Expr::Call { callee, args } => {
+                let callee = &self.infer.type_of_expr[*callee];
+                let sig = callee.callable_sig(db)?;
+                (sig, args.clone())
+            }
+            Expr::MethodCall { receiver, args, .. } => {
+                let mut args = args.clone();
+                args.insert(0, *receiver);
+                // FIXME: note that we erase information about substs here. This
+                // is not right, but, luckily, doesn't matter as we care only
+                // about the number of params
+                let callee = self.infer.method_resolution(call_id)?;
+                let sig = db.callable_item_signature(callee.into()).value;
+                (sig, args)
+            }
+            _ => return None,
+        };
+        if sig.is_varargs {
+            return None;
+        }
+        let params = sig.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.owner.into());
+            if let Ok(source_ptr) = source_map.expr_syntax(call_id) {
+                if is_method_call {
+                    param_count -= 1;
+                    arg_count -= 1;
+                }
+                self.sink.push(MismatchedArgCount {
+                    file: source_ptr.file_id,
+                    call_expr: source_ptr.value,
+                    expected: param_count,
+                    found: arg_count,
+                });
+            }
+        }
+        None
+    }
    fn validate_match(
        &mut self,
        id: ExprId,
@@ -147,7 +216,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,
@@ -228,7 +297,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,
@@ -243,7 +312,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
@@ -312,3 +381,185 @@ pub fn record_pattern_missing_fields(
    }
    Some((variant_def, missed_fields, exhaustive))
 }
+#[cfg(test)]
+mod tests {
+    use crate::diagnostics::tests::check_diagnostics;
+    #[test]
+    fn simple_free_fn_zero() {
+        check_diagnostics(
+            r#"
+fn zero() {}
+fn f() { zero(1); }
+       //^^^^^^^ Expected 0 arguments, found 1
+"#,
+        );
+        check_diagnostics(
+            r#"
+fn zero() {}
+fn f() { zero(); }
+"#,
+        );
+    }
+    #[test]
+    fn simple_free_fn_one() {
+        check_diagnostics(
+            r#"
+fn one(arg: u8) {}
+fn f() { one(); }
+       //^^^^^ Expected 1 argument, found 0
+"#,
+        );
+        check_diagnostics(
+            r#"
+fn one(arg: u8) {}
+fn f() { one(1); }
+"#,
+        );
+    }
+    #[test]
+    fn method_as_fn() {
+        check_diagnostics(
+            r#"
+struct S;
+impl S { fn method(&self) {} }
+fn f() {
+    S::method();
+} //^^^^^^^^^^^ Expected 1 argument, found 0
+"#,
+        );
+        check_diagnostics(
+            r#"
+struct S;
+impl S { fn method(&self) {} }
+fn f() {
+    S::method(&S);
+    S.method();
+}
+"#,
+        );
+    }
+    #[test]
+    fn method_with_arg() {
+        check_diagnostics(
+            r#"
+struct S;
+impl S { fn method(&self, arg: u8) {} }
+            fn f() {
+                S.method();
+            } //^^^^^^^^^^ Expected 1 argument, found 0
+            "#,
+        );
+        check_diagnostics(
+            r#"
+struct S;
+impl S { fn method(&self, arg: u8) {} }
+fn f() {
+    S::method(&S, 0);
+    S.method(1);
+}
+"#,
+        );
+    }
+    #[test]
+    fn tuple_struct() {
+        check_diagnostics(
+            r#"
+struct Tup(u8, u16);
+fn f() {
+    Tup(0);
+} //^^^^^^ Expected 2 arguments, found 1
+"#,
+        )
+    }
+    #[test]
+    fn enum_variant() {
+        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);
+    }
+}
+        "#,
+        )
+    }
+    #[test]
+    fn arg_count_lambda() {
+        check_diagnostics(
+            r#"
+fn main() {
+    let f = |()| ();
+    f();
+  //^^^ Expected 1 argument, found 0
+    f(());
+    f((), ());
+  //^^^^^^^^^ Expected 1 argument, found 2
+}
+"#,
+        )
+    }
+}
diff --git a/crates/ra_hir_ty/src/_match.rs b/crates/ra_hir_ty/src/diagnostics/match_check.rs
index 5495ce284..507edcb7d 100644
--- a/crates/ra_hir_ty/src/_match.rs
+++ b/crates/ra_hir_ty/src/diagnostics/match_check.rs
@@ -41,9 +41,9 @@
 //! ```ignore
 //! // x: (Option<bool>, Result<()>)
 //! match x {
-//!     (Some(true), _) => {}
+//!     (Some(true), _) => (),
-//!     (None, Err(())) => {}
+//!     (None, Err(())) => (),
-//!     (None, Err(_)) => {}
+//!     (None, Err(_)) => (),
 //! }
 //! ```
 //!
@@ -218,15 +218,16 @@
 //!   ```
 use std::sync::Arc;
-use smallvec::{smallvec, SmallVec};
+use hir_def::{
+    adt::VariantData,
-use crate::{
+    body::Body,
-    db::HirDatabase,
+    expr::{Expr, Literal, Pat, PatId},
-    expr::{Body, Expr, Literal, Pat, PatId},
+    AdtId, EnumVariantId, VariantId,
-    ApplicationTy, InferenceResult, Ty, TypeCtor,
 };
-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(super) struct MatchCheckCtx<'a> {
-    pub match_expr: Idx<Expr>,
+    pub(super) match_expr: Idx<Expr>,
-    pub body: Arc<Body>,
+    pub(super) body: Arc<Body>,
-    pub infer: Arc<InferenceResult>,
+    pub(super) infer: Arc<InferenceResult>,
-    pub db: &'a dyn HirDatabase,
+    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;
+    use crate::diagnostics::tests::check_diagnostics;
-    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 (()) {
-                    (()) => {}
-                }
-            }
-        ",
-        );
-    }
    #[test]
-    fn tuple_of_two_empty_tuple_no_arms() {
+    fn empty_tuple() {
-        check_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            fn test_fn() {
+fn main() {
-                match ((), ()) {
+    match () { }
-                }
+        //^^ Missing match arm
-            }
+   match (()) { }
-        ",
+       //^^^^ Missing match arm
-        );
-    }
-    #[test]
+    match () { _ => (), }
-    fn tuple_of_two_empty_tuple_no_diagnostic() {
+    match () { () => (), }
-        check_no_diagnostic(
+    match (()) { (()) => (), }
-            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) => {},
-                }
-            }
-        ",
        );
    }
    #[test]
-    fn tuple_of_bools_no_diagnostic() {
+    fn tuple_of_two_empty_tuple() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            fn test_fn() {
+fn main() {
-                match (false, true) {
+    match ((), ()) { }
-                    (true, true) => {},
+        //^^^^^^^^ Missing match arm
-                    (true, false) => {},
-                    (false, true) => {},
-                    (false, false) => {},
-                }
-            }
-        ",
-        );
-    }
-    #[test]
+    match ((), ()) { ((), ()) => (), }
-    fn tuple_of_bools_binding_missing_arms() {
+}
-        check_diagnostic(
+"#,
-            r"
+        );
-            fn test_fn() {
+    }
-                match (false, true) {
-                    (true, _x) => {},
+    #[test]
-                }
+    fn boolean() {
-            }
+        check_diagnostics(
-        ",
+            r#"
-        );
+fn test_main() {
-    }
+    match false { }
+        //^^^^^ Missing match arm
-    #[test]
+    match false { true => (), }
-    fn tuple_of_bools_binding_no_diagnostic() {
+        //^^^^^ Missing match arm
-        check_no_diagnostic(
+    match (false, true) {}
-            r"
+        //^^^^^^^^^^^^^ Missing match arm
-            fn test_fn() {
+    match (false, true) { (true, true) => (), }
-                match (false, true) {
+        //^^^^^^^^^^^^^ Missing match arm
-                    (true, _x) => {},
+    match (false, true) {
-                    (false, true) => {},
+        //^^^^^^^^^^^^^ Missing match arm
-                    (false, false) => {},
+        (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() {
+    fn tuple_of_tuple_and_bools() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            fn test_fn() {
+fn main() {
-                match (false, true, false) {
+    match (false, ((), false)) {}
-                    (false, ..) => {},
+        //^^^^^^^^^^^^^^^^^^^^ Missing match arm
-                    (true, ..) => {},
+    match (false, ((), false)) { (true, ((), true)) => (), }
-                }
+        //^^^^^^^^^^^^^^^^^^^^ Missing match arm
-            }
+    match (false, ((), false)) { (true, _) => (), }
-        ",
+        //^^^^^^^^^^^^^^^^^^^^ Missing match arm
-        );
-    }
-    #[test]
+    match (false, ((), false)) {
-    fn tuple_of_bools_with_ellipsis_at_beginning_no_diagnostic() {
+        (true, ((), true)) => (),
-        check_no_diagnostic(
+        (true, ((), false)) => (),
-            r"
+        (false, ((), true)) => (),
-            fn test_fn() {
+        (false, ((), false)) => (),
-                match (false, true, false) {
-                    (.., false) => {},
-                    (.., true) => {},
-                }
-            }
-        ",
-        );
    }
+    match (false, ((), false)) {
-    #[test]
+        (true, ((), true)) => (),
-    fn tuple_of_bools_with_ellipsis_no_diagnostic() {
+        (true, ((), false)) => (),
-        check_no_diagnostic(
+        (false, _) => (),
-            r"
-            fn test_fn() {
-                match (false, true, 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() {
+    fn enums() {
-        check_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            fn test_fn() {
+enum Either { A, B, }
-                match (false, ((), false)) {
-                    (true, ((), true)) => {},
-                }
-            }
-        ",
-        );
-    }
-    #[test]
+fn main() {
-    fn tuple_of_tuple_and_bools_no_diagnostic() {
+    match Either::A { }
-        check_no_diagnostic(
+        //^^^^^^^^^ Missing match arm
-            r"
+    match Either::B { Either::A => (), }
-            fn test_fn() {
+        //^^^^^^^^^ Missing match arm
-                match (false, ((), false)) {
-                    (true, ((), true)) => {},
-                    (true, ((), false)) => {},
-                    (false, ((), true)) => {},
-                    (false, ((), false)) => {},
-                }
-            }
-        ",
-        );
-    }
-    #[test]
+    match &Either::B {
-    fn tuple_of_tuple_and_bools_wildcard_missing_arms() {
+        //^^^^^^^^^^ Missing match arm
-        check_diagnostic(
+        Either::A => (),
-            r"
-            fn test_fn() {
-                match (false, ((), false)) {
-                    (true, _) => {},
-                }
-            }
-        ",
-        );
    }
-    #[test]
+    match Either::B {
-    fn tuple_of_tuple_and_bools_wildcard_no_diagnostic() {
+        Either::A => (), Either::B => (),
-        check_no_diagnostic(
-            r"
-            fn test_fn() {
-                match (false, ((), false)) {
-                    (true, ((), true)) => {},
-                    (true, ((), false)) => {},
-                    (false, _) => {},
-                }
-            }
-        ",
-        );
    }
+    match &Either::B {
-    #[test]
+        Either::A => (), Either::B => (),
-    fn enum_no_arms() {
-        check_diagnostic(
-            r"
-            enum Either {
-                A,
-                B,
-            }
-            fn test_fn() {
-                match Either::A {
-                }
-            }
-        ",
-        );
    }
+}
-    #[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() {
+    fn enum_containing_bool() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            enum Either {
+enum Either { A(bool), B }
-                A,
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::A => {},
-                    Either::B => {},
-                }
-            }
-        ",
-        );
-    }
-    #[test]
+fn main() {
-    fn enum_ref_missing_arms() {
+    match Either::B { }
-        check_diagnostic(
+        //^^^^^^^^^ Missing match arm
-            r"
+    match Either::B {
-            enum Either {
+        //^^^^^^^^^ Missing match arm
-                A,
+        Either::A(true) => (), Either::B => ()
-                B,
-            }
-            fn test_fn() {
-                match &Either::B {
-                    Either::A => {},
-                }
-            }
-        ",
-        );
    }
-    #[test]
+    match Either::B {
-    fn enum_ref_no_diagnostic() {
+        Either::A(true) => (),
-        check_no_diagnostic(
+        Either::A(false) => (),
-            r"
+        Either::B => (),
-            enum Either {
-                A,
-                B,
-            }
-            fn test_fn() {
-                match &Either::B {
-                    Either::A => {},
-                    Either::B => {},
-                }
-            }
-        ",
-        );
    }
+    match Either::B {
-    #[test]
+        Either::B => (),
-    fn enum_containing_bool_no_arms() {
+        _ => (),
-        check_diagnostic(
-            r"
-            enum Either {
-                A(bool),
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                }
-            }
-        ",
-        );
    }
+    match Either::B {
-    #[test]
+        Either::A(_) => (),
-    fn enum_containing_bool_missing_arms() {
+        Either::B => (),
-        check_diagnostic(
-            r"
-            enum Either {
-                A(bool),
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::A(true) => (),
-                    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() {
+    fn enum_different_sizes() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            enum Either {
+enum Either { A(bool), B(bool, bool) }
-                A(bool),
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::B => (),
-                    _ => (),
-                }
-            }
-        ",
-        );
-    }
-    #[test]
+fn main() {
-    fn enum_containing_bool_with_wild_2_no_diagnostic() {
+    match Either::A(false) {
-        check_no_diagnostic(
+        //^^^^^^^^^^^^^^^^ Missing match arm
-            r"
+        Either::A(_) => (),
-            enum Either {
+        Either::B(false, _) => (),
-                A(bool),
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::A(_) => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
    }
-    #[test]
+    match Either::A(false) {
-    fn enum_different_sizes_missing_arms() {
+        Either::A(_) => (),
-        check_diagnostic(
+        Either::B(true, _) => (),
-            r"
+        Either::B(false, _) => (),
-            enum Either {
-                A(bool),
-                B(bool, bool),
-            }
-            fn test_fn() {
-                match Either::A(false) {
-                    Either::A(_) => (),
-                    Either::B(false, _) => (),
-                }
-            }
-        ",
-        );
    }
+    match Either::A(false) {
-    #[test]
+        Either::A(true) | Either::A(false) => (),
-    fn enum_different_sizes_no_diagnostic() {
+        Either::B(true, _) => (),
-        check_no_diagnostic(
+        Either::B(false, _) => (),
-            r"
-            enum Either {
-                A(bool),
-                B(bool, bool),
-            }
-            fn test_fn() {
-                match Either::A(false) {
-                    Either::A(_) => (),
-                    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(
+        check_diagnostics(
-            r"
+            r#"
-            enum Either {
+enum Either { A(bool), B(bool, bool) }
-                A(bool),
+enum Either2 { C, D }
-                B(bool, bool),
-            }
+fn main() {
-            enum Either2 {
+    match (Either::A(false), Either2::C) {
-                C,
+        (Either::A(true), _) | (Either::A(false), _) => (),
-                D,
+        (Either::B(true, _), Either2::C) => (),
-            }
+        (Either::B(false, _), Either2::C) => (),
-            fn test_fn() {
+        (Either::B(_, _), Either2::D) => (),
-                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 => (),
-                }
-            }
-        ",
-        );
    }
+}
-    #[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(
+        check_diagnostics(
-            r"
+            r#"
-            fn test_fn() {
+enum Either { A, B }
-                match (0) {
+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(
+        check_diagnostics(
-            r"
+            r#"
-            enum Either {
+enum Either { A, B(u32) }
-                A,
-                B(u32),
-            }
-            fn test_fn() {
-                match Either::A {
-                    Either::A => (),
-                    Either::B() => (),
-                }
-            }
-        ",
-        );
-    }
-    #[test]
+fn main() {
-    fn enum_not_in_scope() {
+    match Either::A {
-        // The enum is not in scope so we don't perform exhaustiveness
+        Either::A => (),
-        // checking, but we want to be sure we don't panic here (and
+        Either::B() => (),
-        // we don't create a diagnostic).
+    }
-        check_no_diagnostic(
+}
-            r"
+"#,
-            fn test_fn() {
-                match Foo::Bar {
-                    Foo::Baz => (),
-                }
-            }
-        ",
        );
    }
    #[test]
    fn expr_diverges() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            enum Either {
+enum Either { A, B }
-                A,
-                B,
-            }
-            fn test_fn() {
-                match loop {} {
-                    Either::A => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
-    }
-    #[test]
+fn main() {
-    fn expr_loop_with_break() {
+    match loop {} {
-        check_no_diagnostic(
+        Either::A => (),
-            r"
+        Either::B => (),
-            enum Either {
+    }
-                A,
+    match loop {} {
-                B,
+        Either::A => (),
-            }
+    }
-            fn test_fn() {
+    match loop { break Foo::A } {
-                match loop { break Foo::A } {
+        //^^^^^^^^^^^^^^^^^^^^^ Missing match arm
-                    Either::A => (),
+        Either::A => (),
-                    Either::B => (),
+    }
-                }
+    match loop { break Foo::A } {
-            }
+        Either::A => (),
-        ",
+        Either::B => (),
+    }
+}
+"#,
        );
    }
    #[test]
    fn expr_partially_diverges() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            enum Either<T> {
+enum Either<T> { A(T), B }
-                A(T),
-                B,
-            }
-            fn foo() -> Either<!> {
-                Either::B
-            }
-            fn test_fn() -> u32 {
-                match foo() {
-                    Either::A(val) => val,
-                    Either::B => 0,
-                }
-            }
-        ",
-        );
-    }
-    #[test]
+fn foo() -> Either<!> { Either::B }
-    fn enum_record_no_arms() {
+fn main() -> u32 {
-        check_diagnostic(
+    match foo() {
-            r"
+        Either::A(val) => val,
-            enum Either {
+        Either::B => 0,
-                A { foo: bool },
-                B,
-            }
-            fn test_fn() {
-                let a = Either::A { foo: true };
-                match a {
-                }
-            }
-        ",
-        );
    }
+}
-    #[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() {
+    fn enum_record() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            enum Either {
+enum Either { A { foo: bool }, B }
-                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 => (),
-                }
-            }
-        ",
-        );
-    }
-    #[test]
+fn main() {
-    fn enum_record_missing_field_no_diagnostic() {
+    let a = Either::A { foo: true };
-        // When `Either::A` is missing a struct member, we don't want
+    match a { }
-        // to fire the missing match arm diagnostic. This should fire
+        //^ Missing match arm
-        // some other diagnostic.
+    match a { Either::A { foo: true } => () }
-        check_no_diagnostic(
+        //^ Missing match arm
-            r"
+    match a {
-            enum Either {
+        Either::A { } => (),
-                A { foo: bool },
+                //^^^ Missing structure fields:
-                B,
+                //  | - foo
-            }
+        Either::B => (),
-            fn test_fn() {
-                let a = Either::B;
-                match a {
-                    Either::A { } => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
    }
+    match a {
+        //^ Missing match arm
+        Either::A { } => (),
+    }           //^^^ Missing structure fields:
+                //  | - foo
-    #[test]
+    match a {
-    fn enum_record_missing_field_missing_match_arm() {
+        Either::A { foo: true } => (),
-        // Even though `Either::A` is missing fields, we still want to fire
+        Either::A { foo: false } => (),
-        // the missing arm diagnostic here, since we know `Either::B` is missing.
+        Either::B => (),
-        check_diagnostic(
-            r"
-            enum Either {
-                A { foo: bool },
-                B,
-            }
-            fn test_fn() {
-                let a = Either::B;
-                match a {
-                    Either::A { } => (),
-                }
-            }
-        ",
-        );
    }
+    match a {
-    #[test]
+        Either::A { foo: _ } => (),
-    fn enum_record_no_diagnostic_wild() {
+        Either::B => (),
-        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 => (),
-                }
-            }
-        ",
-        );
    }
+}
-    #[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() {
+    fn enum_record_fields_out_of_order() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            enum Either {
+enum Either {
-                A { foo: bool, bar: () },
+    A { foo: bool, bar: () },
-                B,
+    B,
-            }
+}
-            fn test_fn() {
-                let a = Either::A { foo: true };
-                match a {
-                    Either::A { bar: (), foo: false } => (),
-                    Either::A { foo: true, bar: () } => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
-    }
-    #[test]
+fn main() {
-    fn enum_record_ellipsis_missing_arm() {
+    let a = Either::A { foo: true, bar: () };
-        check_diagnostic(
+    match a {
-            r"
+        //^ Missing match arm
-            enum Either {
+        Either::A { bar: (), foo: false } => (),
-                A { foo: bool, bar: bool },
+        Either::A { foo: true, bar: () } => (),
-                B,
-            }
-            fn test_fn() {
-                match Either::B {
-                    Either::A { foo: true, .. } => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
    }
-    #[test]
+    match a {
-    fn enum_record_ellipsis_no_diagnostic() {
+        Either::A { bar: (), foo: false } => (),
-        check_no_diagnostic(
+        Either::A { foo: true, bar: () } => (),
-            r"
+        Either::B => (),
-            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 => (),
-                }
-            }
-        ",
-        );
    }
+}
-    #[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() {
+    fn enum_record_ellipsis() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            enum Either {
+enum Either {
-                A { foo: bool, bar: bool },
+    A { foo: bool, bar: bool },
-                B,
+    B,
-            }
+}
-            fn test_fn() {
-                let a = Either::B;
-                match a {
-                    Either::A { .. } => (),
-                    Either::B => (),
-                }
-            }
-        ",
-        );
-    }
-    #[test]
+fn main() {
-    fn enum_tuple_partial_ellipsis_no_diagnostic() {
+    let a = Either::B;
-        check_no_diagnostic(
+    match a {
-            r"
+        //^ Missing match arm
-            enum Either {
+        Either::A { foo: true, .. } => (),
-                A(bool, bool, bool, bool),
+        Either::B => (),
-                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 => {},
-                }
-            }
-        ",
-        );
    }
+    match a {
-    #[test]
+        //^ Missing match arm
-    fn enum_tuple_partial_ellipsis_2_no_diagnostic() {
+        Either::A { .. } => (),
-        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 => {},
-                }
-            }
-        ",
-        );
    }
-    #[test]
+    match a {
-    fn enum_tuple_partial_ellipsis_missing_arm() {
+        Either::A { foo: true, .. } => (),
-        check_diagnostic(
+        Either::A { foo: false, .. } => (),
-            r"
+        Either::B => (),
-            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 => {},
-                }
-            }
-        ",
-        );
    }
-    #[test]
+    match a {
-    fn enum_tuple_partial_ellipsis_2_missing_arm() {
+        Either::A { .. } => (),
-        check_diagnostic(
+        Either::B => (),
-            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 => {},
-                }
-            }
-        ",
-        );
    }
+}
-    #[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() {
+    fn enum_tuple_partial_ellipsis() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            enum Never {}
+enum Either {
+    A(bool, bool, bool, bool),
+    B,
+}
-            fn test_fn(never: Never) {
+fn main() {
-                match never {}
+    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() {
+    fn never() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            enum Never {}
+enum Never {}
-            fn test_fn(never: &Never) {
+fn enum_(never: Never) {
-                match never {}
+    match never {}
-            }
+}
-        ",
+fn enum_ref(never: &Never) {
-        );
+    match never {}
-    }
+}
+fn bang(never: !) {
-    #[test]
+    match never {}
-    fn expr_diverges_missing_arm() {
+}
-        check_no_diagnostic(
+"#,
-            r"
-            enum Either {
-                A,
-                B,
-            }
-            fn test_fn() {
-                match loop {} {
-                    Either::A => (),
-                }
-            }
-        ",
        );
    }
    #[test]
    fn or_pattern_panic() {
-        check_no_diagnostic(
+        check_diagnostics(
-            r"
+            r#"
-            pub enum Category {
+pub enum Category { Infinity, Zero }
-                Infinity,
-                Zero,
-            }
-            fn panic(a: Category, b: Category) {
+fn panic(a: Category, b: Category) {
-                match (a, b) {
+    match (a, b) {
-                    (Category::Zero | Category::Infinity, _) => {}
+        (Category::Zero | Category::Infinity, _) => (),
-                    (_, Category::Zero | Category::Infinity) => {}
+        (_, Category::Zero | Category::Infinity) => (),
-                }
-            }
-        ",
-        );
    }
-    #[test]
+    // FIXME: This is a false positive, but the code used to cause a panic in the match checker,
-    fn or_pattern_panic_2() {
+    // so this acts as a regression test for that.
-        // FIXME: This is a false positive, but the code used to cause a panic in the match checker,
+    match (a, b) {
-        // so this acts as a regression test for that.
+        //^^^^^^ Missing match arm
-        check_diagnostic(
+        (Category::Infinity, Category::Infinity) | (Category::Zero, Category::Zero) => (),
-            r"
+        (Category::Infinity | Category::Zero, _) => (),
-            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, _) => {}
-                }
-            }
-        ",
-        );
    }
 }
+"#,
-#[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
+    mod false_negatives {
-    //! test module should document known false negatives. Eventually we will have a complete
+        //! The implementation of match checking here is a work in progress. As we roll this out, we
-    //! implementation of match checking and this module will be empty.
+        //! 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
-    //! The reasons for documenting known false negatives:
+        //! implementation of match checking and this module will be empty.
-    //!
+        //!
-    //!   1. It acts as a backlog of work that can be done to improve the behavior of the system.
+        //! The reasons for documenting known false negatives:
-    //!   2. It ensures the code doesn't panic when handling these cases.
+        //!
+        //!   1. It acts as a backlog of work that can be done to improve the behavior of the system.
-    use super::tests::*;
+        //!   2. It ensures the code doesn't panic when handling these cases.
+        use super::*;
-    #[test]
-    fn integers() {
+        #[test]
-        // This is a false negative.
+        fn integers() {
-        // We don't currently check integer exhaustiveness.
+            // We don't currently check integer exhaustiveness.
-        check_no_diagnostic(
+            check_diagnostics(
-            r"
+                r#"
-            fn test_fn() {
+fn main() {
-                match 5 {
+    match 5 {
-                    10 => (),
+        10 => (),
-                    11..20 => (),
+        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) => (),
-                }
-            }
-        ",
-        );
    }
+}
+"#,
+            );
+        }
-    #[test]
+        #[test]
-    fn expr_loop_missing_arm() {
+        fn internal_or() {
-        // This is a false negative.
+            // We do not currently handle patterns with internal `or`s.
-        // We currently infer the type of `loop { break Foo::A }` to `!`, which
+            check_diagnostics(
-        // causes us to skip the diagnostic since `Either::A` doesn't type check
+                r#"
-        // with `!`.
+fn main() {
-        check_diagnostic(
+    enum Either { A(bool), B }
-            r"
+    match Either::B {
-            enum Either {
+        Either::A(true | false) => (),
-                A,
-                B,
-            }
-            fn test_fn() {
-                match loop { break Foo::A } {
-                    Either::A => (),
-                }
-            }
-        ",
-        );
    }
+}
+"#,
+            );
+        }
-    #[test]
+        #[test]
-    fn tuple_of_bools_with_ellipsis_at_end_missing_arm() {
+        fn tuple_of_bools_with_ellipsis_at_end_missing_arm() {
-        // This is a false negative.
+            // We don't currently handle tuple patterns with ellipsis.
-        // We don't currently handle tuple patterns with ellipsis.
+            check_diagnostics(
-        check_no_diagnostic(
+                r#"
-            r"
+fn main() {
-            fn test_fn() {
+    match (false, true, false) {
-                match (false, true, false) {
+        (false, ..) => (),
-                    (false, ..) => {},
-                }
-            }
-        ",
-        );
    }
+}
+"#,
+            );
+        }
-    #[test]
+        #[test]
-    fn tuple_of_bools_with_ellipsis_at_beginning_missing_arm() {
+        fn tuple_of_bools_with_ellipsis_at_beginning_missing_arm() {
-        // This is a false negative.
+            // We don't currently handle tuple patterns with ellipsis.
-        // We don't currently handle tuple patterns with ellipsis.
+            check_diagnostics(
-        check_no_diagnostic(
+                r#"
-            r"
+fn main() {
-            fn test_fn() {
+    match (false, true, false) {
-                match (false, true, false) {
+        (.., false) => (),
-                    (.., false) => {},
-                }
-            }
-        ",
-        );
    }
+}
+"#,
+            );
+        }
-    #[test]
+        #[test]
-    fn struct_missing_arm() {
+        fn struct_missing_arm() {
-        // This is a false negative.
+            // We don't currently handle structs.
-        // We don't currently handle structs.
+            check_diagnostics(
-        check_no_diagnostic(
+                r#"
-            r"
+struct Foo { a: bool }
-            struct Foo {
+fn main(f: Foo) {
-                a: bool,
+    match f { Foo { a: true } => () }
-            }
+}
-            fn test_fn(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..5cc76bdce 100644
--- a/crates/ra_hir_ty/src/unsafe_validation.rs
+++ b/crates/ra_hir_ty/src/diagnostics/unsafe_check.rs
@@ -6,35 +6,38 @@ use std::sync::Arc;
 use hir_def::{
    body::Body,
    expr::{Expr, ExprId, UnaryOp},
-    DefWithBodyId, FunctionId,
+    DefWithBodyId,
 };
 use hir_expand::diagnostics::DiagnosticSink;
 use crate::{
-    db::HirDatabase, diagnostics::MissingUnsafe, lower::CallableDef, ApplicationTy,
+    db::HirDatabase, diagnostics::MissingUnsafe, lower::CallableDefId, ApplicationTy,
    InferenceResult, Ty, TypeCtor,
 };
-pub struct UnsafeValidator<'a, 'b: 'a> {
+pub(super) struct UnsafeValidator<'a, 'b: 'a> {
-    func: FunctionId,
+    owner: DefWithBodyId,
    infer: Arc<InferenceResult>,
    sink: &'a mut DiagnosticSink<'b>,
 }
 impl<'a, 'b> UnsafeValidator<'a, 'b> {
-    pub fn new(
+    pub(super) fn new(
-        func: FunctionId,
+        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) {
+    pub(super) fn validate_body(&mut self, db: &dyn HirDatabase) {
-        let def = self.func.into();
+        let def = self.owner.into();
        let unsafe_expressions = unsafe_expressions(db, self.infer.as_ref(), def);
-        let func_data = db.function_data(self.func);
+        let is_unsafe = match self.owner {
-        if func_data.is_unsafe
+            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)
@@ -85,7 +88,7 @@ fn walk_unsafe(
        Expr::Call { callee, .. } => {
            let ty = &infer[*callee];
            if let &Ty::Apply(ApplicationTy {
-                ctor: TypeCtor::FnDef(CallableDef::FunctionId(func)),
+                ctor: TypeCtor::FnDef(CallableDefId::FunctionId(func)),
                ..
            }) = ty
            {
@@ -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 23cea1a2a..19770e609 100644
--- a/crates/ra_hir_ty/src/display.rs
+++ b/crates/ra_hir_ty/src/display.rs
@@ -3,7 +3,7 @@
 use std::fmt;
 use crate::{
-    db::HirDatabase, utils::generics, ApplicationTy, CallableDef, FnSig, GenericPredicate,
+    db::HirDatabase, utils::generics, ApplicationTy, CallableDefId, FnSig, GenericPredicate,
    Obligation, OpaqueTyId, ProjectionTy, Substs, TraitRef, Ty, TypeCtor,
 };
 use hir_def::{
@@ -243,22 +243,36 @@ impl HirDisplay for ApplicationTy {
                    write!(f, ")")?;
                }
            }
-            TypeCtor::FnPtr { .. } => {
+            TypeCtor::FnPtr { is_varargs, .. } => {
-                let sig = FnSig::from_fn_ptr_substs(&self.parameters);
+                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() {
-                    write!(f, " -> {}", ret.display(f.db))?;
+                    let ret_display = if f.omit_verbose_types() {
+                        ret.display_truncated(f.db, f.max_size)
+                    } else {
+                        ret.display(f.db)
+                    };
+                    write!(f, " -> {}", ret_display)?;
                }
            }
            TypeCtor::FnDef(def) => {
                let sig = f.db.callable_item_signature(def).subst(&self.parameters);
                match def {
-                    CallableDef::FunctionId(ff) => write!(f, "fn {}", f.db.function_data(ff).name)?,
+                    CallableDefId::FunctionId(ff) => {
-                    CallableDef::StructId(s) => write!(f, "{}", f.db.struct_data(s).name)?,
+                        write!(f, "fn {}", f.db.function_data(ff).name)?
-                    CallableDef::EnumVariantId(e) => {
+                    }
+                    CallableDefId::StructId(s) => write!(f, "{}", f.db.struct_data(s).name)?,
+                    CallableDefId::EnumVariantId(e) => {
                        write!(f, "{}", f.db.enum_data(e.parent).variants[e.local_id].name)?
                    }
                };
@@ -279,7 +293,12 @@ impl HirDisplay for ApplicationTy {
                write!(f, ")")?;
                let ret = sig.ret();
                if *ret != Ty::unit() {
-                    write!(f, " -> {}", ret.display(f.db))?;
+                    let ret_display = if f.omit_verbose_types() {
+                        ret.display_truncated(f.db, f.max_size)
+                    } else {
+                        ret.display(f.db)
+                    };
+                    write!(f, " -> {}", ret_display)?;
                }
            }
            TypeCtor::Adt(def_id) => {
@@ -369,7 +388,7 @@ impl HirDisplay for ApplicationTy {
                        let data = (*datas)
                            .as_ref()
                            .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone());
-                        data.clone().subst(&self.parameters)
+                        data.subst(&self.parameters)
                    }
                };
                write!(f, "impl ")?;
@@ -388,7 +407,13 @@ impl HirDisplay for ApplicationTy {
                        f.write_joined(sig.params(), ", ")?;
                        write!(f, "|")?;
                    };
-                    write!(f, " -> {}", sig.ret().display(f.db))?;
+                    let ret_display = if f.omit_verbose_types() {
+                        sig.ret().display_truncated(f.db, f.max_size)
+                    } else {
+                        sig.ret().display(f.db)
+                    };
+                    write!(f, " -> {}", ret_display)?;
                } else {
                    write!(f, "{{closure}}")?;
                }
@@ -456,7 +481,7 @@ impl HirDisplay for Ty {
                        let data = (*datas)
                            .as_ref()
                            .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone());
-                        data.clone().subst(&opaque_ty.parameters)
+                        data.subst(&opaque_ty.parameters)
                    }
                };
                write!(f, "impl ")?;
diff --git a/crates/ra_hir_ty/src/infer.rs b/crates/ra_hir_ty/src/infer.rs
index 3719f76a6..28f32a0a4 100644
--- a/crates/ra_hir_ty/src/infer.rs
+++ b/crates/ra_hir_ty/src/infer.rs
@@ -18,8 +18,6 @@ use std::mem;
 use std::ops::Index;
 use std::sync::Arc;
-use rustc_hash::FxHashMap;
 use hir_def::{
    body::Body,
    data::{ConstData, FunctionData, StaticData},
@@ -28,13 +26,15 @@ use hir_def::{
    path::{path, Path},
    resolver::{HasResolver, Resolver, TypeNs},
    type_ref::{Mutability, TypeRef},
-    AdtId, AssocItemId, DefWithBodyId, EnumVariantId, FieldId, FunctionId, TraitId, TypeAliasId,
+    AdtId, AssocItemId, DefWithBodyId, EnumVariantId, FieldId, FunctionId, Lookup, TraitId,
-    VariantId,
+    TypeAliasId, VariantId,
 };
 use hir_expand::{diagnostics::DiagnosticSink, name::name};
 use ra_arena::map::ArenaMap;
 use ra_prof::profile;
 use ra_syntax::SmolStr;
+use rustc_hash::FxHashMap;
+use stdx::impl_from;
 use super::{
    primitive::{FloatTy, IntTy},
@@ -84,8 +84,7 @@ enum ExprOrPatId {
    ExprId(ExprId),
    PatId(PatId),
 }
+impl_from!(ExprId, PatId for ExprOrPatId);
-impl_froms!(ExprOrPatId: ExprId, PatId);
 /// Binding modes inferred for patterns.
 /// https://doc.rust-lang.org/reference/patterns.html#binding-modes
@@ -169,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))
@@ -376,17 +375,21 @@ impl<'a> InferenceContext<'a> {
    ) -> Ty {
        match assoc_ty {
            Some(res_assoc_ty) => {
+                let trait_ = match res_assoc_ty.lookup(self.db.upcast()).container {
+                    hir_def::AssocContainerId::TraitId(trait_) => trait_,
+                    _ => panic!("resolve_associated_type called with non-associated type"),
+                };
                let ty = self.table.new_type_var();
-                let builder = Substs::build_for_def(self.db, res_assoc_ty)
+                let substs = Substs::build_for_def(self.db, res_assoc_ty)
                    .push(inner_ty)
-                    .fill(params.iter().cloned());
+                    .fill(params.iter().cloned())
+                    .build();
+                let trait_ref = TraitRef { trait_, substs: substs.clone() };
                let projection = ProjectionPredicate {
                    ty: ty.clone(),
-                    projection_ty: ProjectionTy {
+                    projection_ty: ProjectionTy { associated_ty: res_assoc_ty, parameters: substs },
-                        associated_ty: res_assoc_ty,
-                        parameters: builder.build(),
-                    },
                };
+                self.obligations.push(Obligation::Trait(trait_ref));
                self.obligations.push(Obligation::Projection(projection));
                self.resolve_ty_as_possible(ty)
            }
@@ -757,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::{
@@ -775,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 22884522a..731b062c2 100644
--- a/crates/ra_hir_ty/src/infer/expr.rs
+++ b/crates/ra_hir_ty/src/infer/expr.rs
@@ -17,7 +17,7 @@ use crate::{
    autoderef, method_resolution, op,
    traits::{FnTrait, InEnvironment},
    utils::{generics, variant_data, Generics},
-    ApplicationTy, Binders, CallableDef, InferTy, IntTy, Mutability, Obligation, Rawness, Substs,
+    ApplicationTy, Binders, CallableDefId, InferTy, IntTy, Mutability, Obligation, Rawness, Substs,
    TraitRef, Ty, TypeCtor,
 };
@@ -85,10 +85,8 @@ impl<'a> InferenceContext<'a> {
            ctor: TypeCtor::Tuple { cardinality: num_args as u16 },
            parameters,
        });
-        let substs = Substs::build_for_generics(&generic_params)
+        let substs =
-            .push(ty.clone())
+            Substs::build_for_generics(&generic_params).push(ty.clone()).push(arg_ty).build();
-            .push(arg_ty.clone())
-            .build();
        let trait_env = Arc::clone(&self.trait_env);
        let implements_fn_trait =
@@ -222,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 =
@@ -407,8 +405,15 @@ impl<'a> InferenceContext<'a> {
                                    .subst(&a_ty.parameters)
                            })
                        }
-                        // FIXME:
+                        TypeCtor::Adt(AdtId::UnionId(u)) => {
-                        TypeCtor::Adt(AdtId::UnionId(_)) => None,
+                            self.db.union_data(u).variant_data.field(name).map(|local_id| {
+                                let field = FieldId { parent: u.into(), local_id };
+                                self.write_field_resolution(tgt_expr, field);
+                                self.db.field_types(u.into())[field.local_id]
+                                    .clone()
+                                    .subst(&a_ty.parameters)
+                            })
+                        }
                        _ => None,
                    },
                    _ => None,
@@ -849,7 +854,7 @@ impl<'a> InferenceContext<'a> {
                }
                // add obligation for trait implementation, if this is a trait method
                match def {
-                    CallableDef::FunctionId(f) => {
+                    CallableDefId::FunctionId(f) => {
                        if let AssocContainerId::TraitId(trait_) =
                            f.lookup(self.db.upcast()).container
                        {
@@ -860,7 +865,7 @@ impl<'a> InferenceContext<'a> {
                            self.obligations.push(Obligation::Trait(TraitRef { trait_, substs }));
                        }
                    }
-                    CallableDef::StructId(_) | CallableDef::EnumVariantId(_) => {}
+                    CallableDefId::StructId(_) | CallableDefId::EnumVariantId(_) => {}
                }
            }
        }
diff --git a/crates/ra_hir_ty/src/infer/unify.rs b/crates/ra_hir_ty/src/infer/unify.rs
index 269495ca0..2e895d911 100644
--- a/crates/ra_hir_ty/src/infer/unify.rs
+++ b/crates/ra_hir_ty/src/infer/unify.rs
@@ -9,7 +9,7 @@ use test_utils::mark;
 use super::{InferenceContext, Obligation};
 use crate::{
    BoundVar, Canonical, DebruijnIndex, GenericPredicate, InEnvironment, InferTy, Substs, Ty,
-    TypeCtor, TypeWalk,
+    TyKind, TypeCtor, TypeWalk,
 };
 impl<'a> InferenceContext<'a> {
@@ -86,10 +86,20 @@ where
    }
    fn into_canonicalized<T>(self, result: T) -> Canonicalized<T> {
-        Canonicalized {
+        let kinds = self
-            value: Canonical { value: result, num_vars: self.free_vars.len() },
+            .free_vars
-            free_vars: self.free_vars,
+            .iter()
-        }
+            .map(|v| match v {
+                // mapping MaybeNeverTypeVar to the same kind as general ones
+                // should be fine, because as opposed to int or float type vars,
+                // they don't restrict what kind of type can go into them, they
+                // just affect fallback.
+                InferTy::TypeVar(_) | InferTy::MaybeNeverTypeVar(_) => TyKind::General,
+                InferTy::IntVar(_) => TyKind::Integer,
+                InferTy::FloatVar(_) => TyKind::Float,
+            })
+            .collect();
+        Canonicalized { value: Canonical { value: result, kinds }, free_vars: self.free_vars }
    }
    pub(crate) fn canonicalize_ty(mut self, ty: Ty) -> Canonicalized<Ty> {
@@ -131,26 +141,41 @@ impl<T> Canonicalized<T> {
        ty
    }
-    pub fn apply_solution(&self, ctx: &mut InferenceContext<'_>, solution: Canonical<Vec<Ty>>) {
+    pub fn apply_solution(&self, ctx: &mut InferenceContext<'_>, solution: Canonical<Substs>) {
        // the solution may contain new variables, which we need to convert to new inference vars
-        let new_vars = Substs((0..solution.num_vars).map(|_| ctx.table.new_type_var()).collect());
+        let new_vars = Substs(
+            solution
+                .kinds
+                .iter()
+                .map(|k| match k {
+                    TyKind::General => ctx.table.new_type_var(),
+                    TyKind::Integer => ctx.table.new_integer_var(),
+                    TyKind::Float => ctx.table.new_float_var(),
+                })
+                .collect(),
+        );
        for (i, ty) in solution.value.into_iter().enumerate() {
            let var = self.free_vars[i];
            // eagerly replace projections in the type; we may be getting types
            // e.g. from where clauses where this hasn't happened yet
-            let ty = ctx.normalize_associated_types_in(ty.subst_bound_vars(&new_vars));
+            let ty = ctx.normalize_associated_types_in(ty.clone().subst_bound_vars(&new_vars));
            ctx.table.unify(&Ty::Infer(var), &ty);
        }
    }
 }
-pub fn unify(ty1: &Canonical<Ty>, ty2: &Canonical<Ty>) -> Option<Substs> {
+pub fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substs> {
    let mut table = InferenceTable::new();
-    let num_vars = ty1.num_vars.max(ty2.num_vars);
+    let vars = Substs(
-    let vars =
+        tys.kinds
-        Substs::builder(num_vars).fill(std::iter::repeat_with(|| table.new_type_var())).build();
+            .iter()
-    let ty1_with_vars = ty1.value.clone().subst_bound_vars(&vars);
+            // we always use type vars here because we want everything to
-    let ty2_with_vars = ty2.value.clone().subst_bound_vars(&vars);
+            // fallback to Unknown in the end (kind of hacky, as below)
+            .map(|_| table.new_type_var())
+            .collect(),
+    );
+    let ty1_with_vars = tys.value.0.clone().subst_bound_vars(&vars);
+    let ty2_with_vars = tys.value.1.clone().subst_bound_vars(&vars);
    if !table.unify(&ty1_with_vars, &ty2_with_vars) {
        return None;
    }
@@ -162,7 +187,7 @@ pub fn unify(ty1: &Canonical<Ty>, ty2: &Canonical<Ty>) -> Option<Substs> {
        }
    }
    Some(
-        Substs::builder(ty1.num_vars)
+        Substs::builder(tys.kinds.len())
            .fill(vars.iter().map(|v| table.resolve_ty_completely(v.clone())))
            .build(),
    )
diff --git a/crates/ra_hir_ty/src/lib.rs b/crates/ra_hir_ty/src/lib.rs
index c9513b752..7698cb0d4 100644
--- a/crates/ra_hir_ty/src/lib.rs
+++ b/crates/ra_hir_ty/src/lib.rs
@@ -6,25 +6,6 @@ macro_rules! eprintln {
    ($($tt:tt)*) => { stdx::eprintln!($($tt)*) };
 }
-macro_rules! impl_froms {
-    ($e:ident: $($v:ident $(($($sv:ident),*))?),*) => {
-        $(
-            impl From<$v> for $e {
-                fn from(it: $v) -> $e {
-                    $e::$v(it)
-                }
-            }
-            $($(
-                impl From<$sv> for $e {
-                    fn from(it: $sv) -> $e {
-                        $e::$v($v::$sv(it))
-                    }
-                }
-            )*)?
-        )*
-    }
-}
 mod autoderef;
 pub mod primitive;
 pub mod traits;
@@ -32,22 +13,18 @@ pub mod method_resolution;
 mod op;
 mod lower;
 pub(crate) mod infer;
-pub mod display;
 pub(crate) mod utils;
+pub mod display;
 pub mod db;
 pub mod diagnostics;
-pub mod expr;
-pub mod unsafe_validation;
 #[cfg(test)]
 mod tests;
 #[cfg(test)]
 mod test_db;
-mod _match;
-use std::ops::Deref;
+use std::{iter, mem, ops::Deref, sync::Arc};
-use std::sync::Arc;
-use std::{iter, mem};
 use hir_def::{
    expr::ExprId,
@@ -55,18 +32,19 @@ use hir_def::{
    AdtId, AssocContainerId, DefWithBodyId, GenericDefId, HasModule, Lookup, TraitId, TypeAliasId,
    TypeParamId,
 };
-use ra_db::{impl_intern_key, salsa, CrateId};
+use itertools::Itertools;
+use ra_db::{salsa, CrateId};
 use crate::{
    db::HirDatabase,
+    display::HirDisplay,
    primitive::{FloatTy, IntTy},
    utils::{generics, make_mut_slice, Generics},
 };
-use display::HirDisplay;
 pub use autoderef::autoderef;
 pub use infer::{InferTy, InferenceResult};
-pub use lower::CallableDef;
+pub use lower::CallableDefId;
 pub use lower::{
    associated_type_shorthand_candidates, callable_item_sig, ImplTraitLoweringMode, TyDefId,
    TyLoweringContext, ValueTyDefId,
@@ -74,7 +52,6 @@ pub use lower::{
 pub use traits::{InEnvironment, Obligation, ProjectionPredicate, TraitEnvironment};
 pub use chalk_ir::{BoundVar, DebruijnIndex};
-use itertools::Itertools;
 /// A type constructor or type name: this might be something like the primitive
 /// type `bool`, a struct like `Vec`, or things like function pointers or
@@ -125,7 +102,7 @@ pub enum TypeCtor {
    /// fn foo() -> i32 { 1 }
    /// let bar = foo; // bar: fn() -> i32 {foo}
    /// ```
-    FnDef(CallableDef),
+    FnDef(CallableDefId),
    /// A pointer to a function.  Written as `fn() -> i32`.
    ///
@@ -135,7 +112,8 @@ pub enum TypeCtor {
    /// fn foo() -> i32 { 1 }
    /// let bar: fn() -> i32 = foo;
    /// ```
-    FnPtr { num_args: u16 },
+    // FIXME make this a Ty variant like in Chalk
+    FnPtr { num_args: u16, is_varargs: bool },
    /// The never type `!`.
    Never,
@@ -162,19 +140,6 @@ pub enum TypeCtor {
    Closure { def: DefWithBodyId, expr: ExprId },
 }
-/// This exists just for Chalk, because Chalk just has a single `StructId` where
-/// we have different kinds of ADTs, primitive types and special type
-/// constructors like tuples and function pointers.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
-pub struct TypeCtorId(salsa::InternId);
-impl_intern_key!(TypeCtorId);
-/// This exists just for Chalk, because Chalk just has a single `FnDefId` where
-/// we have different IDs for struct and enum variant constructors.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
-pub struct CallableDefId(salsa::InternId);
-impl_intern_key!(CallableDefId);
 impl TypeCtor {
    pub fn num_ty_params(self, db: &dyn HirDatabase) -> usize {
        match self {
@@ -210,7 +175,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,
        }
    }
@@ -662,13 +627,27 @@ impl TypeWalk for GenericPredicate {
 /// Basically a claim (currently not validated / checked) that the contained
 /// type / trait ref contains no inference variables; any inference variables it
-/// contained have been replaced by bound variables, and `num_vars` tells us how
+/// contained have been replaced by bound variables, and `kinds` tells us how
-/// many there are. This is used to erase irrelevant differences between types
+/// many there are and whether they were normal or float/int variables. This is
-/// before using them in queries.
+/// used to erase irrelevant differences between types before using them in
+/// queries.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Canonical<T> {
    pub value: T,
-    pub num_vars: usize,
+    pub kinds: Arc<[TyKind]>,
+}
+impl<T> Canonical<T> {
+    pub fn new(value: T, kinds: impl IntoIterator<Item = TyKind>) -> Self {
+        Self { value, kinds: kinds.into_iter().collect() }
+    }
+}
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum TyKind {
+    General,
+    Integer,
+    Float,
 }
 /// A function signature as seen by type inference: Several parameter types and
@@ -676,19 +655,20 @@ pub struct Canonical<T> {
 #[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 {
+    pub fn from_fn_ptr_substs(substs: &Substs, is_varargs: bool) -> FnSig {
-        FnSig { params_and_return: Arc::clone(&substs.0) }
+        FnSig { params_and_return: Arc::clone(&substs.0), is_varargs }
    }
    pub fn params(&self) -> &[Ty] {
@@ -733,7 +713,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),
        )
    }
@@ -787,15 +767,6 @@ impl Ty {
        }
    }
-    pub fn as_callable(&self) -> Option<(CallableDef, &Substs)> {
-        match self {
-            Ty::Apply(ApplicationTy { ctor: TypeCtor::FnDef(callable_def), parameters }) => {
-                Some((*callable_def, parameters))
-            }
-            _ => None,
-        }
-    }
    pub fn is_never(&self) -> bool {
        matches!(self, Ty::Apply(ApplicationTy { ctor: TypeCtor::Never, .. }))
    }
@@ -827,10 +798,12 @@ impl Ty {
        }
    }
-    fn callable_sig(&self, db: &dyn HirDatabase) -> Option<FnSig> {
+    pub 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))
@@ -877,7 +850,7 @@ impl Ty {
                            let data = (*it)
                                .as_ref()
                                .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone());
-                            data.clone().subst(&opaque_ty.parameters)
+                            data.subst(&opaque_ty.parameters)
                        })
                    }
                };
diff --git a/crates/ra_hir_ty/src/lower.rs b/crates/ra_hir_ty/src/lower.rs
index 3dc154e92..1eacc6f95 100644
--- a/crates/ra_hir_ty/src/lower.rs
+++ b/crates/ra_hir_ty/src/lower.rs
@@ -5,10 +5,7 @@
 //!  - Building the type for an item: This happens through the `type_for_def` query.
 //!
 //! This usually involves resolving names, collecting generic arguments etc.
-use std::iter;
+use std::{iter, sync::Arc};
-use std::sync::Arc;
-use smallvec::SmallVec;
 use hir_def::{
    adt::StructKind,
@@ -24,6 +21,8 @@ use hir_def::{
 use hir_expand::name::Name;
 use ra_arena::map::ArenaMap;
 use ra_db::CrateId;
+use smallvec::SmallVec;
+use stdx::impl_from;
 use test_utils::mark;
 use crate::{
@@ -177,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));
@@ -339,7 +341,7 @@ impl Ty {
                    let segment = remaining_segments.first().unwrap();
                    let found = associated_type_by_name_including_super_traits(
                        ctx.db,
-                        trait_ref.clone(),
+                        trait_ref,
                        &segment.name,
                    );
                    match found {
@@ -720,8 +722,7 @@ fn assoc_type_bindings_from_type_bound<'a>(
                None => return SmallVec::<[GenericPredicate; 1]>::new(),
                Some(t) => t,
            };
-            let projection_ty =
+            let projection_ty = ProjectionTy { associated_ty, parameters: super_trait_ref.substs };
-                ProjectionTy { associated_ty, parameters: super_trait_ref.substs.clone() };
            let mut preds = SmallVec::with_capacity(
                binding.type_ref.as_ref().map_or(0, |_| 1) + binding.bounds.len(),
            );
@@ -767,11 +768,11 @@ fn count_impl_traits(type_ref: &TypeRef) -> usize {
 }
 /// Build the signature of a callable item (function, struct or enum variant).
-pub fn callable_item_sig(db: &dyn HirDatabase, def: CallableDef) -> PolyFnSig {
+pub fn callable_item_sig(db: &dyn HirDatabase, def: CallableDefId) -> PolyFnSig {
    match def {
-        CallableDef::FunctionId(f) => fn_sig_for_fn(db, f),
+        CallableDefId::FunctionId(f) => fn_sig_for_fn(db, f),
-        CallableDef::StructId(s) => fn_sig_for_struct_constructor(db, s),
+        CallableDefId::StructId(s) => fn_sig_for_struct_constructor(db, s),
-        CallableDef::EnumVariantId(e) => fn_sig_for_enum_variant_constructor(db, e),
+        CallableDefId::EnumVariantId(e) => fn_sig_for_enum_variant_constructor(db, e),
    }
 }
@@ -998,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
@@ -1049,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.
@@ -1073,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<_>>();