Merge pull request #513 from rescript-lang/functions-codelens

Code Lens

Author: zth

CHANGELOG.md

@@ -14,7 +14,9 @@
 
 #### :rocket: New Feature
 
-- Inlay Hints (experimetal). `rescript.settings.inlayHints.enable: true`
+- Inlay Hints (experimetal). `rescript.settings.inlayHints.enable: true`. Turned off by default.
+- Code Lenses for functions (experimetal). `rescript.settings.codeLens: true`. Turned off by default.
+
 ## v1.4.2
 
 #### :bug: Bug Fix

README.md

@@ -117,6 +117,15 @@ rescript.settings.inlayHints.enable: true
 rescript.settings.inlayHints.maxLength: 25
 ```
 
+### Code Lens (experimental)
+
+This tells the editor to add code lenses to function definitions, showing its full type above the definition.
+
+```jsonc
+// Enable (experimental) code lens.
+rescript.settings.codeLens: true
+```
+
 ### Hide generated files
 
 You can configure VSCode to collapse the JavaScript files ReScript generates under its source ReScript file. This will "hide" the generated files in the VSCode file explorer, but still leaving them accessible by expanding the source ReScript file they belong to.

analysis/src/Cli.ml

@@ -11,7 +11,8 @@ API examples:
   ./rescript-editor-analysis.exe references src/MyFile.res 10 2
   ./rescript-editor-analysis.exe rename src/MyFile.res 10 2 foo
   ./rescript-editor-analysis.exe diagnosticSyntax src/MyFile.res
-  /rescript-editor-analysis.exe inlayHint src/MyFile.res 0 3 25
+  ./rescript-editor-analysis.exe inlayHint src/MyFile.res 0 3 25
+  ./rescript-editor-analysis.exe codeLens src/MyFile.res
 
 Dev-time examples:
   ./rescript-editor-analysis.exe dump src/MyFile.res src/MyFile2.res
@@ -70,6 +71,10 @@ Options:
 
     ./rescript-editor-analysis.exe inlayHint src/MyFile.res 0 3 25
 
+  codeLens: get all code lens entries for file src/MyFile.res
+
+    ./rescript-editor-analysis.exe codeLens src/MyFile.res
+
   test: run tests specified by special comments in file src/MyFile.res
 
     ./rescript-editor-analysis.exe test src/src/MyFile.res
@@ -98,6 +103,7 @@ let main () =
     Commands.inlayhint ~path
       ~pos:(int_of_string line_start, int_of_string line_end)
       ~maxLength ~debug:false
+  | [_; "codeLens"; path] -> Commands.codeLens ~path ~debug:false
   | [_; "codeAction"; path; line; col; currentFile] ->
     Commands.codeAction ~path
       ~pos:(int_of_string line, int_of_string col)

analysis/src/Commands.ml

@@ -32,6 +32,10 @@ let inlayhint ~path ~pos ~maxLength ~debug =
   let result = Hint.inlay ~path ~pos ~maxLength ~debug |> Protocol.array in
   print_endline result
 
+let codeLens ~path ~debug =
+  let result = Hint.codeLens ~path ~debug |> Protocol.array in
+  print_endline result
+
 let hover ~path ~pos ~currentFile ~debug =
   let result =
     match Cmt.fullFromPath ~path with
@@ -391,6 +395,9 @@ let test ~path =
             let line_end = 6 in
             print_endline ("Inlay Hint " ^ path ^ " " ^ string_of_int line_start ^ ":" ^ string_of_int line_end);
             inlayhint ~path ~pos:(line_start, line_end) ~maxLength:"25" ~debug:false)
+          | "cle" ->
+            print_endline ("Code Lens " ^ path);
+            codeLens ~path ~debug:false
           | _ -> ());
           print_newline ())
     in

analysis/src/Hint.ml

@@ -119,4 +119,60 @@ let inlay ~path ~pos ~maxLength ~debug =
                | Some value ->
                  if String.length label > value then None else Some result
                | None -> Some result)
-             | None -> None)))
+             | None -> None)))
+
+let codeLens ~path ~debug =
+  let lenses = ref [] in
+  let push loc =
+    let range = Utils.cmtLocToRange loc in
+    lenses := range :: !lenses
+  in
+  (* Code lenses are only emitted for functions right now. So look for value bindings that are functions,
+     and use the loc of the value binding itself so we can look up the full function type for our code lens. *)
+  let value_binding (iterator : Ast_iterator.iterator)
+      (vb : Parsetree.value_binding) =
+    (match vb with
+    | {
+     pvb_pat = {ppat_desc = Ppat_var _; ppat_loc};
+     pvb_expr = {pexp_desc = Pexp_fun _};
+    } ->
+      push ppat_loc
+    | _ -> ());
+    Ast_iterator.default_iterator.value_binding iterator vb
+  in
+  let iterator = {Ast_iterator.default_iterator with value_binding} in
+  (* We only print code lenses in implementation files. This is because they'd be redundant in interface files,
+     where the definition itself will be the same thing as what would've been printed in the code lens. *)
+  (if Filename.check_suffix path ".res" then
+   let parser =
+     Res_driver.parsingEngine.parseImplementation ~forPrinter:false
+   in
+   let {Res_driver.parsetree = structure} = parser ~filename:path in
+   iterator.structure iterator structure |> ignore);
+  !lenses
+  |> List.filter_map (fun (range : Protocol.range) ->
+         match Cmt.fullFromPath ~path with
+         | None -> None
+         | Some full -> (
+           match
+             References.getLocItem ~full
+               ~pos:(range.start.line, range.start.character + 1)
+               ~debug
+           with
+           | Some {locType = Typed (_, typeExpr, _)} ->
+             Some
+               (Protocol.stringifyCodeLens
+                  {
+                    range;
+                    command =
+                      Some
+                        {
+                          (* Code lenses can run commands. An empty command string means we just want the editor
+                             to print the text, not link to running a command. *)
+                          command = "";
+                          (* Print the type with a huge line width, because the code lens always prints on a
+                             single line in the editor. *)
+                          title = typeExpr |> Shared.typeToString ~lineWidth:400;
+                        };
+                  })
+           | _ -> None))

analysis/src/PrintType.ml

@@ -1,6 +1,6 @@
-let printExpr typ =
+let printExpr ?(lineWidth = 60) typ =
   Printtyp.reset_names ();
-  Res_doc.toString ~width:60
+  Res_doc.toString ~width:lineWidth
     (Res_outcome_printer.printOutTypeDoc (Printtyp.tree_of_typexp false typ))
 
 let printDecl ~recStatus name decl =

analysis/src/Protocol.ml

@@ -1,6 +1,13 @@
 type position = {line: int; character: int}
 type range = {start: position; end_: position}
 type markupContent = {kind: string; value: string}
+
+(* https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#command *)
+type command = {title: string; command: string}
+
+(* https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#codeLens *)
+type codeLens = {range: range; command: command option}
+
 type inlayHint = {
   position: position;
   label: string;
@@ -147,6 +154,22 @@ let stringifyHint hint =
     (stringifyPosition hint.position)
     (Json.escape hint.label) hint.kind hint.paddingLeft hint.paddingRight
 
+let stringifyCommand (command : command) =
+  Printf.sprintf {|{"title": "%s", "command": "%s"}|}
+    (Json.escape command.title)
+    (Json.escape command.command)
+
+let stringifyCodeLens (codeLens : codeLens) =
+  Printf.sprintf
+    {|{
+        "range": %s,
+        "command": %s
+    }|}
+    (stringifyRange codeLens.range)
+    (match codeLens.command with
+    | None -> ""
+    | Some command -> stringifyCommand command)
+
 (* https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#diagnostic *)
 let stringifyDiagnostic d =
   Printf.sprintf

analysis/src/Shared.ml

@@ -49,12 +49,12 @@ let declToString ?(recStatus = Types.Trec_not) name t =
 let cacheTypeToString = ref false
 let typeTbl = Hashtbl.create 1
 
-let typeToString (t : Types.type_expr) =
+let typeToString ?lineWidth (t : Types.type_expr) =
   match
     if !cacheTypeToString then Hashtbl.find_opt typeTbl (t.id, t) else None
   with
   | None ->
-    let s = PrintType.printExpr t in
+    let s = PrintType.printExpr ?lineWidth t in
     Hashtbl.replace typeTbl (t.id, t) s;
     s
   | Some s -> s

analysis/tests/src/CodeLens.res

@@ -0,0 +1,11 @@
+let add = (x, y) => x + y
+
+let foo = (~age, ~name) => name ++ string_of_int(age)
+
+let ff = (~opt1=0, ~a, ~b, (), ~opt2=0, (), ~c) => a + b + c + opt1 + opt2
+
+let compFF = Completion.ff
+
+@react.component
+let make = (~name) => React.string(name)
+//^cle

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

@@ -0,0 +1,15 @@
+Code Lens src/CodeLens.res
+[{
+        "range": {"start": {"line": 9, "character": 4}, "end": {"line": 9, "character": 8}},
+        "command": {"title": "{\"name\": string} => React.element", "command": ""}
+    }, {
+        "range": {"start": {"line": 4, "character": 4}, "end": {"line": 4, "character": 6}},
+        "command": {"title": "(~opt1: int=?, ~a: int, ~b: int, unit, ~opt2: int=?, unit, ~c: int) => int", "command": ""}
+    }, {
+        "range": {"start": {"line": 2, "character": 4}, "end": {"line": 2, "character": 7}},
+        "command": {"title": "(~age: int, ~name: string) => string", "command": ""}
+    }, {
+        "range": {"start": {"line": 0, "character": 4}, "end": {"line": 0, "character": 7}},
+        "command": {"title": "(int, int) => int", "command": ""}
+    }]
+