Merge remote-tracking branch 'origin/parallel-project-analysis' into otel_parallel

Author: safesparrow

src/Compiler/Driver/CompilerImports.fs

@@ -2141,6 +2141,20 @@ and [<Sealed>] TcImports
         node {
             CheckDisposed()
 
+            // TODO inject top-down from FSharpChecker
+            let runInParallel =
+                Environment.GetEnvironmentVariable("FCS_PARALLEL_PROJECTS_ANALYSIS")
+                |> bool.TryParse
+                |> function
+                    | true, runInParallel -> runInParallel
+                    | false, _ -> false
+
+            let runMethod =
+                if runInParallel then
+                    NodeCode.Parallel
+                else
+                    NodeCode.Sequential
+
             let! results =
                 nms
                 |> List.map (fun nm ->
@@ -2151,7 +2165,7 @@ and [<Sealed>] TcImports
                             errorR (Error(FSComp.SR.buildProblemReadingAssembly (nm.resolvedPath, e.Message), nm.originalReference.Range))
                             return None
                     })
-                |> NodeCode.Sequential
+                |> runMethod
 
             let dllinfos, phase2s = results |> Array.choose id |> List.ofArray |> List.unzip
             fixupOrphanCcus ()

src/Compiler/Facilities/BuildGraph.fs

@@ -182,6 +182,12 @@ type NodeCode private () =
 
             return results.ToArray()
         }
+    
+    static member Parallel (computations: NodeCode<'T> seq) =
+        computations
+        |> Seq.map (fun (Node x) -> x)
+        |> Async.Parallel
+        |> Node
 
 type private AgentMessage<'T> = GetValue of AsyncReplyChannel<Result<'T, Exception>> * callerCancellationToken: CancellationToken
 
@@ -331,7 +337,7 @@ type GraphNode<'T>(retryCompute: bool, computation: NodeCode<'T>) =
                             // occur, making sure we are under the protection of the 'try'.
                             // For example, NodeCode's 'try/finally' (TryFinally) uses async.TryFinally which does
                             // implicit cancellation checks even before the try is entered, as do the
-                            // de-sugaring of 'do!' and other CodeCode constructs.
+                            // de-sugaring of 'do!' and other NodeCode constructs.
                             let mutable taken = false
 
                             try

src/Compiler/Facilities/BuildGraph.fsi

@@ -65,6 +65,8 @@ type NodeCode =
 
     static member Sequential: computations: NodeCode<'T> seq -> NodeCode<'T[]>
 
+    static member Parallel: 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>