Added support for keywords in completion

Also added a test for it

Author: Eli Dowling

sample/MainProject/Completions.fs

@@ -10,4 +10,6 @@ let private ``name with space``() =
     ""
 
 let private completeSpace() = 
-    na
+    na
+let private completeKeyword() =
+    mat

src/FSharpLanguageServer/Conversions.fs

@@ -176,9 +176,14 @@ let private asCompletionItem(i: DeclarationListItem): CompletionItem =
 
 /// Convert an F# `DeclarationListInfo` to an LSP `CompletionList`
 /// Used in rendering autocomplete lists
-let asCompletionList(ds: DeclarationListInfo): CompletionList =
+let asCompletionList(ds: DeclarationListInfo) (addKeywords:bool): CompletionList =
+    
     let items = [for i in ds.Items do yield asCompletionItem(i)]
-    {isIncomplete=List.isEmpty(items); items=items}
+    let allItems=
+        if addKeywords then items @ FsAutoComplete.KeywordList.keywordCompletionItems
+        else items
+
+    {isIncomplete=List.isEmpty(allItems); items=allItems}
 
 /// Convert an F# `MethodGroupItemParameter` to an LSP `ParameterInformation`
 let private asParameterInformation(p: MethodGroupItemParameter): ParameterInformation =

src/FSharpLanguageServer/FSAC/Keywordlist.fs

@@ -0,0 +1,78 @@
+namespace FsAutoComplete
+open LSP.Types
+open LSP.BaseTypes
+open FSharp.Compiler.Text
+open FSharp.Compiler.Tokenization
+open FSharp.Compiler.EditorServices
+open FSharp.Compiler.Symbols
+
+module KeywordList =
+    open FSharp.Data
+
+    let keywordDescriptions = FSharpKeywords.KeywordsWithDescription |> dict
+
+    let keywordTooltips =
+        keywordDescriptions
+        |> Seq.map (fun kv ->
+        let lines = kv.Value.Replace("\r\n", "\n").Split('\n')
+
+        let allLines =
+            Array.concat [| [| "<summary>" |]
+                            lines
+                            [| "</summary>" |] |]
+
+        let tip =
+            ToolTipText [ ToolTipElement.Single(
+                            [| TaggedText.tagText kv.Key |],
+                            FSharpXmlDoc.FromXmlText(FSharp.Compiler.Xml.XmlDoc(allLines, Range.Zero))
+                        ) ]
+
+        kv.Key, tip)
+        |> dict
+
+    let hashDirectives =
+        [   
+            "r", "References an assembly"
+            "load", "Reads a source file, compiles it, and runs it."
+            "I", "Specifies an assembly search path in quotation marks."
+            "light", "Enables or disables lightweight syntax, for compatibility with other versions of ML"
+            "if", "Supports conditional compilation"
+            "else", "Supports conditional compilation"
+            "endif", "Supports conditional compilation"
+            "nowarn", "Disables a compiler warning or warnings"
+            "line", "Indicates the original source code line" 
+        ]
+        |> dict
+
+    let hashSymbolCompletionItems =
+        hashDirectives
+        |> Seq.map (fun kv ->
+        { defaultCompletionItem with
+            detail=Some kv.Key
+            kind = Some CompletionItemKind.Keyword
+            insertText = Some kv.Key
+            filterText = Some kv.Key
+            sortText = Some kv.Key
+            documentation = Some( {kind=MarkupKind.Markdown;value=kv.Value})
+            label = "#" + kv.Key })
+        |> Seq.toArray 
+
+    let allKeywords: string list =
+        keywordDescriptions
+        |> Seq.map ((|KeyValue|) >> fst)
+        |> Seq.toList
+
+    let keywordCompletionItems =
+        allKeywords
+        |> List.mapi (fun id k ->
+        {defaultCompletionItem with  
+                label = k
+                detail= Some k
+                data= JsonValue.Record [|"FullName", JsonValue.String(k)|]
+                CompletionItem.kind = Some CompletionItemKind.Keyword
+                documentation =Some ({kind=MarkupKind.Markdown;value=keywordDescriptions[k]})
+                sortText = None//Some(sprintf "1000000%d" id)
+                filterText = Some k
+                insertText = Some k
+            })
+        

src/FSharpLanguageServer/FSharpLanguageServer.fsproj

@@ -10,6 +10,7 @@
     <Compile Include="FSAC/ToolTips/Format.fs" />
     <Compile Include="FSAC/ToolTips/XmlDoc.fs" />
     <Compile Include="FSAC/ToolTips/ToolTip.fs" />
+    <Compile Include="FSAC/Keywordlist.fs" />
     <Compile Include="SourceLink.fs" />
     <Compile Include="SyntaxTreeOps.fs" />
     <Compile Include="TipFormatter.fs" />

src/FSharpLanguageServer/Program.fs

@@ -665,7 +665,13 @@ type Server(client: ILanguageClient) =
                         let declarations = checkResult.GetDeclarationListInfo(Some parseResult, p.position.line+1, line, partialName)
                         lastCompletion <- Some declarations
                         lgInfo "Found {num} completions" declarations.Items.Length
-                        return Some(asCompletionList(declarations))
+
+                        let addKeywords =
+                            not declarations.IsForType
+                            && not declarations.IsError
+                            && partialName.QualifyingIdents.IsEmpty
+                    
+                        return Some(asCompletionList declarations addKeywords)
             }
         member this.Hover(p: TextDocumentPositionParams): Async<Hover option> =
             async {
@@ -688,13 +694,15 @@ type Server(client: ILanguageClient) =
                     lgDebug "Hover tooltipText={text}" tips
                     return Some(asHover(tips))
             }
+            
         // Add documentation to a completion item
         // Generating documentation is an expensive step, so we want to defer it until the user is actually looking at it
         member this.ResolveCompletionItem(p: CompletionItem): Async<CompletionItem> =
             async {
                 let mutable result = p
                 if lastCompletion.IsSome then
                     for candidate in lastCompletion.Value.Items do
+                            
                         if candidate.FullName = p.data?FullName.AsString() then
                             lgInfo "Resolve description for {candidate}" candidate.FullName
                             let! resolved = TipFormatter.resolveDocs(p, candidate)

tests/Expecto/FsharpLanguageServer/ServerTests.fs

@@ -251,6 +251,14 @@ let serverTests=
                     yield c.insertText]
         Expect.contains insertText (Some("``name with space``")) "missing correct completion"
     }
+    ftest "complete Keyword" {
+        let client, server = createServerAndReadFile("MainProject", "Completions.fs")
+        match server.Completion(textDocumentPosition("MainProject", "Completions.fs", 15, 8)) |> Async.RunSynchronously with 
+        | None ->  failtest "no completions"
+        | Some(completions) -> 
+            Expect.contains (labels(completions.items)) "match" "missing correct completion"
+    }
+    
     //TODO
     ptest "dont complete inside a string" {
         let client, server = createServerAndReadFile("MainProject", "CompleteInString.fs")