Emit missing-fields diagnostics from inference

crates/hir-ty/src/diagnostics/expr.rs

@@ -128,16 +128,6 @@ impl<'db> ExprValidator<'db> {
         }
 
         for (id, expr) in body.exprs() {
-            if let Some((variant, missed_fields)) =
-                record_literal_missing_fields(db, self.infer, id, expr)
-            {
-                self.diagnostics.push(BodyValidationDiagnostic::RecordMissingFields {
-                    record: Either::Left(id),
-                    variant,
-                    missed_fields,
-                });
-            }
-
             match expr {
                 Expr::Match { expr, arms } => {
                     self.validate_match(id, *expr, arms);

crates/hir-ty/src/infer.rs

@@ -301,6 +301,14 @@ pub enum InferenceDiagnostic {
         #[type_visitable(ignore)]
         variant: VariantId,
     },
+    MissingFields {
+        #[type_visitable(ignore)]
+        expr: ExprId,
+        #[type_visitable(ignore)]
+        fields: Vec<LocalFieldId>,
+        #[type_visitable(ignore)]
+        variant: VariantId,
+    },
     PrivateField {
         #[type_visitable(ignore)]
         expr: ExprId,

crates/hir-ty/src/infer/expr.rs

@@ -1090,7 +1090,11 @@ impl<'db> InferenceContext<'_, 'db> {
                     }
                 }
                 if !missing_mandatory_fields.is_empty() {
-                    // FIXME: Emit an error: missing fields.
+                    self.push_diagnostic(InferenceDiagnostic::MissingFields {
+                        expr,
+                        fields: missing_mandatory_fields,
+                        variant,
+                    });
                 }
             }
             RecordSpread::Expr(base_expr) => {
@@ -1182,7 +1186,13 @@ impl<'db> InferenceContext<'_, 'db> {
                 {
                     debug!(?remaining_fields);
 
-                    // FIXME: Emit an error: missing fields.
+                    let missing_fields = remaining_fields.values().copied().collect();
+
+                    self.push_diagnostic(InferenceDiagnostic::MissingFields {
+                        expr,
+                        fields: missing_fields,
+                        variant,
+                    });
                 }
             }
         }

crates/hir/src/diagnostics.rs

@@ -786,6 +786,38 @@ impl<'db> AnyDiagnostic<'db> {
                 };
                 DuplicateField { field: expr_or_pat, variant: variant.into() }.into()
             }
+            InferenceDiagnostic::MissingFields { expr, fields, variant } => {
+                let variant_data = variant.fields(db);
+                let missed_fields = fields
+                    .iter()
+                    .map(|&idx| {
+                        (
+                            variant_data.fields()[idx].name.clone(),
+                            Field { parent: (*variant).into(), id: idx },
+                        )
+                    })
+                    .collect();
+
+                let record = expr_syntax(*expr)?;
+                let file = record.file_id;
+                let root = record.file_syntax(db);
+                let Either::Left(ast::Expr::RecordExpr(record_expr)) = record.value.to_node(&root)
+                else {
+                    never!("should always map to a `ast::RecordExpr`");
+                    return None;
+                };
+
+                record_expr.record_expr_field_list()?;
+
+                let field_list_parent_path = record_expr.path().map(|path| AstPtr::new(&path));
+                MissingFields {
+                    file,
+                    field_list_parent: AstPtr::new(&Either::Left(record_expr)),
+                    field_list_parent_path,
+                    missed_fields,
+                }
+                .into()
+            }
             &InferenceDiagnostic::MismatchedArgCount { call_expr, expected, found } => {
                 MismatchedArgCount { call_expr: expr_syntax(call_expr)?, expected, found }.into()
             }

crates/hir/src/lib.rs

@@ -83,8 +83,8 @@ use hir_expand::{
     proc_macro::ProcMacroKind,
 };
 use hir_ty::{
-    GenericPredicates, InferBodyId, InferenceResult, ParamEnvAndCrate, TyDefId,
-    TyLoweringDiagnostic, ValueTyDefId, all_super_traits, autoderef, check_orphan_rules,
+    GenericPredicates, InferBodyId, InferenceDiagnostic, InferenceResult, ParamEnvAndCrate,
+    TyDefId, TyLoweringDiagnostic, ValueTyDefId, all_super_traits, autoderef, check_orphan_rules,
     consteval::try_const_usize,
     db::{AnonConstId, InternedClosure, InternedClosureId, InternedCoroutineClosureId},
     diagnostics::BodyValidationDiagnostic,
@@ -2191,7 +2191,12 @@ impl DefWithBody {
         expr_store_diagnostics(db, acc, source_map);
 
         let infer = InferenceResult::of(db, id);
+        let mut delayed_missing_fields_diagnostics = Vec::new();
         for d in infer.diagnostics() {
+            if matches!(d, InferenceDiagnostic::MissingFields { .. }) {
+                delayed_missing_fields_diagnostics.push(d);
+                continue;
+            }
             acc.extend(AnyDiagnostic::inference_diagnostic(
                 db,
                 id,
@@ -2352,6 +2357,16 @@ impl DefWithBody {
         for diagnostic in BodyValidationDiagnostic::collect(db, id, style_lints) {
             acc.extend(AnyDiagnostic::body_validation_diagnostic(db, diagnostic, source_map));
         }
+        for d in delayed_missing_fields_diagnostics {
+            acc.extend(AnyDiagnostic::inference_diagnostic(
+                db,
+                id,
+                d,
+                source_map,
+                sig_source_map,
+                env,
+            ));
+        }
 
         for diag in hir_ty::diagnostics::incorrect_case(db, id.into()) {
             acc.push(diag.into())