handle completing root switch case when theres more than one case

Author: zth

analysis/src/CompletionFrontEnd.ml

@@ -705,13 +705,35 @@ let completionWithParser1 ~currentFile ~debug ~offset ~path ~posCursor ~text =
         | Some ctxPath ->
           setResult
             (Completable.Cpattern {typ = ctxPath; nested = []; prefix = ""}))
-      | Pexp_match (exp, _cases) -> (
-        (* If there's more than one case, or the case isn't a pattern hole, set that we're looking for this path currently. *)
+      | Pexp_match (exp, cases) -> (
+        (* If there's more than one case, or the case isn't a pattern hole, figure out if we're completing another
+           broken parser case (`switch x { | true => () | <com> }` for example). *)
         match exp |> exprToContextPath with
         | None -> ()
-        | Some ctxPath -> setLookingForPat ctxPath)
+        | Some ctxPath -> (
+          let caseWithCursor =
+            cases
+            |> List.find_opt (fun case ->
+                   case.Parsetree.pc_lhs.ppat_loc
+                   |> CursorPosition.classifyLoc ~pos:posBeforeCursor
+                   = HasCursor)
+          in
+          let caseWithPatHole =
+            cases
+            |> List.find_opt (fun case -> isPatternHole case.Parsetree.pc_lhs)
+          in
+          match (caseWithPatHole, caseWithCursor) with
+          | _, Some _ ->
+            (* Always continue if there's a case with the cursor *)
+            setLookingForPat ctxPath
+          | Some _, None ->
+            (* If there's no case with the cursor, but a broken parser case, complete for the top level. *)
+            setResult
+              (Completable.Cpattern {typ = ctxPath; nested = []; prefix = ""})
+          | None, None -> ()))
       | _ -> unsetLookingForPat ()
   in
+
   let case (iterator : Ast_iterator.iterator) (case : Parsetree.case) =
     let oldScope = !scope in
     scopePattern case.pc_lhs;

analysis/tests/src/CompletionPattern.res

@@ -170,3 +170,9 @@ let s = (true, Some(true), [false])
 
 // switch s { | (true, , []) }
 //                    ^com
+
+// switch s { | (true, []) => () |  }
+//                                 ^com
+
+// switch s { | (true, []) => () | (true, , [])  }
+//                                       ^com

analysis/tests/src/expected/Completion.res.txt

@@ -965,7 +965,6 @@ Resolved opens 2 Completion.res Completion.res
 []
 
 Complete src/Completion.res 243:8
-looking for: Cpath Value[someR] 
 posCursor:[243:8] posNoWhite:[243:7] Found expr:[241:8->246:1]
 posCursor:[243:8] posNoWhite:[243:7] Found expr:[242:14->243:8]
 Pexp_apply ...[243:3->243:4] (...[242:14->242:15], ...[243:5->243:8])

analysis/tests/src/expected/CompletionPattern.res.txt

@@ -198,7 +198,6 @@ Completable: Cpattern Value[f]->recordField(nest), recordBody
   }]
 
 Complete src/CompletionPattern.res 70:22
-looking for: Cpath Value[f] 
 posCursor:[70:22] posNoWhite:[70:21] Found expr:[67:8->74:1]
 posCursor:[70:22] posNoWhite:[70:21] Found expr:[69:2->72:13]
 posCursor:[70:22] posNoWhite:[70:21] Found expr:[70:5->72:13]
@@ -690,3 +689,37 @@ Completable: Cpattern Value[s]->tuple($1)
     "insertTextFormat": 2
   }]
 
+Complete src/CompletionPattern.res 173:35
+XXX Not found!
+Completable: Cpattern Value[s]
+[{
+    "label": "(_, _, _)",
+    "kind": 12,
+    "tags": [],
+    "detail": "(bool, option<bool>, array<bool>)",
+    "documentation": null,
+    "insertText": "(${1:_}, ${2:_}, ${3:_})",
+    "insertTextFormat": 2
+  }]
+
+Complete src/CompletionPattern.res 176:41
+looking for: Cpath Value[s] 
+posCursor:[176:41] posNoWhite:[176:40] Found expr:[176:3->176:50]
+posCursor:[176:41] posNoWhite:[176:40] Found pattern:[176:35->176:47]
+Completable: Cpattern Value[s]->tuple($1)
+[{
+    "label": "None",
+    "kind": 4,
+    "tags": [],
+    "detail": "bool",
+    "documentation": null
+  }, {
+    "label": "Some(_)",
+    "kind": 4,
+    "tags": [],
+    "detail": "bool",
+    "documentation": null,
+    "insertText": "Some(${1:_})",
+    "insertTextFormat": 2
+  }]
+