identify typed context for labelled argument assignments

Author: zth

analysis/src/CompletionBackEnd.ml

@@ -1337,6 +1337,7 @@ let processCompletable ~debug ~package ~scope ~env ~pos ~forHover
   in
   match completable with
   | Cnone -> []
+  | CtypedContext _contextPath -> []
   | Cpath contextPath ->
     contextPath
     |> getCompletionsForContextPath ~package ~opens ~rawOpens ~allFiles ~pos

analysis/src/CompletionFrontEnd.ml

@@ -137,7 +137,8 @@ type label = labelled option
 type arg = {label: label; exp: Parsetree.expression}
 
 let findNamedArgCompletable ~(args : arg list) ~endPos ~posBeforeCursor
-    ~(contextPath : Completable.contextPath) ~posAfterFunExpr =
+    ~(contextPath : Completable.contextPath) ~posAfterFunExpr ~charBeforeCursor
+    ~debug =
   let allNames =
     List.fold_right
       (fun arg allLabels ->
@@ -149,11 +150,19 @@ let findNamedArgCompletable ~(args : arg list) ~endPos ~posBeforeCursor
   let rec loop args =
     match args with
     | {label = Some labelled; exp} :: rest ->
+      (* Figure out if we're completing the labelled argument name, or assigning to the labelled argument *)
       if
         labelled.posStart <= posBeforeCursor
         && posBeforeCursor < labelled.posEnd
+        && charBeforeCursor <> Some '='
+        (* We need to account for empty assignments being parsed as regular labelled arguments without an assignment *)
       then Some (Completable.CnamedArg (contextPath, labelled.name, allNames))
-      else if exp.pexp_loc |> Loc.hasPos ~pos:posBeforeCursor then None
+      else if
+        exp.pexp_loc |> Loc.hasPos ~pos:posBeforeCursor
+        || charBeforeCursor = Some '='
+      then (
+        if debug then Printf.printf "found typed context \n";
+        Some (Completable.CtypedContext contextPath))
       else loop rest
     | {label = None; exp} :: rest ->
       if exp.pexp_loc |> Loc.hasPos ~pos:posBeforeCursor then None
@@ -592,6 +601,7 @@ let completionWithParser1 ~currentFile ~debug ~offset ~path ~posCursor ~text =
             | Some contextPath ->
               findNamedArgCompletable ~contextPath ~args
                 ~endPos:(Loc.end_ expr.pexp_loc) ~posBeforeCursor
+                ~charBeforeCursor ~debug
                 ~posAfterFunExpr:(Loc.end_ funExpr.pexp_loc)
             | None -> None
           in

analysis/src/SharedTypes.ml

@@ -433,6 +433,7 @@ module Completable = struct
     | Cpath of contextPath
     | Cjsx of string list * string * string list
         (** E.g. (["M", "Comp"], "id", ["id1", "id2"]) for <M.Comp id1=... id2=... ... id *)
+    | CtypedContext of contextPath  (** WIP, just a dummy arg for now *)
 
   let toString =
     let str s = if s = "" then "\"\"" else s in
@@ -471,4 +472,5 @@ module Completable = struct
     | Cnone -> "Cnone"
     | Cjsx (sl1, s, sl2) ->
       "Cjsx(" ^ (sl1 |> list) ^ ", " ^ str s ^ ", " ^ (sl2 |> list) ^ ")"
+    | CtypedContext cp -> "CtypedContext(" ^ (cp |> contextPathToString) ^ ")"
 end

analysis/tests/src/TypeContextCompletion.res

@@ -8,9 +8,15 @@ let someVariantToString = (~someVariant) =>
   | Four => "Four"
   }
 
+// let x = someVariantToString(~someVaria
+//                                       ^com
+
 // let x = someVariantToString(~someVariant=
 //                                          ^com
 
+// let x = someVariantToString(~someVariant=T
+//                                           ^com
+
 module SomeComponent = {
   @react.component
   let make = (~whatever) => {

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

@@ -1,12 +1,32 @@
-Complete src/TypeContextCompletion.res 10:44
-posCursor:[10:44] posNoWhite:[10:43] Found expr:[10:11->18:1]
-Pexp_apply ...[10:11->10:30] (~someVariant10:32->10:43=...[13:0->17:3])
-Completable: CnamedArg(Value[someVariantToString], "", [someVariant])
+Complete src/TypeContextCompletion.res 10:41
+posCursor:[10:41] posNoWhite:[10:40] Found expr:[10:11->24:1]
+Pexp_apply ...[10:11->10:30] (~someVaria10:32->10:41=...[10:32->10:41], ...[19:0->23:3])
+Completable: CnamedArg(Value[someVariantToString], someVaria, [someVaria])
 Found type for function (~someVariant: someVariant) => string
+[{
+    "label": "someVariant",
+    "kind": 4,
+    "tags": [],
+    "detail": "someVariant",
+    "documentation": null
+  }]
+
+Complete src/TypeContextCompletion.res 13:44
+posCursor:[13:44] posNoWhite:[13:43] Found expr:[13:11->24:1]
+Pexp_apply ...[13:11->13:30] (~someVariant13:32->13:43=...[19:0->23:3])
+found typed context 
+Completable: CtypedContext(Value[someVariantToString])
+[]
+
+Complete src/TypeContextCompletion.res 16:45
+posCursor:[16:45] posNoWhite:[16:44] Found expr:[16:11->24:1]
+Pexp_apply ...[16:11->16:30] (~someVariant16:32->16:43=...[16:44->16:45], ...[19:0->23:3])
+found typed context 
+Completable: CtypedContext(Value[someVariantToString])
 []
 
-Complete src/TypeContextCompletion.res 20:37
-posCursor:[20:37] posNoWhite:[20:36] Found expr:[20:14->20:37]
-JSX <SomeComponent:[20:14->20:27] whatever[20:28->20:36]=...__ghost__[0:-1->0:-1]> _children:None
+Complete src/TypeContextCompletion.res 26:37
+posCursor:[26:37] posNoWhite:[26:36] Found expr:[26:14->26:37]
+JSX <SomeComponent:[26:14->26:27] whatever[26:28->26:36]=...__ghost__[0:-1->0:-1]> _children:None
 []