prepare code actions in analysis bin

Author: zth

analysis/src/CodeActions.ml

@@ -5,6 +5,8 @@ let kindToString kind = match kind with RefactorRewrite -> "refactor.rewrite"
 module TextDocument = struct
   type t = {version : string option; uri : string}
 
+  let make ~version ~uri = {version; uri}
+
   let toString t =
     Printf.sprintf {|{"version": %s, "uri": "%s"}|}
       (match t.version with
@@ -16,6 +18,8 @@ end
 module Position = struct
   type t = {line : int; character : int}
 
+  let make ~line ~character = {line; character}
+
   let toString t =
     Printf.sprintf {|{"line": %s, "character": %s}|} (string_of_int t.line)
       (string_of_int t.character)
@@ -24,6 +28,8 @@ end
 module TextEditRange = struct
   type t = {start : Position.t; end_ : Position.t}
 
+  let make ~start ~end_ = {start; end_}
+
   let toString t =
     Printf.sprintf {|{"start": %s, "end": %s}|}
       (t.start |> Position.toString)
@@ -33,34 +39,55 @@ end
 module TextEdit = struct
   type t = {newText : string; range : TextEditRange.t}
 
+  let make ~newText ~range = {newText; range}
+
   let toString t =
-    Printf.sprintf {|{"newText": %s, "range": %s}|} t.newText
+    Printf.sprintf {|{"newText": "%s", "range": %s}|} (Json.escape t.newText)
       (t.range |> TextEditRange.toString)
 end
 
 module DocumentChange = struct
   type t = {textDocument : TextDocument.t; edits : TextEdit.t list}
 
+  let make ~textDocument ~edits = {textDocument; edits}
+
   let toString t =
     Printf.sprintf {|{"textDocument": %s, "edits": [%s]}|}
       (t.textDocument |> TextDocument.toString)
-      ""
+      (t.edits
+      |> List.map (fun edit -> edit |> TextEdit.toString)
+      |> String.concat ",")
 end
 
 module CodeActionEdit = struct
   type t = {documentChanges : DocumentChange.t list}
 
-  let toString t = Printf.sprintf {|{"documentChanges": [%s]}|} ""
+  let make ~documentChanges = {documentChanges}
+
+  let toString t =
+    Printf.sprintf {|{"documentChanges": [%s]}|}
+      (t.documentChanges
+      |> List.map (fun documentChange ->
+             documentChange |> DocumentChange.toString)
+      |> String.concat ",")
 end
 
 module CodeAction = struct
   type t = {title : string; kind : kind; edit : CodeActionEdit.t}
 
+  let make ~title ~kind ~edit = {title; kind; edit}
+
   let toString t =
-    Printf.sprintf {|{"title": %s, "kind": "%s", "edit": %s}|} t.title
+    Printf.sprintf {|{"title": "%s", "kind": "%s", "edit": %s}|} t.title
       (kindToString t.kind)
       (t.edit |> CodeActionEdit.toString)
 end
 
 (* This is the return that's expected when resolving code actions *)
-type result = CodeAction.t list
+type result = CodeAction.t list
+
+let stringifyCodeActions codeActions =
+  Printf.sprintf {|[%s]|}
+    (codeActions
+    |> List.map (fun codeAction -> codeAction |> CodeAction.toString)
+    |> String.concat ",")

analysis/src/Commands.ml

@@ -116,11 +116,42 @@ let codeAction ~path ~line ~col =
           match locItem.SharedTypes.locType with
           | Typed (n, t, _) -> (
             match Printtyp.tree_of_typexp false t with
-            | Otyp_constr (Oide_ident "option", _) -> Protocol.stringifyCodeAction {range = Utils.cmtLocToRange locItem.loc; newText = "switch " ^ n ^ " { | None => failWith(\"TODO\") | Some(" ^ n ^ ") => _" ^ n ^ " }"}
-            | _ -> Protocol.null
-          )
-          | Constant _constant ->
-            Protocol.stringifyHover {contents = "constant"}
+            | Otyp_constr (Oide_ident "option", _) ->
+              let range = Utils.cmtLocToRange locItem.loc in
+              CodeActions.(
+                stringifyCodeActions
+                  [
+                    CodeAction.make ~title:"Unwrap optional"
+                      ~kind:RefactorRewrite
+                      ~edit:
+                        (CodeActionEdit.make
+                           ~documentChanges:
+                             [
+                               DocumentChange.make
+                                 ~textDocument:
+                                   (TextDocument.make ~version:None ~uri:path)
+                                 ~edits:
+                                   [
+                                     TextEdit.make
+                                       ~newText:
+                                         ("switch " ^ n
+                                        ^ " { | None => failWith(\"TODO\") | \
+                                           Some(" ^ n ^ ") => _" ^ n ^ " }")
+                                       ~range:
+                                         (TextEditRange.make
+                                            ~start:
+                                              (Position.make
+                                                 ~line:range.start.line
+                                                 ~character:
+                                                   range.start.character)
+                                            ~end_:
+                                              (Position.make
+                                                 ~line:range.end_.line
+                                                 ~character:range.end_.character));
+                                   ];
+                             ]);
+                  ])
+            | _ -> Protocol.null)
           | _ -> Protocol.null))
   in
   print_endline result

server/src/server.ts

@@ -438,43 +438,15 @@ function codeAction(msg: p.RequestMessage): p.ResponseMessage {
     ],
     msg
   );
-  let result: null | {
-    content: string;
-    range: {
-      start: { line: number; character: number };
-      end: { line: number; character: number };
-    };
-  } = response.result as any;
+
+  let { result } = response;
 
   let res: v.ResponseMessage = {
     jsonrpc: c.jsonrpcVersion,
     id: msg.id,
   };
 
-  if (result == null) {
-    res.result = null;
-    return res;
-  }
-
-  let textEdit: v.TextEdit = { newText: result.content, range: result.range };
-
-  let codeAction: v.CodeAction = {
-    title: "Unwrap optional",
-    kind: v.CodeActionKind.RefactorRewrite,
-    edit: {
-      documentChanges: [
-        {
-          textDocument: {
-            version: null,
-            uri: params.textDocument.uri,
-          },
-          edits: [textEdit],
-        },
-      ],
-    },
-  };
-
-  res.result = [codeAction];
+  res.result = result ?? null;
   return res;
 }