tmp

Author: auduchinok

ReSharper.FSharp/src/FSharp/FSharp.Common/FSharp.Common.fsproj

@@ -12,6 +12,7 @@
     <DisableImplicitFSharpCoreReference>true</DisableImplicitFSharpCoreReference>
     <RootNamespace>JetBrains.ReSharper.Plugins.FSharp</RootNamespace>
     <AssemblyName>JetBrains.ReSharper.Plugins.FSharp.Common</AssemblyName>
+    <NoWarn>FS0057</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>

ReSharper.FSharp/src/FSharp/FSharp.Common/src/Checker/FcsCheckerService.fs

@@ -25,6 +25,7 @@ open JetBrains.ReSharper.Plugins.FSharp.Shim.AssemblyReader
 open JetBrains.ReSharper.Plugins.FSharp.Util
 open JetBrains.ReSharper.Psi
 open JetBrains.ReSharper.Psi.CSharp
+open JetBrains.ReSharper.Psi.Caches
 open JetBrains.ReSharper.Psi.Modules
 open JetBrains.ReSharper.Psi.Tree
 open JetBrains.ReSharper.Psi.VB
@@ -36,6 +37,7 @@ module FcsCheckerService =
         SourceText.ofString(document.GetText())
 
 
+// add the project key?
 type FcsProject =
     { OutputPath: VirtualFileSystemPath
       ProjectOptions: FSharpProjectOptions
@@ -74,6 +76,57 @@ type FcsProject =
         writer.WriteLine()
 
 
+[<SolutionComponent>]
+type FcsSnapshotCache(fcsProjectProvider: IFcsProjectProvider, locks: IShellLocks) =
+    let snapshots = Dictionary<FcsProjectKey, FSharpProjectSnapshot>()
+
+    let remove (psiModule: IPsiModule) =
+        let projectKey = FcsProjectKey.Create(psiModule)
+        snapshots.Remove(projectKey) |> ignore
+
+        match fcsProjectProvider.GetReferencedModule(projectKey) with
+        | None -> ()
+        | Some referencedModule ->
+
+        // todo: recursive update?
+        for referencingProject in referencedModule.ReferencingProjects do
+            snapshots.Remove(referencingProject) |> ignore
+
+    member this.GetProjectSnapshot(projectKey: FcsProjectKey, options: FSharpProjectOptions) =
+        // todo: use source files in file snapshots?
+        lock this (fun _ ->
+            snapshots.GetOrCreateValue(projectKey, fun (projectKey: FcsProjectKey) ->
+                FSharpProjectSnapshot.FromOptions(options).RunAsTask()
+            )
+        )
+
+    interface IPsiSourceFileCache with
+        member this.MarkAsDirty(sourceFile) =
+            locks.AssertWriteAccessAllowed()
+            remove sourceFile.PsiModule
+
+        member this.OnDocumentChange(sourceFile, _) =
+            locks.AssertWriteAccessAllowed()
+            remove sourceFile.PsiModule
+
+        member this.OnPsiChange(elementContainingChanges, _) =
+            if isNotNull elementContainingChanges then
+                locks.AssertWriteAccessAllowed()
+                remove (elementContainingChanges.GetPsiModule())
+
+        member this.HasDirtyFiles = false
+        member this.UpToDate _ = true
+        member this.SyncUpdate _ = ()
+
+        member this.Build(_, _) = null
+        member this.Drop _ = ()
+        member this.Dump(_, _) = ()
+        member this.Load(_, _) = null
+        member this.Merge(_, _) = ()
+        member this.MergeLoaded _ = ()
+        member this.Save(_, _) = ()
+
+
 [<RequireQualifiedAccess>]
 type FcsProjectInvalidationType =
     /// Used when invalidation is needed for a project still known to FCS.
@@ -88,14 +141,16 @@ type FcsProjectInvalidationType =
 type FcsCheckerService(lifetime: Lifetime, logger: ILogger, onSolutionCloseNotifier: OnSolutionCloseNotifier,
         settingsStore: ISettingsStore, locks: IShellLocks, configurations: RunsProducts.ProductConfigurations) =
 
-    let checker =
-        Environment.SetEnvironmentVariable("FCS_CheckFileInProjectCacheSize", "20")
+    let settingsStoreLive = settingsStore.BindToContextLive(lifetime, ContextRange.ApplicationWide)
 
-        let settingsStoreLive = settingsStore.BindToContextLive(lifetime, ContextRange.ApplicationWide)
+    let getSettingProperty name =
+        let setting = SettingsUtil.getEntry<FSharpOptions> settingsStore name
+        settingsStoreLive.GetValueProperty(lifetime, setting, null)
 
-        let getSettingProperty name =
-            let setting = SettingsUtil.getEntry<FSharpOptions> settingsStore name
-            settingsStoreLive.GetValueProperty(lifetime, setting, null)
+    let useTransparentCompiler = true //(getSettingProperty "UseTransparentCompiler").Value
+
+    let checker =
+        Environment.SetEnvironmentVariable("FCS_CheckFileInProjectCacheSize", "20")
 
         let skipImpl = getSettingProperty "SkipImplementationAnalysis"
         let analyzerProjectReferencesInParallel = getSettingProperty "ParallelProjectReferencesAnalysis"
@@ -106,7 +161,8 @@ type FcsCheckerService(lifetime: Lifetime, logger: ILogger, onSolutionCloseNotif
                                      keepAllBackgroundResolutions = false,
                                      keepAllBackgroundSymbolUses = false,
                                      enablePartialTypeChecking = skipImpl.Value,
-                                     parallelReferenceResolution = analyzerProjectReferencesInParallel.Value)
+                                     parallelReferenceResolution = analyzerProjectReferencesInParallel.Value,
+                                     useTransparentCompiler = useTransparentCompiler)
 
             checker
 
@@ -174,8 +230,19 @@ type FcsCheckerService(lifetime: Lifetime, logger: ILogger, onSolutionCloseNotif
         let source = FcsCheckerService.getSourceText sourceFile.Document
         logger.Trace("ParseAndCheckFile: start {0}, {1}", path, opName)
 
+        let getParseAndCheckResults () =
+            if useTransparentCompiler then
+                let projectKey = FcsProjectKey.Create(psiModule)
+                let fcsSnapshotCache = sourceFile.GetSolution().GetComponent<FcsSnapshotCache>()
+                let snapshot = fcsSnapshotCache.GetProjectSnapshot(projectKey, options)
+                match x.Checker.ParseAndCheckFileInProject(path, snapshot).RunAsTask() with
+                | _, FSharpCheckFileAnswer.Aborted -> None
+                | parseFileResults, FSharpCheckFileAnswer.Succeeded checkFileResults -> Some(parseFileResults, checkFileResults)
+            else
+                x.Checker.ParseAndCheckDocument(path, source, options, allowStaleResults, opName).RunAsTask()
+
         // todo: don't cancel the computation when file didn't change
-        match x.Checker.ParseAndCheckDocument(path, source, options, allowStaleResults, opName).RunAsTask() with
+        match getParseAndCheckResults () with
         | Some (parseResults, checkResults) ->
             logger.Trace("ParseAndCheckFile: finish {0}, {1}", path, opName)
             Some { ParseResults = parseResults; CheckResults = checkResults }

ReSharper.FSharp/src/FSharp/FSharp.Common/src/Settings/FSharpOptions.fs

@@ -29,6 +29,7 @@ module FSharpOptions =
     let [<Literal>] nonFSharpProjectInMemoryReferences = "Analyze C# and VB.NET project references in-memory"
     let [<Literal>] outOfScopeCompletion = "Enable out of scope items completion"
     let [<Literal>] topLevelOpenCompletion = "Add 'open' declarations to top level module or namespace"
+    let [<Literal>] useTransparentCompilerDescription = "Use TransparentCompiler"
 
 
 [<SettingsKey(typeof<FSharpSettings>, "FSharpOptions")>]
@@ -46,7 +47,10 @@ type FSharpOptions =
       mutable EnableOutOfScopeCompletion: bool
 
       [<SettingsEntry(true, topLevelOpenCompletion); DefaultValue>]
-      mutable TopLevelOpenCompletion: bool }
+      mutable TopLevelOpenCompletion: bool
+
+      [<SettingsEntry(false, useTransparentCompilerDescription)>]
+      mutable UseTransparentCompiler: bool }
 
 type FantomasLocationSettings =
     | AutoDetected = 0
@@ -155,6 +159,9 @@ type FSharpOptionsProvider(lifetime, solution, settings, settingsSchema) =
     member val NonFSharpProjectInMemoryReferences =
         base.GetValueProperty<bool>("NonFSharpProjectInMemoryReferences").Value with get, set
 
+    member val UseTransparentCompiler =
+        base.GetValueProperty<bool>("UseTransparentCompiler").Value
+
     member this.UpdateAssemblyReaderSetting() =
         this.NonFSharpProjectInMemoryReferences <-
             base.GetValueProperty<bool>("NonFSharpProjectInMemoryReferences").Value