codeaction: add docstring template

Author: aspeddro

Diff for: analysis/src/Xform.ml

@@ -252,6 +252,103 @@ module AddTypeAnnotation = struct
         | _ -> ()))
 end
 
+module AddDocTemplate = struct
+  let mkIterator ~pos ~result =
+    let signature_item (iterator : Ast_iterator.iterator)
+        (item : Parsetree.signature_item) =
+      match item.psig_desc with
+      | Psig_value value_description as r
+        when Loc.hasPos ~pos value_description.pval_loc
+             && ProcessAttributes.findDocAttribute
+                  value_description.pval_attributes
+                = None ->
+        result := Some (r, item.psig_loc)
+      | Psig_type (_, hd :: _) as r
+        when Loc.hasPos ~pos hd.ptype_loc
+             && ProcessAttributes.findDocAttribute hd.ptype_attributes = None ->
+        result := Some (r, item.psig_loc)
+      | Psig_module {pmd_name = {loc}} as r ->
+        if Loc.start loc = pos then result := Some (r, item.psig_loc)
+        else Ast_iterator.default_iterator.signature_item iterator item
+      | _ -> Ast_iterator.default_iterator.signature_item iterator item
+    in
+    {Ast_iterator.default_iterator with signature_item}
+
+  let createTemplate () =
+    let docContent = ["\n"; "\n"] in
+    let expression =
+      Ast_helper.Exp.constant
+        (Parsetree.Pconst_string (String.concat "" docContent, None))
+    in
+    let structureItemDesc = Parsetree.Pstr_eval (expression, []) in
+    let structureItem = Ast_helper.Str.mk structureItemDesc in
+    let attrLoc =
+      {
+        Location.none with
+        loc_start = Lexing.dummy_pos;
+        loc_end =
+          {
+            Lexing.dummy_pos with
+            pos_lnum = Lexing.dummy_pos.pos_lnum (* force line break *);
+          };
+      }
+    in
+    (Location.mkloc "res.doc" attrLoc, Parsetree.PStr [structureItem])
+
+  let processSigValue (vl_desc : Parsetree.value_description) loc =
+    let attr = createTemplate () in
+    let newValueBinding =
+      {vl_desc with pval_attributes = attr :: vl_desc.pval_attributes}
+    in
+    let signature_item_desc = Parsetree.Psig_value newValueBinding in
+    Ast_helper.Sig.mk ~loc signature_item_desc
+
+  let processTypeDecl (typ : Parsetree.type_declaration) =
+    let attr = createTemplate () in
+    let newTypeDeclaration =
+      {typ with ptype_attributes = attr :: typ.ptype_attributes}
+    in
+    newTypeDeclaration
+
+  let processModDecl (modDecl : Parsetree.module_declaration) loc =
+    let attr = createTemplate () in
+    let newModDecl =
+      {modDecl with pmd_attributes = attr :: modDecl.pmd_attributes}
+    in
+    Ast_helper.Sig.mk ~loc (Parsetree.Psig_module newModDecl)
+
+  let xform ~path ~pos ~codeActions ~signature ~printSignatureItem =
+    let result = ref None in
+    let iterator = mkIterator ~pos ~result in
+    iterator.signature iterator signature;
+    match !result with
+    | Some (signatureItem, loc) -> (
+      let newSignatureItem =
+        match signatureItem with
+        | Psig_value value_desc ->
+          Some (processSigValue value_desc value_desc.pval_loc) (* Some loc *)
+        | Psig_type (flag, hd :: tl) ->
+          let newFirstTypeDecl = processTypeDecl hd in
+          Some
+            (Ast_helper.Sig.mk ~loc
+               (Parsetree.Psig_type (flag, newFirstTypeDecl :: tl)))
+        | Psig_module modDecl -> Some (processModDecl modDecl loc)
+        | _ -> None
+      in
+
+      match newSignatureItem with
+      | Some sig_item ->
+        let range = rangeOfLoc sig_item.psig_loc in
+        let newText = printSignatureItem ~range sig_item in
+        let codeAction =
+          CodeActions.make ~title:"Add Documentation template"
+            ~kind:RefactorRewrite ~uri:path ~newText ~range
+        in
+        codeActions := codeAction :: !codeActions
+      | None -> ())
+    | None -> ()
+end
+
 let parse ~filename =
   let {Res_driver.parsetree = structure; comments} =
     Res_driver.parsingEngine.parseImplementation ~forPrinter:false ~filename
@@ -280,6 +377,27 @@ let parse ~filename =
   in
   (structure, printExpr, printStructureItem)
 
+let parseInterface ~filename =
+  let {Res_driver.parsetree = structure; comments} =
+    Res_driver.parsingEngine.parseInterface ~forPrinter:false ~filename
+  in
+  let filterComments ~loc comments =
+    (* Relevant comments in the range of the expression *)
+    let filter comment =
+      Loc.hasPos ~pos:(Loc.start (Res_comment.loc comment)) loc
+    in
+    comments |> List.filter filter
+  in
+  let printSignatureItem ~(range : Protocol.range)
+      (item : Parsetree.signature_item) =
+    let signature_item = [item] in
+    signature_item
+    |> Res_printer.printInterface ~width:!Res_cli.ResClflags.width
+         ~comments:(comments |> filterComments ~loc:item.psig_loc)
+    |> Utils.indent range.start.character
+  in
+  (structure, printSignatureItem)
+
 let extractCodeActions ~path ~pos ~currentFile ~debug =
   match Cmt.loadFullCmtFromPath ~path with
   | Some full when Files.classifySourceFile currentFile = Res ->
@@ -291,4 +409,9 @@ let extractCodeActions ~path ~pos ~currentFile ~debug =
     IfThenElse.xform ~pos ~codeActions ~printExpr ~path structure;
     AddBracesToFn.xform ~pos ~codeActions ~path ~printStructureItem structure;
     !codeActions
+  | _ when Files.classifySourceFile currentFile = Resi ->
+    let signature, printSignatureItem = parseInterface ~filename:currentFile in
+    let codeActions = ref [] in
+    AddDocTemplate.xform ~pos ~codeActions ~path ~signature ~printSignatureItem;
+    !codeActions
   | _ -> []

Diff for: analysis/tests/not_compiled/DocTemplate.resi

@@ -0,0 +1,20 @@
+type a = {a: int}
+//	^xfm
+
+type rec t = A | B
+// ^xfm
+and e = C
+@unboxed type name = Name(string)
+//             ^xfm
+let a: int
+//  ^xfm
+let inc: int => int
+//  ^xfm
+module T: {
+  //   ^xfm
+  let b: int
+  //  ^xfm
+}
+@module("path")
+external dirname: string => string = "dirname"
+//^xfm

Diff for: analysis/tests/not_compiled/expected/DocTemplate.resi.txt

@@ -0,0 +1,85 @@
+Xform not_compiled/DocTemplate.resi 3:3
+can't find module DocTemplate
+Hit: Add Documentation template
+{"start": {"line": 3, "character": 0}, "end": {"line": 5, "character": 9}}
+newText:
+<--here
+/**
+
+*/
+type rec t = A | B
+// ^xfm
+and e = C
+
+Xform not_compiled/DocTemplate.resi 6:15
+can't find module DocTemplate
+Hit: Add Documentation template
+{"start": {"line": 6, "character": 0}, "end": {"line": 6, "character": 33}}
+newText:
+<--here
+/**
+
+*/
+@unboxed
+type name = Name(string)
+
+Xform not_compiled/DocTemplate.resi 8:4
+can't find module DocTemplate
+Hit: Add Documentation template
+{"start": {"line": 8, "character": 0}, "end": {"line": 8, "character": 10}}
+newText:
+<--here
+/**
+
+*/
+let a: int
+
+Xform not_compiled/DocTemplate.resi 10:4
+can't find module DocTemplate
+Hit: Add Documentation template
+{"start": {"line": 10, "character": 0}, "end": {"line": 10, "character": 19}}
+newText:
+<--here
+/**
+
+*/
+let inc: int => int
+
+Xform not_compiled/DocTemplate.resi 12:7
+can't find module DocTemplate
+Hit: Add Documentation template
+{"start": {"line": 12, "character": 0}, "end": {"line": 16, "character": 1}}
+newText:
+<--here
+/**
+
+*/
+module T: {
+  //   ^xfm
+  let b: int
+  //  ^xfm
+}
+
+Xform not_compiled/DocTemplate.resi 14:6
+can't find module DocTemplate
+Hit: Add Documentation template
+{"start": {"line": 14, "character": 2}, "end": {"line": 14, "character": 12}}
+newText:
+  <--here
+  /**
+  
+  */
+  let b: int
+
+Xform not_compiled/DocTemplate.resi 18:2
+can't find module DocTemplate
+Hit: Add Documentation template
+{"start": {"line": 17, "character": 0}, "end": {"line": 18, "character": 46}}
+newText:
+<--here
+/**
+
+*/
+@module("path")
+external dirname: string => string = "dirname"
+

Diff for: analysis/tests/test.sh

@@ -7,7 +7,7 @@ for file in src/*.{res,resi}; do
   fi
 done
 
-for file in not_compiled/*.res; do
+for file in not_compiled/*.{res,resi}; do
   output="$(dirname $file)/expected/$(basename $file).txt"
   ../rescript-editor-analysis.exe test $file &> $output
   # CI. We use LF, and the CI OCaml fork prints CRLF. Convert.