feat(diagnostics): add handler for base expression in struct pattern

crates/hir-def/src/expr_store.rs

@@ -303,6 +303,7 @@ pub enum ExpressionStoreDiagnostics {
     UnreachableLabel { node: InFile<AstPtr<ast::Lifetime>>, name: Name },
     AwaitOutsideOfAsync { node: InFile<AstPtr<ast::AwaitExpr>>, location: String },
     UndeclaredLabel { node: InFile<AstPtr<ast::Lifetime>>, name: Name },
+    BaseExprInStructPattern { node: InFile<AstPtr<ast::Expr>> },
 }
 
 impl ExpressionStoreBuilder {

crates/hir-def/src/expr_store/lower.rs

@@ -1806,7 +1806,13 @@ impl<'db> ExprCollector<'db> {
                 };
                 let record_field_list = e.record_expr_field_list()?;
                 let ellipsis = record_field_list.dotdot_token().is_some();
-                // FIXME: Report an error here if `record_field_list.spread().is_some()`.
+                if let Some(spread) = record_field_list.spread() {
+                    self.store.diagnostics.push(
+                        ExpressionStoreDiagnostics::BaseExprInStructPattern {
+                            node: self.expander.in_file(AstPtr::new(&spread)),
+                        },
+                    );
+                }
                 let args = record_field_list
                     .fields()
                     .filter_map(|f| {
@@ -2817,7 +2823,7 @@ impl<'db> ExprCollector<'db> {
 
     // endregion: patterns
 
-    /// Returns `None` (and emits diagnostics) when `owner` if `#[cfg]`d out, and `Some(())` when
+    /// Returns `false` (and emits diagnostics) when `owner` if `#[cfg]`d out, and `true` when
     /// not.
     fn check_cfg(&mut self, owner: &dyn ast::HasAttrs) -> bool {
         let enabled = self.expander.is_cfg_enabled(owner, self.cfg_options);

crates/hir/src/diagnostics.rs

@@ -55,6 +55,7 @@ macro_rules! diagnostics {
 
 diagnostics![AnyDiagnostic<'db> ->
     AwaitOutsideOfAsync,
+    BaseExprInStructPattern,
     BreakOutsideOfLoop,
     CastToUnsized<'db>,
     ExpectedFunction<'db>,
@@ -486,6 +487,11 @@ pub struct InvalidLhsOfAssignment {
     pub lhs: InFile<AstPtr<Either<ast::Expr, ast::Pat>>>,
 }
 
+#[derive(Debug)]
+pub struct BaseExprInStructPattern {
+    pub node: InFile<AstPtr<ast::Expr>>,
+}
+
 impl<'db> AnyDiagnostic<'db> {
     pub(crate) fn body_validation_diagnostic(
         db: &'db dyn HirDatabase,

crates/hir/src/lib.rs

@@ -2388,6 +2388,9 @@ fn expr_store_diagnostics<'db>(
             ExpressionStoreDiagnostics::UndeclaredLabel { node, name } => {
                 UndeclaredLabel { node: *node, name: name.clone() }.into()
             }
+            ExpressionStoreDiagnostics::BaseExprInStructPattern { node } => {
+                BaseExprInStructPattern { node: *node }.into()
+            }
         });
     }
 

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

@@ -0,0 +1,65 @@
+use crate::{Diagnostic, DiagnosticCode, DiagnosticsContext};
+
+// Diagnostic: base-expr-in-struct-pattern
+//
+// This diagnostic is triggered if a struct pattern contains a base expression (`..base`).
+pub(crate) fn base_expr_in_struct_pattern(
+    ctx: &DiagnosticsContext<'_>,
+    d: &hir::BaseExprInStructPattern,
+) -> Diagnostic {
+    Diagnostic::new_with_syntax_node_ptr(
+        ctx,
+        DiagnosticCode::SyntaxError,
+        "base expressions aren't allowed in struct patterns",
+        d.node.map(Into::into),
+    )
+    .stable()
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::check_diagnostics;
+
+    #[test]
+    fn spread_variable() {
+        check_diagnostics(
+            r#"
+struct Foo { bar: u32, baz: u32 }
+fn test(f: Foo, g: Foo) {
+    if let Foo { ..g } = f {}
+                // ^ error: base expressions aren't allowed in struct patterns
+    if let Foo { bar: 0, ..g } = f {}
+                        // ^ error: base expressions aren't allowed in struct patterns
+    if let Foo { bar: 0, baz: 0, ..g } = f {}
+                                // ^ error: base expressions aren't allowed in struct patterns
+}
+        "#,
+        );
+    }
+
+    #[test]
+    fn spread_default() {
+        check_diagnostics(
+            r#"
+struct Foo { bar: u32, baz: u32 }
+fn test(f: Foo) {
+    if let Foo { ..Default::default() } = f {}
+                // ^^^^^^^^^^^^^^^^^^ error: base expressions aren't allowed in struct patterns
+}
+        "#,
+        );
+    }
+
+    #[test]
+    fn spread_struct() {
+        check_diagnostics(
+            r#"
+struct Foo { bar: u32, baz: u32 }
+fn test(f: Foo) {
+    if let Foo { ..Foo { bar: 0, baz: 0 } } = f {}
+                // ^^^^^^^^^^^^^^^^^^^^^^ error: base expressions aren't allowed in struct patterns
+}
+        "#,
+        );
+    }
+}

crates/ide-diagnostics/src/lib.rs

@@ -31,6 +31,7 @@ extern crate rustc_driver as _;
 mod handlers {
     pub(crate) mod await_outside_of_async;
     pub(crate) mod bad_rtn;
+    pub(crate) mod base_expr_in_struct_pattern;
     pub(crate) mod break_outside_of_loop;
     pub(crate) mod elided_lifetimes_in_path;
     pub(crate) mod expected_function;
@@ -483,6 +484,7 @@ pub fn semantic_diagnostics(
             AnyDiagnostic::GenericDefaultRefersToSelf(d) => handlers::generic_default_refers_to_self::generic_default_refers_to_self(&ctx, &d),
             AnyDiagnostic::InvalidLhsOfAssignment(d) => handlers::invalid_lhs_of_assignment::invalid_lhs_of_assignment(&ctx, &d),
             AnyDiagnostic::TypeMustBeKnown(d) => handlers::type_must_be_known::type_must_be_known(&ctx, &d),
+            AnyDiagnostic::BaseExprInStructPattern(d) => handlers::base_expr_in_struct_pattern::base_expr_in_struct_pattern(&ctx, &d),
         };
         res.push(d)
     }