2 files changed, 82 insertions, 30 deletions

diff --git a/crates/completion/src/completions/pattern.rs b/crates/completion/src/completions/pattern.rs
index 595160ff5..9282c3827 100644
--- a/crates/completion/src/completions/pattern.rs
+++ b/crates/completion/src/completions/pattern.rs
@@ -11,6 +11,12 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
         return;
     }
 
+    if let Some(ty) = &ctx.expected_type {
+        super::complete_enum_variants(acc, ctx, ty, |acc, ctx, variant, path| {
+            acc.add_qualified_variant_pat(ctx, variant, path)
+        });
+    }
+
     // FIXME: ideally, we should look at the type we are matching against and
     // suggest variants + auto-imports
     ctx.scope.process_all_names(&mut |name, res| {
@@ -31,6 +37,14 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
                 _ => false,
             },
             hir::ScopeDef::MacroDef(_) => true,
+            hir::ScopeDef::ImplSelfType(impl_) => match impl_.target_ty(ctx.db).as_adt() {
+                Some(hir::Adt::Struct(strukt)) => {
+                    acc.add_struct_pat(ctx, strukt, Some(name.clone()));
+                    true
+                }
+                Some(hir::Adt::Enum(_)) => !ctx.is_irrefutable_pat_binding,
+                _ => true,
+            },
             _ => false,
         };
         if add_resolution {
@@ -258,4 +272,46 @@ fn main() {
 "#,
         );
     }
+
+    #[test]
+    fn completes_self_pats() {
+        check_snippet(
+            r#"
+struct Foo(i32);
+impl Foo {
+    fn foo() {
+        match () {
+            $0
+        }
+    }
+}
+    "#,
+            expect![[r#"
+                bn Self Self($1)$0
+                bn Foo  Foo($1)$0
+            "#]],
+        )
+    }
+
+    #[test]
+    fn completes_qualified_variant() {
+        check_snippet(
+            r#"
+enum Foo {
+    Bar { baz: i32 }
+}
+impl Foo {
+    fn foo() {
+        match {Foo::Bar { baz: 0 }} {
+            B$0
+        }
+    }
+}
+    "#,
+            expect![[r#"
+                bn Self::Bar Self::Bar { baz$1 }$0
+                bn Foo::Bar  Foo::Bar { baz$1 }$0
+            "#]],
+        )
+    }
 }
diff --git a/crates/completion/src/completions/unqualified_path.rs b/crates/completion/src/completions/unqualified_path.rs
index e2482f959..e9d0ff665 100644
--- a/crates/completion/src/completions/unqualified_path.rs
+++ b/crates/completion/src/completions/unqualified_path.rs
@@ -1,8 +1,6 @@
 //! Completion of names from the current scope, e.g. locals and imported items.
 
-use std::iter;
-
-use hir::{Adt, ModuleDef, ScopeDef, Type};
+use hir::ScopeDef;
 use syntax::AstNode;
 use test_utils::mark;
 
@@ -21,7 +19,9 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
     }
 
     if let Some(ty) = &ctx.expected_type {
-        complete_enum_variants(acc, ctx, ty);
+        super::complete_enum_variants(acc, ctx, ty, |acc, ctx, variant, path| {
+            acc.add_qualified_enum_variant(ctx, variant, path)
+        });
     }
 
     if ctx.is_pat_binding_or_const {
@@ -45,32 +45,6 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
     });
 }
 
-fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &Type) {
-    if let Some(Adt::Enum(enum_data)) =
-        iter::successors(Some(ty.clone()), |ty| ty.remove_ref()).last().and_then(|ty| ty.as_adt())
-    {
-        let variants = enum_data.variants(ctx.db);
-
-        let module = if let Some(module) = ctx.scope.module() {
-            // Compute path from the completion site if available.
-            module
-        } else {
-            // Otherwise fall back to the enum's definition site.
-            enum_data.module(ctx.db)
-        };
-
-        for variant in variants {
-            if let Some(path) = module.find_use_path(ctx.db, ModuleDef::from(variant)) {
-                // Variants with trivial paths are already added by the existing completion logic,
-                // so we should avoid adding these twice
-                if path.segments().len() > 1 {
-                    acc.add_qualified_enum_variant(ctx, variant, path);
-                }
-            }
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use expect_test::{expect, Expect};
@@ -729,6 +703,28 @@ fn f() -> m::E { V$0 }
     }
 
     #[test]
+    fn completes_enum_variant_impl() {
+        check(
+            r#"
+enum Foo { Bar, Baz, Quux }
+impl Foo {
+    fn foo() { match Foo::Bar { Q$0 } }
+}
+"#,
+            expect![[r#"
+                ev Self::Bar  ()
+                ev Self::Baz  ()
+                ev Self::Quux ()
+                ev Foo::Bar   ()
+                ev Foo::Baz   ()
+                ev Foo::Quux  ()
+                sp Self
+                en Foo
+            "#]],
+        )
+    }
+
+    #[test]
     fn dont_complete_attr() {
         check(
             r#"