Completition for type name? #3418

Iterate through TupleStructPat's until a MatchArm if
one exists. Store in a new is_pat_bind_and_path bool
and allow the `complete_scope` to find matches.

Added some tests to ensure it works in simple and nested cases.

1 files changed, 106 insertions, 1 deletions

diff --git a/crates/ra_ide/src/completion/complete_scope.rs b/crates/ra_ide/src/completion/complete_scope.rs
index 81d3cc1b6..82842e7e3 100644
--- a/crates/ra_ide/src/completion/complete_scope.rs
+++ b/crates/ra_ide/src/completion/complete_scope.rs
@@ -3,7 +3,7 @@
 use crate::completion::{CompletionContext, Completions};
 
 pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) {
-    if !ctx.is_trivial_path {
+    if !ctx.is_trivial_path && !ctx.is_pat_binding_and_path {
         return;
     }
 
@@ -21,6 +21,111 @@ mod tests {
     }
 
     #[test]
+    fn nested_bind_pat_and_path() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                enum First {
+                    A,
+                    B,
+                }
+                enum Second {
+                    A(First),
+                    B(First),
+                }
+                fn quux(x: Option<Option<Second>>>) {
+                    match x {
+                        None => (),
+                        Some(Some(Second(Fi<|>))) => (),
+                    }
+                }
+                "
+            ),
+            @r###"
+            [
+                CompletionItem {
+                    label: "First",
+                    source_range: [363; 365),
+                    delete: [363; 365),
+                    insert: "First",
+                    kind: Enum,
+                },
+                CompletionItem {
+                    label: "Second",
+                    source_range: [363; 365),
+                    delete: [363; 365),
+                    insert: "Second",
+                    kind: Enum,
+                },
+                CompletionItem {
+                    label: "quux(…)",
+                    source_range: [363; 365),
+                    delete: [363; 365),
+                    insert: "quux(${1:x})$0",
+                    kind: Function,
+                    lookup: "quux",
+                    detail: "fn quux(x: Option<Option<Second>>)",
+                },
+            ]
+            "###
+        );
+    }
+
+    #[test]
+    fn bind_pat_and_path() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                enum Enum {
+                    A,
+                    B,
+                }
+                fn quux(x: Option<Enum>) {
+                    match x {
+                        None => (),
+                        Some(en<|>) => (),
+                    }
+                }
+                "
+            ),
+            @r###"
+            [
+                CompletionItem {
+                    label: "Enum",
+                    source_range: [231; 233),
+                    delete: [231; 233),
+                    insert: "Enum",
+                    kind: Enum,
+                },
+                CompletionItem {
+                    label: "None",
+                    source_range: [231; 233),
+                    delete: [231; 233),
+                    insert: "None",
+                    kind: Binding,
+                },
+                CompletionItem {
+                    label: "quux(…)",
+                    source_range: [231; 233),
+                    delete: [231; 233),
+                    insert: "quux(${1:x})$0",
+                    kind: Function,
+                    lookup: "quux",
+                    detail: "fn quux(x: Option<Enum>)",
+                },
+                CompletionItem {
+                    label: "x",
+                    source_range: [231; 233),
+                    delete: [231; 233),
+                    insert: "x",
+                    kind: Binding,
+                },
+            ]
+            "###
+        );
+    }
+
+    #[test]
     fn completes_bindings_from_let() {
         assert_debug_snapshot!(
             do_reference_completion(