Incremental builder with async lazy evaluation / Reactor removal

src/fsharp/BuildGraph.fsi

@@ -0,0 +1,120 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+module internal FSharp.Compiler.BuildGraph
+
+open System
+open System.Threading
+open System.Threading.Tasks
+open FSharp.Compiler.ErrorLogger
+open Internal.Utilities.Library
+
+/// This represents the global state established as each task function runs as part of the build.
+///
+/// Use to reset error and warning handlers.
+type CompilationGlobalsScope =
+    new : ErrorLogger * BuildPhase -> CompilationGlobalsScope
+    interface IDisposable
+
+/// Represents code that can be run as part of the build graph.
+///
+/// This is essentially cancellable async code where the only asynchronous waits are on nodes.
+/// When a node is evaluated the evaluation is run synchronously on the thread of the
+/// first requestor.
+[<NoEquality;NoComparison;Sealed>]
+type NodeCode<'T>
+
+type Async<'T> with
+
+    /// Asynchronously await code in the build graph
+    static member AwaitNodeCode: node: NodeCode<'T> -> Async<'T>
+
+/// A standard builder for node code.
+[<Sealed>]
+type NodeCodeBuilder =
+
+    member Bind : NodeCode<'T> * ('T -> NodeCode<'U>) -> NodeCode<'U>
+
+    member Zero : unit -> NodeCode<unit>
+
+    member Delay : (unit -> NodeCode<'T>) -> NodeCode<'T>
+
+    member Return : 'T -> NodeCode<'T> 
+
+    member ReturnFrom : NodeCode<'T> -> NodeCode<'T>
+
+    member TryWith : NodeCode<'T> * (exn -> NodeCode<'T>) -> NodeCode<'T>
+
+    member TryFinally : NodeCode<'T> * (unit -> unit) -> NodeCode<'T>
+
+    member For : xs: 'T seq * binder: ('T -> NodeCode<unit>) -> NodeCode<unit>
+
+    member Combine : x1: NodeCode<unit> * x2: NodeCode<'T> -> NodeCode<'T>
+
+    /// A limited form 'use' for establishing the compilation globals.  (Note
+    /// that a proper generic 'use' could be implemented but has not currently been necessary)
+    member Using : CompilationGlobalsScope * (CompilationGlobalsScope -> NodeCode<'T>) -> NodeCode<'T>
+
+/// Specifies code that can be run as part of the build graph.
+val node : NodeCodeBuilder
+
+/// Contains helpers to specify code that can be run as part of the build graph.
+[<AbstractClass;Sealed>]
+type NodeCode =
+
+    /// Only used for testing, do not use
+    static member RunImmediate: computation: NodeCode<'T> * ct: CancellationToken -> 'T
+
+    /// Used in places where we don't care about cancellation, e.g. the command line compiler
+    /// and F# Interactive
+    static member RunImmediateWithoutCancellation: computation: NodeCode<'T> -> 'T
+
+    static member CancellationToken: NodeCode<CancellationToken>
+
+    static member Sequential: computations: NodeCode<'T> seq -> NodeCode<'T []>
+
+    /// Execute the cancellable computation synchronously using the ambient cancellation token of
+    /// the NodeCode.
+    static member FromCancellable: computation: Cancellable<'T> -> NodeCode<'T>
+
+    /// Only used for testing, do not use
+    static member StartAsTask_ForTesting: computation: NodeCode<'T> * ?ct: CancellationToken -> Task<'T>
+
+    /// Only used for testing, do not use
+    static member AwaitWaitHandle_ForTesting: waitHandle: WaitHandle -> NodeCode<bool>
+
+/// Contains helpers related to the build graph
+[<RequireQualifiedAccess>]
+module internal GraphNode =
+
+    /// Allows to specify the language for error messages
+    val SetPreferredUILang: preferredUiLang: string option -> unit
+
+/// Evaluate the computation, allowing asynchronous waits on existing ongoing evaluations of the
+/// same node, and strongly cache the result.
+///
+/// Once the result has been cached, the computation function will also be removed, or 'null'ed out, 
+/// as to prevent any references captured by the computation from being strongly held.
+[<Sealed>]
+type internal GraphNode<'T> =
+
+    /// - retryCompute - When set to 'true', subsequent requesters will retry the computation if the first-in request cancels. Retrying computations will have better callstacks.
+    /// - computation - The computation code to run.
+    new: retryCompute: bool * computation: NodeCode<'T> -> GraphNode<'T>
+
+    /// By default, 'retryCompute' is 'true'.
+    new : computation: NodeCode<'T> -> GraphNode<'T>
+
+    /// Return NodeCode which, when executed, will get the value of the computation if already computed, or
+    /// await an existing in-progress computation for the node if one exists, or else will synchronously
+    /// start the computation on the current thread.
+    member GetOrComputeValue: unit -> NodeCode<'T>
+
+    /// Return 'Some' if the computation has already been computed, else None if
+    /// the computation is in-progress or has not yet been started.
+    member TryPeekValue: unit -> 'T voption
+
+    /// Return 'true' if the computation has already been computed.
+    member HasValue: bool
+
+    /// Return 'true' if the computation is in-progress.
+    member IsComputing: bool

src/fsharp/CheckDeclarations.fs

@@ -5003,8 +5003,8 @@ module TcDeclarations =
 // Bind module types
 //------------------------------------------------------------------------- 
 
-let rec TcSignatureElementNonMutRec cenv parent typeNames endm (env: TcEnv) synSigDecl: Eventually<TcEnv> =
-  eventually {
+let rec TcSignatureElementNonMutRec cenv parent typeNames endm (env: TcEnv) synSigDecl: Cancellable<TcEnv> =
+  cancellable {
     try 
         match synSigDecl with 
         | SynModuleSigDecl.Exception (edef, m) ->
@@ -5155,7 +5155,7 @@ let rec TcSignatureElementNonMutRec cenv parent typeNames endm (env: TcEnv) synS
 
 
 and TcSignatureElements cenv parent endm env xml mutRecNSInfo defs = 
-    eventually {
+    cancellable {
         // Ensure the .Deref call in UpdateAccModuleOrNamespaceType succeeds 
         if cenv.compilingCanonicalFslibModuleType then 
             let doc = xml.ToXmlDoc(true, Some [])
@@ -5170,10 +5170,10 @@ and TcSignatureElements cenv parent endm env xml mutRecNSInfo defs =
     }
 
 and TcSignatureElementsNonMutRec cenv parent typeNames endm env defs = 
-    Eventually.fold (TcSignatureElementNonMutRec cenv parent typeNames endm) env defs
+    Cancellable.fold (TcSignatureElementNonMutRec cenv parent typeNames endm) env defs
 
 and TcSignatureElementsMutRec cenv parent typeNames m mutRecNSInfo envInitial (defs: SynModuleSigDecl list) =
-    eventually {
+    cancellable {
         let m = match defs with [] -> m | _ -> defs |> List.map (fun d -> d.Range) |> List.reduce unionRanges
         let scopem = (defs, m) ||> List.foldBack (fun h m -> unionRanges h.Range m) 
 
@@ -5227,7 +5227,7 @@ and TcSignatureElementsMutRec cenv parent typeNames m mutRecNSInfo envInitial (d
 
 and TcModuleOrNamespaceSignatureElementsNonMutRec cenv parent env (id, modKind, defs, m: range, xml) =
 
-  eventually {
+  cancellable {
     let endm = m.EndRange // use end of range for errors 
 
     // Create the module type that will hold the results of type checking.... 
@@ -5287,7 +5287,7 @@ let CheckLetOrDoInNamespace binds m =
 
 /// The non-mutually recursive case for a declaration
 let rec TcModuleOrNamespaceElementNonMutRec (cenv: cenv) parent typeNames scopem env synDecl = 
-  eventually {
+  cancellable {
     cenv.synArgNameGenerator.Reset()
     let tpenv = emptyUnscopedTyparEnv
 
@@ -5468,7 +5468,7 @@ let rec TcModuleOrNamespaceElementNonMutRec (cenv: cenv) parent typeNames scopem
 
 /// The non-mutually recursive case for a sequence of declarations
 and TcModuleOrNamespaceElementsNonMutRec cenv parent typeNames endm (defsSoFar, env, envAtEnd) (moreDefs: SynModuleDecl list) =
- eventually {
+ cancellable {
     match moreDefs with 
     | (firstDef :: otherDefs) ->
         // Lookahead one to find out the scope of the next declaration.
@@ -5488,7 +5488,7 @@ and TcModuleOrNamespaceElementsNonMutRec cenv parent typeNames endm (defsSoFar,
 
 /// The mutually recursive case for a sequence of declarations (and nested modules)
 and TcModuleOrNamespaceElementsMutRec (cenv: cenv) parent typeNames m envInitial mutRecNSInfo (defs: SynModuleDecl list) =
- eventually {
+ cancellable {
 
     let m = match defs with [] -> m | _ -> defs |> List.map (fun d -> d.Range) |> List.reduce unionRanges
     let scopem = (defs, m) ||> List.foldBack (fun h m -> unionRanges h.Range m) 
@@ -5578,7 +5578,7 @@ and TcMutRecDefsFinish cenv defs m =
     TMDefRec(true, tycons, binds, m)
 
 and TcModuleOrNamespaceElements cenv parent endm env xml mutRecNSInfo defs =
-  eventually {
+  cancellable {
     // Ensure the deref_nlpath call in UpdateAccModuleOrNamespaceType succeeds 
     if cenv.compilingCanonicalFslibModuleType then 
         let doc = xml.ToXmlDoc(true, Some [])
@@ -5798,7 +5798,7 @@ let TypeCheckOneImplFile
 
  let infoReader = InfoReader(g, amap)
 
- eventually {
+ cancellable {
     let cenv = 
         cenv.Create (g, isScript, niceNameGen, amap, topCcu, false, Option.isSome rootSigOpt,
             conditionalDefines, tcSink, (LightweightTcValForUsingInBuildMethodCall g), isInternalTestSpanStackReferring,
@@ -5904,7 +5904,7 @@ let TypeCheckOneImplFile
 
 /// Check an entire signature file
 let TypeCheckOneSigFile (g, niceNameGen, amap, topCcu, checkForErrors, conditionalDefines, tcSink, isInternalTestSpanStackReferring) tcEnv (ParsedSigFileInput (_, qualNameOfFile, _, _, sigFileFrags)) = 
- eventually {     
+ cancellable {     
     let cenv = 
         cenv.Create 
             (g, false, niceNameGen, amap, topCcu, true, false, conditionalDefines, tcSink,

src/fsharp/CheckDeclarations.fsi

@@ -39,13 +39,13 @@ val TypeCheckOneImplFile :
       -> TcEnv 
       -> ModuleOrNamespaceType option
       -> ParsedImplFileInput
-      -> Eventually<TopAttribs * TypedImplFile * ModuleOrNamespaceType * TcEnv * bool>
+      -> Cancellable<TopAttribs * TypedImplFile * ModuleOrNamespaceType * TcEnv * bool>
 
 val TypeCheckOneSigFile : 
       TcGlobals * NiceNameGenerator * ImportMap * CcuThunk  * (unit -> bool) * ConditionalDefines option * NameResolution.TcResultsSink * bool
       -> TcEnv                             
       -> ParsedSigFileInput
-      -> Eventually<TcEnv * ModuleOrNamespaceType * bool>
+      -> Cancellable<TcEnv * ModuleOrNamespaceType * bool>
 
 exception ParameterlessStructCtor of range
 

src/fsharp/CompilerConfig.fs

@@ -25,6 +25,7 @@ open FSharp.Compiler.Text
 open FSharp.Compiler.Text.Range
 open FSharp.Compiler.Xml
 open FSharp.Compiler.TypedTree
+open FSharp.Compiler.BuildGraph
 
 #if !NO_EXTENSIONTYPING
 open FSharp.Compiler.ExtensionTyping
@@ -205,7 +206,7 @@ and IProjectReference =
     abstract FileName: string
 
     /// Evaluate raw contents of the assembly file generated by the project
-    abstract EvaluateRawContents: CompilationThreadToken -> Cancellable<IRawFSharpAssemblyData option>
+    abstract EvaluateRawContents: unit -> NodeCode<IRawFSharpAssemblyData option>
 
     /// Get the logical timestamp that would be the timestamp of the assembly file generated by the project
     ///

src/fsharp/CompilerConfig.fsi

@@ -19,6 +19,7 @@ open FSharp.Compiler.ErrorLogger
 open FSharp.Compiler.Features
 open FSharp.Compiler.CodeAnalysis
 open FSharp.Compiler.Text
+open FSharp.Compiler.BuildGraph
 
 exception FileNameNotResolved of (*filename*) string * (*description of searched locations*) string * range
 exception LoadedSourceNotFoundIgnoring of (*filename*) string * range
@@ -68,7 +69,7 @@ and IProjectReference =
     abstract FileName: string
 
     /// Evaluate raw contents of the assembly file generated by the project
-    abstract EvaluateRawContents: CompilationThreadToken -> Cancellable<IRawFSharpAssemblyData option>
+    abstract EvaluateRawContents: unit -> NodeCode<IRawFSharpAssemblyData option>
 
     /// Get the logical timestamp that would be the timestamp of the assembly file generated by the project.
     ///