1 files changed, 161 insertions, 17 deletions

diff --git a/crates/completion/src/completions/pattern.rs b/crates/completion/src/completions/pattern.rs
index 4d56731ec..eee31098d 100644
--- a/crates/completion/src/completions/pattern.rs
+++ b/crates/completion/src/completions/pattern.rs
@@ -2,9 +2,9 @@
 
 use crate::{CompletionContext, Completions};
 
-/// Completes constats and paths in patterns.
+/// Completes constants and paths in patterns.
 pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
-    if !(ctx.is_pat_binding_or_const || ctx.is_irrefutable_let_pat_binding) {
+    if !(ctx.is_pat_binding_or_const || ctx.is_irrefutable_pat_binding) {
         return;
     }
     if ctx.record_pat_syntax.is_some() {
@@ -15,20 +15,21 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
     // suggest variants + auto-imports
     ctx.scope.process_all_names(&mut |name, res| {
         let add_resolution = match &res {
-            hir::ScopeDef::ModuleDef(def) => {
-                if ctx.is_irrefutable_let_pat_binding {
-                    matches!(def, hir::ModuleDef::Adt(hir::Adt::Struct(_)))
-                } else {
-                    matches!(
-                        def,
-                        hir::ModuleDef::Adt(hir::Adt::Enum(..))
-                            | hir::ModuleDef::Adt(hir::Adt::Struct(..))
-                            | hir::ModuleDef::Variant(..)
-                            | hir::ModuleDef::Const(..)
-                            | hir::ModuleDef::Module(..)
-                    )
+            hir::ScopeDef::ModuleDef(def) => match def {
+                hir::ModuleDef::Adt(hir::Adt::Struct(strukt)) => {
+                    acc.add_struct_pat(ctx, strukt.clone(), Some(name.clone()));
+                    true
                 }
-            }
+                hir::ModuleDef::Variant(variant) if !ctx.is_irrefutable_pat_binding => {
+                    acc.add_variant_pat(ctx, variant.clone(), Some(name.clone()));
+                    true
+                }
+                hir::ModuleDef::Adt(hir::Adt::Enum(..))
+                | hir::ModuleDef::Variant(..)
+                | hir::ModuleDef::Const(..)
+                | hir::ModuleDef::Module(..) => !ctx.is_irrefutable_pat_binding,
+                _ => false,
+            },
             hir::ScopeDef::MacroDef(_) => true,
             _ => false,
         };
@@ -42,13 +43,21 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
 mod tests {
     use expect_test::{expect, Expect};
 
-    use crate::{test_utils::completion_list, CompletionKind};
+    use crate::{
+        test_utils::{check_edit, completion_list},
+        CompletionKind,
+    };
 
     fn check(ra_fixture: &str, expect: Expect) {
         let actual = completion_list(ra_fixture, CompletionKind::Reference);
         expect.assert_eq(&actual)
     }
 
+    fn check_snippet(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Snippet);
+        expect.assert_eq(&actual)
+    }
+
     #[test]
     fn completes_enum_variants_and_modules() {
         check(
@@ -69,7 +78,7 @@ fn foo() {
                 en E
                 ct Z
                 st Bar
-                ev X   ()
+                ev X
                 md m
             "#]],
         );
@@ -114,4 +123,139 @@ fn foo() {
             "#]],
         );
     }
+
+    #[test]
+    fn completes_in_param() {
+        check(
+            r#"
+enum E { X }
+
+static FOO: E = E::X;
+struct Bar { f: u32 }
+
+fn foo(<|>) {
+}
+"#,
+            expect![[r#"
+                st Bar
+            "#]],
+        );
+    }
+
+    #[test]
+    fn completes_pat_in_let() {
+        check_snippet(
+            r#"
+struct Bar { f: u32 }
+
+fn foo() {
+   let <|>
+}
+"#,
+            expect![[r#"
+                bn Bar Bar { f$1 }$0
+            "#]],
+        );
+    }
+
+    #[test]
+    fn completes_param_pattern() {
+        check_snippet(
+            r#"
+struct Foo { bar: String, baz: String }
+struct Bar(String, String);
+struct Baz;
+fn outer(<|>) {}
+"#,
+            expect![[r#"
+                bn Foo Foo { bar$1, baz$2 }: Foo$0
+                bn Bar Bar($1, $2): Bar$0
+            "#]],
+        )
+    }
+
+    #[test]
+    fn completes_let_pattern() {
+        check_snippet(
+            r#"
+struct Foo { bar: String, baz: String }
+struct Bar(String, String);
+struct Baz;
+fn outer() {
+    let <|>
+}
+"#,
+            expect![[r#"
+                bn Foo Foo { bar$1, baz$2 }$0
+                bn Bar Bar($1, $2)$0
+            "#]],
+        )
+    }
+
+    #[test]
+    fn completes_refutable_pattern() {
+        check_snippet(
+            r#"
+struct Foo { bar: i32, baz: i32 }
+struct Bar(String, String);
+struct Baz;
+fn outer() {
+    match () {
+        <|>
+    }
+}
+"#,
+            expect![[r#"
+                bn Foo Foo { bar$1, baz$2 }$0
+                bn Bar Bar($1, $2)$0
+            "#]],
+        )
+    }
+
+    #[test]
+    fn omits_private_fields_pat() {
+        check_snippet(
+            r#"
+mod foo {
+    pub struct Foo { pub bar: i32, baz: i32 }
+    pub struct Bar(pub String, String);
+    pub struct Invisible(String, String);
+}
+use foo::*;
+
+fn outer() {
+    match () {
+        <|>
+    }
+}
+"#,
+            expect![[r#"
+                bn Foo Foo { bar$1, .. }$0
+                bn Bar Bar($1, ..)$0
+            "#]],
+        )
+    }
+
+    #[test]
+    fn only_shows_ident_completion() {
+        check_edit(
+            "Foo",
+            r#"
+struct Foo(i32);
+fn main() {
+    match Foo(92) {
+        <|>(92) => (),
+    }
+}
+"#,
+            r#"
+struct Foo(i32);
+fn main() {
+    match Foo(92) {
+        Foo(92) => (),
+    }
+}
+"#,
+        );
+    }
 }