Add diagnostic for RecordPat, TupleStructPat

Author: WeiTheShinobi

crates/hir-ty/src/infer.rs

@@ -352,9 +352,9 @@ pub enum InferenceDiagnostic {
         #[type_visitable(ignore)]
         id: ExprOrPatId,
     },
-    UnresolvedRecordExpr {
+    UnresolvedVariant {
         #[type_visitable(ignore)]
-        expr: ExprId,
+        id: ExprOrPatId,
     },
     // FIXME: This should be emitted in body lowering
     BreakOutsideOfLoop {
@@ -2278,6 +2278,8 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
         let interner = DbInterner::conjure();
         let (resolution, unresolved) = if value_ns {
             let Some(res) = path_ctx.resolve_path_in_value_ns(HygieneId::ROOT) else {
+                drop(ctx);
+                self.push_diagnostic(InferenceDiagnostic::UnresolvedVariant { id: node });
                 return (self.types.types.error, None);
             };
             match res {
@@ -2313,7 +2315,11 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
         } else {
             match path_ctx.resolve_path_in_type_ns() {
                 Some((it, idx)) => (it, idx),
-                None => return (self.types.types.error, None),
+                None => {
+                    drop(ctx);
+                    self.push_diagnostic(InferenceDiagnostic::UnresolvedVariant { id: node });
+                    return (self.types.types.error, None);
+                }
             }
         };
         return match resolution {

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

@@ -964,7 +964,6 @@ impl<'db> InferenceContext<'_, 'db> {
     ) -> Ty<'db> {
         // Find the relevant variant
         let (adt_ty, Some(variant)) = self.resolve_variant(expr.into(), path, false) else {
-            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,7 +160,7 @@ diagnostics![AnyDiagnostic<'db> ->
     UnresolvedMethodCall<'db>,
     UnresolvedModule,
     UnresolvedIdent,
-    UnresolvedRecordExpr,
+    UnresolvedVariant,
     UnusedMut,
     UnusedVariable,
     GenericArgsProhibited,
@@ -364,8 +364,8 @@ pub struct UnresolvedIdent {
 }
 
 #[derive(Debug)]
-pub struct UnresolvedRecordExpr {
-    pub expr: InFile<ExprOrPatPtr>,
+pub struct UnresolvedVariant {
+    pub node: InFile<ExprOrPatPtr>,
 }
 
 #[derive(Debug)]
@@ -907,9 +907,9 @@ impl<'db> AnyDiagnostic<'db> {
                 };
                 UnresolvedIdent { node }.into()
             }
-            &InferenceDiagnostic::UnresolvedRecordExpr { expr } => {
-                let expr = expr_syntax(expr)?;
-                UnresolvedRecordExpr { expr }.into()
+            &InferenceDiagnostic::UnresolvedVariant { id } => {
+                let node = expr_or_pat_syntax(id)?;
+                UnresolvedVariant { node }.into()
             }
             &InferenceDiagnostic::BreakOutsideOfLoop { expr, is_break, bad_value_break } => {
                 let expr = expr_syntax(expr)?;

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

@@ -0,0 +1,79 @@
+use either::Either;
+use syntax::{AstNode, ast};
+
+use crate::{Diagnostic, DiagnosticCode, DiagnosticsContext, adjusted_display_range};
+
+// 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_variant(
+    ctx: &DiagnosticsContext<'_, '_>,
+    d: &hir::UnresolvedVariant,
+) -> Diagnostic {
+    Diagnostic::new(
+        DiagnosticCode::RustcHardError("E0422"),
+        "cannot find struct, variant or union type in this scope".to_owned(),
+        adjusted_display_range(ctx, d.node, &|node| match node {
+            Either::Left(ast::Expr::RecordExpr(it)) => it.path().map(|p| p.syntax().text_range()),
+            Either::Right(ast::Pat::RecordPat(it)) => it.path().map(|p| p.syntax().text_range()),
+            Either::Right(ast::Pat::TupleStructPat(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#"
+fn main() {
+    let _ = DoesNotExist { x: 1, y: 2 };
+    //      ^^^^^^^^^^^^ error: cannot find struct, variant or union type in this scope
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn unresolved_record_pat() {
+        check_diagnostics(
+            r#"
+fn main() {
+    struct Exist { x: i32, y: i32 }
+    let a = Exist { x: 1, y: 2 };
+    match a {
+        Exist { .. } => {}
+        DoesNotExist { .. } => {}
+     // ^^^^^^^^^^^^ error: cannot find struct, variant or union type in this scope
+        _ => {}
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn unresolved_tuple_struct_pat() {
+        check_diagnostics(
+            r#"
+fn main() {
+    struct Tuple(i32, i32);
+    let t = Tuple(1, 2);
+    match t {
+        Tuple( .. ) => {}
+        DoesNotExist( .. ) => {}
+    //  ^^^^^^^^^^^^ error: cannot find struct, variant or union type in this scope
+        _ => {}
+    }
+}
+"#,
+        );
+    }
+}

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

@@ -92,7 +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 unresolved_variant;
     pub(crate) mod unused_must_use;
     pub(crate) mod unused_variables;
 
@@ -502,7 +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::UnresolvedVariant(d)  => handlers::unresolved_variant::unresolved_variant(&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,