complete record bodies/fields in patterns

Author: zth

analysis/src/CompletionBackEnd.ml

@@ -1570,7 +1570,7 @@ let printConstructorArgs argsLen ~asSnippet =
   else ""
 
 let completeTypedValue ~env ~envWhereCompletionStarted ~full ~prefix
-    ~expandOption ~includeLocalValues =
+    ~expandOption ~includeLocalValues ~completionContext =
   let namesUsed = Hashtbl.create 10 in
   let rec completeTypedValueInner t ~env ~full ~prefix ~expandOption =
     let items =
@@ -1645,13 +1645,21 @@ let completeTypedValue ~env ~envWhereCompletionStarted ~full ~prefix
             ~insertText:(printConstructorArgs numExprs ~asSnippet:true)
             ~kind:(Value typ) ~env ();
         ]
-      | Some (Trecord {env; fields; typeExpr}) ->
-        fields
-        |> List.map (fun (field : field) ->
-               Completion.create ~name:field.fname.txt
-                 ~kind:(Field (field, typeExpr |> Shared.typeToString))
-                 ~env)
-        |> filterItems ~prefix
+      | Some (Trecord {env; fields; typeExpr}) -> (
+        match completionContext with
+        | Some Completable.RecordField ->
+          fields
+          |> List.map (fun (field : field) ->
+                 Completion.create ~name:field.fname.txt
+                   ~kind:(Field (field, typeExpr |> Shared.typeToString))
+                   ~env)
+          |> filterItems ~prefix
+        | None ->
+          [
+            Completion.createWithSnippet ~name:"{}"
+              ~insertText:(if !Cfg.supportsSnippets then "{$0}" else "{}")
+              ~sortText:"a" ~kind:(Value typeExpr) ~env ();
+          ])
       | _ -> []
     in
     (* Include all values and modules in completion if there's a prefix, not otherwise *)
@@ -1742,20 +1750,22 @@ let getJsxLabels ~componentPath ~findTypeOfValue ~package =
 
 let rec resolveNestedPattern typ ~env ~package ~nested =
   match nested with
-  | [] -> Some (typ, env)
+  | [] -> Some (typ, env, None)
   | patternPath :: nested -> (
     match (patternPath, typ |> extractType ~env ~package) with
     | Completable.PTupleItem {itemNum}, Some (Tuple (env, tupleItems, _)) -> (
       match List.nth_opt tupleItems itemNum with
       | None -> None
       | Some typ -> typ |> resolveNestedPattern ~env ~package ~nested)
-    | Completable.PRecordField {fieldName}, Some (Trecord {env; fields}) -> (
+    | PFollowRecordField {fieldName}, Some (Trecord {env; fields}) -> (
       match
         fields
         |> List.find_opt (fun (field : field) -> field.fname.txt = fieldName)
       with
       | None -> None
       | Some {typ} -> typ |> resolveNestedPattern ~env ~package ~nested)
+    | PRecordBody _, Some (Trecord {env; typeExpr}) ->
+      Some (typeExpr, env, Some Completable.RecordField)
     | _ -> None)
 
 let processCompletable ~debug ~full ~scope ~env ~pos ~forHover
@@ -1821,7 +1831,7 @@ let processCompletable ~debug ~full ~scope ~env ~pos ~forHover
     | Some (_, typ, env) ->
       typ
       |> completeTypedValue ~env ~envWhereCompletionStarted ~full ~prefix
-           ~expandOption:true ~includeLocalValues:true)
+           ~expandOption:true ~includeLocalValues:true ~completionContext:None)
   | Cdecorator prefix ->
     let mkDecorator (name, docstring) =
       {(Completion.create ~name ~kind:(Label "") ~env) with docstring}
@@ -2086,11 +2096,11 @@ Note: The `@react.component` decorator requires the react-jsx config to be set i
     | Some (Optional _, typ) ->
       typ
       |> completeTypedValue ~env ~envWhereCompletionStarted ~full ~prefix
-           ~expandOption:true ~includeLocalValues:true
+           ~expandOption:true ~includeLocalValues:true ~completionContext:None
     | Some ((Unlabelled _ | Labelled _), typ) ->
       typ
       |> completeTypedValue ~env ~envWhereCompletionStarted ~full ~prefix
-           ~expandOption:false ~includeLocalValues:true)
+           ~expandOption:false ~includeLocalValues:true ~completionContext:None)
   | CnamedArg (cp, prefix, identsSeen) ->
     let labels =
       match
@@ -2131,7 +2141,7 @@ Note: The `@react.component` decorator requires the react-jsx config to be set i
     | Some (typ, env) ->
       typ
       |> completeTypedValue ~env ~envWhereCompletionStarted ~full ~prefix
-           ~expandOption:false ~includeLocalValues:false
+           ~expandOption:false ~includeLocalValues:false ~completionContext:None
     | None -> [])
   | Cpattern {typ; prefix; nested = Some nested} -> (
     let envWhereCompletionStarted = env in
@@ -2144,8 +2154,8 @@ Note: The `@react.component` decorator requires the react-jsx config to be set i
     | Some (typ, env) -> (
       match typ |> resolveNestedPattern ~env ~package:full.package ~nested with
       | None -> []
-      | Some (typ, env) ->
+      | Some (typ, env, completionContext) ->
         typ
         |> completeTypedValue ~env ~envWhereCompletionStarted ~full ~prefix
-             ~expandOption:false ~includeLocalValues:false)
+             ~expandOption:false ~includeLocalValues:false ~completionContext)
     | None -> [])

analysis/src/CompletionFrontEnd.ml

@@ -497,34 +497,40 @@ let completionWithParser1 ~currentFile ~debug ~offset ~path ~posCursor ~text =
         | _, Some patHoleCount ->
           appendNestedPat (Completable.PTupleItem {itemNum = patHoleCount})
         | _ -> ())
-      | Ppat_record ([], _) -> commitFoundPat ~prefix:"" ()
+      | Ppat_record ([], _) ->
+        appendNestedPat (Completable.PRecordBody {seenFields = []});
+        commitFoundPat ~prefix:"" ()
       | Ppat_record (fields, _) -> (
+        (* TODO: Identify seen fields. *)
         let fieldWithCursor = ref None in
         let fieldWithPatHole = ref None in
         fields
-        |> List.filter (fun (_, f) ->
-               (* Ensure we only include fields with patterns we can continue into. *)
-               match f.Parsetree.ppat_desc with
-               | Ppat_tuple _ | Ppat_construct _ | Ppat_variant _
-               | Ppat_record _ ->
-                 true
-               | _ -> false)
         |> List.iter (fun (fname, f) ->
                match
                  ( fname.Location.txt,
                    f.Parsetree.ppat_loc
                    |> CursorPosition.classifyLoc ~pos:posBeforeCursor )
                with
                | Longident.Lident fname, HasCursor ->
-                 fieldWithCursor := Some fname
-               | Lident fname, EmptyLoc when isPatternHole f ->
-                 fieldWithPatHole := Some fname
+                 fieldWithCursor := Some (fname, f)
+               | Lident fname, _ when isPatternHole f ->
+                 fieldWithPatHole := Some (fname, f)
                | _ -> ());
         match (!fieldWithCursor, !fieldWithPatHole) with
-        | Some fname, _ ->
-          appendNestedPat (Completable.PRecordField {fieldName = fname})
-        | None, Some fname ->
-          appendNestedPat (Completable.PRecordField {fieldName = fname})
+        | Some (fname, f), _ | None, Some (fname, f) -> (
+          match f.ppat_desc with
+          | Ppat_record _ | Ppat_construct _ | Ppat_variant _ | Ppat_tuple _ ->
+            (* These are things we can continue into in the pattern. *)
+            appendNestedPat (Completable.PFollowRecordField {fieldName = fname})
+          | Ppat_extension ({txt = "rescript.patternhole"}, _) ->
+            (* A pattern hole means for example `{someField: <com>}`. We want to complete for the type of `someField`.  *)
+            appendNestedPat (Completable.PFollowRecordField {fieldName = fname});
+            commitFoundPat ~prefix:"" ()
+          | Ppat_var {txt} ->
+            (* A var means `{s}` or similar. Complete for fields. *)
+            appendNestedPat (Completable.PRecordBody {seenFields = []});
+            commitFoundPat ~prefix:txt ()
+          | _ -> ())
         | _ -> ())
       | _ -> ()
   in

analysis/src/SharedTypes.ml

@@ -550,14 +550,19 @@ module Completable = struct
             (** The loc item for the left hand side of the pipe. *)
       }
 
+  (** Additional context for a pattern completion where needed. *)
+  type patternContext = RecordField
+
   type patternPath =
     | PTupleItem of {itemNum: int}
-    | PRecordField of {fieldName: string}
+    | PFollowRecordField of {fieldName: string}
+    | PRecordBody of {seenFields: string list}
 
   let patternPathToString p =
     match p with
     | PTupleItem {itemNum} -> "tuple($" ^ string_of_int itemNum ^ ")"
-    | PRecordField {fieldName} -> "recordField(" ^ fieldName ^ ")"
+    | PFollowRecordField {fieldName} -> "recordField(" ^ fieldName ^ ")"
+    | PRecordBody _ -> "recordBody"
 
   type t =
     | Cdecorator of string  (** e.g. @module *)

analysis/tests/src/CompletionPattern.res

@@ -43,6 +43,9 @@ let f: someRecord = {
 
 let z = (f, true)
 
+// switch f { | }
+//             ^com
+
 // switch f { | {}}
 //               ^com
 
@@ -52,5 +55,8 @@ let z = (f, true)
 // switch z { | ({o}, _)}
 //                 ^com
 
+// switch f { | {nest: }}
+//                    ^com
+
 // switch f { | {nest: {}}}
 //                      ^com

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

@@ -74,11 +74,25 @@ Completable: Cpattern Value[x]=t
     "documentation": null
   }]
 
-Complete src/CompletionPattern.res 45:17
-looking for: Cpath Value[f] 
-posCursor:[45:17] posNoWhite:[45:16] Found expr:[45:3->45:19]
-posCursor:[45:17] posNoWhite:[45:16] Found pattern:[45:16->45:18]
+Complete src/CompletionPattern.res 45:15
+XXX Not found!
 Completable: Cpattern Value[f]
+[{
+    "label": "{}",
+    "kind": 12,
+    "tags": [],
+    "detail": "someRecord",
+    "documentation": null,
+    "sortText": "a",
+    "insertText": "{$0}",
+    "insertTextFormat": 2
+  }]
+
+Complete src/CompletionPattern.res 48:17
+looking for: Cpath Value[f] 
+posCursor:[48:17] posNoWhite:[48:16] Found expr:[48:3->48:19]
+posCursor:[48:17] posNoWhite:[48:16] Found pattern:[48:16->48:18]
+Completable: Cpattern Value[f]->recordBody
 [{
     "label": "first",
     "kind": 5,
@@ -105,12 +119,12 @@ Completable: Cpattern Value[f]
     "documentation": null
   }]
 
-Complete src/CompletionPattern.res 48:19
+Complete src/CompletionPattern.res 51:19
 looking for: Cpath Value[f] 
-posCursor:[48:19] posNoWhite:[48:18] Found expr:[48:3->48:21]
-posCursor:[48:19] posNoWhite:[48:18] Found pattern:[48:16->48:20]
-posCursor:[48:19] posNoWhite:[48:18] Found pattern:[48:17->48:19]
-Completable: Cpattern Value[f]=fi
+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]
+Completable: Cpattern Value[f]=fi->recordBody
 [{
     "label": "first",
     "kind": 5,
@@ -119,13 +133,13 @@ Completable: Cpattern Value[f]=fi
     "documentation": null
   }]
 
-Complete src/CompletionPattern.res 51:19
+Complete src/CompletionPattern.res 54:19
 looking for: Cpath Value[z] 
-posCursor:[51:19] posNoWhite:[51:18] Found expr:[51:3->51:25]
-posCursor:[51:19] posNoWhite:[51:18] Found pattern:[51:16->51:24]
-posCursor:[51:19] posNoWhite:[51:18] Found pattern:[51:17->51:20]
-posCursor:[51:19] posNoWhite:[51:18] Found pattern:[51:18->51:19]
-Completable: Cpattern Value[z]=o->tuple($0)
+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]
+Completable: Cpattern Value[z]=o->tuple($0), recordBody
 [{
     "label": "optThird",
     "kind": 5,
@@ -134,12 +148,28 @@ Completable: Cpattern Value[z]=o->tuple($0)
     "documentation": null
   }]
 
-Complete src/CompletionPattern.res 54:24
+Complete src/CompletionPattern.res 57:22
 looking for: Cpath Value[f] 
-posCursor:[54:24] posNoWhite:[54:23] Found expr:[54:3->54:27]
-posCursor:[54:24] posNoWhite:[54:23] Found pattern:[54:16->54:26]
-posCursor:[54:24] posNoWhite:[54:23] Found pattern:[54:23->54:25]
+posCursor:[57:22] posNoWhite:[57:21] Found expr:[57:3->57:25]
+posCursor:[57:22] posNoWhite:[57:21] Found pattern:[57:16->57:25]
 Completable: Cpattern Value[f]->recordField(nest)
+[{
+    "label": "{}",
+    "kind": 12,
+    "tags": [],
+    "detail": "nestedRecord",
+    "documentation": null,
+    "sortText": "a",
+    "insertText": "{$0}",
+    "insertTextFormat": 2
+  }]
+
+Complete src/CompletionPattern.res 60: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]
+Completable: Cpattern Value[f]->recordField(nest), recordBody
 [{
     "label": "nested",
     "kind": 5,