Merge #7618

7618: Show qualified variant pattern completions r=Veykril a=Veykril

![UTMZyplssw](https://user-images.githubusercontent.com/3757771/107425157-e9c31800-6b1e-11eb-8963-96653115f8e0.gif)
bors r+

Co-authored-by: Lukas Wirth <[email protected]>

4 files changed, 95 insertions, 45 deletions

diff --git a/crates/completion/src/completions.rs b/crates/completion/src/completions.rs
index c3ce6e51d..3b582ed07 100644
--- a/crates/completion/src/completions.rs
+++ b/crates/completion/src/completions.rs
@@ -15,7 +15,9 @@ pub(crate) mod trait_impl;
 pub(crate) mod mod_;
 pub(crate) mod flyimport;
 
-use hir::{ModPath, ScopeDef, Type};
+use std::iter;
+
+use hir::{known, ModPath, ScopeDef, Type};
 
 use crate::{
     item::Builder,
@@ -118,7 +120,18 @@ impl Completions {
         variant: hir::Variant,
         local_name: Option<hir::Name>,
     ) {
-        if let Some(item) = render_variant_pat(RenderContext::new(ctx), variant, local_name) {
+        if let Some(item) = render_variant_pat(RenderContext::new(ctx), variant, local_name, None) {
+            self.add(item);
+        }
+    }
+
+    pub(crate) fn add_qualified_variant_pat(
+        &mut self,
+        ctx: &CompletionContext,
+        variant: hir::Variant,
+        path: ModPath,
+    ) {
+        if let Some(item) = render_variant_pat(RenderContext::new(ctx), variant, None, Some(path)) {
             self.add(item);
         }
     }
@@ -166,3 +179,46 @@ impl Completions {
         self.add(item);
     }
 }
+
+fn complete_enum_variants(
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    ty: &hir::Type,
+    cb: impl Fn(&mut Completions, &CompletionContext, hir::Variant, hir::ModPath),
+) {
+    if let Some(hir::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)
+        };
+
+        if let Some(impl_) = ctx.impl_def.as_ref().and_then(|impl_| ctx.sema.to_def(impl_)) {
+            if impl_.target_ty(ctx.db) == *ty {
+                for &variant in &variants {
+                    let self_path = hir::ModPath::from_segments(
+                        hir::PathKind::Plain,
+                        iter::once(known::SELF_TYPE).chain(iter::once(variant.name(ctx.db))),
+                    );
+                    cb(acc, ctx, variant, self_path);
+                }
+            }
+        }
+
+        for variant in variants {
+            if let Some(path) = module.find_use_path(ctx.db, hir::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 {
+                    cb(acc, ctx, variant, path);
+                }
+            }
+        }
+    }
+}
diff --git a/crates/completion/src/completions/pattern.rs b/crates/completion/src/completions/pattern.rs
index 43a5160cb..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| {
@@ -286,4 +292,26 @@ impl Foo {
             "#]],
         )
     }
+
+    #[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 5112ecc2d..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::{known, 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,44 +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)
-        };
-
-        if let Some(impl_) = ctx.impl_def.as_ref().and_then(|impl_| ctx.sema.to_def(impl_)) {
-            if impl_.target_ty(ctx.db) == *ty {
-                for &variant in &variants {
-                    let self_path = hir::ModPath::from_segments(
-                        hir::PathKind::Plain,
-                        iter::once(known::SELF_TYPE).chain(iter::once(variant.name(ctx.db))),
-                    );
-                    acc.add_qualified_enum_variant(ctx, variant, self_path.clone());
-                }
-            }
-        }
-
-        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};
diff --git a/crates/completion/src/render/pattern.rs b/crates/completion/src/render/pattern.rs
index 61d8a17e5..465dfe00c 100644
--- a/crates/completion/src/render/pattern.rs
+++ b/crates/completion/src/render/pattern.rs
@@ -49,13 +49,17 @@ pub(crate) fn render_variant_pat(
     ctx: RenderContext<'_>,
     variant: hir::Variant,
     local_name: Option<Name>,
+    path: Option<hir::ModPath>,
 ) -> Option<CompletionItem> {
     let _p = profile::span("render_variant_pat");
 
     let fields = variant.fields(ctx.db());
     let (visible_fields, fields_omitted) = visible_fields(&ctx, &fields, variant)?;
 
-    let name = local_name.unwrap_or_else(|| variant.name(ctx.db())).to_string();
+    let name = match &path {
+        Some(path) => path.to_string(),
+        None => local_name.unwrap_or_else(|| variant.name(ctx.db())).to_string(),
+    };
     let pat = render_pat(&ctx, &name, variant.kind(ctx.db()), &visible_fields, fields_omitted)?;
 
     Some(build_completion(ctx, name, pat, variant))