[WIP] In-Memory documents for FCS

src/fsharp/FSharp.Compiler.Service/FSharp.Compiler.Service.fsproj

@@ -825,6 +825,12 @@
 	<Compile Include="..\service\SemanticClassificationKey.fs">
 		<Link>Service/SemanticClassificationKey.fs</Link>
 	</Compile>
+	<Compile Include="..\service\FSharpDocument.fsi">
+		<Link>Service/FSharpDocument.fsi</Link>
+	</Compile>
+	<Compile Include="..\service\FSharpDocument.fs">
+		<Link>Service/FSharpDocument.fs</Link>
+	</Compile>
     <Compile Include="..\service\IncrementalBuild.fsi">
       <Link>Service/IncrementalBuild.fsi</Link>
     </Compile>

src/fsharp/ParseAndCheckInputs.fs

@@ -402,6 +402,22 @@ let checkInputFile (tcConfig: TcConfig) filename =
     else
         error(Error(FSComp.SR.buildInvalidSourceFileExtension(SanitizeFileName filename tcConfig.implicitIncludeDir), rangeStartup))
 
+let parseInputStreamAux (tcConfig: TcConfig, lexResourceManager, conditionalCompilationDefines, filename, isLastCompiland, errorLogger, retryLocked, stream: Stream) =
+    use reader = stream.GetReader(tcConfig.inputCodePage, retryLocked)
+
+    // Set up the LexBuffer for the file
+    let lexbuf = UnicodeLexing.StreamReaderAsLexbuf(not tcConfig.compilingFslib, tcConfig.langVersion.SupportsFeature, reader)
+
+    // Parse the file drawing tokens from the lexbuf
+    ParseOneInputLexbuf(tcConfig, lexResourceManager, conditionalCompilationDefines, lexbuf, filename, isLastCompiland, errorLogger)
+
+let parseInputSourceTextAux (tcConfig: TcConfig, lexResourceManager, conditionalCompilationDefines, filename, isLastCompiland, errorLogger, sourceText: ISourceText) =
+    // Set up the LexBuffer for the file
+    let lexbuf = UnicodeLexing.SourceTextAsLexbuf(not tcConfig.compilingFslib, tcConfig.langVersion.SupportsFeature, sourceText)
+
+    // Parse the file drawing tokens from the lexbuf
+    ParseOneInputLexbuf(tcConfig, lexResourceManager, conditionalCompilationDefines, lexbuf, filename, isLastCompiland, errorLogger)
+
 let parseInputFileAux (tcConfig: TcConfig, lexResourceManager, conditionalCompilationDefines, filename, isLastCompiland, errorLogger, retryLocked) =
     // Get a stream reader for the file
     use fileStream = FileSystem.OpenFileForReadShim(filename)
@@ -422,6 +438,22 @@ let ParseOneInputFile (tcConfig: TcConfig, lexResourceManager, conditionalCompil
         errorRecovery e rangeStartup
         EmptyParsedInput(filename, isLastCompiland)
 
+/// Parse an input from stream
+let ParseOneInputStream (tcConfig: TcConfig, lexResourceManager, conditionalCompilationDefines, filename, isLastCompiland, errorLogger, retryLocked, stream: Stream) =
+    try
+       parseInputStreamAux(tcConfig, lexResourceManager, conditionalCompilationDefines, filename, isLastCompiland, errorLogger, retryLocked, stream)
+    with e ->
+        errorRecovery e rangeStartup
+        EmptyParsedInput(filename, isLastCompiland)
+
+/// Parse an input from source text
+let ParseOneInputSourceText (tcConfig: TcConfig, lexResourceManager, conditionalCompilationDefines, filename, isLastCompiland, errorLogger, sourceText: ISourceText) =
+    try
+       parseInputSourceTextAux(tcConfig, lexResourceManager, conditionalCompilationDefines, filename, isLastCompiland, errorLogger, sourceText)
+    with e ->
+        errorRecovery e rangeStartup
+        EmptyParsedInput(filename, isLastCompiland)
+
 /// Parse multiple input files from disk
 let ParseInputFiles (tcConfig: TcConfig, lexResourceManager, conditionalCompilationDefines, sourceFiles, errorLogger: ErrorLogger, exiter: Exiter, createErrorLogger: (Exiter -> CapturingErrorLogger), retryLocked) =
     try

src/fsharp/ParseAndCheckInputs.fsi

@@ -3,6 +3,7 @@
 /// Contains logic to coordinate the parsing and checking of one or a group of files
 module internal FSharp.Compiler.ParseAndCheckInputs
 
+open System.IO
 open Internal.Utilities.Library
 open FSharp.Compiler.CheckExpressions
 open FSharp.Compiler.CheckDeclarations
@@ -49,6 +50,12 @@ val ApplyNoWarnsToTcConfig: TcConfig * ParsedInput * string -> TcConfig
 /// Parse one input file
 val ParseOneInputFile: TcConfig * Lexhelp.LexResourceManager * conditionalCompilationDefines: string list * string * isLastCompiland: (bool * bool) * ErrorLogger * retryLocked: bool -> ParsedInput
 
+/// Parse one input stream
+val ParseOneInputStream: TcConfig * Lexhelp.LexResourceManager * conditionalCompilationDefines: string list * string * isLastCompiland: (bool * bool) * ErrorLogger * retryLocked: bool * stream: Stream -> ParsedInput
+
+/// Parse one input source text
+val ParseOneInputSourceText: TcConfig * Lexhelp.LexResourceManager * conditionalCompilationDefines: string list * string * isLastCompiland: (bool * bool) * ErrorLogger * sourceText: ISourceText -> ParsedInput
+
 /// Parse multiple input files from disk
 val ParseInputFiles: TcConfig * Lexhelp.LexResourceManager * conditionalCompilationDefines: string list * string list * ErrorLogger * Exiter * createErrorLogger: (Exiter -> CapturingErrorLogger) * retryLocked: bool -> (ParsedInput * string) list
 

src/fsharp/absil/ilread.fs

@@ -3913,7 +3913,6 @@ let createByteFileChunk opts fileName chunk =
 
 let getBinaryFile fileName useMemoryMappedFile =
     let stream = FileSystem.OpenFileForReadShim(fileName, useMemoryMappedFile = useMemoryMappedFile)
-    let byteMem = stream.AsByteMemory()
 
     let safeHolder =
         { new obj() with
@@ -3927,7 +3926,7 @@ let getBinaryFile fileName useMemoryMappedFile =
 
     stats.memoryMapFileOpenedCount <- stats.memoryMapFileOpenedCount + 1
 
-    safeHolder, RawMemoryFile(fileName, safeHolder, byteMem) :> BinaryFile
+    safeHolder, RawMemoryFile(fileName, safeHolder, stream.AsByteMemory()) :> BinaryFile
 
 let OpenILModuleReaderFromBytes fileName assemblyContents options =
     let pefile = ByteFile(fileName, assemblyContents) :> BinaryFile

src/fsharp/service/FSharpCheckerResults.fsi

@@ -50,7 +50,7 @@ type public FSharpProjectOptions =
       /// This is the unique identifier for the project, it is case sensitive. If it's None, will key off of ProjectFileName in our caching.
       ProjectId: string option
 
-      /// The files in the project
+      /// The source files in the project
       SourceFiles: string[]
 
       /// Additional command line argument options for the project. These can include additional files and references.

src/fsharp/service/FSharpDocument.fs

@@ -0,0 +1,125 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace FSharp.Compiler.CodeAnalysis
+
+open System
+open System.Collections.Generic
+open System.Collections.Immutable
+open System.IO
+open System.IO.MemoryMappedFiles
+open System.Xml
+open System.Runtime.InteropServices
+open System.Threading
+open Internal.Utilities.Library
+open Internal.Utilities.Library.Extras
+open FSharp.Compiler
+open FSharp.Compiler.AbstractIL
+open FSharp.Compiler.AbstractIL.IL
+open FSharp.Compiler.AbstractIL.ILBinaryReader
+open FSharp.Compiler.CheckExpressions
+open FSharp.Compiler.CheckDeclarations
+open FSharp.Compiler.CompilerConfig
+open FSharp.Compiler.CompilerDiagnostics
+open FSharp.Compiler.CompilerGlobalState
+open FSharp.Compiler.CompilerImports
+open FSharp.Compiler.CompilerOptions
+open FSharp.Compiler.CreateILModule
+open FSharp.Compiler.DependencyManager
+open FSharp.Compiler.Diagnostics
+open FSharp.Compiler.EditorServices
+open FSharp.Compiler.ErrorLogger
+open FSharp.Compiler.IO
+open FSharp.Compiler.CodeAnalysis
+open FSharp.Compiler.NameResolution
+open FSharp.Compiler.ParseAndCheckInputs
+open FSharp.Compiler.ScriptClosure
+open FSharp.Compiler.Syntax
+open FSharp.Compiler.TcGlobals
+open FSharp.Compiler.Text
+open FSharp.Compiler.Text.Range
+open FSharp.Compiler.Xml
+open FSharp.Compiler.TypedTree
+open FSharp.Compiler.TypedTreeOps
+
+[<RequireQualifiedAccess>]
+type DocumentText =
+    | OnDisk
+    | Stream of Stream
+    | SourceText of ISourceText
+
+    interface IDisposable with
+
+        member this.Dispose() =
+            match this with
+            | Stream stream -> stream.Dispose()
+            | _ -> ()
+
+[<AbstractClass>]
+type FSharpDocument internal () =
+
+    abstract FilePath : string
+
+    abstract TimeStamp : DateTime
+
+    abstract GetText : unit -> DocumentText
+
+type private FSharpDocumentMemoryMappedFile(filePath: string, timeStamp: DateTime, openStream: unit -> Stream) =
+    inherit FSharpDocument()
+
+    override _.FilePath = filePath
+
+    override _.TimeStamp = timeStamp
+
+    override _.GetText() =
+        openStream () |> DocumentText.Stream
+
+type private FSharpDocumentByteArray(filePath: string, timeStamp: DateTime, bytes: byte[]) =
+    inherit FSharpDocument()
+
+    override _.FilePath = filePath
+
+    override _.TimeStamp = timeStamp
+
+    override _.GetText() =
+        DocumentText.Stream(new MemoryStream(bytes, 0, bytes.Length, false) :> Stream)
+
+type private FSharpDocumentFromFile(filePath: string) =
+    inherit FSharpDocument()
+
+    override _.FilePath = filePath
+
+    override _.TimeStamp = FileSystem.GetLastWriteTimeShim(filePath)
+
+    override _.GetText() = DocumentText.OnDisk
+
+type private FSharpDocumentCustom(filePath: string, getTimeStamp, getSourceText) =
+    inherit FSharpDocument()
+
+    override _.FilePath = filePath
+
+    override _.TimeStamp = getTimeStamp()
+
+    override _.GetText() =
+        DocumentText.SourceText(getSourceText())
+
+type FSharpDocument with
+
+    static member Create(filePath, getTimeStamp, getSourceText) =
+        FSharpDocumentCustom(filePath, getTimeStamp, getSourceText) :> FSharpDocument
+
+    static member CreateFromFile(filePath: string) =
+        FSharpDocumentFromFile(filePath) :> FSharpDocument
+
+    static member CreateCopyFromFile(filePath: string) =
+        let timeStamp = FileSystem.GetLastWriteTimeShim(filePath)
+
+        // We want to use mmaped documents only when
+        // not running on mono, since its MemoryMappedFile implementation throws when "mapName" is not provided (is null), (see: https://github.com/mono/mono/issues/10245)
+        if runningOnMono then
+            let bytes = FileSystem.OpenFileForReadShim(filePath, useMemoryMappedFile = false).ReadAllBytes()
+            FSharpDocumentByteArray(filePath, timeStamp, bytes) :> FSharpDocument
+        else
+            let openStream = fun () ->
+                FileSystem.OpenFileForReadShim(filePath, useMemoryMappedFile = true, shouldShadowCopy = true)
+            FSharpDocumentMemoryMappedFile(filePath, timeStamp, openStream) :> FSharpDocument
+

src/fsharp/service/FSharpDocument.fsi

@@ -0,0 +1,30 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace FSharp.Compiler.CodeAnalysis
+
+open System
+open System.IO
+open FSharp.Compiler.Text
+
+[<RequireQualifiedAccess>]
+type internal DocumentText =
+    | OnDisk
+    | Stream of Stream
+    | SourceText of ISourceText
+
+    interface IDisposable
+
+[<AbstractClass>]
+type FSharpDocument =
+
+    abstract FilePath : string
+
+    abstract TimeStamp : DateTime
+
+    abstract internal GetText : unit -> DocumentText
+
+    static member internal CreateFromFile : filePath: string -> FSharpDocument
+
+    static member CreateCopyFromFile : filePath: string -> FSharpDocument
+
+    static member Create : filePath: string * getTimeStamp: (unit -> DateTime) * getSourceText: (unit -> ISourceText) -> FSharpDocument