functions and labels

zth · zth · commit 7e69428ebcde · 2023-08-27T21:50:24.000+02:00
diff --git a/analysis/src/CompletionFrontEndNew.ml b/analysis/src/CompletionFrontEndNew.ml
@@ -238,6 +238,13 @@ module CompletionInstruction = struct
               to the record itself. *)
         prefix: string;
       }  (** Completing inside of an expression. *)
+    | CnamedArg of {
+        ctxPath: ctxPath;
+            (** Context path to the function with the argument. *)
+        seenLabels: string list;
+            (** All the already seen labels in the function call. *)
+        prefix: string;  (** The text the user has written so far.*)
+      }
 
   let ctxPath ctxPath = CtxPath ctxPath
 
@@ -257,6 +264,9 @@ module CompletionInstruction = struct
         ctxPath = completionContext.ctxPath;
       }
 
+  let namedArg ~prefix ~functionContextPath ~seenLabels =
+    CnamedArg {prefix; ctxPath = functionContextPath; seenLabels}
+
   let toString (c : t) =
     match c with
     | CtxPath ctxPath ->
@@ -276,6 +286,10 @@ module CompletionInstruction = struct
         (match prefix with
         | "" -> ""
         | prefix -> Printf.sprintf ", prefix: \"%s\"" prefix)
+    | CnamedArg {prefix; ctxPath; seenLabels} ->
+      "CnamedArg("
+      ^ (ctxPath |> ctxPathToString)
+      ^ ", " ^ str prefix ^ ", " ^ (seenLabels |> list) ^ ")"
 end
 
 module CompletionResult = struct
@@ -298,6 +312,12 @@ module CompletionResult = struct
     Some
       ( CompletionInstruction.expression ~completionContext ~prefix,
         completionContext )
+
+  let namedArg ~(completionContext : CompletionContext.t) ~prefix ~seenLabels
+      ~functionContextPath =
+    Some
+      ( CompletionInstruction.namedArg ~functionContextPath ~prefix ~seenLabels,
+        completionContext )
 end
 
 let flattenLidCheckDot ?(jsx = true) ~(completionContext : CompletionContext.t)
@@ -908,55 +928,126 @@ and completeExpr ~completionContext (expr : Parsetree.expression) :
     if locHasPos lhs.pexp_loc then completeExpr ~completionContext lhs
     else if locHasPos rhs.pexp_loc then completeExpr ~completionContext rhs
     else None
+  | Pexp_apply (fnExpr, _args) when locHasPos fnExpr.pexp_loc ->
+    (* Handle when the cursor is in the function expression itself. *)
+    fnExpr
+    |> completeExpr
+         ~completionContext:(completionContext |> CompletionContext.resetCtx)
   | Pexp_apply (fnExpr, args) -> (
-    if locHasPos fnExpr.pexp_loc then
-      (* someFn<com>(). Cursor in the function expression itself. *)
-      completeExpr
-        ~completionContext:(CompletionContext.resetCtx completionContext)
-        fnExpr
-    else
-      (* Check if the args has the cursor. *)
-      (* Keep track of the positions of unlabelled arguments. *)
-      let unlabelledArgPos = ref (-1) in
-      let fnContextPath = exprToContextPath fnExpr in
-      let argWithCursorInExpr =
-        args
-        |> List.find_opt
-             (fun ((arg, argExpr) : Asttypes.arg_label * Parsetree.expression)
-             ->
-               if arg = Nolabel then unlabelledArgPos := !unlabelledArgPos + 1;
-               locHasPos argExpr.pexp_loc)
+    (* Handle when the cursor isn't in the function expression. Possibly in an argument. *)
+    (* TODO: Are we moving into all expressions we need here? The fn expression itself? *)
+    let fnContextPath = exprToContextPath fnExpr in
+    match fnContextPath with
+    | None -> None
+    | Some functionContextPath -> (
+      let beforeCursor = completionContext.positionContext.beforeCursor in
+      let isPipedExpr = false (* TODO: Implement *) in
+      let args = extractExpApplyArgs ~args in
+      let endPos = Loc.end_ expr.pexp_loc in
+      let posAfterFnExpr = Loc.end_ fnExpr.pexp_loc in
+      let fnHasCursor =
+        posAfterFnExpr <= beforeCursor && beforeCursor < endPos
+      in
+      (* All of the labels already written in the application. *)
+      let seenLabels =
+        List.fold_right
+          (fun arg seenLabels ->
+            match arg with
+            | {label = Some labelled} -> labelled.name :: seenLabels
+            | {label = None} -> seenLabels)
+          args []
       in
-      (* TODO: Complete labelled argument names, pipes *)
       let makeCompletionContextWithArgumentLabel argumentLabel
           ~functionContextPath =
         completionContext |> CompletionContext.resetCtx
         |> CompletionContext.currentlyExpectingOrReset
              (Some
                 (Type (CFunctionArgument {functionContextPath; argumentLabel})))
       in
-      match (argWithCursorInExpr, fnContextPath) with
-      | None, _ -> None
-      | Some (Nolabel, argExpr), Some functionContextPath ->
+      (* Piped expressions always have an initial unlabelled argument. *)
+      let unlabelledCount = ref (if isPipedExpr then 1 else 0) in
+      let rec loop args =
+        match args with
+        | {label = Some labelled; exp} :: rest ->
+          if labelled.posStart <= beforeCursor && beforeCursor < labelled.posEnd
+          then
+            (* Complete for a label: `someFn(~labelNam<com>)` *)
+            CompletionResult.namedArg ~completionContext ~prefix:labelled.name
+              ~seenLabels ~functionContextPath
+          else if locHasPos exp.pexp_loc then
+            (* Completing in the assignment of labelled argument, with a value.
+               `someFn(~someLabel=someIden<com>)` *)
+            let completionContext =
+              makeCompletionContextWithArgumentLabel (Labelled labelled.name)
+                ~functionContextPath
+            in
+            completeExpr ~completionContext exp
+          else if CompletionExpressions.isExprHole exp then
+            (* Completing in the assignment of labelled argument, with no value yet.
+               The parser inserts an expr hole. `someFn(~someLabel=<com>)` *)
+            let completionContext =
+              makeCompletionContextWithArgumentLabel (Labelled labelled.name)
+                ~functionContextPath
+            in
+            CompletionResult.expression ~completionContext ~prefix:""
+          else loop rest
+        | {label = None; exp} :: rest ->
+          if Res_parsetree_viewer.isTemplateLiteral exp then
+            (* Ignore template literals, or we mess up completion inside of them. *)
+            None
+          else if locHasPos exp.pexp_loc then
+            (* Completing in an unlabelled argument with a value. `someFn(someV<com>) *)
+            let completionContext =
+              makeCompletionContextWithArgumentLabel
+                (Unlabelled {argumentPosition = !unlabelledCount})
+                ~functionContextPath
+            in
+            completeExpr ~completionContext exp
+          else if CompletionExpressions.isExprHole exp then
+            (* Completing in an unlabelled argument without a value. `someFn(true, <com>) *)
+            let completionContext =
+              makeCompletionContextWithArgumentLabel
+                (Unlabelled {argumentPosition = !unlabelledCount})
+                ~functionContextPath
+            in
+            CompletionResult.expression ~completionContext ~prefix:""
+          else (
+            unlabelledCount := !unlabelledCount + 1;
+            loop rest)
+        | [] ->
+          if fnHasCursor then
+            (* No matches, but we know we have the cursor. Check the first char
+               behind the cursor. '~' means label completion. *)
+            match completionContext.positionContext.charBeforeCursor with
+            | Some '~' ->
+              CompletionResult.namedArg ~completionContext ~prefix:""
+                ~seenLabels ~functionContextPath
+            | _ ->
+              (* No '~'. Assume we want to complete for the next unlabelled argument. *)
+              let completionContext =
+                makeCompletionContextWithArgumentLabel
+                  (Unlabelled {argumentPosition = !unlabelledCount})
+                  ~functionContextPath
+              in
+              CompletionResult.expression ~completionContext ~prefix:""
+          else None
+      in
+      match args with
+      (* Special handling for empty fn calls, e.g. `let _ = someFn(<com>)` *)
+      | [
+       {
+         label = None;
+         exp = {pexp_desc = Pexp_construct ({txt = Lident "()"}, _)};
+       };
+      ]
+        when fnHasCursor ->
         let completionContext =
           makeCompletionContextWithArgumentLabel
-            (Unlabelled {argumentPosition = !unlabelledArgPos})
-            ~functionContextPath
-        in
-        completeExpr ~completionContext argExpr
-      | Some (Labelled label, argExpr), Some functionContextPath ->
-        let completionContext =
-          makeCompletionContextWithArgumentLabel (Labelled label)
+            (Unlabelled {argumentPosition = 0})
             ~functionContextPath
         in
-        completeExpr ~completionContext argExpr
-      | Some (Optional label, argExpr), Some functionContextPath ->
-        let completionContext =
-          makeCompletionContextWithArgumentLabel (Optional label)
-            ~functionContextPath
-        in
-        completeExpr ~completionContext argExpr
-      | _ -> None)
+        CompletionResult.expression ~completionContext ~prefix:""
+      | _ -> loop args))
   | Pexp_fun _ ->
     (* We've found a function definition, like `let whatever = (someStr: string) => {}` *)
     let rec loopFnExprs ~(completionContext : CompletionContext.t)
diff --git a/analysis/src/new-completions-todo.md b/analysis/src/new-completions-todo.md
@@ -2,3 +2,4 @@
 
 - Figure out location for completeExpr - when do we need to check locs, and when not?
 - Pipe PPX transform, should we run it ourselves in the editor tooling?
+- Is there a practical difference btween Cexpression and Cpath?
diff --git a/analysis/tests/src/CompletionNew.res b/analysis/tests/src/CompletionNew.res
@@ -23,7 +23,7 @@ type nestedRecord = {
   maybeVariant?: someVariant,
 }
 
-type someRecord = {nested: option<nestedRecord>, variant: someVariant}
+type someRecord = {nested: option<nestedRecord>, variant: someVariant, someString: string}
 
 // let myFunc: someRecord = {}
 //                           ^co2
@@ -127,3 +127,15 @@ type fn = (~name: string=?, string) => bool
 
 // let x = foo->M
 //               ^co2
+
+// == Function arguments ==
+
+let someFun = (~firstLabel, ~secondLabel=?, r: someRecord) => {
+  firstLabel ++ secondLabel->Belt.Option.getWithDefault("") ++ r.someString
+}
+
+// let ff = someFun(~secondLabel, ~f)
+//                                  ^co2
+
+// let ff = someFun(~secondLabel, ~f)
+//                                   ^co2
diff --git a/analysis/tests/src/expected/CompletionNew.res.txt b/analysis/tests/src/expected/CompletionNew.res.txt
@@ -154,7 +154,9 @@ Scope: 0 items
 Looking for type: Type<CFunctionArgument CId(Value)=someFunc(~labelledArg)>
 
 Complete2 src/CompletionNew.res 117:33
-No completions
+Result: Cexpression: ctxPath: , rootType: Type<CFunctionArgument CId(Value)=someFunc(~labelledArg)>
+Scope: 0 items
+Looking for type: Type<CFunctionArgument CId(Value)=someFunc(~labelledArg)>
 
 Complete2 src/CompletionNew.res 121:17
 Result: CtxPath: (CId(Value)=foo)->id
@@ -171,3 +173,13 @@ Result: Cexpression: ctxPath: CId(Module)=M, rootType: Unit, prefix: "M"
 Scope: 0 items
 Looking for type: Unit
 
+Complete2 src/CompletionNew.res 136:36
+Result: CnamedArg(CId(Value)=someFun, f, [secondLabel, f])
+Scope: 0 items
+Looking for type: TypeAtLoc: [136:7->136:9]
+
+Complete2 src/CompletionNew.res 139:37
+Result: Cexpression: ctxPath: , rootType: Type<CFunctionArgument CId(Value)=someFun($0)>
+Scope: 0 items
+Looking for type: Type<CFunctionArgument CId(Value)=someFun($0)>
+

Original file line number	Diff line number	Diff line change
`@@ -2,3 +2,4 @@`
`2`	`2`
`3`	`3`	`- Figure out location for completeExpr - when do we need to check locs, and when not?`
`4`	`4`	`- Pipe PPX transform, should we run it ourselves in the editor tooling?`
	`5`	`+- Is there a practical difference btween Cexpression and Cpath?`