revert script compilation to behave like it used to

src/fsharp/CompilerConfig.fs

@@ -337,6 +337,7 @@ type TargetFrameworkForScripts =
         match fx.Value with
         | "netcore" -> PrimaryAssembly.System_Runtime
         | "netfx"  -> PrimaryAssembly.Mscorlib
+        | "netstandard"  -> PrimaryAssembly.NetStandard
         | _  -> failwith "invalid value"
         // // Indicates we assume "netstandard.dll", i.e .NET Standard 2.0 and above
         // | "netstandard"  -> PrimaryAssembly.NetStandard

src/fsharp/LegacyHostedCompilerForTesting.fs

@@ -65,7 +65,7 @@ type internal InProcCompiler(legacyReferenceResolver) =
             { new Exiter with
                  member this.Exit n = exitCode <- n; raise StopProcessing }
         try 
-            mainCompile(ctok, argv, legacyReferenceResolver, false, ReduceMemoryFlag.Yes, CopyFSharpCoreFlag.Yes, None, exiter, loggerProvider.Provider, None, None)
+            mainCompile(ctok, argv, legacyReferenceResolver, false, ReduceMemoryFlag.Yes, CopyFSharpCoreFlag.Yes, exiter, loggerProvider.Provider, None, None)
         with 
             | StopProcessing -> ()
             | ReportedError _  | WrappedError(ReportedError _,_)  ->

src/fsharp/fsc.fs

@@ -219,7 +219,7 @@ let TypeCheck (ctok, tcConfig, tcImports, tcGlobals, errorLogger: ErrorLogger, a
 /// copied to the output folder, for example (except perhaps FSharp.Core.dll).
 ///
 /// NOTE: there is similar code in IncrementalBuilder.fs and this code should really be reconciled with that
-let AdjustForScriptCompile(ctok, tcConfigB: TcConfigBuilder, defaultToDotNetFramework, commandLineSourceFiles, dependencyProvider) =
+let AdjustForScriptCompile(ctok, tcConfigB: TcConfigBuilder, commandLineSourceFiles, lexResourceManager, dependencyProvider) =
 
     let combineFilePath file =
         try
@@ -234,7 +234,26 @@ let AdjustForScriptCompile(ctok, tcConfigB: TcConfigBuilder, defaultToDotNetFram
         
     // Script compilation is active if the last item being compiled is a script and --noframework has not been specified
     let mutable allSources = []       
-    
+
+    // In script compilation, we pre-infer the kind of scripts expected based on the compilation flags coming in on the command line.
+    //
+    // This has the following effect:
+    //    If --targetprofile:netcore has been specified, and a #netfx declaration exists in a script, then give a warning
+    //    If --targetprofile:mscorlib has been specified, and a #netcore declaration exists in a script, then give a warning
+    //    If --targetprofile:netstandard has been specified, and either a #netcore or #netfx declaration exists in a script, then give a warning
+    if commandLineSourceFiles |> List.exists IsScript && tcConfigB.inferredTargetFrameworkForScripts.IsNone then
+        let targetFrameworkForScripts =
+            match tcConfigB.primaryAssembly with
+            | PrimaryAssembly.Mscorlib -> 
+                TargetFrameworkForScripts "netfx"
+            | PrimaryAssembly.System_Runtime ->
+                TargetFrameworkForScripts "netcore"
+            | PrimaryAssembly.NetStandard -> 
+                TargetFrameworkForScripts "netstandard"
+        tcConfigB.inferredTargetFrameworkForScripts <- Some { InferredFramework = targetFrameworkForScripts; WhereInferred = None }
+        
+    let tcConfig = TcConfig.Create(tcConfigB, validate=false) 
+
     let AddIfNotPresent(filename: string) =
         if not(allSources |> List.contains filename) then
             allSources <- filename :: allSources
@@ -242,46 +261,34 @@ let AdjustForScriptCompile(ctok, tcConfigB: TcConfigBuilder, defaultToDotNetFram
     let AppendClosureInformation filename =
         if IsScript filename then 
 
-            // Get the source to infer the target framework from any #targetfx declarations in the script
-            let source = SourceText.ofString (File.ReadAllText filename)
-
-            // Do we assume .NET Framework references for scripts? In the absence of either explicit argument
-            // or an explicit #targetfx declaration, then for compilation and analysis the default
-            // depends on the toolchain the tooling is are running on.
-            let defaultToDotNetFramework = defaultArg defaultToDotNetFramework (not FSharpEnvironment.isRunningOnCoreClr)
-
-            let loadClosure = 
-                LoadClosure.ComputeClosureOfScriptText(ctok, tcConfigB.legacyReferenceResolver, 
-                    tcConfigB.defaultFSharpBinariesDir, filename, source, 
-                    CodeContext.Compilation, tcConfigB.useSimpleResolution, tcConfigB.useFsiAuxLib,
-                    tcConfigB.useSdkRefs, new Lexhelp.LexResourceManager(), 
-                    (fun _ -> ()), defaultToDotNetFramework, 
-                    tcConfigB.tryGetMetadataSnapshot, tcConfigB.reduceMemoryUsage, dependencyProvider)
+            let closure = 
+                LoadClosure.ComputeClosureOfScriptFiles
+                   (ctok, tcConfig, [filename, rangeStartup], CodeContext.Compilation, 
+                    lexResourceManager, dependencyProvider)
 
             // Record the new references (non-framework) references from the analysis of the script. (The full resolutions are recorded
             // as the corresponding #I paths used to resolve them are local to the scripts and not added to the tcConfigB - they are
             // added to localized clones of the tcConfigB).
             let references =
-                loadClosure.References
+                closure.References
                 |> List.collect snd
                 |> List.filter (fun r -> not (Range.equals r.originalReference.Range range0) && not (Range.equals r.originalReference.Range rangeStartup))
 
             references |> List.iter (fun r -> tcConfigB.AddReferencedAssemblyByPath(r.originalReference.Range, r.resolvedPath))
 
             // Also record the other declarations from the script.
-            loadClosure.NoWarns |> List.collect (fun (n, ms) -> ms|>List.map(fun m->m, n)) |> List.iter (fun (x,m) -> tcConfigB.TurnWarningOff(x, m))
-            loadClosure.SourceFiles |> List.map fst |> List.iter AddIfNotPresent
-            loadClosure.AllRootFileDiagnostics |> List.iter diagnosticSink
+            closure.NoWarns |> List.collect (fun (n, ms) -> ms|>List.map(fun m->m, n)) |> List.iter (fun (x,m) -> tcConfigB.TurnWarningOff(x, m))
+            closure.SourceFiles |> List.map fst |> List.iter AddIfNotPresent
+            closure.AllRootFileDiagnostics |> List.iter diagnosticSink
 
             // If there was an explicit #targetfx in the script then push that as a requirement into the overall compilation and add all the framework references implied
             // by the script too.
-            match loadClosure.InferredTargetFramework.WhereInferred with
+            match closure.InferredTargetFramework.WhereInferred with
             | Some m ->
-                tcConfigB.CheckExplicitFrameworkDirective(loadClosure.InferredTargetFramework.InferredFramework, m)
-                tcConfigB.primaryAssembly <- loadClosure.InferredTargetFramework.InferredFramework.PrimaryAssembly
-                tcConfigB.fxResolver <- FxResolver(tcConfigB.reduceMemoryUsage, tcConfigB.tryGetMetadataSnapshot, Some loadClosure.InferredTargetFramework.UseDotNetFramework)
+                tcConfigB.CheckExplicitFrameworkDirective(closure.InferredTargetFramework.InferredFramework, m)
+                tcConfigB.primaryAssembly <- closure.InferredTargetFramework.InferredFramework.PrimaryAssembly
                 if tcConfigB.framework then
-                    let references = loadClosure.References |> List.collect snd
+                    let references = closure.References |> List.collect snd
                     references |> List.iter (fun r -> tcConfigB.AddReferencedAssemblyByPath(r.originalReference.Range, r.resolvedPath))
             | None -> ()
             
@@ -1762,7 +1769,6 @@ type Args<'T> = Args  of 'T
 let main0(ctok, argv, legacyReferenceResolver, bannerAlreadyPrinted, 
           reduceMemoryUsage: ReduceMemoryFlag, defaultCopyFSharpCore: CopyFSharpCoreFlag, 
           exiter: Exiter, errorLoggerProvider : ErrorLoggerProvider,
-          defaultToDotNetFramework: bool option,
           disposables : DisposablesTracker) = 
 
     // See Bug 735819 
@@ -1826,7 +1832,7 @@ let main0(ctok, argv, legacyReferenceResolver, bannerAlreadyPrinted,
         try 
             let sourceFiles = 
                 let files = ProcessCommandLineFlags (tcConfigB, setProcessThreadLocals, lcidFromCodePage, argv)
-                AdjustForScriptCompile(ctok, tcConfigB, defaultToDotNetFramework, files, dependencyProvider)
+                AdjustForScriptCompile(ctok, tcConfigB, files, lexResourceManager, dependencyProvider)
             sourceFiles
 
         with e -> 
@@ -1834,6 +1840,9 @@ let main0(ctok, argv, legacyReferenceResolver, bannerAlreadyPrinted,
             delayForFlagsLogger.ForwardDelayedDiagnostics tcConfigB
             exiter.Exit 1 
     
+    let useDotNetFramework = (tcConfigB.primaryAssembly = PrimaryAssembly.Mscorlib)
+    tcConfigB.fxResolver <- FxResolver(tcConfigB.reduceMemoryUsage, tcConfigB.tryGetMetadataSnapshot, Some useDotNetFramework)
+
     tcConfigB.conditionalCompilationDefines <- "COMPILED" :: tcConfigB.conditionalCompilationDefines 
     displayBannerIfNeeded tcConfigB
 
@@ -2266,7 +2275,6 @@ let mainCompile
          bannerAlreadyPrinted,
          reduceMemoryUsage, 
          defaultCopyFSharpCore,
-         defaultToDotNetFramework,
          exiter: Exiter,
          errorLoggerProvider,
          tcImportsCapture,
@@ -2281,7 +2289,7 @@ let mainCompile
                     System.Console.SetOut(savedOut)
                 with _ -> ()}
 
-    main0(ctok, argv, legacyReferenceResolver, bannerAlreadyPrinted, reduceMemoryUsage, defaultCopyFSharpCore, exiter, errorLoggerProvider, defaultToDotNetFramework, d)
+    main0(ctok, argv, legacyReferenceResolver, bannerAlreadyPrinted, reduceMemoryUsage, defaultCopyFSharpCore, exiter, errorLoggerProvider, d)
     |> main1
     |> main2a
     |> main2b (tcImportsCapture,dynamicAssemblyCreator)

src/fsharp/fsc.fsi

@@ -42,7 +42,6 @@ val mainCompile :
     bannerAlreadyPrinted: bool * 
     reduceMemoryUsage: ReduceMemoryFlag * 
     defaultCopyFSharpCore: CopyFSharpCoreFlag * 
-    defaultToDotNetFramework: bool option *
     exiter: Exiter * 
     loggerProvider: ErrorLoggerProvider * 
     tcImportsCapture: (TcImports -> unit) option *

src/fsharp/fscmain.fs

@@ -63,7 +63,7 @@ module Driver =
         // thus we can use file-locking memory mapped files.
         //
         // This is also one of only two places where CopyFSharpCoreFlag.Yes is set.  The other is in LegacyHostedCompilerForTesting.
-        mainCompile (ctok, argv, legacyReferenceResolver, (*bannerAlreadyPrinted*)false, ReduceMemoryFlag.No, CopyFSharpCoreFlag.Yes, None, quitProcessExiter, ConsoleLoggerProvider(), None, None)
+        mainCompile (ctok, argv, legacyReferenceResolver, (*bannerAlreadyPrinted*)false, ReduceMemoryFlag.No, CopyFSharpCoreFlag.Yes, quitProcessExiter, ConsoleLoggerProvider(), None, None)
         0 
 
 [<EntryPoint>]

src/fsharp/service/service.fs

@@ -169,12 +169,12 @@ module CompileHelpers =
             1
 
     /// Compile using the given flags.  Source files names are resolved via the FileSystem API. The output file must be given by a -o flag. 
-    let compileFromArgs (ctok, argv: string[], legacyReferenceResolver, defaultToDotNetFramework, tcImportsCapture, dynamicAssemblyCreator)  = 
+    let compileFromArgs (ctok, argv: string[], legacyReferenceResolver, tcImportsCapture, dynamicAssemblyCreator)  = 
     
         let errors, errorLogger, loggerProvider = mkCompilationErrorHandlers()
         let result = 
             tryCompile errorLogger (fun exiter -> 
-                mainCompile (ctok, argv, legacyReferenceResolver, (*bannerAlreadyPrinted*)true, ReduceMemoryFlag.Yes, CopyFSharpCoreFlag.No, defaultToDotNetFramework, exiter, loggerProvider, tcImportsCapture, dynamicAssemblyCreator) )
+                mainCompile (ctok, argv, legacyReferenceResolver, (*bannerAlreadyPrinted*)true, ReduceMemoryFlag.Yes, CopyFSharpCoreFlag.No, exiter, loggerProvider, tcImportsCapture, dynamicAssemblyCreator) )
     
         errors.ToArray(), result
 
@@ -1078,11 +1078,11 @@ type FSharpChecker(legacyReferenceResolver,
         let userOpName = defaultArg userOpName "Unknown"
         backgroundCompiler.TryGetRecentCheckResultsForFile(filename,options,sourceText, userOpName)
 
-    member __.Compile(argv: string[], ?defaultToDotNetFramework: bool, ?userOpName: string) =
+    member __.Compile(argv: string[], ?userOpName: string) =
         let userOpName = defaultArg userOpName "Unknown"
         backgroundCompiler.Reactor.EnqueueAndAwaitOpAsync (userOpName, "Compile", "", fun ctok -> 
             cancellable {
-                return CompileHelpers.compileFromArgs (ctok, argv, legacyReferenceResolver, defaultToDotNetFramework, None, None)
+                return CompileHelpers.compileFromArgs (ctok, argv, legacyReferenceResolver, None, None)
             })
 
     member __.Compile (ast:ParsedInput list, assemblyName:string, outFile:string, dependencies:string list, ?pdbFile:string, ?executable:bool, ?noframework:bool, ?userOpName: string) =
@@ -1109,12 +1109,8 @@ type FSharpChecker(legacyReferenceResolver,
         let debugInfo =  otherFlags |> Array.exists (fun arg -> arg = "-g" || arg = "--debug:+" || arg = "/debug:+")
         let dynamicAssemblyCreator = Some (CompileHelpers.createDynamicAssembly (ctok, debugInfo, tcImportsRef, execute.IsSome, assemblyBuilderRef))
 
-        // Do we assume .NET Framework references for scripts? For dynamic compilation this
-        // depends only on the toolchain the tooling is are running on.
-        let defaultToDotNetFramework = Some (not FSharpEnvironment.isRunningOnCoreClr)
-
         // Perform the compilation, given the above capturing function.
-        let errorsAndWarnings, result = CompileHelpers.compileFromArgs (ctok, otherFlags, legacyReferenceResolver, defaultToDotNetFramework, tcImportsCapture, dynamicAssemblyCreator)
+        let errorsAndWarnings, result = CompileHelpers.compileFromArgs (ctok, otherFlags, legacyReferenceResolver, tcImportsCapture, dynamicAssemblyCreator)
 
         // Retrieve and return the results
         let assemblyOpt = 

src/fsharp/service/service.fsi

@@ -333,9 +333,8 @@ type public FSharpChecker =
     /// </summary>
     ///
     /// <param name="argv">The command line arguments for the project build.</param>
-    /// <param name="defaultToDotNetFramework">Indicates scripts without explicit target framework declarations should be assumed to be .NET Framework scripts.</param>
     /// <param name="userOpName">An optional string used for tracing compiler operations associated with this request.</param>
-    member Compile: argv:string[] * ?defaultToDotNetFramework: bool * ?userOpName: string -> Async<FSharpErrorInfo [] * int>
+    member Compile: argv:string[] * ?userOpName: string -> Async<FSharpErrorInfo [] * int>
 
     /// <summary>
     /// TypeCheck and compile provided AST

tests/FSharp.Compiler.Service.Tests/SurfaceArea.netstandard.fs

@@ -21518,7 +21518,7 @@ FSharp.Compiler.SourceCodeServices.FSharpChecker: Microsoft.FSharp.Control.FShar
 FSharp.Compiler.SourceCodeServices.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[System.Tuple`2[FSharp.Compiler.Range+range,FSharp.Compiler.Range+range][]] MatchBraces(System.String, FSharp.Compiler.Text.ISourceText, FSharp.Compiler.SourceCodeServices.FSharpParsingOptions, Microsoft.FSharp.Core.FSharpOption`1[System.String])
 FSharp.Compiler.SourceCodeServices.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[System.Tuple`2[FSharp.Compiler.Range+range,FSharp.Compiler.Range+range][]] MatchBraces(System.String, System.String, FSharp.Compiler.SourceCodeServices.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[System.String])
 FSharp.Compiler.SourceCodeServices.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[System.Tuple`2[FSharp.Compiler.SourceCodeServices.FSharpErrorInfo[],System.Int32]] Compile(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SyntaxTree+ParsedInput], System.String, System.String, Microsoft.FSharp.Collections.FSharpList`1[System.String], Microsoft.FSharp.Core.FSharpOption`1[System.String], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.String])
-FSharp.Compiler.SourceCodeServices.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[System.Tuple`2[FSharp.Compiler.SourceCodeServices.FSharpErrorInfo[],System.Int32]] Compile(System.String[], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.String])
+FSharp.Compiler.SourceCodeServices.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[System.Tuple`2[FSharp.Compiler.SourceCodeServices.FSharpErrorInfo[],System.Int32]] Compile(System.String[], Microsoft.FSharp.Core.FSharpOption`1[System.String])
 FSharp.Compiler.SourceCodeServices.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[System.Tuple`2[FSharp.Compiler.SourceCodeServices.FSharpParseFileResults,FSharp.Compiler.SourceCodeServices.FSharpCheckFileAnswer]] ParseAndCheckFileInProject(System.String, Int32, FSharp.Compiler.Text.ISourceText, FSharp.Compiler.SourceCodeServices.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[System.Object], Microsoft.FSharp.Core.FSharpOption`1[System.String])
 FSharp.Compiler.SourceCodeServices.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[System.Tuple`2[FSharp.Compiler.SourceCodeServices.FSharpParseFileResults,FSharp.Compiler.SourceCodeServices.FSharpCheckFileResults]] GetBackgroundCheckResultsForFileInProject(System.String, FSharp.Compiler.SourceCodeServices.FSharpProjectOptions, Microsoft.FSharp.Core.FSharpOption`1[System.String])
 FSharp.Compiler.SourceCodeServices.FSharpChecker: Microsoft.FSharp.Control.FSharpAsync`1[System.Tuple`2[FSharp.Compiler.SourceCodeServices.FSharpProjectOptions,Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.SourceCodeServices.FSharpErrorInfo]]] GetProjectOptionsFromScript(System.String, FSharp.Compiler.Text.ISourceText, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.DateTime], Microsoft.FSharp.Core.FSharpOption`1[System.String[]], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Microsoft.FSharp.Core.FSharpOption`1[System.Object], Microsoft.FSharp.Core.FSharpOption`1[System.Int64], Microsoft.FSharp.Core.FSharpOption`1[System.String])

vsintegration/tests/UnitTests/Tests.Watson.fs

@@ -28,7 +28,7 @@ type Check =
                     |]
 
                 let ctok = AssumeCompilationThreadWithoutEvidence ()
-                let _code = mainCompile (ctok, argv, LegacyMSBuildReferenceResolver.getResolver(), false, ReduceMemoryFlag.No, CopyFSharpCoreFlag.No, None, FSharp.Compiler.ErrorLogger.QuitProcessExiter, ConsoleLoggerProvider(), None, None)
+                let _code = mainCompile (ctok, argv, LegacyMSBuildReferenceResolver.getResolver(), false, ReduceMemoryFlag.No, CopyFSharpCoreFlag.No, FSharp.Compiler.ErrorLogger.QuitProcessExiter, ConsoleLoggerProvider(), None, None)
                 ()
             with 
             | :? 'TException as e ->