Adds various helpers for FSharpSnapshot and multi-file projects

Author: TheAngryByrd

src/FSharp.Analyzers.SDK.Testing/FSharp.Analyzers.SDK.Testing.fs

@@ -13,6 +13,14 @@ open System.Collections.ObjectModel
 open FSharp.Compiler.CodeAnalysis
 open FSharp.Compiler.Diagnostics
 open FSharp.Compiler.Text
+open FSharp.Compiler.CodeAnalysis.ProjectSnapshot
+
+type FSharpChecker with
+
+    member x.ParseAndCheckProject(opts: AnalyzerProjectOptions) : Async<FSharpCheckProjectResults> =
+        match opts with
+        | BackgroundCompilerOptions options -> x.ParseAndCheckProject options
+        | TransparentCompilerOptions snapshot -> x.ParseAndCheckProject snapshot
 
 type FSharpProjectOptions with
 
@@ -31,6 +39,25 @@ type FSharpProjectOptions with
             Stamp = None
         }
 
+type FSharpProjectSnapshot with
+
+    static member zero =
+        FSharpProjectSnapshot.Create(
+            "",
+            None,
+            None,
+            [],
+            [],
+            [],
+            [],
+            false,
+            false,
+            DateTime.UtcNow,
+            None,
+            [],
+            None
+        )
+
 type Package =
     {
         Name: string
@@ -118,10 +145,53 @@ let mkOptions (compilerArgs: string array) =
         Stamp = None
     }
 
+let mkSnapshot (compilerArgs: string array) =
+
+    let sourceFiles =
+        compilerArgs
+        |> Array.choose (fun (line: string) ->
+            if
+                isFSharpFile line
+                && File.Exists line
+            then
+
+                FSharpFileSnapshot.CreateFromFileSystem(line)
+                |> Some
+            else
+                None
+        )
+        |> Array.toList
+
+    let otherOptions =
+        compilerArgs
+        |> Array.filter (fun line -> not (isFSharpFile line))
+        |> Array.toList
+
+    FSharpProjectSnapshot.Create(
+        "Project",
+        None,
+        None,
+        sourceFiles,
+        [],
+        otherOptions,
+        [],
+        false,
+        false,
+        DateTime.Now,
+        None,
+        [],
+        None
+
+    )
+
 let mkOptionsFromBinaryLog build =
     let compilerArgs = readCompilerArgsFromBinLog build
     mkOptions compilerArgs
 
+let mkSnapshotFromBinaryLog build =
+    let compilerArgs = readCompilerArgsFromBinLog build
+    mkSnapshot compilerArgs
+
 let getCachedIfOldBuildSucceeded binLogPath =
     if File.Exists binLogPath then
         let build = BinaryLog.ReadBuild binLogPath
@@ -196,6 +266,8 @@ let createProject
             printfn $"Exception:\n%s{e.ToString()}"
     }
 
+open System.Threading.Tasks
+
 let mkOptionsFromProject (framework: string) (additionalPkgs: Package list) =
     task {
         try
@@ -219,7 +291,7 @@ let mkOptionsFromProject (framework: string) (additionalPkgs: Package list) =
                 let cached = getCachedIfOldBuildSucceeded binLogPath
 
                 match cached with
-                | Some f -> task { return f }
+                | Some f -> Task.FromResult f
                 | None ->
                     task {
                         Directory.CreateDirectory(binLogCache)
@@ -235,77 +307,153 @@ let mkOptionsFromProject (framework: string) (additionalPkgs: Package list) =
             return FSharpProjectOptions.zero
     }
 
-let getContextFor (opts: FSharpProjectOptions) isSignature source =
-    let fileName = if isSignature then "A.fsi" else "A.fs"
-    let files = Map.ofArray [| (fileName, SourceText.ofString source) |]
+let mkSnapshotFromProject (framework: string) (additionalPkgs: Package list) =
+    task {
+        try
+            let id = Guid.NewGuid().ToString("N")
+            let tmpProjectDir = Path.Combine(Path.GetTempPath(), id)
+
+            let uniqueBinLogName =
+                let packages =
+                    additionalPkgs
+                    |> List.map (fun p -> p.ToString())
+                    |> String.concat "_"
+
+                $"v{Utils.currentFSharpAnalyzersSDKVersion}_{framework}_{packages}.binlog"
 
-    let documentSource fileName =
-        Map.tryFind fileName files
-        |> async.Return
+            let binLogCache =
+                Path.Combine(Path.GetTempPath(), "FSharp.Analyzers.SDK.BinLogCache")
 
-    let fcs = Utils.createFCS (Some documentSource)
-    let pathToAnalyzerDlls = Path.GetFullPath(".")
+            let binLogPath = Path.Combine(binLogCache, uniqueBinLogName)
 
-    let assemblyLoadStats =
-        let client = Client<CliAnalyzerAttribute, CliContext>()
-        client.LoadAnalyzers pathToAnalyzerDlls
+            let! binLogFile =
+                let cached = getCachedIfOldBuildSucceeded binLogPath
 
-    if assemblyLoadStats.AnalyzerAssemblies = 0 then
-        failwith $"no Dlls found in {pathToAnalyzerDlls}"
+                match cached with
+                | Some f -> Task.FromResult f
+                | None ->
+                    task {
+                        Directory.CreateDirectory(binLogCache)
+                        |> ignore
 
-    if assemblyLoadStats.Analyzers = 0 then
-        failwith $"no Analyzers found in {pathToAnalyzerDlls}"
+                        let! _ = createProject binLogPath tmpProjectDir framework additionalPkgs
+                        return BinaryLog.ReadBuild binLogPath
+                    }
 
-    if assemblyLoadStats.FailedAssemblies > 0 then
-        failwith
-            $"failed to load %i{assemblyLoadStats.FailedAssemblies} Analyzers in {pathToAnalyzerDlls}"
+            return mkSnapshotFromBinaryLog binLogFile
+        with e ->
+            printfn $"Exception:\n%s{e.ToString()}"
+            return FSharpProjectSnapshot.zero
+    }
 
-    let opts =
-        { opts with
-            SourceFiles = [| fileName |]
-        }
+type SourceFile = { FileName: string; Source: string }
+
+let getContextFor (opts: AnalyzerProjectOptions) allSources fileToAnalyze =
+    task {
+
+        let analyzedFileName = fileToAnalyze.FileName
+
+        let docSourceMap =
+            allSources
+            |> List.map (fun sf -> sf.FileName, SourceText.ofString sf.Source)
+            |> Map.ofList
+
+        let documentSource fileName =
+            Map.tryFind fileName docSourceMap
+            |> async.Return
+
+        let fcs = Utils.createFCS (Some documentSource)
+        let pathToAnalyzerDlls = Path.GetFullPath(".")
+
+        let assemblyLoadStats =
+            let client = Client<CliAnalyzerAttribute, CliContext>()
+            client.LoadAnalyzers pathToAnalyzerDlls
+
+        if assemblyLoadStats.AnalyzerAssemblies = 0 then
+            failwith $"no Dlls found in {pathToAnalyzerDlls}"
+
+        if assemblyLoadStats.Analyzers = 0 then
+            failwith $"no Analyzers found in {pathToAnalyzerDlls}"
+
+        if assemblyLoadStats.FailedAssemblies > 0 then
+            failwith
+                $"failed to load %i{assemblyLoadStats.FailedAssemblies} Analyzers in {pathToAnalyzerDlls}"
+
+        let! analyzerOpts =
+            match opts with
+            | BackgroundCompilerOptions bOpts ->
+                task {
+
+                    let allFileNames =
+                        allSources
+                        |> List.map (fun sf -> sf.FileName)
+                        |> Array.ofList
+
+                    let bOpts =
+                        { bOpts with
+                            SourceFiles = allFileNames
+                        }
+
+                    do! fcs.NotifyFileChanged(analyzedFileName, bOpts) // workaround for https://github.com/dotnet/fsharp/issues/15960
+                    return BackgroundCompilerOptions bOpts
+                }
+            | TransparentCompilerOptions snap ->
+                let docSource = DocumentSource.Custom documentSource
+
+                let fileSnapshots =
+                    allSources
+                    |> List.map (fun sf ->
+                        FSharpFileSnapshot.CreateFromDocumentSource(sf.FileName, docSource)
+                    )
+
+                snap.Replace fileSnapshots
+                |> TransparentCompilerOptions
+                |> Task.FromResult
+
+        let! checkProjectResults = fcs.ParseAndCheckProject analyzerOpts
+
+        let allSymbolUses = checkProjectResults.GetAllUsesOfAllSymbols()
+
+        if Array.isEmpty allSymbolUses then
+            failwith "no symboluses"
+
+        match!
+            Utils.typeCheckFile
+                fcs
+                Abstractions.NullLogger.Instance
+                analyzerOpts
+                analyzedFileName
+                (Utils.SourceOfSource.DiscreteSource fileToAnalyze.Source)
+        with
+        | Ok(parseFileResults, checkFileResults) ->
+            let diagErrors =
+                checkFileResults.Diagnostics
+                |> Array.filter (fun d -> d.Severity = FSharpDiagnosticSeverity.Error)
+
+            if not (Array.isEmpty diagErrors) then
+                raise (CompilerDiagnosticErrors diagErrors)
+
+            let sourceText = SourceText.ofString fileToAnalyze.Source
+
+            return
+                Utils.createContext
+                    checkProjectResults
+                    analyzedFileName
+                    sourceText
+                    (parseFileResults, checkFileResults)
+                    analyzerOpts
+        | Error e -> return failwith $"typechecking file failed: %O{e}"
+    }
+
+let getContext (opts: FSharpProjectOptions) source =
+    let source = { FileName = "A.fs"; Source = source }
+
+    (getContextFor (BackgroundCompilerOptions opts) [ source ] source).GetAwaiter().GetResult()
+
+let getContextForSignature (opts: FSharpProjectOptions) source =
+    let source = { FileName = "A.fsi"; Source = source }
 
-    fcs.NotifyFileChanged(fileName, opts)
-    |> Async.RunSynchronously // workaround for https://github.com/dotnet/fsharp/issues/15960
-
-    let checkProjectResults =
-        fcs.ParseAndCheckProject(opts)
-        |> Async.RunSynchronously
-
-    let allSymbolUses = checkProjectResults.GetAllUsesOfAllSymbols()
-    let analyzerOpts = BackgroundCompilerOptions opts
-
-    if Array.isEmpty allSymbolUses then
-        failwith "no symboluses"
-
-    match
-        Utils.typeCheckFile
-            fcs
-            Abstractions.NullLogger.Instance
-            opts
-            fileName
-            (Utils.SourceOfSource.DiscreteSource source)
-    with
-    | Ok(parseFileResults, checkFileResults) ->
-        let diagErrors =
-            checkFileResults.Diagnostics
-            |> Array.filter (fun d -> d.Severity = FSharpDiagnosticSeverity.Error)
-
-        if not (Array.isEmpty diagErrors) then
-            raise (CompilerDiagnosticErrors diagErrors)
-
-        let sourceText = SourceText.ofString source
-
-        Utils.createContext
-            checkProjectResults
-            fileName
-            sourceText
-            (parseFileResults, checkFileResults)
-            analyzerOpts
-    | Error e -> failwith $"typechecking file failed: %O{e}"
-
-let getContext (opts: FSharpProjectOptions) source = getContextFor opts false source
-let getContextForSignature (opts: FSharpProjectOptions) source = getContextFor opts true source
+    (getContextFor (BackgroundCompilerOptions opts) [ source ] source).GetAwaiter().GetResult()
 
 module Assert =
 

src/FSharp.Analyzers.SDK.Testing/FSharp.Analyzers.SDK.Testing.fsi

@@ -19,7 +19,36 @@ exception CompilerDiagnosticErrors of FSharpDiagnostic array
 val mkOptionsFromProject:
     framework: string -> additionalPkgs: Package list -> Task<FSharpProjectOptions>
 
+/// <summary>Creates a classlib project in a temporary folder to gather the needed FSharpProjectSnapshot.</summary>
+/// <param name="framework">The target framework for the tested code to use. E.g. net6.0, net7.0</param>
+/// <param name="additionalPkgs">A list of additional packages that should be referenced. The tested code can use these.</param>
+/// <returns>FSharpProjectSnapshot</returns>
+val mkSnapshotFromProject:
+    framework: string -> additionalPkgs: list<Package> -> Task<FSharpProjectSnapshot>
+
+type SourceFile = { FileName: string; Source: string }
+
+/// <summary>Creates CliContext for a given set of sources and options.</summary>
+/// <param name="opts">The project options to use.</param>
+/// <param name="allSources">All the source files in the project.</param>
+/// <param name="fileToAnalyze">The file to analyze.</param>
+/// <returns>CliContext</returns>
+val getContextFor:
+    opts: AnalyzerProjectOptions ->
+    allSources: list<SourceFile> ->
+    fileToAnalyze: SourceFile ->
+        Task<CliContext>
+
+/// <summary>Creates CliContext for a given source and options.</summary>
+/// <param name="opts">The project options to use.</param>
+/// <param name="source">The file to analyze.</param>
+/// <returns>CliContext</returns>
 val getContext: opts: FSharpProjectOptions -> source: string -> CliContext
+
+/// <summary>Creates CliContext for a given signature source and options.</summary>
+/// <param name="opts">The project options to use.</param>
+/// <param name="source">The file to analyze.</param>
+/// <returns>CliContext</returns>
 val getContextForSignature: opts: FSharpProjectOptions -> source: string -> CliContext
 
 module Assert =