WIP: Rework documentation parser

release/package.json

@@ -1384,6 +1384,15 @@
 					"description": "The prefix displayed before the signature",
 					"default": "  // "
 				},
+				"FSharp.tooltipMode": {
+					"type": "string",
+					"description": "Control if tooltip should show only the summary or all the information",
+					"enum": [
+						"summary",
+						"full"
+					],
+					"default": "full"
+				},
 				"FSharp.disableFailedProjectNotifications": {
 					"type": "boolean",
 					"default": false,

src/Components/InfoPanel.fs

@@ -16,7 +16,10 @@ module InfoPanel =
 
     module Panel =
 
-        let showdown = Fable.Import.Showdown.showdown.Converter.Create()
+        let showdownOptions = Fable.Import.Showdown.showdown.getDefaultOptions() :?> Fable.Import.Showdown.Showdown.ConverterOptions
+        showdownOptions.tables <- Some true
+
+        let showdown = Fable.Import.Showdown.showdown.Converter.Create(showdownOptions)
 
         let mutable panel : WebviewPanel option = None
 
@@ -31,7 +34,6 @@ module InfoPanel =
             else
                 false
 
-
         let setContent str =
             panel |> Option.iter (fun p ->
                 let str = showdown.makeHtml str
@@ -79,7 +81,6 @@ module InfoPanel =
 
                 let commentContent =
                     res.Comment
-                    |> Markdown.createCommentString
 
                 let footerContent =
                     res.Footer

src/Components/SignatureData.fs

@@ -19,10 +19,29 @@ module SignatureData =
                     p.Data.Parameters
                     |> Seq.concat
                     |> Seq.where (fun prm -> String.IsNullOrWhiteSpace prm.Name |> not)
-                    |> Seq.map (fun prm -> sprintf "///   * `%s` - parameter of type `%s`" prm.Name prm.Type)
+                    |> Seq.map (fun prm -> sprintf """/// <param name="%s"></param>""" prm.Name)
                     |> String.concat "\n"
-                let pms = if pms = "" then "///" else pms
-                let comment = sprintf "\n/// **Description**\n///\n/// **Parameters**\n%s\n///\n/// **Output Type**\n///   * `%s`\n///\n/// **Exceptions**\n///" pms p.Data.OutputType
+
+                let generics =
+                    p.Data.Generics
+                    |> Seq.map (fun generic ->
+                        sprintf """/// <typeparam name="'%s"></typeparam>""" generic
+                    )
+                    |> String.concat "\n"
+
+                let comment =
+                    [
+                        yield "/// <summary>"
+                        yield "/// "
+                        yield "/// </summary>"
+                        if pms <> "" then
+                            yield pms
+                        if generics <> "" then
+                            yield generics
+                        yield "/// <returns></returns>"
+                    ]
+                    |> String.concat "\n"
+
                 let x = window.activeTextEditor.selection.active.line
                 let t = window.activeTextEditor.document.getText(Range(x, 0., x, 1000.))
                 let t' = t.TrimStart(' ')

src/Core/DTO.fs

@@ -284,7 +284,8 @@ module DTO =
 
     type SignatureData =
         { OutputType : string
-          Parameters : Parameter list list }
+          Parameters : Parameter list list
+          Generics : string list }
 
     type RangesAtPosition = {Ranges: Range list list}
 

src/Core/Utils.fs

@@ -200,120 +200,6 @@ module Array =
         | _ when n >= xs.Length || n < 0 -> xs, [||]
         | _ -> xs.[0..n-1], xs.[n..]
 
-module Markdown =
-
-    open System.Text.RegularExpressions
-
-    let private stringReplacePatterns =
-        [ "&lt;", "<"
-          "&gt;", ">"
-          "&quot;", "\""
-          "&apos;", "'"
-          "&amp;", "&"
-          "<summary>", "**Description**\n\n"
-          "</summary>", "\n"
-          "<para>", "\n"
-          "</para>", "\n"
-          "<remarks>", ""
-          "</remarks>", "\n" ]
-
-    let private regexReplacePatterns =
-        let r pat = Regex(pat, RegexOptions.IgnoreCase)
-
-        let code (strings : string array) =
-            let str = strings.[0]
-            if str.Contains("\n") then
-                "```forceNoHighlight" + str + "```"
-            else
-                "`" + str + "`"
-        let returns = Array.item 0 >> sprintf "\n**Returns**\n\n%s"
-
-        let param (s : string[]) = sprintf "* `%s`: %s"(s.[0].Substring(1, s.[0].Length - 2)) s.[1]
-
-        [ r"<c>((?:(?!<c>)(?!<\/c>)[\s\S])*)<\/c>", code
-          r"""<see\s+cref=(?:'[^']*'|"[^"]*")>((?:(?!<\/see>)[\s\S])*)<\/see>""", code
-          r"""<param\s+name=('[^']*'|"[^"]*")>((?:(?!<\/param>)[\s\S])*)<\/param>""", param
-          r"""<typeparam\s+name=('[^']*'|"[^"]*")>((?:(?!<\/typeparam>)[\s\S])*)<\/typeparam>""", param
-          r"""<exception\s+cref=('[^']*'|"[^"]*")>((?:(?!<\/exception>)[\s\S])*)<\/exception>""", param
-          r"""<a\s+href=('[^']*'|"[^"]*")>((?:(?!<\/a>)[\s\S])*)<\/a>""", fun s -> (s.[0].Substring(1, s.[0].Length - 2))
-          r"<returns>((?:(?!<\/returns>)[\s\S])*)<\/returns>", returns ]
-
-    /// Helpers to create a new section in the markdown comment
-    let private suffixXmlKey (tag : string) (value : string) (str : string) =
-        match str.IndexOf(tag) with
-        | x when x <> -1 ->
-            let insertAt =
-                if str.Chars(x - 1) = ' ' then
-                    x - 1
-                else
-                    x
-            str.Insert(insertAt, value)
-        | _ -> str
-
-    let private suffixTypeparam = suffixXmlKey "<typeparam" "\n**Type parameters**\n\n"
-
-    let private suffixException = suffixXmlKey "<exception" "\n**Exceptions**\n\n"
-
-    let private suffixParam = suffixXmlKey "<param" "\n**Parameters**\n\n"
-
-    /// Replaces XML tags with Markdown equivalents.
-    /// List of standard tags: https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/xml-documentation
-    let private replaceXml (str : string) : string =
-        let str =
-            str
-            |> suffixTypeparam
-            |> suffixException
-            |> suffixParam
-
-        let res =
-            regexReplacePatterns
-            |> List.fold (fun res (regex : Regex, formatter : string[] -> string) ->
-                // repeat replacing with same pattern to handle nested tags, like `<c>..<c>..</c>..</c>`
-                let rec loop res : string =
-                    match regex.Match res with
-                    | m when m.Success ->
-                        let splitted =
-                            m.Groups
-                            |> Seq.cast<Group>
-                            |> Seq.map (fun g -> g.Value)
-                            |> Seq.toArray
-                            |> Array.splitAt 1
-                        match splitted with
-                        | [| firstGroup |], otherGroups ->
-                            loop <| res.Replace(firstGroup, formatter otherGroups)
-                        | _ -> failwithf "Error in regex pattern for nested xml tags with %s" res
-                    | _ -> res
-                loop res
-            ) str
-
-        stringReplacePatterns
-        |> List.fold (fun (res : string) (oldValue, newValue) ->
-            res.Replace(oldValue, newValue)
-        ) res
-
-    let private normalizeLeadingSpace (content : string) =
-        content
-            .Replace("\r\n", "\n")
-            .Split('\n')
-        |> Array.map(fun line ->
-            if line.Length > 1 && line.[0] = ' ' then
-                line.[1..]
-            else
-                line
-        )
-        |> String.concat "\n"
-
-    let createCommentBlock (comment : string) : MarkdownString =
-        comment
-        |> replaceXml
-        |> normalizeLeadingSpace
-        |> (fun v -> MarkdownString v)
-
-    let createCommentString (comment : string) : string =
-        comment
-        |> replaceXml
-        |> normalizeLeadingSpace
-
 module Promise =
 
     open Fable.Import.JS