Merge pull request #132 from ionide/master

Ionide/FsAutoComplete changes

Author: rneatherway

paket.lock

@@ -8,7 +8,7 @@ NUGET
       System.Reflection.Metadata (>= 1.4.1-beta-24227-04)
     FSharp.Compiler.Service.ProjectCracker (6.0.2)
     FSharp.Core (4.0.0.1) - redirects: on
-    FSharpLint.Core (0.4.4)
+    FSharpLint.Core (0.4.8)
       FParsec (>= 1.0.2)
       FSharp.Compiler.Service (>= 6.0)
       FSharp.Compiler.Service.ProjectCracker (>= 6.0)

src/FsAutoComplete.Core/CommandResponse.fs

@@ -21,8 +21,8 @@ module internal CompletionUtils =
       0x00011, ("Property", "P")
       0x0005,  ("Event", "e")
       0x0007,  ("Field", "F") (* fieldblue ? *)
-      0x0020,  ("Field", "F") (* fieldyellow ? *)
-      0x0001,  ("Field", "F") (* const *)
+      0x0020,  ("Field", "Fy") (* fieldyellow ? *)
+      0x0001,  ("Function", "Fc") (* const *)
       0x0004,  ("Property", "P") (* enummember *)
       0x0006,  ("Exception", "X") (* exception *)
       0x0009,  ("Text File Icon", "t") (* TextLine *)
@@ -33,7 +33,7 @@ module internal CompletionUtils =
       0x00014, ("Class", "C") (* Typedef *)
       0x00015, ("Type", "T") (* Type *)
       0x00016, ("Type", "T") (* Union *)
-      0x00017, ("Field", "F") (* Variable *)
+      0x00017, ("Field", "V") (* Variable *)
       0x00019, ("Class", "C") (* Intrinsic *)
       0x0001f, ("Other", "o") (* error *)
       0x00021, ("Other", "o") (* Misc1 *)
@@ -56,7 +56,7 @@ module internal CompletionUtils =
     | FSharpEnclosingEntityKind.DU -> "D"
 
 module CommandResponse =
- 
+
   type ResponseMsg<'T> =
     {
       Kind: string
@@ -228,12 +228,24 @@ module CommandResponse =
         Logs = logMap }
     serialize { Kind = "project"; Data = projectData }
 
-  let completion (serialize : Serializer) (decls: FSharpDeclarationListItem[]) =
+  let completion (serialize : Serializer) (decls: FSharpDeclarationListItem[]) includeKeywords =
+      let keywords = ["abstract"; "and"; "as"; "assert"; "base"; "begin"; "class"; "default"; "delegate"; "do";
+          "done"; "downcast"; "downto"; "elif"; "else"; "end"; "exception"; "extern"; "false"; "finally"; "for";
+          "fun"; "function"; "global"; "if"; "in"; "inherit"; "inline"; "interface"; "internal"; "lazy"; "let";
+          "match"; "member"; "module"; "mutable"; "namespace"; "new"; "null"; "of"; "open"; "or"; "override";
+          "private"; "public"; "rec"; "return"; "sig"; "static"; "struct"; "then"; "to"; "true"; "try"; "type";
+          "upcast"; "use"; "val"; "void"; "when"; "while"; "with"; "yield"
+      ]
+
       serialize {  Kind = "completion"
                    Data = [ for d in decls do
                                let code = Microsoft.FSharp.Compiler.SourceCodeServices.PrettyNaming.QuoteIdentifierIfNeeded d.Name
                                let (glyph, glyphChar) = CompletionUtils.getIcon d.Glyph
-                               yield {CompletionResponse.Name = d.Name; ReplacementText = code; Glyph = glyph; GlyphChar = glyphChar } ] }
+                               yield {CompletionResponse.Name = d.Name; ReplacementText = code; Glyph = glyph; GlyphChar = glyphChar }
+                            if includeKeywords then
+                              for k in keywords do
+                                yield {CompletionResponse.Name = k; ReplacementText = k; Glyph = "Keyword"; GlyphChar = "K"}
+                          ] }
 
   let symbolUse (serialize : Serializer) (symbol: FSharpSymbolUse, uses: FSharpSymbolUse[]) =
     let su =

src/FsAutoComplete.Core/Commands.fs

@@ -10,6 +10,7 @@ module Response = CommandResponse
 type Commands (serialize : Serializer) =
     let checker = FSharpCompilerServiceChecker()
     let state = FsAutoComplete.State.Initial
+    let fsharpLintConfig = ConfigurationManager.ConfigurationManager()
 
     member private __.SerializeResultAsync (successToString: Serializer -> 'a -> Async<string>, ?failureToString: Serializer -> string -> string) =
         Async.bind <| function
@@ -26,19 +27,22 @@ type Commands (serialize : Serializer) =
     member __.TryGetFileCheckerOptionsWithLines = state.TryGetFileCheckerOptionsWithLines
     member __.Files = state.Files
 
-    member __.Parse file lines = async {
+    member __.Parse file lines version = async {
         let colorizations = state.ColorizationOutput
         let parse' fileName text options =
             async {
-                let! _parseResults, checkResults = checker.ParseAndCheckFileInProject(fileName, 0, text, options)
+                let! result = checker.ParseAndCheckFileInProject(fileName, version, text, options)
                 return
-                    match checkResults with
-                    | FSharpCheckFileAnswer.Aborted -> [Response.info serialize "Parse aborted"]
-                    | FSharpCheckFileAnswer.Succeeded results ->
-                        if colorizations then
-                            [ Response.errors serialize (results.Errors)
-                              Response.colorizations serialize (results.GetExtraColorizationsAlternate()) ]
-                        else [ Response.errors serialize (results.Errors) ]
+                    match result with
+                    | Failure e -> [Response.error serialize e]
+                    | Success (_, checkResults) ->
+                        match checkResults with
+                        | FSharpCheckFileAnswer.Aborted -> [Response.info serialize "Parse aborted"]
+                        | FSharpCheckFileAnswer.Succeeded results ->
+                            if colorizations then
+                                [ Response.errors serialize (results.Errors)
+                                  Response.colorizations serialize (results.GetExtraColorizationsAlternate()) ]
+                            else [ Response.errors serialize (results.Errors) ]
             }
         let file = Path.GetFullPath file
         let text = String.concat "\n" lines
@@ -113,7 +117,7 @@ type Commands (serialize : Serializer) =
     member __.Colorization enabled = state.ColorizationOutput <- enabled
     member __.Error msg = [Response.error serialize msg]
 
-    member __.Completion (tyRes : ParseAndCheckResults) (pos: Pos) lineStr filter = async {
+    member __.Completion (tyRes : ParseAndCheckResults) (pos: Pos) lineStr filter includeKeywords = async {
         let! res = tyRes.TryGetCompletions pos lineStr filter
         return match res with
                 | Some (decls, residue) ->
@@ -125,10 +129,10 @@ type Commands (serialize : Serializer) =
                       Array.sortBy declName decls
                       |> Array.tryFind (fun d -> (declName d).StartsWith(residue, StringComparison.InvariantCultureIgnoreCase))
                     let res = match firstMatchOpt with
-                                | None -> [Response.completion serialize decls]
+                                | None -> [Response.completion serialize decls includeKeywords]
                                 | Some d ->
                                     [Response.helpText serialize (d.Name, d.DescriptionText)
-                                     Response.completion serialize decls]
+                                     Response.completion serialize decls includeKeywords]
 
                     for decl in decls do
                         state.HelpText.[declName decl] <- decl.DescriptionText
@@ -172,9 +176,11 @@ type Commands (serialize : Serializer) =
                     match tyRes.GetAST with
                     | None -> [ Response.info serialize "Something went wrong during parsing"]
                     | Some tree ->
+                        fsharpLintConfig.LoadConfigurationForProject file
+                        let opts = fsharpLintConfig.GetConfigurationForProject (file)
                         let res =
                             Lint.lintParsedSource
-                                Lint.OptionalLintParameters.Default
+                                { Lint.OptionalLintParameters.Default with Configuration = Some opts}
                                 { Ast = tree
                                   Source = source
                                   TypeCheckResults = Some tyRes.GetCheckResults

src/FsAutoComplete.Core/CompilerServiceInterface.fs

@@ -4,6 +4,7 @@ open System
 open System.IO
 open Microsoft.FSharp.Compiler.SourceCodeServices
 open Utils
+open System.Collections.Concurrent
 
 type ParseAndCheckResults
     (
@@ -51,7 +52,7 @@ type ParseAndCheckResults
     | None -> return Failure "Could not find ident at this location"
     | Some(col, identIsland) ->
 
-      let! declarations = checkResults.GetDeclarationLocationAlternate(pos.Line, col + 1, lineStr, identIsland, false)
+      let! declarations = checkResults.GetDeclarationLocationAlternate(pos.Line, col, lineStr, identIsland, false)
 
       match declarations with
       | FSharpFindDeclResult.DeclNotFound _ -> return Failure "Could not find declaration"
@@ -64,7 +65,7 @@ type ParseAndCheckResults
     | Some(col,identIsland) ->
 
       // TODO: Display other tooltip types, for example for strings or comments where appropriate
-      let! tip = checkResults.GetToolTipTextAlternate(pos.Line, col + 1, lineStr, identIsland, FSharpTokenTag.Identifier)
+      let! tip = checkResults.GetToolTipTextAlternate(pos.Line, col, lineStr, identIsland, FSharpTokenTag.Identifier)
 
       match tip with
       | FSharpToolTipText(elems) when elems |> List.forall (function
@@ -79,7 +80,7 @@ type ParseAndCheckResults
         | None -> return (Failure "No ident at this location")
         | Some(colu, identIsland) ->
 
-        let! symboluse = checkResults.GetSymbolUseAtLocation(pos.Line, colu + 1, lineStr, identIsland)
+        let! symboluse = checkResults.GetSymbolUseAtLocation(pos.Line, colu, lineStr, identIsland)
         match symboluse with
         | None -> return (Failure "No symbol information found")
         | Some symboluse ->
@@ -105,14 +106,50 @@ type ParseAndCheckResults
   member __.GetAST = parseResults.ParseTree
   member __.GetCheckResults = checkResults
 
+type private FileState =
+    | Checked
+    | NeedChecking
+    | BeingChecked
+    | Cancelled
+
+type Version = int
+
 type FSharpCompilerServiceChecker() =
   let checker =
     FSharpChecker.Create(
       projectCacheSize = 200,
       keepAllBackgroundResolutions = true,
       keepAssemblyContents = true)
 
-  do checker.BeforeBackgroundFileCheck.Add (fun _ -> ())
+  let files = ConcurrentDictionary<string, Version * FileState>()
+  do checker.BeforeBackgroundFileCheck.Add ignore
+  
+  let isResultObsolete fileName = 
+      match files.TryGetValue fileName with
+      | true, (_, Cancelled) -> true
+      | _ -> false
+
+  let fileChanged filePath version = 
+    files.AddOrUpdate (filePath, (version, NeedChecking), (fun _ (oldVersion, oldState) -> 
+        if version <> oldVersion then
+           (version,
+            match oldState with
+            | BeingChecked -> Cancelled
+            | Cancelled -> Cancelled
+            | NeedChecking -> NeedChecking
+            | Checked -> NeedChecking)
+        else oldVersion, oldState))
+    |> debug "[LanguageService] %s changed: set status to %A" filePath
+
+
+  let fixFileName path = 
+    if (try Path.GetFullPath path |> ignore; true with _ -> false) then path
+    else 
+        match Environment.OSVersion.Platform with
+        | PlatformID.Unix 
+        | PlatformID.MacOSX -> Environment.GetEnvironmentVariable "HOME"
+        | _ -> Environment.ExpandEnvironmentVariables "%HOMEDRIVE%%HOMEPATH%"
+        </> Path.GetFileName path
 
   let ensureCorrectFSharpCore (options: string[]) =
     Environment.fsharpCoreOpt
@@ -187,8 +224,42 @@ type FSharpCompilerServiceChecker() =
     return res |> Array.collect id
   }
 
-  member __.ParseAndCheckFileInProject(fileName, version, source, options) =
-    checker.ParseAndCheckFileInProject(fileName, version, source, options)
+  member __.ParseAndCheckFileInProject(filePath, version, source, options) =
+    async { 
+      debug "[LanguageService] ParseAndCheckFileInProject - enter"
+      fileChanged filePath version
+      let fixedFilePath = fixFileName filePath
+      let! res = Async.Catch (async {
+          try
+               // wait until the previous checking completed
+               while files.ContainsKey filePath &&
+                     (match files.TryGetValue filePath with
+                      | true, (v, Checked) 
+                      | true, (v, NeedChecking) -> 
+                         files.[filePath] <- (v, BeingChecked)
+                         true
+                      | _ -> false) do
+                   do! Async.Sleep 20
+               
+               debug "[LanguageService] Change state for %s to `BeingChecked`" filePath
+               debug "[LanguageService] Parse and typecheck source..."
+               return! checker.ParseAndCheckFileInProject 
+                                 (fixedFilePath, version, source, options, 
+                                  IsResultObsolete (fun _ -> isResultObsolete filePath), null) 
+          finally 
+               match files.TryGetValue filePath with
+               | true, (v, BeingChecked)
+               | true, (v, Cancelled) -> files.[filePath] <- (v, Checked)
+               | _ -> ()
+      })
+
+      debug "[LanguageService]: Check completed"
+      // Construct new typed parse result if the task succeeded
+      return
+          match res with
+          | Choice1Of2 x -> Success x
+          | Choice2Of2 e -> Failure e.Message
+    }
 
   member __.TryGetRecentCheckResultsForFile(file, options, ?source) =
     checker.TryGetRecentCheckResultsForFile(file, options, ?source=source)
@@ -207,8 +278,7 @@ type FSharpCompilerServiceChecker() =
           return!
             options
             |> Seq.filter (fun (_, projectOpts) -> projectOpts = opts)
-            |> Seq.map fst
-            |> Seq.map (fun projectFile -> async {
+            |> Seq.map (fun (projectFile,_) -> async {
                 let! parseRes, _ = checker.GetBackgroundCheckResultsForFileInProject(projectFile, opts)
                 return (parseRes.GetNavigationItems().Declarations |> Array.map (fun decl -> decl, projectFile))
               })
@@ -231,11 +301,19 @@ type FSharpCompilerServiceChecker() =
                p.OtherOptions
           { p with OtherOptions = opts }, logMap
 
-        let compileFiles = Seq.filter (fun (s:string) -> s.EndsWith(".fs")) po.OtherOptions
+        let po =
+            match po.ProjectFileNames with
+            | [||] ->
+                 let compileFiles, otherOptions =
+                    po.OtherOptions |> Array.partition (fun (s:string) -> s.EndsWith(".fs"))
+                 { po with ProjectFileNames = compileFiles; OtherOptions = otherOptions }
+            | _ -> po
+
+        let po = { po with ProjectFileNames = po.ProjectFileNames |> Array.map normalizeDirSeparators }
         let outputFile = Seq.tryPick (chooseByPrefix "--out:") po.OtherOptions
         let references = Seq.choose (chooseByPrefix "-r:") po.OtherOptions
 
-        Success (po, Seq.toList compileFiles, outputFile, Seq.toList references, logMap)
+        Success (po, Array.toList po.ProjectFileNames, outputFile, Seq.toList references, logMap)
       with e ->
         Failure e.Message
 

src/FsAutoComplete.Core/FsAutoComplete.Core.fsproj

@@ -66,6 +66,7 @@
   -->
   <ItemGroup>
     <Compile Include="Utils.fs" />
+    <Compile Include="Lexer.fs" />
     <Compile Include="Environment.fs" />
     <Compile Include="TipFormatter.fs" />
     <Compile Include="FileSystem.fs" />