4 files changed, 692 insertions, 26 deletions

diff --git a/crates/hir/Cargo.toml b/crates/hir/Cargo.toml
index 560b15238..7c148fd40 100644
--- a/crates/hir/Cargo.toml
+++ b/crates/hir/Cargo.toml
@@ -16,6 +16,7 @@ either = "1.5.3"
 arrayvec = "0.7"
 itertools = "0.10.0"
 smallvec = "1.4.0"
+once_cell = "1"
 
 stdx = { path = "../stdx", version = "0.0.0" }
 syntax = { path = "../syntax", version = "0.0.0" }
diff --git a/crates/hir/src/diagnostics.rs b/crates/hir/src/diagnostics.rs
index 2cdbd172a..8a7c3a4fd 100644
--- a/crates/hir/src/diagnostics.rs
+++ b/crates/hir/src/diagnostics.rs
@@ -7,17 +7,12 @@ use std::any::Any;
 
 use cfg::{CfgExpr, CfgOptions, DnfExpr};
 use hir_def::path::ModPath;
-use hir_expand::{HirFileId, InFile};
+use hir_expand::{name::Name, HirFileId, InFile};
 use stdx::format_to;
 use syntax::{ast, AstPtr, SyntaxNodePtr, TextRange};
 
-pub use hir_ty::{
-    diagnostics::{
-        IncorrectCase, MismatchedArgCount, MissingFields, MissingMatchArms,
-        MissingOkOrSomeInTailExpr, NoSuchField, RemoveThisSemicolon,
-        ReplaceFilterMapNextWithFindMap,
-    },
-    diagnostics_sink::{Diagnostic, DiagnosticCode, DiagnosticSink, DiagnosticSinkBuilder},
+pub use crate::diagnostics_sink::{
+    Diagnostic, DiagnosticCode, DiagnosticSink, DiagnosticSinkBuilder,
 };
 
 // Diagnostic: unresolved-module
@@ -251,3 +246,364 @@ impl Diagnostic for UnimplementedBuiltinMacro {
         self
     }
 }
+
+// Diagnostic: no-such-field
+//
+// This diagnostic is triggered if created structure does not have field provided in record.
+#[derive(Debug)]
+pub struct NoSuchField {
+    pub file: HirFileId,
+    pub field: AstPtr<ast::RecordExprField>,
+}
+
+impl Diagnostic for NoSuchField {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("no-such-field")
+    }
+
+    fn message(&self) -> String {
+        "no such field".to_string()
+    }
+
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile::new(self.file, self.field.clone().into())
+    }
+
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+}
+
+// Diagnostic: break-outside-of-loop
+//
+// This diagnostic is triggered if the `break` keyword is used outside of a loop.
+#[derive(Debug)]
+pub struct BreakOutsideOfLoop {
+    pub file: HirFileId,
+    pub expr: AstPtr<ast::Expr>,
+}
+
+impl Diagnostic for BreakOutsideOfLoop {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("break-outside-of-loop")
+    }
+    fn message(&self) -> String {
+        "break outside of loop".to_string()
+    }
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile { file_id: self.file, value: self.expr.clone().into() }
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+}
+
+// Diagnostic: missing-unsafe
+//
+// This diagnostic is triggered if an operation marked as `unsafe` is used outside of an `unsafe` function or block.
+#[derive(Debug)]
+pub struct MissingUnsafe {
+    pub file: HirFileId,
+    pub expr: AstPtr<ast::Expr>,
+}
+
+impl Diagnostic for MissingUnsafe {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("missing-unsafe")
+    }
+    fn message(&self) -> String {
+        format!("This operation is unsafe and requires an unsafe function or block")
+    }
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile { file_id: self.file, value: self.expr.clone().into() }
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+}
+
+// Diagnostic: missing-structure-fields
+//
+// This diagnostic is triggered if record lacks some fields that exist in the corresponding structure.
+//
+// Example:
+//
+// ```rust
+// struct A { a: u8, b: u8 }
+//
+// let a = A { a: 10 };
+// ```
+#[derive(Debug)]
+pub struct MissingFields {
+    pub file: HirFileId,
+    pub field_list_parent: AstPtr<ast::RecordExpr>,
+    pub field_list_parent_path: Option<AstPtr<ast::Path>>,
+    pub missed_fields: Vec<Name>,
+}
+
+impl Diagnostic for MissingFields {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("missing-structure-fields")
+    }
+    fn message(&self) -> String {
+        let mut buf = String::from("Missing structure fields:\n");
+        for field in &self.missed_fields {
+            format_to!(buf, "- {}\n", field);
+        }
+        buf
+    }
+
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile {
+            file_id: self.file,
+            value: self
+                .field_list_parent_path
+                .clone()
+                .map(SyntaxNodePtr::from)
+                .unwrap_or_else(|| self.field_list_parent.clone().into()),
+        }
+    }
+
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+}
+
+// Diagnostic: missing-pat-fields
+//
+// This diagnostic is triggered if pattern lacks some fields that exist in the corresponding structure.
+//
+// Example:
+//
+// ```rust
+// struct A { a: u8, b: u8 }
+//
+// let a = A { a: 10, b: 20 };
+//
+// if let A { a } = a {
+//     // ...
+// }
+// ```
+#[derive(Debug)]
+pub struct MissingPatFields {
+    pub file: HirFileId,
+    pub field_list_parent: AstPtr<ast::RecordPat>,
+    pub field_list_parent_path: Option<AstPtr<ast::Path>>,
+    pub missed_fields: Vec<Name>,
+}
+
+impl Diagnostic for MissingPatFields {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("missing-pat-fields")
+    }
+    fn message(&self) -> String {
+        let mut buf = String::from("Missing structure fields:\n");
+        for field in &self.missed_fields {
+            format_to!(buf, "- {}\n", field);
+        }
+        buf
+    }
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile {
+            file_id: self.file,
+            value: self
+                .field_list_parent_path
+                .clone()
+                .map(SyntaxNodePtr::from)
+                .unwrap_or_else(|| self.field_list_parent.clone().into()),
+        }
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+}
+
+// Diagnostic: replace-filter-map-next-with-find-map
+//
+// This diagnostic is triggered when `.filter_map(..).next()` is used, rather than the more concise `.find_map(..)`.
+#[derive(Debug)]
+pub struct ReplaceFilterMapNextWithFindMap {
+    pub file: HirFileId,
+    /// This expression is the whole method chain up to and including `.filter_map(..).next()`.
+    pub next_expr: AstPtr<ast::Expr>,
+}
+
+impl Diagnostic for ReplaceFilterMapNextWithFindMap {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("replace-filter-map-next-with-find-map")
+    }
+    fn message(&self) -> String {
+        "replace filter_map(..).next() with find_map(..)".to_string()
+    }
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile { file_id: self.file, value: self.next_expr.clone().into() }
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+}
+
+// Diagnostic: mismatched-arg-count
+//
+// This diagnostic is triggered if a function is invoked with an incorrect amount of arguments.
+#[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 code(&self) -> DiagnosticCode {
+        DiagnosticCode("mismatched-arg-count")
+    }
+    fn message(&self) -> String {
+        let s = if self.expected == 1 { "" } else { "s" };
+        format!("Expected {} argument{}, found {}", self.expected, s, self.found)
+    }
+    fn display_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
+    }
+}
+
+#[derive(Debug)]
+pub struct RemoveThisSemicolon {
+    pub file: HirFileId,
+    pub expr: AstPtr<ast::Expr>,
+}
+
+impl Diagnostic for RemoveThisSemicolon {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("remove-this-semicolon")
+    }
+
+    fn message(&self) -> String {
+        "Remove this semicolon".to_string()
+    }
+
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile { file_id: self.file, value: self.expr.clone().into() }
+    }
+
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+}
+
+// Diagnostic: missing-ok-or-some-in-tail-expr
+//
+// This diagnostic is triggered if a block that should return `Result` returns a value not wrapped in `Ok`,
+// or if a block that should return `Option` returns a value not wrapped in `Some`.
+//
+// Example:
+//
+// ```rust
+// fn foo() -> Result<u8, ()> {
+//     10
+// }
+// ```
+#[derive(Debug)]
+pub struct MissingOkOrSomeInTailExpr {
+    pub file: HirFileId,
+    pub expr: AstPtr<ast::Expr>,
+    // `Some` or `Ok` depending on whether the return type is Result or Option
+    pub required: String,
+}
+
+impl Diagnostic for MissingOkOrSomeInTailExpr {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("missing-ok-or-some-in-tail-expr")
+    }
+    fn message(&self) -> String {
+        format!("wrap return expression in {}", self.required)
+    }
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile { file_id: self.file, value: self.expr.clone().into() }
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+}
+
+// Diagnostic: missing-match-arm
+//
+// This diagnostic is triggered if `match` block is missing one or more match arms.
+#[derive(Debug)]
+pub struct MissingMatchArms {
+    pub file: HirFileId,
+    pub match_expr: AstPtr<ast::Expr>,
+    pub arms: AstPtr<ast::MatchArmList>,
+}
+
+impl Diagnostic for MissingMatchArms {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("missing-match-arm")
+    }
+    fn message(&self) -> String {
+        String::from("Missing match arm")
+    }
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile { file_id: self.file, value: self.match_expr.clone().into() }
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+}
+
+#[derive(Debug)]
+pub struct InternalBailedOut {
+    pub file: HirFileId,
+    pub pat_syntax_ptr: SyntaxNodePtr,
+}
+
+impl Diagnostic for InternalBailedOut {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("internal:match-check-bailed-out")
+    }
+    fn message(&self) -> String {
+        format!("Internal: match check bailed out")
+    }
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile { file_id: self.file, value: self.pat_syntax_ptr.clone() }
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+}
+
+pub use hir_ty::diagnostics::IncorrectCase;
+
+impl Diagnostic for IncorrectCase {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("incorrect-ident-case")
+    }
+
+    fn message(&self) -> String {
+        format!(
+            "{} `{}` should have {} name, e.g. `{}`",
+            self.ident_type,
+            self.ident_text,
+            self.expected_case.to_string(),
+            self.suggested_text
+        )
+    }
+
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile::new(self.file, self.ident.clone().into())
+    }
+
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+
+    fn is_experimental(&self) -> bool {
+        true
+    }
+}
diff --git a/crates/hir/src/diagnostics_sink.rs b/crates/hir/src/diagnostics_sink.rs
new file mode 100644
index 000000000..084fa8b06
--- /dev/null
+++ b/crates/hir/src/diagnostics_sink.rs
@@ -0,0 +1,109 @@
+//! Semantic errors and warnings.
+//!
+//! The `Diagnostic` trait defines a trait object which can represent any
+//! diagnostic.
+//!
+//! `DiagnosticSink` struct is used as an emitter for diagnostic. When creating
+//! a `DiagnosticSink`, you supply a callback which can react to a `dyn
+//! Diagnostic` or to any concrete diagnostic (downcasting is used internally).
+//!
+//! Because diagnostics store file offsets, it's a bad idea to store them
+//! directly in salsa. For this reason, every hir subsytem defines it's own
+//! strongly-typed closed set of diagnostics which use hir ids internally, are
+//! stored in salsa and do *not* implement the `Diagnostic` trait. Instead, a
+//! subsystem provides a separate, non-query-based API which can walk all stored
+//! values and transform them into instances of `Diagnostic`.
+
+use std::{any::Any, fmt};
+
+use hir_expand::InFile;
+use syntax::SyntaxNodePtr;
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct DiagnosticCode(pub &'static str);
+
+impl DiagnosticCode {
+    pub fn as_str(&self) -> &str {
+        self.0
+    }
+}
+
+pub trait Diagnostic: Any + Send + Sync + fmt::Debug + 'static {
+    fn code(&self) -> DiagnosticCode;
+    fn message(&self) -> String;
+    /// Source element that triggered the diagnostics.
+    ///
+    /// Note that this should reflect "semantics", rather than specific span we
+    /// want to highlight. When rendering the diagnostics into an error message,
+    /// the IDE will fetch the `SyntaxNode` and will narrow the span
+    /// appropriately.
+    fn display_source(&self) -> InFile<SyntaxNodePtr>;
+    fn as_any(&self) -> &(dyn Any + Send + 'static);
+    fn is_experimental(&self) -> bool {
+        false
+    }
+}
+
+pub struct DiagnosticSink<'a> {
+    callbacks: Vec<Box<dyn FnMut(&dyn Diagnostic) -> Result<(), ()> + 'a>>,
+    filters: Vec<Box<dyn FnMut(&dyn Diagnostic) -> bool + 'a>>,
+    default_callback: Box<dyn FnMut(&dyn Diagnostic) + 'a>,
+}
+
+impl<'a> DiagnosticSink<'a> {
+    pub fn push(&mut self, d: impl Diagnostic) {
+        let d: &dyn Diagnostic = &d;
+        self._push(d);
+    }
+
+    fn _push(&mut self, d: &dyn Diagnostic) {
+        for filter in &mut self.filters {
+            if !filter(d) {
+                return;
+            }
+        }
+        for cb in &mut self.callbacks {
+            match cb(d) {
+                Ok(()) => return,
+                Err(()) => (),
+            }
+        }
+        (self.default_callback)(d)
+    }
+}
+
+pub struct DiagnosticSinkBuilder<'a> {
+    callbacks: Vec<Box<dyn FnMut(&dyn Diagnostic) -> Result<(), ()> + 'a>>,
+    filters: Vec<Box<dyn FnMut(&dyn Diagnostic) -> bool + 'a>>,
+}
+
+impl<'a> DiagnosticSinkBuilder<'a> {
+    pub fn new() -> Self {
+        Self { callbacks: Vec::new(), filters: Vec::new() }
+    }
+
+    pub fn filter<F: FnMut(&dyn Diagnostic) -> bool + 'a>(mut self, cb: F) -> Self {
+        self.filters.push(Box::new(cb));
+        self
+    }
+
+    pub fn on<D: Diagnostic, F: FnMut(&D) + 'a>(mut self, mut cb: F) -> Self {
+        let cb = move |diag: &dyn Diagnostic| match diag.as_any().downcast_ref::<D>() {
+            Some(d) => {
+                cb(d);
+                Ok(())
+            }
+            None => Err(()),
+        };
+        self.callbacks.push(Box::new(cb));
+        self
+    }
+
+    pub fn build<F: FnMut(&dyn Diagnostic) + 'a>(self, default_callback: F) -> DiagnosticSink<'a> {
+        DiagnosticSink {
+            callbacks: self.callbacks,
+            filters: self.filters,
+            default_callback: Box::new(default_callback),
+        }
+    }
+}
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index b9c1dc44d..2468c0dc6 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -27,6 +27,7 @@ mod attrs;
 mod has_source;
 
 pub mod diagnostics;
+pub mod diagnostics_sink;
 pub mod db;
 
 mod display;
@@ -35,14 +36,10 @@ use std::{iter, sync::Arc};
 
 use arrayvec::ArrayVec;
 use base_db::{CrateDisplayName, CrateId, Edition, FileId};
-use diagnostics::{
-    InactiveCode, MacroError, UnimplementedBuiltinMacro, UnresolvedExternCrate, UnresolvedImport,
-    UnresolvedMacroCall, UnresolvedModule, UnresolvedProcMacro,
-};
 use either::Either;
 use hir_def::{
     adt::{ReprKind, VariantData},
-    body::BodyDiagnostic,
+    body::{BodyDiagnostic, SyntheticSyntax},
     expr::{BindingAnnotation, LabelId, Pat, PatId},
     item_tree::ItemTreeNode,
     lang_item::LangItemTarget,
@@ -60,8 +57,8 @@ use hir_ty::{
     autoderef,
     consteval::ConstExt,
     could_unify,
-    diagnostics_sink::DiagnosticSink,
-    method_resolution::{self, def_crates, TyFingerprint},
+    diagnostics::BodyValidationDiagnostic,
+    method_resolution::{self, TyFingerprint},
     primitive::UintTy,
     subst_prefix,
     traits::FnTrait,
@@ -72,6 +69,7 @@ use hir_ty::{
 };
 use itertools::Itertools;
 use nameres::diagnostics::DefDiagnosticKind;
+use once_cell::unsync::Lazy;
 use rustc_hash::FxHashSet;
 use stdx::{format_to, impl_from};
 use syntax::{
@@ -80,7 +78,17 @@ use syntax::{
 };
 use tt::{Ident, Leaf, Literal, TokenTree};
 
-use crate::db::{DefDatabase, HirDatabase};
+use crate::{
+    db::{DefDatabase, HirDatabase},
+    diagnostics::{
+        BreakOutsideOfLoop, InactiveCode, InternalBailedOut, MacroError, MismatchedArgCount,
+        MissingFields, MissingMatchArms, MissingOkOrSomeInTailExpr, MissingPatFields,
+        MissingUnsafe, NoSuchField, RemoveThisSemicolon, ReplaceFilterMapNextWithFindMap,
+        UnimplementedBuiltinMacro, UnresolvedExternCrate, UnresolvedImport, UnresolvedMacroCall,
+        UnresolvedModule, UnresolvedProcMacro,
+    },
+    diagnostics_sink::DiagnosticSink,
+};
 
 pub use crate::{
     attrs::{HasAttrs, Namespace},
@@ -353,7 +361,9 @@ impl ModuleDef {
             None => return,
         };
 
-        hir_ty::diagnostics::validate_module_item(db, module.id.krate(), id, sink)
+        for diag in hir_ty::diagnostics::validate_module_item(db, module.id.krate(), id) {
+            sink.push(diag)
+        }
     }
 }
 
@@ -445,7 +455,12 @@ impl Module {
         self.id.def_map(db.upcast())[self.id.local_id].scope.visibility_of(def.clone().into())
     }
 
-    pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
+    pub fn diagnostics(
+        self,
+        db: &dyn HirDatabase,
+        sink: &mut DiagnosticSink,
+        internal_diagnostics: bool,
+    ) {
         let _p = profile::span("Module::diagnostics").detail(|| {
             format!("{:?}", self.name(db).map_or("<unknown>".into(), |name| name.to_string()))
         });
@@ -591,11 +606,11 @@ impl Module {
         }
         for decl in self.declarations(db) {
             match decl {
-                crate::ModuleDef::Function(f) => f.diagnostics(db, sink),
+                crate::ModuleDef::Function(f) => f.diagnostics(db, sink, internal_diagnostics),
                 crate::ModuleDef::Module(m) => {
                     // Only add diagnostics from inline modules
                     if def_map[m.id.local_id].origin.is_inline() {
-                        m.diagnostics(db, sink)
+                        m.diagnostics(db, sink, internal_diagnostics)
                     }
                 }
                 _ => {
@@ -607,7 +622,7 @@ impl Module {
         for impl_def in self.impl_defs(db) {
             for item in impl_def.items(db) {
                 if let AssocItem::Function(f) = item {
-                    f.diagnostics(db, sink);
+                    f.diagnostics(db, sink, internal_diagnostics);
                 }
             }
         }
@@ -1009,7 +1024,12 @@ impl Function {
         db.function_data(self.id).is_async()
     }
 
-    pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
+    pub fn diagnostics(
+        self,
+        db: &dyn HirDatabase,
+        sink: &mut DiagnosticSink,
+        internal_diagnostics: bool,
+    ) {
         let krate = self.module(db).id.krate();
 
         let source_map = db.body_with_source_map(self.id.into()).1;
@@ -1042,8 +1062,174 @@ impl Function {
             }
         }
 
-        hir_ty::diagnostics::validate_module_item(db, krate, self.id.into(), sink);
-        hir_ty::diagnostics::validate_body(db, self.id.into(), sink);
+        let infer = db.infer(self.id.into());
+        let source_map = Lazy::new(|| db.body_with_source_map(self.id.into()).1);
+        for d in &infer.diagnostics {
+            match d {
+                hir_ty::InferenceDiagnostic::NoSuchField { expr } => {
+                    let field = source_map.field_syntax(*expr);
+                    sink.push(NoSuchField { file: field.file_id, field: field.value })
+                }
+                hir_ty::InferenceDiagnostic::BreakOutsideOfLoop { expr } => {
+                    let ptr = source_map
+                        .expr_syntax(*expr)
+                        .expect("break outside of loop in synthetic syntax");
+                    sink.push(BreakOutsideOfLoop { file: ptr.file_id, expr: ptr.value })
+                }
+            }
+        }
+
+        for expr in hir_ty::diagnostics::missing_unsafe(db, self.id.into()) {
+            match source_map.expr_syntax(expr) {
+                Ok(in_file) => {
+                    sink.push(MissingUnsafe { file: in_file.file_id, expr: in_file.value })
+                }
+                Err(SyntheticSyntax) => {
+                    // FIXME: Here and eslwhere in this file, the `expr` was
+                    // desugared, report or assert that this doesn't happen.
+                }
+            }
+        }
+
+        for diagnostic in
+            BodyValidationDiagnostic::collect(db, self.id.into(), internal_diagnostics)
+        {
+            match diagnostic {
+                BodyValidationDiagnostic::RecordLiteralMissingFields {
+                    record_expr,
+                    variant,
+                    missed_fields,
+                } => match source_map.expr_syntax(record_expr) {
+                    Ok(source_ptr) => {
+                        let root = source_ptr.file_syntax(db.upcast());
+                        if let ast::Expr::RecordExpr(record_expr) = &source_ptr.value.to_node(&root)
+                        {
+                            if let Some(_) = record_expr.record_expr_field_list() {
+                                let variant_data = variant.variant_data(db.upcast());
+                                let missed_fields = missed_fields
+                                    .into_iter()
+                                    .map(|idx| variant_data.fields()[idx].name.clone())
+                                    .collect();
+                                sink.push(MissingFields {
+                                    file: source_ptr.file_id,
+                                    field_list_parent: AstPtr::new(&record_expr),
+                                    field_list_parent_path: record_expr
+                                        .path()
+                                        .map(|path| AstPtr::new(&path)),
+                                    missed_fields,
+                                })
+                            }
+                        }
+                    }
+                    Err(SyntheticSyntax) => (),
+                },
+                BodyValidationDiagnostic::RecordPatMissingFields {
+                    record_pat,
+                    variant,
+                    missed_fields,
+                } => match source_map.pat_syntax(record_pat) {
+                    Ok(source_ptr) => {
+                        if let Some(expr) = source_ptr.value.as_ref().left() {
+                            let root = source_ptr.file_syntax(db.upcast());
+                            if let ast::Pat::RecordPat(record_pat) = expr.to_node(&root) {
+                                if let Some(_) = record_pat.record_pat_field_list() {
+                                    let variant_data = variant.variant_data(db.upcast());
+                                    let missed_fields = missed_fields
+                                        .into_iter()
+                                        .map(|idx| variant_data.fields()[idx].name.clone())
+                                        .collect();
+                                    sink.push(MissingPatFields {
+                                        file: source_ptr.file_id,
+                                        field_list_parent: AstPtr::new(&record_pat),
+                                        field_list_parent_path: record_pat
+                                            .path()
+                                            .map(|path| AstPtr::new(&path)),
+                                        missed_fields,
+                                    })
+                                }
+                            }
+                        }
+                    }
+                    Err(SyntheticSyntax) => (),
+                },
+
+                BodyValidationDiagnostic::ReplaceFilterMapNextWithFindMap { method_call_expr } => {
+                    if let Ok(next_source_ptr) = source_map.expr_syntax(method_call_expr) {
+                        sink.push(ReplaceFilterMapNextWithFindMap {
+                            file: next_source_ptr.file_id,
+                            next_expr: next_source_ptr.value,
+                        });
+                    }
+                }
+                BodyValidationDiagnostic::MismatchedArgCount { call_expr, expected, found } => {
+                    match source_map.expr_syntax(call_expr) {
+                        Ok(source_ptr) => sink.push(MismatchedArgCount {
+                            file: source_ptr.file_id,
+                            call_expr: source_ptr.value,
+                            expected,
+                            found,
+                        }),
+                        Err(SyntheticSyntax) => (),
+                    }
+                }
+                BodyValidationDiagnostic::RemoveThisSemicolon { expr } => {
+                    match source_map.expr_syntax(expr) {
+                        Ok(source_ptr) => sink.push(RemoveThisSemicolon {
+                            file: source_ptr.file_id,
+                            expr: source_ptr.value,
+                        }),
+                        Err(SyntheticSyntax) => (),
+                    }
+                }
+                BodyValidationDiagnostic::MissingOkOrSomeInTailExpr { expr, required } => {
+                    match source_map.expr_syntax(expr) {
+                        Ok(source_ptr) => sink.push(MissingOkOrSomeInTailExpr {
+                            file: source_ptr.file_id,
+                            expr: source_ptr.value,
+                            required,
+                        }),
+                        Err(SyntheticSyntax) => (),
+                    }
+                }
+                BodyValidationDiagnostic::MissingMatchArms { match_expr } => {
+                    match source_map.expr_syntax(match_expr) {
+                        Ok(source_ptr) => {
+                            let root = source_ptr.file_syntax(db.upcast());
+                            if let ast::Expr::MatchExpr(match_expr) =
+                                &source_ptr.value.to_node(&root)
+                            {
+                                if let (Some(match_expr), Some(arms)) =
+                                    (match_expr.expr(), match_expr.match_arm_list())
+                                {
+                                    sink.push(MissingMatchArms {
+                                        file: source_ptr.file_id,
+                                        match_expr: AstPtr::new(&match_expr),
+                                        arms: AstPtr::new(&arms),
+                                    })
+                                }
+                            }
+                        }
+                        Err(SyntheticSyntax) => (),
+                    }
+                }
+                BodyValidationDiagnostic::InternalBailedOut { pat } => {
+                    match source_map.pat_syntax(pat) {
+                        Ok(source_ptr) => {
+                            let pat_syntax_ptr = source_ptr.value.either(Into::into, Into::into);
+                            sink.push(InternalBailedOut {
+                                file: source_ptr.file_id,
+                                pat_syntax_ptr,
+                            });
+                        }
+                        Err(SyntheticSyntax) => (),
+                    }
+                }
+            }
+        }
+
+        for diag in hir_ty::diagnostics::validate_module_item(db, krate, self.id.into()) {
+            sink.push(diag)
+        }
     }
 
     /// Whether this function declaration has a definition.
@@ -1451,6 +1637,20 @@ impl AssocItem {
             _ => None,
         }
     }
+
+    pub fn containing_trait_impl(self, db: &dyn HirDatabase) -> Option<Trait> {
+        match self.container(db) {
+            AssocItemContainer::Impl(i) => i.trait_(db),
+            _ => None,
+        }
+    }
+
+    pub fn containing_trait_or_trait_impl(self, db: &dyn HirDatabase) -> Option<Trait> {
+        match self.container(db) {
+            AssocItemContainer::Trait(t) => Some(t),
+            AssocItemContainer::Impl(i) => i.trait_(db),
+        }
+    }
 }
 
 impl HasVisibility for AssocItem {
@@ -1748,7 +1948,7 @@ impl Impl {
     }
 
     pub fn all_for_type(db: &dyn HirDatabase, Type { krate, ty, .. }: Type) -> Vec<Impl> {
-        let def_crates = match def_crates(db, &ty, krate) {
+        let def_crates = match method_resolution::def_crates(db, &ty, krate) {
             Some(def_crates) => def_crates,
             None => return Vec::new(),
         };
@@ -2154,7 +2354,7 @@ impl Type {
         krate: Crate,
         mut callback: impl FnMut(AssocItem) -> Option<T>,
     ) -> Option<T> {
-        for krate in def_crates(db, &self.ty, krate.id)? {
+        for krate in method_resolution::def_crates(db, &self.ty, krate.id)? {
             let impls = db.inherent_impls_in_crate(krate);
 
             for impl_def in impls.for_self_ty(&self.ty) {