handle completing for new record fields, and filtering already seen fields

Author: zth

analysis/src/CompletionBackEnd.ml

@@ -1647,8 +1647,10 @@ let completeTypedValue ~env ~envWhereCompletionStarted ~full ~prefix
         ]
       | Some (Trecord {env; fields; typeExpr}) -> (
         match completionContext with
-        | Some Completable.RecordField ->
+        | Some (Completable.RecordField {seenFields}) ->
           fields
+          |> List.filter (fun (field : field) ->
+                 List.mem field.fname.txt seenFields = false)
           |> List.map (fun (field : field) ->
                  Completion.create ~name:field.fname.txt
                    ~kind:(Field (field, typeExpr |> Shared.typeToString))
@@ -1764,8 +1766,8 @@ let rec resolveNestedPattern typ ~env ~package ~nested =
       with
       | None -> None
       | Some {typ} -> typ |> resolveNestedPattern ~env ~package ~nested)
-    | PRecordBody _, Some (Trecord {env; typeExpr}) ->
-      Some (typeExpr, env, Some Completable.RecordField)
+    | PRecordBody {seenFields}, Some (Trecord {env; typeExpr}) ->
+      Some (typeExpr, env, Some (Completable.RecordField {seenFields}))
     | _ -> None)
 
 let processCompletable ~debug ~full ~scope ~env ~pos ~forHover

analysis/src/CompletionFrontEnd.ml

@@ -305,6 +305,15 @@ let completionWithParser1 ~currentFile ~debug ~offset ~path ~posCursor ~text =
     let line, col = posCursor in
     (line, max 0 col - offset + offsetNoWhite)
   in
+  (* Identifies the first character before the cursor that's not white space.
+     Should be used very sparingly, but can be used to drive completion triggering
+     in scenarios where the parser eats things we'd need to complete.
+     Example: let {whatever,     <cursor>}, char is ','. *)
+  let firstCharBeforeCursorNoWhite =
+    if offsetNoWhite < String.length text && offsetNoWhite >= 0 then
+      Some text.[offsetNoWhite]
+    else None
+  in
   let posBeforeCursor = Pos.posBeforeCursor posCursor in
   let charBeforeCursor, blankAfterCursor =
     match Pos.positionToOffset text posCursor with
@@ -498,10 +507,10 @@ let completionWithParser1 ~currentFile ~debug ~offset ~path ~posCursor ~text =
           appendNestedPat (Completable.PTupleItem {itemNum = patHoleCount})
         | _ -> ())
       | Ppat_record ([], _) ->
+        (* Empty fields means we're in a record body `{}`. Complete for the fields. *)
         appendNestedPat (Completable.PRecordBody {seenFields = []});
         commitFoundPat ~prefix:"" ()
       | Ppat_record (fields, _) -> (
-        (* TODO: Identify seen fields. *)
         let fieldWithCursor = ref None in
         let fieldWithPatHole = ref None in
         fields
@@ -516,6 +525,13 @@ let completionWithParser1 ~currentFile ~debug ~offset ~path ~posCursor ~text =
                | Lident fname, _ when isPatternHole f ->
                  fieldWithPatHole := Some (fname, f)
                | _ -> ());
+        let seenFields =
+          fields
+          |> List.filter_map (fun (fieldName, _f) ->
+                 match fieldName with
+                 | {Location.txt = Longident.Lident fieldName} -> Some fieldName
+                 | _ -> None)
+        in
         match (!fieldWithCursor, !fieldWithPatHole) with
         | Some (fname, f), _ | None, Some (fname, f) -> (
           match f.ppat_desc with
@@ -528,10 +544,19 @@ let completionWithParser1 ~currentFile ~debug ~offset ~path ~posCursor ~text =
             commitFoundPat ~prefix:"" ()
           | Ppat_var {txt} ->
             (* A var means `{s}` or similar. Complete for fields. *)
-            appendNestedPat (Completable.PRecordBody {seenFields = []});
+            appendNestedPat (Completable.PRecordBody {seenFields});
             commitFoundPat ~prefix:txt ()
           | _ -> ())
-        | _ -> ())
+        | None, None -> (
+          (* Figure out if we're completing for a new field.
+             If the cursor is inside of the record body, but no field has the cursor,
+             and there's no pattern hole. Check the first char to the left of the cursor,
+             ignoring white space. If that's a comma, we assume you're completing for a new field. *)
+          match firstCharBeforeCursorNoWhite with
+          | Some ',' ->
+            appendNestedPat (Completable.PRecordBody {seenFields});
+            commitFoundPat ~prefix:"" ()
+          | _ -> ()))
       | _ -> ()
   in
   let case (iterator : Ast_iterator.iterator) (case : Parsetree.case) =

analysis/src/SharedTypes.ml

@@ -551,7 +551,7 @@ module Completable = struct
       }
 
   (** Additional context for a pattern completion where needed. *)
-  type patternContext = RecordField
+  type patternContext = RecordField of {seenFields: string list}
 
   type patternPath =
     | PTupleItem of {itemNum: int}

analysis/tests/src/CompletionPattern.res

@@ -49,6 +49,9 @@ let z = (f, true)
 // switch f { | {}}
 //               ^com
 
+// switch f { | {first,  , second }}
+//                      ^com
+
 // switch f { | {fi}}
 //                 ^com
 

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

@@ -119,11 +119,30 @@ Completable: Cpattern Value[f]->recordBody
     "documentation": null
   }]
 
-Complete src/CompletionPattern.res 51:19
+Complete src/CompletionPattern.res 51:24
 looking for: Cpath Value[f] 
-posCursor:[51:19] posNoWhite:[51:18] Found expr:[51:3->51:21]
-posCursor:[51:19] posNoWhite:[51:18] Found pattern:[51:16->51:20]
-posCursor:[51:19] posNoWhite:[51:18] Found pattern:[51:17->51:19]
+posCursor:[51:24] posNoWhite:[51:22] Found expr:[51:3->51:36]
+posCursor:[51:24] posNoWhite:[51:22] Found pattern:[51:16->51:35]
+Completable: Cpattern Value[f]->recordBody
+[{
+    "label": "optThird",
+    "kind": 5,
+    "tags": [],
+    "detail": "optThird: option<[#second(someRecord) | #first]>\n\nsomeRecord",
+    "documentation": null
+  }, {
+    "label": "nest",
+    "kind": 5,
+    "tags": [],
+    "detail": "nest: nestedRecord\n\nsomeRecord",
+    "documentation": null
+  }]
+
+Complete src/CompletionPattern.res 54:19
+looking for: Cpath Value[f] 
+posCursor:[54:19] posNoWhite:[54:18] Found expr:[54:3->54:21]
+posCursor:[54:19] posNoWhite:[54:18] Found pattern:[54:16->54:20]
+posCursor:[54:19] posNoWhite:[54:18] Found pattern:[54:17->54:19]
 Completable: Cpattern Value[f]=fi->recordBody
 [{
     "label": "first",
@@ -133,12 +152,12 @@ Completable: Cpattern Value[f]=fi->recordBody
     "documentation": null
   }]
 
-Complete src/CompletionPattern.res 54:19
+Complete src/CompletionPattern.res 57:19
 looking for: Cpath Value[z] 
-posCursor:[54:19] posNoWhite:[54:18] Found expr:[54:3->54:25]
-posCursor:[54:19] posNoWhite:[54:18] Found pattern:[54:16->54:24]
-posCursor:[54:19] posNoWhite:[54:18] Found pattern:[54:17->54:20]
-posCursor:[54:19] posNoWhite:[54:18] Found pattern:[54:18->54:19]
+posCursor:[57:19] posNoWhite:[57:18] Found expr:[57:3->57:25]
+posCursor:[57:19] posNoWhite:[57:18] Found pattern:[57:16->57:24]
+posCursor:[57:19] posNoWhite:[57:18] Found pattern:[57:17->57:20]
+posCursor:[57:19] posNoWhite:[57:18] Found pattern:[57:18->57:19]
 Completable: Cpattern Value[z]=o->tuple($0), recordBody
 [{
     "label": "optThird",
@@ -148,10 +167,10 @@ Completable: Cpattern Value[z]=o->tuple($0), recordBody
     "documentation": null
   }]
 
-Complete src/CompletionPattern.res 57:22
+Complete src/CompletionPattern.res 60:22
 looking for: Cpath Value[f] 
-posCursor:[57:22] posNoWhite:[57:21] Found expr:[57:3->57:25]
-posCursor:[57:22] posNoWhite:[57:21] Found pattern:[57:16->57:25]
+posCursor:[60:22] posNoWhite:[60:21] Found expr:[60:3->60:25]
+posCursor:[60:22] posNoWhite:[60:21] Found pattern:[60:16->60:25]
 Completable: Cpattern Value[f]->recordField(nest)
 [{
     "label": "{}",
@@ -164,11 +183,11 @@ Completable: Cpattern Value[f]->recordField(nest)
     "insertTextFormat": 2
   }]
 
-Complete src/CompletionPattern.res 60:24
+Complete src/CompletionPattern.res 63:24
 looking for: Cpath Value[f] 
-posCursor:[60:24] posNoWhite:[60:23] Found expr:[60:3->60:27]
-posCursor:[60:24] posNoWhite:[60:23] Found pattern:[60:16->60:26]
-posCursor:[60:24] posNoWhite:[60:23] Found pattern:[60:23->60:25]
+posCursor:[63:24] posNoWhite:[63:23] Found expr:[63:3->63:27]
+posCursor:[63:24] posNoWhite:[63:23] Found pattern:[63:16->63:26]
+posCursor:[63:24] posNoWhite:[63:23] Found pattern:[63:23->63:25]
 Completable: Cpattern Value[f]->recordField(nest), recordBody
 [{
     "label": "nested",