add test cases and identify arguments for completion

Author: zth

analysis/src/CompletionBackEnd.ml

@@ -1817,6 +1817,7 @@ Note: The `@react.component` decorator requires the react-jsx config to be set i
            in
            (dec2, doc))
     |> List.map mkDecorator
+  | Cargument _ -> []
   | CnamedArg (cp, prefix, identsSeen) ->
     let labels =
       match

analysis/src/CompletionFrontEnd.ml

@@ -106,7 +106,17 @@ let extractJsxProps ~(compName : Longident.t Location.loc) ~args =
   in
   args |> processProps ~acc:[]
 
-let findNamedArgCompletable ~(args : arg list) ~endPos ~posBeforeCursor
+let extractCompletableArgValueInfo exp =
+  match exp.Parsetree.pexp_desc with
+  | Pexp_ident {txt} -> Some (Utils.flattenLongIdent txt |> List.hd)
+  | _ -> None
+
+let isExprHole exp =
+  match exp.Parsetree.pexp_desc with
+  | Pexp_extension ({txt = "rescript.exprhole"}, _) -> true
+  | _ -> false
+
+let findArgCompletables ~(args : arg list) ~endPos ~posBeforeCursor
     ~(contextPath : Completable.contextPath) ~posAfterFunExpr =
   let allNames =
     List.fold_right
@@ -116,18 +126,55 @@ let findNamedArgCompletable ~(args : arg list) ~endPos ~posBeforeCursor
         | {label = None} -> allLabels)
       args []
   in
+  let unlabelledCount = ref 0 in
   let rec loop args =
     match args with
     | {label = Some labelled; exp} :: rest ->
       if
         labelled.posStart <= posBeforeCursor
         && posBeforeCursor < labelled.posEnd
       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 then
+        (* Completing in the assignment of labelled argument *)
+        match extractCompletableArgValueInfo exp with
+        | None -> None
+        | Some prefix ->
+          Some
+            (Cargument
+               {contextPath; argumentLabel = Labelled labelled.name; prefix})
+      else if isExprHole exp then
+        Some
+          (Cargument
+             {contextPath; argumentLabel = Labelled labelled.name; prefix = ""})
       else loop rest
     | {label = None; exp} :: rest ->
-      if exp.pexp_loc |> Loc.hasPos ~pos:posBeforeCursor then None
-      else loop rest
+      (* TODO: Better guard for this... This is so completion does not trigger
+         inside of template string calls, which are regular calls *)
+      if Res_parsetree_viewer.isTemplateLiteral exp then None
+      else if exp.pexp_loc |> Loc.hasPos ~pos:posBeforeCursor then
+        (* Completing in an unlabelled argument *)
+        match extractCompletableArgValueInfo exp with
+        | None -> None
+        | Some prefix ->
+          Some
+            (Cargument
+               {
+                 contextPath;
+                 argumentLabel =
+                   Unlabelled {argumentPosition = !unlabelledCount};
+                 prefix;
+               })
+      else if isExprHole exp then
+        Some
+          (Cargument
+             {
+               contextPath;
+               argumentLabel = Unlabelled {argumentPosition = !unlabelledCount};
+               prefix = "";
+             })
+      else (
+        unlabelledCount := !unlabelledCount + 1;
+        loop rest)
     | [] ->
       if posAfterFunExpr <= posBeforeCursor && posBeforeCursor < endPos then
         Some (CnamedArg (contextPath, "", allNames))
@@ -578,16 +625,16 @@ let completionWithParser1 ~currentFile ~debug ~offset ~path ~posCursor ~text =
                        (Loc.toString exp.pexp_loc))
               |> String.concat ", ");
 
-          let namedArgCompletable =
+          let argCompletable =
             match exprToContextPath funExpr with
             | Some contextPath ->
-              findNamedArgCompletable ~contextPath ~args
+              findArgCompletables ~contextPath ~args
                 ~endPos:(Loc.end_ expr.pexp_loc) ~posBeforeCursor
                 ~posAfterFunExpr:(Loc.end_ funExpr.pexp_loc)
             | None -> None
           in
 
-          setResultOpt namedArgCompletable
+          setResultOpt argCompletable
         | Pexp_send (lhs, {txt; loc}) -> (
           (* e["txt"]
              If the string for txt is not closed, it could go over several lines.

analysis/src/SharedTypes.ml

@@ -502,6 +502,10 @@ module Completable = struct
   (* Completion context *)
   type completionContext = Type | Value | Module | Field
 
+  type argumentLabel =
+    | Unlabelled of {argumentPosition: int}
+    | Labelled of string
+
   type contextPath =
     | CPString
     | CPArray
@@ -526,6 +530,11 @@ 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 *)
+    | Cargument of {
+        contextPath: contextPath;
+        argumentLabel: argumentLabel;
+        prefix: string;
+      }
 
   let toString =
     let completionContextToString = function
@@ -564,6 +573,14 @@ module Completable = struct
     | Cnone -> "Cnone"
     | Cjsx (sl1, s, sl2) ->
       "Cjsx(" ^ (sl1 |> list) ^ ", " ^ str s ^ ", " ^ (sl2 |> list) ^ ")"
+    | Cargument {contextPath; argumentLabel; prefix} ->
+      contextPathToString contextPath
+      ^ "("
+      ^ (match argumentLabel with
+        | Unlabelled {argumentPosition} -> "$" ^ string_of_int argumentPosition
+        | Labelled name -> "~" ^ name)
+      ^ (if prefix <> "" then "=" ^ prefix else "")
+      ^ ")"
 end
 
 module CursorPosition = struct

analysis/tests/src/CompletionFunctionArguments.res

@@ -11,3 +11,18 @@ let someFn = (~isOn) => {
 
 // let _ = someFn(~isOn=t)
 //                       ^com
+
+let _ = someFn(
+  ~isOn={
+    // switch someFn(~isOn=)
+    //                     ^com
+    true
+  },
+)
+
+let someOtherFn = (includeName, age) => {
+  "Hello" ++ (includeName ? " Some Name" : "") ++ ", you are age " ++ Belt.Int.toString(age)
+}
+
+// let _ = someOtherFn(t)
+//                      ^com

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

@@ -1,15 +1,28 @@
 Complete src/CompletionFunctionArguments.res 8:24
 posCursor:[8:24] posNoWhite:[8:23] Found expr:[8:11->8:25]
 Pexp_apply ...[8:11->8:17] (~isOn8:19->8:23=...__ghost__[0:-1->0:-1])
-Completable: CnamedArg(Value[someFn], "", [isOn])
-Found type for function (~isOn: bool) => string
+Completable: Value[someFn](~isOn)
 []
 
 Complete src/CompletionFunctionArguments.res 11:25
 posCursor:[11:25] posNoWhite:[11:24] Found expr:[11:11->11:26]
 Pexp_apply ...[11:11->11:17] (~isOn11:19->11:23=...[11:24->11:25])
-posCursor:[11:25] posNoWhite:[11:24] Found expr:[11:24->11:25]
-Pexp_ident t:[11:24->11:25]
-Completable: Cpath Value[t]
+Completable: Value[someFn](~isOn=t)
+[]
+
+Complete src/CompletionFunctionArguments.res 16:27
+posCursor:[16:27] posNoWhite:[16:26] Found expr:[14:8->20:1]
+Pexp_apply ...[14:8->14:14] (~isOn15:3->15:7=...[16:7->18:8])
+posCursor:[16:27] posNoWhite:[16:26] Found expr:[16:7->18:8]
+posCursor:[16:27] posNoWhite:[16:26] Found expr:[16:7->16:28]
+posCursor:[16:27] posNoWhite:[16:26] Found expr:[16:14->16:28]
+Pexp_apply ...[16:14->16:20] (~isOn16:22->16:26=...__ghost__[0:-1->0:-1])
+Completable: Value[someFn](~isOn)
+[]
+
+Complete src/CompletionFunctionArguments.res 26:24
+posCursor:[26:24] posNoWhite:[26:23] Found expr:[26:11->26:25]
+Pexp_apply ...[26:11->26:22] (...[26:23->26:24])
+Completable: Value[someOtherFn]($0=t)
 []