Parallel project analysis behind a feature flag (#13521)

* Allow parallel project analysis with an environment variable

* reformat CompilerImports.fs

* Wire in the flag from top-level, add an internal option to the FSC, add a constructor arg to the FSharpChecker.

* Fantomas formatting

* Update surface baseline

* Cleanup

* Dummy commit to trigger PR checks

* Update surface baseline after merge

* Empty commit to trigger PR check rerun

* Empty commit to trigger PR check rerun

* Restore tests/fsharp/regression/13219/test.fsx

Author: safesparrow

src/Compiler/Driver/CompilerConfig.fs

@@ -388,6 +388,11 @@ type MetadataAssemblyGeneration =
     | ReferenceOut of outputPath: string
     | ReferenceOnly
 
+[<RequireQualifiedAccess>]
+type ParallelReferenceResolution =
+    | On
+    | Off
+
 [<NoEquality; NoComparison>]
 type TcConfigBuilder =
     {
@@ -580,6 +585,8 @@ type TcConfigBuilder =
         mutable xmlDocInfoLoader: IXmlDocumentationInfoLoader option
 
         mutable exiter: Exiter
+
+        mutable parallelReferenceResolution: ParallelReferenceResolution
     }
 
     // Directories to start probing in
@@ -767,6 +774,7 @@ type TcConfigBuilder =
             sdkDirOverride = sdkDirOverride
             xmlDocInfoLoader = None
             exiter = QuitProcessExiter
+            parallelReferenceResolution = ParallelReferenceResolution.Off
         }
 
     member tcConfigB.FxResolver =
@@ -1310,6 +1318,7 @@ type TcConfig private (data: TcConfigBuilder, validate: bool) =
     member _.applyLineDirectives = data.applyLineDirectives
     member _.xmlDocInfoLoader = data.xmlDocInfoLoader
     member _.exiter = data.exiter
+    member _.parallelReferenceResolution = data.parallelReferenceResolution
 
     static member Create(builder, validate) =
         use _ = UseBuildPhase BuildPhase.Parameter

src/Compiler/Driver/CompilerConfig.fsi

@@ -198,6 +198,11 @@ type MetadataAssemblyGeneration =
     /// Only emits the assembly as a reference assembly.
     | ReferenceOnly
 
+[<RequireQualifiedAccess>]
+type ParallelReferenceResolution =
+    | On
+    | Off
+
 [<NoEquality; NoComparison>]
 type TcConfigBuilder =
     {
@@ -482,6 +487,8 @@ type TcConfigBuilder =
         mutable xmlDocInfoLoader: IXmlDocumentationInfoLoader option
 
         mutable exiter: Exiter
+
+        mutable parallelReferenceResolution: ParallelReferenceResolution
     }
 
     static member CreateNew:
@@ -845,6 +852,8 @@ type TcConfig =
 
     member exiter: Exiter
 
+    member parallelReferenceResolution: ParallelReferenceResolution
+
 /// Represents a computation to return a TcConfig. Normally this is just a constant immutable TcConfig,
 /// but for F# Interactive it may be based on an underlying mutable TcConfigBuilder.
 [<Sealed>]

src/Compiler/Driver/CompilerImports.fs

@@ -2141,6 +2141,12 @@ and [<Sealed>] TcImports
         node {
             CheckDisposed()
 
+            let tcConfig = tcConfigP.Get ctok
+            let runMethod =
+                match tcConfig.parallelReferenceResolution with
+                | ParallelReferenceResolution.On -> NodeCode.Parallel
+                | ParallelReferenceResolution.Off -> NodeCode.Sequential
+
             let! results =
                 nms
                 |> List.map (fun nm ->
@@ -2151,7 +2157,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/Driver/CompilerOptions.fs

@@ -1680,6 +1680,14 @@ let internalFlags (tcConfigB: TcConfigBuilder) =
             None
         )
 
+        CompilerOption(
+            "parallelreferenceresolution",
+            tagNone,
+            OptionUnit(fun () -> tcConfigB.parallelReferenceResolution <- ParallelReferenceResolution.On),
+            Some(InternalCommandLineOption("--parallelreferenceresolution", rangeCmdArgs)),
+            None
+        )
+
         testFlag tcConfigB
     ]
     @

src/Compiler/Driver/fsc.fs

@@ -446,6 +446,18 @@ let TryFindVersionAttribute g attrib attribName attribs deterministic =
 [<NoEquality; NoComparison>]
 type Args<'T> = Args of 'T
 
+let getParallelReferenceResolutionFromEnvironment () =
+    Environment.GetEnvironmentVariable("FCS_ParallelReferenceResolution")
+    |> Option.ofObj
+    |> Option.bind (fun flag ->
+        match bool.TryParse flag with
+        | true, runInParallel ->
+            if runInParallel then
+                Some ParallelReferenceResolution.On
+            else
+                Some ParallelReferenceResolution.Off
+        | false, _ -> None)
+
 /// First phase of compilation.
 ///   - Set up console encoding and code page settings
 ///   - Process command line, flags and collect filenames
@@ -533,6 +545,11 @@ let main1
 
     tcConfigB.conditionalDefines <- "COMPILED" :: tcConfigB.conditionalDefines
 
+    // Override ParallelReferenceResolution set on the CLI with an environment setting if present.
+    match getParallelReferenceResolutionFromEnvironment () with
+    | Some parallelReferenceResolution -> tcConfigB.parallelReferenceResolution <- parallelReferenceResolution
+    | None -> ()
+
     // Display the banner text, if necessary
     if not bannerAlreadyPrinted then
         Console.Write(GetBannerText tcConfigB)

src/Compiler/Driver/fsc.fsi

@@ -55,3 +55,6 @@ val CompileFromCommandLineArguments:
     tcImportsCapture: (TcImports -> unit) option *
     dynamicAssemblyCreator: (TcConfig * TcGlobals * string * ILModuleDef -> unit) option ->
         unit
+
+/// Read the parallelReferenceResolution flag from environment variables
+val internal getParallelReferenceResolutionFromEnvironment: unit -> ParallelReferenceResolution option

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>

src/Compiler/Service/IncrementalBuild.fs

@@ -1432,7 +1432,8 @@ type IncrementalBuilder(initialState: IncrementalBuilderInitialState, state: Inc
             enableBackgroundItemKeyStoreAndSemanticClassification,
             enablePartialTypeChecking: bool,
             enableParallelCheckingWithSignatureFiles: bool,
-            dependencyProvider
+            dependencyProvider,
+            parallelReferenceResolution
         ) =
 
       let useSimpleResolutionSwitch = "--simpleresolution"
@@ -1514,6 +1515,7 @@ type IncrementalBuilder(initialState: IncrementalBuilderInitialState, state: Inc
                     |> Some
 
                 tcConfigB.parallelCheckingWithSignatureFiles <- enableParallelCheckingWithSignatureFiles
+                tcConfigB.parallelReferenceResolution <- parallelReferenceResolution
 
                 tcConfigB, sourceFilesNew
 

src/Compiler/Service/IncrementalBuild.fsi

@@ -264,7 +264,8 @@ type internal IncrementalBuilder =
         enableBackgroundItemKeyStoreAndSemanticClassification: bool *
         enablePartialTypeChecking: bool *
         enableParallelCheckingWithSignatureFiles: bool *
-        dependencyProvider: DependencyProvider option ->
+        dependencyProvider: DependencyProvider option *
+        parallelReferenceResolution: ParallelReferenceResolution ->
             NodeCode<IncrementalBuilder option * FSharpDiagnostic[]>
 
 /// Generalized Incremental Builder. This is exposed only for unit testing purposes.