Use project options from project site

Author: Omar Tawfik

vsintegration/src/FSharp.Editor/BraceMatchingService.fs

@@ -23,16 +23,17 @@ type internal FSharpBraceMatchingService() =
     interface IBraceMatcher with
         member this.FindBracesAsync(document, position, cancellationToken) =
             let computation = async {
-                let options = CommonRoslynHelpers.GetFSharpProjectOptionsForRoslynProject(document.Project)
-                let! sourceText = document.GetTextAsync(cancellationToken) |> Async.AwaitTask
-                let! result = FSharpBraceMatchingService.GetBraceMatchingResult(sourceText, document.Name, options, position)
-
-                return match result with
-                       | None -> Nullable()
-                       | Some(left, right) ->
-                           Nullable(BraceMatchingResult(
-                                       CommonRoslynHelpers.FSharpRangeToTextSpan(sourceText, left),
-                                       CommonRoslynHelpers.FSharpRangeToTextSpan(sourceText, right)))
+                match FSharpLanguageService.GetOptions(document.Project.Id) with
+                | Some(options) ->
+                    let! sourceText = document.GetTextAsync(cancellationToken) |> Async.AwaitTask
+                    let! result = FSharpBraceMatchingService.GetBraceMatchingResult(sourceText, document.Name, options, position)
+                    return match result with
+                           | None -> Nullable()
+                           | Some(left, right) ->
+                               Nullable(BraceMatchingResult(
+                                           CommonRoslynHelpers.FSharpRangeToTextSpan(sourceText, left),
+                                           CommonRoslynHelpers.FSharpRangeToTextSpan(sourceText, right)))
+                | None -> return Nullable()
             }
 
             Async.StartAsTask(computation, TaskCreationOptions.None, cancellationToken)

vsintegration/src/FSharp.Editor/BreakpointResolutionService.fs

@@ -44,13 +44,14 @@ type internal FSharpBreakpointResolutionService() =
     interface IBreakpointResolutionService with
         member this.ResolveBreakpointAsync(document: Document, textSpan: TextSpan, cancellationToken: CancellationToken): Task<BreakpointResolutionResult> =
             let computation = async {
-                let options = CommonRoslynHelpers.GetFSharpProjectOptionsForRoslynProject(document.Project)
-                let! sourceText = document.GetTextAsync(cancellationToken) |> Async.AwaitTask
-                let! location = FSharpBreakpointResolutionService.GetBreakpointLocation(sourceText, document.Name, textSpan, options)
-                
-                return match location with
-                       | None -> null
-                       | Some(range) -> BreakpointResolutionResult.CreateSpanResult(document, CommonRoslynHelpers.FSharpRangeToTextSpan(sourceText, range))
+                match FSharpLanguageService.GetOptions(document.Project.Id) with
+                | Some(options) ->
+                    let! sourceText = document.GetTextAsync(cancellationToken) |> Async.AwaitTask
+                    let! location = FSharpBreakpointResolutionService.GetBreakpointLocation(sourceText, document.Name, textSpan, options)
+                    return match location with
+                           | None -> null
+                           | Some(range) -> BreakpointResolutionResult.CreateSpanResult(document, CommonRoslynHelpers.FSharpRangeToTextSpan(sourceText, range))
+                | None -> return null
             }
 
             Async.StartAsTask(computation, TaskCreationOptions.None, cancellationToken)

vsintegration/src/FSharp.Editor/ColorizationService.fs

@@ -130,17 +130,18 @@ type internal FSharpColorizationService() =
 
     interface IEditorClassificationService with
 
-        member this.AddLexicalClassifications(text: SourceText, textSpan: TextSpan, result: List<ClassifiedSpan>, cancellationToken: CancellationToken) =
-            result.AddRange(FSharpColorizationService.GetColorizationData(text, textSpan, None, [], cancellationToken))
+        // Do not perform classification if we don't have project options (#defines matter)
+        member this.AddLexicalClassifications(_: SourceText, _: TextSpan, _: List<ClassifiedSpan>, _: CancellationToken) = ()
 
         member this.AddSyntacticClassificationsAsync(document: Document, textSpan: TextSpan, result: List<ClassifiedSpan>, cancellationToken: CancellationToken) =
             document.GetTextAsync(cancellationToken).ContinueWith(
                 fun (sourceTextTask: Task<SourceText>) ->
-                    let options = CommonRoslynHelpers.GetFSharpProjectOptionsForRoslynProject(document.Project)
-                    let defines = CompilerEnvironment.GetCompilationDefinesForEditing(document.Name, options.OtherOptions |> Seq.toList)
-
-                    if sourceTextTask.Status = TaskStatus.RanToCompletion then
-                        result.AddRange(FSharpColorizationService.GetColorizationData(sourceTextTask.Result, textSpan, None, defines, cancellationToken))
+                    match FSharpLanguageService.GetOptions(document.Project.Id) with
+                    | Some(options) ->
+                        let defines = CompilerEnvironment.GetCompilationDefinesForEditing(document.Name, options.OtherOptions |> Seq.toList)
+                        if sourceTextTask.Status = TaskStatus.RanToCompletion then
+                            result.AddRange(FSharpColorizationService.GetColorizationData(sourceTextTask.Result, textSpan, None, defines, cancellationToken))
+                    | None -> ()
                 , cancellationToken)
 
         // FSROSLYNTODO: Due to issue 12732 on Roslyn side, semantic classification is tied to C#/VB only.
@@ -168,10 +169,6 @@ type internal FSharpColorizationService() =
             Task.Run(fun () -> Async.RunSynchronously(computation, cancellationToken = cancellationToken))
             *)
             Task.CompletedTask
-
-        member this.AdjustStaleClassification(text: SourceText, classifiedSpan: ClassifiedSpan) : ClassifiedSpan =
-            let tokens = FSharpColorizationService.GetColorizationData(text, classifiedSpan.TextSpan, None, [], CancellationToken.None)
-            if tokens.Any() then
-                tokens.First()
-            else
-                new ClassifiedSpan(ClassificationTypeNames.WhiteSpace, classifiedSpan.TextSpan)
+            
+        // Do not perform classification if we don't have project options (#defines matter)
+        member this.AdjustStaleClassification(_: SourceText, classifiedSpan: ClassifiedSpan) : ClassifiedSpan = classifiedSpan

vsintegration/src/FSharp.Editor/CommonRoslynHelpers.fs

@@ -12,26 +12,6 @@ open Microsoft.VisualStudio.FSharp.LanguageService
 
 module internal CommonRoslynHelpers =
 
-    // Create F# project options for a Roslyn project.
-    let rec GetFSharpProjectOptionsForRoslynProject(project: Project) : FSharpProjectOptions = { 
-        ProjectFileName = project.FilePath
-        ProjectFileNames = project.Documents
-            |> Seq.map (fun document -> document.Name)
-            |> Seq.toArray
-        ReferencedProjects = project.ProjectReferences
-            |> Seq.map(fun reference -> project.Solution.Projects |> Seq.find(fun otherProject -> otherProject.Id = reference.ProjectId))
-            |> Seq.map(fun otherProject -> (otherProject.FilePath, GetFSharpProjectOptionsForRoslynProject(otherProject)))
-            |> Seq.toArray
-
-        // FSROSLYNTODO: add defines flags if available from project sites and files
-        OtherOptions = [| |]
-
-        IsIncompleteTypeCheckEnvironment = true
-        UseScriptResolutionRules = false
-        LoadTime = DateTime.MaxValue
-        UnresolvedReferences = None
-    }
-
     let FSharpRangeToTextSpan(sourceText: SourceText, range: range) =
         // Roslyn TextLineCollection is zero-based, F# range lines are one-based
         let startPosition = sourceText.Lines.[range.StartLine - 1].Start + range.StartColumn

vsintegration/src/FSharp.Editor/DocumentDiagnosticAnalyzer.fs

@@ -62,9 +62,11 @@ type internal FSharpDocumentDiagnosticAnalyzer() =
 
     override this.AnalyzeSyntaxAsync(document: Document, cancellationToken: CancellationToken): Task<ImmutableArray<Diagnostic>> =
         let computation = async {
-            let! sourceText = document.GetTextAsync(cancellationToken) |> Async.AwaitTask
-            let options = CommonRoslynHelpers.GetFSharpProjectOptionsForRoslynProject(document.Project)
-            return FSharpDocumentDiagnosticAnalyzer.GetDiagnostics(document.FilePath, sourceText, options, false)
+            match FSharpLanguageService.GetOptions(document.Project.Id) with
+            | Some(options) ->
+                let! sourceText = document.GetTextAsync(cancellationToken) |> Async.AwaitTask
+                return FSharpDocumentDiagnosticAnalyzer.GetDiagnostics(document.FilePath, sourceText, options, false)
+            | None -> return ImmutableArray<Diagnostic>.Empty
         }
 
         Async.StartAsTask(computation, TaskCreationOptions.None, cancellationToken)
@@ -73,9 +75,11 @@ type internal FSharpDocumentDiagnosticAnalyzer() =
 
     override this.AnalyzeSemanticsAsync(document: Document, cancellationToken: CancellationToken): Task<ImmutableArray<Diagnostic>> =
         let computation = async {
-            let! sourceText = document.GetTextAsync(cancellationToken) |> Async.AwaitTask
-            let options = CommonRoslynHelpers.GetFSharpProjectOptionsForRoslynProject(document.Project)
-            return FSharpDocumentDiagnosticAnalyzer.GetDiagnostics(document.FilePath, sourceText, options, true)
+            match FSharpLanguageService.GetOptions(document.Project.Id) with
+            | Some(options) ->
+                let! sourceText = document.GetTextAsync(cancellationToken) |> Async.AwaitTask
+                return FSharpDocumentDiagnosticAnalyzer.GetDiagnostics(document.FilePath, sourceText, options, true)
+            | None -> return ImmutableArray<Diagnostic>.Empty
         }
 
         Async.StartAsTask(computation, TaskCreationOptions.None, cancellationToken)

vsintegration/src/FSharp.Editor/LanguageDebugInfoService.fs

@@ -63,16 +63,16 @@ type internal FSharpLanguageDebugInfoService() =
 
         member this.GetDataTipInfoAsync(document: Document, position: int, cancellationToken: CancellationToken): Task<DebugDataTipInfo> =
             let computation = async {
-                let options = CommonRoslynHelpers.GetFSharpProjectOptionsForRoslynProject(document.Project)
-                let defines = CompilerEnvironment.GetCompilationDefinesForEditing(document.Name, options.OtherOptions |> Seq.toList)
-
-                let! sourceText = document.GetTextAsync(cancellationToken) |> Async.AwaitTask
-                let textSpan = TextSpan.FromBounds(0, sourceText.Length)
-                let tokens = FSharpColorizationService.GetColorizationData(sourceText, textSpan, Some(document.Name), defines, cancellationToken)
-
-                return match FSharpLanguageDebugInfoService.GetDataTipInformation(sourceText, position, tokens) with
-                       | None -> Unchecked.defaultof<DebugDataTipInfo>
-                       | Some(textSpan) -> new DebugDataTipInfo(textSpan, sourceText.GetSubText(textSpan).ToString())
+                match FSharpLanguageService.GetOptions(document.Project.Id) with
+                | Some(options) ->
+                    let defines = CompilerEnvironment.GetCompilationDefinesForEditing(document.Name, options.OtherOptions |> Seq.toList)
+                    let! sourceText = document.GetTextAsync(cancellationToken) |> Async.AwaitTask
+                    let textSpan = TextSpan.FromBounds(0, sourceText.Length)
+                    let tokens = FSharpColorizationService.GetColorizationData(sourceText, textSpan, Some(document.Name), defines, cancellationToken)
+                    return match FSharpLanguageDebugInfoService.GetDataTipInformation(sourceText, position, tokens) with
+                           | None -> Unchecked.defaultof<DebugDataTipInfo>
+                           | Some(textSpan) -> new DebugDataTipInfo(textSpan, sourceText.GetSubText(textSpan).ToString())
+                | None -> return Unchecked.defaultof<DebugDataTipInfo>
             }
 
             Async.StartAsTask(computation, TaskCreationOptions.None, cancellationToken)

vsintegration/src/FSharp.Editor/LanguageService.fs

@@ -29,6 +29,13 @@ type internal SVsSettingsPersistenceManager = class end
 type internal FSharpLanguageService(package : FSharpPackage) = 
     inherit AbstractLanguageService<FSharpPackage, FSharpLanguageService, FSharpProjectSite>(package)
 
+    static let optionsCache = Dictionary<ProjectId, FSharpProjectOptions>()
+    static member GetOptions(projectId: ProjectId) =
+        if optionsCache.ContainsKey(projectId) then
+            Some(optionsCache.[projectId])
+        else
+            None
+
     override this.ContentTypeName = FSharpCommonConstants.FSharpContentTypeName
     override this.LanguageName = FSharpCommonConstants.FSharpLanguageName
     override this.RoslynLanguageName = FSharpCommonConstants.FSharpLanguageName
@@ -56,6 +63,11 @@ type internal FSharpLanguageService(package : FSharpPackage) =
                 let site = siteProvider.GetProjectSite()
                 let projectFileName = site.ProjectFileName()
                 let projectId = workspace.ProjectTracker.GetOrCreateProjectIdForPath(projectFileName, projectFileName)
+
+                let options = ProjectSitesAndFiles.GetProjectOptionsForProjectSite(site, site.ProjectFileName())
+                if not (optionsCache.ContainsKey(projectId)) then
+                    optionsCache.Add(projectId, options)
+
                 if obj.ReferenceEquals(workspace.ProjectTracker.GetProject(projectId), null) then
                     let projectSite = new FSharpProjectSite(hier, this.SystemServiceProvider, workspace, projectFileName);
                     projectSite.Initialize(hier, site)                    

vsintegration/src/FSharp.Editor/ProjectSite.fs

@@ -21,13 +21,6 @@ open Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem
 type internal FSharpProjectSite(hierarchy: IVsHierarchy, serviceProvider: System.IServiceProvider, visualStudioWorkspace: VisualStudioWorkspaceImpl, projectName: string) =
     inherit AbstractProject(visualStudioWorkspace.ProjectTracker, null, projectName, hierarchy, FSharpCommonConstants.FSharpLanguageName, serviceProvider, visualStudioWorkspace, null)
 
-    let mutable checkOptions : FSharpProjectOptions option = None
-
-    member internal this.CheckOptions = 
-            match checkOptions with 
-            | Some options -> options
-            | None -> failwith "Options haven't been computed yet."
-
     member internal this.Initialize(hier: IVsHierarchy, site : IProjectSite) =
         this.ProjectTracker.AddProject(this)
 
@@ -40,9 +33,6 @@ type internal FSharpProjectSite(hierarchy: IVsHierarchy, serviceProvider: System
         // Add files and references
         for file in site.SourceFilesOnDisk() do this.AddDocument(hier, file)
         for ref in this.GetReferences(site.CompilerFlags()) do this.AddReference(ref)
-        
-        // Capture the F# specific options that we'll pass to the type checker.
-        checkOptions <- Some(ProjectSitesAndFiles.GetProjectOptionsForProjectSite(site, site.ProjectFileName()))
 
     member this.GetReferences(flags : string[]) =
         flags |> Array.choose(fun flag -> if flag.StartsWith("-r:") then Some(flag.Substring(3)) else None)
@@ -77,6 +67,3 @@ type internal FSharpProjectSite(hierarchy: IVsHierarchy, serviceProvider: System
         for ref in references do if not(this.HasMetadataReference(ref)) then this.AddReference(ref)
         // Removed references
         for ref in this.GetCurrentMetadataReferences() do if not(references |> Seq.contains(ref.FilePath)) then this.RemoveReference(ref.FilePath)
-
-        // If the order of files changed, that'll be captured in the checkOptions.
-        checkOptions <- Some(ProjectSitesAndFiles.GetProjectOptionsForProjectSite(site, site.ProjectFileName()))