Enable in-memory cross project referencing for C# -> F# projects (dotnet#11301)

* Added FSharpReferencedProject

* Touching up the API

* Refactoring and using a Stream instead of a byte[]

* Removing a few API endpoints

* Fixing build

* Updating surface area

* Added ConditionalWeakTable for compilation emission

* Just in case, put a try/with around creating a pe reference

* Remove try/with

* Adding C# in-memory reference for compiler service tests

Author: TIHan

LanguageService/FSharpProjectOptionsManager.fs

@@ -22,6 +22,7 @@ open Microsoft.VisualStudio.Shell.Interop
 open Microsoft.VisualStudio.LanguageServices.Implementation.TaskList
 open Microsoft.CodeAnalysis.ExternalAccess.FSharp.LanguageServices
 open Microsoft.VisualStudio.FSharp.Interactive.Session
+open System.Runtime.CompilerServices
 
 [<AutoOpen>]
 module private FSharpProjectOptionsHelpers =
@@ -65,7 +66,16 @@ module private FSharpProjectOptionsHelpers =
             let doesProjectIdDiffer = p1.ProjectId <> p2.ProjectId
             let p1 = oldProject.Solution.GetProject(p1.ProjectId)
             let p2 = newProject.Solution.GetProject(p2.ProjectId)
-            doesProjectIdDiffer || p1.Version <> p2.Version
+            doesProjectIdDiffer || 
+            (
+                // For F# projects, just check the version until we have a better in-memory model for them.
+                if p1.Language = LanguageNames.FSharp then
+                    p1.Version <> p2.Version
+                else
+                    let v1 = p1.GetDependentVersionAsync(ct).Result
+                    let v2 = p2.GetDependentVersionAsync(ct).Result
+                    v1 <> v2
+            )
         )
 
     let isProjectInvalidated (oldProject: Project) (newProject: Project) (settings: EditorOptions) ct =
@@ -94,6 +104,26 @@ type private FSharpProjectOptionsReactor (workspace: Workspace, settings: Editor
     let cache = ConcurrentDictionary<ProjectId, Project * FSharpParsingOptions * FSharpProjectOptions>()
     let singleFileCache = ConcurrentDictionary<DocumentId, VersionStamp * FSharpParsingOptions * FSharpProjectOptions>()
 
+    // This is used to not constantly emit the same compilation.
+    let weakPEReferences = ConditionalWeakTable<Compilation, FSharpReferencedProject>()
+
+    let createPEReference (referencedProject: Project) (comp: Compilation) ct =
+        match weakPEReferences.TryGetValue comp with
+        | true, fsRefProj -> fsRefProj
+        | _ ->
+            let fsRefProj =
+                FSharpReferencedProject.CreatePortableExecutable(
+                    referencedProject.OutputFilePath, 
+                    DateTime.UtcNow,
+                    let ms = new MemoryStream() // do not dispose the stream as it will be owned on the reference.
+                    let emitOptions = Emit.EmitOptions(metadataOnly = true, includePrivateMembers = false, tolerateErrors = true)
+                    comp.Emit(ms, options = emitOptions, cancellationToken = ct) |> ignore
+                    ms.Position <- 0L
+                    ms
+                )
+            weakPEReferences.Add(comp, fsRefProj)
+            fsRefProj
+
     let rec tryComputeOptionsByFile (document: Document) (ct: CancellationToken) userOpName =
         async {
             let! fileStamp = document.GetTextVersionAsync(ct) |> Async.AwaitTask
@@ -170,7 +200,11 @@ type private FSharpProjectOptionsReactor (workspace: Workspace, settings: Editor
                         if referencedProject.Language = FSharpConstants.FSharpLanguageName then
                             match! tryComputeOptions referencedProject ct with
                             | None -> canBail <- true
-                            | Some(_, projectOptions) -> referencedProjects.Add(referencedProject.OutputFilePath, projectOptions)
+                            | Some(_, projectOptions) -> referencedProjects.Add(FSharpReferencedProject.CreateFSharp(referencedProject.OutputFilePath, projectOptions))
+                        else
+                            let! comp = referencedProject.GetCompilationAsync(ct) |> Async.AwaitTask
+                            let peRef = createPEReference referencedProject comp ct
+                            referencedProjects.Add(peRef)
 
                 if canBail then
                     return None