Match the enum and union

Signed-off-by: hi-rustin <rustin.liu@gmail.com>

crates/ide_completion/src/completions/pattern.rs

@@ -137,30 +137,30 @@ fn pattern_path_completion(
                         }
                     }
                 }
-                hir::PathResolution::Def(hir::ModuleDef::Adt(hir::Adt::Enum(e))) => {
-                    cov_mark::hit!(enum_plain_qualified_use_tree);
-                    e.variants(ctx.db)
-                        .into_iter()
-                        .for_each(|variant| acc.add_enum_variant(ctx, variant, None));
-                }
                 res @ (hir::PathResolution::TypeParam(_)
                 | hir::PathResolution::SelfType(_)
-                | hir::PathResolution::Def(hir::ModuleDef::Adt(hir::Adt::Struct(_)))) => {
+                | hir::PathResolution::Def(hir::ModuleDef::Adt(hir::Adt::Struct(_)))
+                | hir::PathResolution::Def(hir::ModuleDef::Adt(hir::Adt::Enum(_)))
+                | hir::PathResolution::Def(hir::ModuleDef::Adt(hir::Adt::Union(_)))) => {
                     let ty = match res {
                         hir::PathResolution::TypeParam(param) => param.ty(ctx.db),
                         hir::PathResolution::SelfType(impl_def) => impl_def.self_ty(ctx.db),
                         hir::PathResolution::Def(hir::ModuleDef::Adt(hir::Adt::Struct(s))) => {
                             s.ty(ctx.db)
                         }
+                        hir::PathResolution::Def(hir::ModuleDef::Adt(hir::Adt::Enum(e))) => {
+                            cov_mark::hit!(enum_plain_qualified_use_tree);
+                            e.variants(ctx.db)
+                                .into_iter()
+                                .for_each(|variant| acc.add_enum_variant(ctx, variant, None));
+                            e.ty(ctx.db)
+                        }
+                        hir::PathResolution::Def(hir::ModuleDef::Adt(hir::Adt::Union(u))) => {
+                            u.ty(ctx.db)
+                        }
                         _ => return,
                     };
 
-                    if let Some(hir::Adt::Enum(e)) = ty.as_adt() {
-                        e.variants(ctx.db)
-                            .into_iter()
-                            .for_each(|variant| acc.add_enum_variant(ctx, variant, None));
-                    }
-
                     let traits_in_scope = ctx.scope.visible_traits();
                     let mut seen = FxHashSet::default();
                     ty.iterate_path_candidates(

crates/ide_completion/src/tests/pattern.rs

@@ -306,6 +306,7 @@ fn func() {
             ev TupleV(…)   TupleV(u32)
             ev RecordV {…} RecordV { field: u32 }
             ev UnitV       UnitV
+            ct ASSOC_CONST const ASSOC_CONST: ()
         "#]],
     );
 }
@@ -466,5 +467,53 @@ fn f(t: Ty) {
         expect![[r#"
             ct ABC const ABC: Self
         "#]],
+    );
+
+    check_empty(
+        r#"
+struct MyEnum;
+
+impl MyEnum {
+    pub const A: i32 = 123;
+    pub const B: i32 = 456;
+}
+
+fn f(e: MyEnum) {
+    match e {
+        MyEnum::$0 => {}
+        _ => {}
+    }
+}
+"#,
+        expect![[r#"
+            ct A pub const A: i32
+            ct B pub const B: i32
+        "#]],
+    );
+
+    check_empty(
+        r#"
+#[repr(C)]
+union U {
+    i: i32,
+    f: f32,
+}
+
+impl U {
+    pub const C: i32 = 123;
+    pub const D: i32 = 456;
+}
+
+fn f(u: U) {
+    match u {
+        U::$0 => {}
+        _ => {}
+    }
+}
+"#,
+        expect![[r#"
+            ct C pub const C: i32
+            ct D pub const D: i32
+        "#]],
     )
 }