feat: add diagnostic for E0422

crates/hir-ty/src/infer.rs

@@ -352,6 +352,10 @@ pub enum InferenceDiagnostic {
         #[type_visitable(ignore)]
         id: ExprOrPatId,
     },
+    UnresolvedRecordExpr {
+        #[type_visitable(ignore)]
+        expr: ExprId,
+    },
     // FIXME: This should be emitted in body lowering
     BreakOutsideOfLoop {
         #[type_visitable(ignore)]

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

@@ -964,7 +964,7 @@ impl<'db> InferenceContext<'_, 'db> {
     ) -> Ty<'db> {
         // Find the relevant variant
         let (adt_ty, Some(variant)) = self.resolve_variant(expr.into(), path, false) else {
-            // FIXME: Emit an error.
+            self.push_diagnostic(InferenceDiagnostic::UnresolvedRecordExpr { expr });
             for field in fields {
                 self.infer_expr_no_expect(field.expr, ExprIsRead::Yes);
             }

crates/hir/src/diagnostics.rs

@@ -160,6 +160,7 @@ diagnostics![AnyDiagnostic<'db> ->
     UnresolvedMethodCall<'db>,
     UnresolvedModule,
     UnresolvedIdent,
+    UnresolvedRecordExpr,
     UnusedMut,
     UnusedVariable,
     GenericArgsProhibited,
@@ -362,6 +363,11 @@ pub struct UnresolvedIdent {
     pub node: InFile<(ExprOrPatPtr, Option<TextRange>)>,
 }
 
+#[derive(Debug)]
+pub struct UnresolvedRecordExpr {
+    pub expr: InFile<ExprOrPatPtr>,
+}
+
 #[derive(Debug)]
 pub struct PrivateField {
     pub expr: InFile<ExprOrPatPtr>,
@@ -901,6 +907,10 @@ impl<'db> AnyDiagnostic<'db> {
                 };
                 UnresolvedIdent { node }.into()
             }
+            &InferenceDiagnostic::UnresolvedRecordExpr { expr } => {
+                let expr = expr_syntax(expr)?;
+                UnresolvedRecordExpr { expr }.into()
+            }
             &InferenceDiagnostic::BreakOutsideOfLoop { expr, is_break, bad_value_break } => {
                 let expr = expr_syntax(expr)?;
                 BreakOutsideOfLoop { expr, is_break, bad_value_break }.into()

crates/ide-diagnostics/src/handlers/inactive_code.rs

@@ -71,7 +71,8 @@ fn f() {
     fn abc() {}
     abc(#[cfg(a)] 0);
       //^^^^^^^^^^^ weak: code is inactive due to #[cfg] directives: a is disabled
-    let x = Struct {
+    struct Struct {}
+    let _x = Struct {
         #[cfg(a)] f: 0,
       //^^^^^^^^^^^^^^ weak: code is inactive due to #[cfg] directives: a is disabled
     };

crates/ide-diagnostics/src/handlers/unresolved_record_expr.rs

@@ -0,0 +1,45 @@
+use either::Either;
+use syntax::{AstNode, ast::Expr};
+
+use crate::{Diagnostic, DiagnosticCode, DiagnosticsContext};
+
+// Diagnostic: unresolved-record-expr
+//
+// This diagnostic is triggered if the struct, variant, or union type referred to by a record expression does not exist in the current scope.
+pub(crate) fn unresolved_record_expr(
+    ctx: &DiagnosticsContext<'_, '_>,
+    d: &hir::UnresolvedRecordExpr,
+) -> Diagnostic {
+    Diagnostic::new(
+        DiagnosticCode::RustcHardError("E0422"),
+        "cannot find struct, variant or union type in this scope".to_owned(),
+        crate::adjusted_display_range(ctx, d.expr, &|expr| match expr {
+            Either::Left(Expr::RecordExpr(it)) => it.path().map(|p| p.syntax().text_range()),
+            _ => None,
+        }),
+    )
+    .stable()
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::check_diagnostics;
+
+    #[test]
+    fn unresolved_record_expr() {
+        check_diagnostics(
+            r#"
+struct Exist {
+    x: i32,
+    y: i32,
+}
+
+fn main() {
+    let _ = Exist { x: 1, y: 2 };
+    let _ = DoesNotExist { x: 1, y: 2 };
+         // ^^^^^^^^^^^^ error: cannot find struct, variant or union type in this scope
+}
+"#,
+        );
+    }
+}

crates/ide-diagnostics/src/lib.rs

@@ -92,6 +92,7 @@ mod handlers {
     pub(crate) mod unresolved_macro_call;
     pub(crate) mod unresolved_method;
     pub(crate) mod unresolved_module;
+    pub(crate) mod unresolved_record_expr;
     pub(crate) mod unused_must_use;
     pub(crate) mod unused_variables;
 
@@ -501,6 +502,7 @@ pub fn semantic_diagnostics(
             AnyDiagnostic::UnresolvedMacroCall(d) => handlers::unresolved_macro_call::unresolved_macro_call(&ctx, &d),
             AnyDiagnostic::UnresolvedMethodCall(d) => handlers::unresolved_method::unresolved_method(&ctx, &d),
             AnyDiagnostic::UnresolvedModule(d) => handlers::unresolved_module::unresolved_module(&ctx, &d),
+            AnyDiagnostic::UnresolvedRecordExpr(d)  => handlers::unresolved_record_expr::unresolved_record_expr(&ctx, &d),
             AnyDiagnostic::UnusedMustUse(d) => handlers::unused_must_use::unused_must_use(&ctx, &d),
             AnyDiagnostic::UnusedMut(d) => match handlers::mutability_errors::unused_mut(&ctx, &d) {
                 Some(it) => it,