Make it actually correct via human intervention

T-Gro · T-Gro · commit ee9405236cd1 · 2025-10-17T11:46:38.000+02:00
diff --git a/.gitignore b/.gitignore
@@ -148,3 +148,13 @@ TestResults/*.trx
 StandardOutput.txt
 StandardError.txt
 **/TestResults/
+
+# CompilerCompat test project generated files
+tests/projects/CompilerCompat/**/nuget.config
+tests/projects/CompilerCompat/**/global.json
+tests/projects/CompilerCompat/**/*.deps.json
+tests/projects/CompilerCompat/**/*.xml
+tests/projects/CompilerCompat/local-nuget-packages/
+tests/projects/CompilerCompat/lib-output-*/
+tests/projects/CompilerCompat/**/bin/
+tests/projects/CompilerCompat/**/obj/
diff --git a/tests/FSharp.Compiler.ComponentTests/CompilerCompatibilityTests.fs b/tests/FSharp.Compiler.ComponentTests/CompilerCompatibilityTests.fs
@@ -2,6 +2,7 @@ module FSharp.Compiler.ComponentTests.CompilerCompatibilityTests
 
 
 open System.IO
+open System.Diagnostics
 open Xunit
 open TestFramework
 
@@ -12,18 +13,124 @@ type CompilerCompatibilityTests() =
     let libProjectPath = Path.Combine(projectsPath, "CompilerCompatLib")
     let appProjectPath = Path.Combine(projectsPath, "CompilerCompatApp")
     
-    let runDotnetBuild projectPath compilerVersion =
-        let args = 
-            match compilerVersion with
-            | "local" -> "build -c Release -p:LoadLocalFSharpBuild=True"
-            | _ -> "build -c Release"
-                
-        let (exitCode, output, error) = Commands.executeProcess "dotnet" args projectPath
+    let createGlobalJson (directory: string) (sdkVersion: string) =
+        let globalJsonPath = Path.Combine(directory, "global.json")
+        let content = $"""{{
+  "sdk": {{
+    "version": "{sdkVersion}",
+    "rollForward": "latestPatch"
+  }}
+}}"""
+        File.WriteAllText(globalJsonPath, content)
+        globalJsonPath
+    
+    let deleteGlobalJson (directory: string) =
+        let globalJsonPath = Path.Combine(directory, "global.json")
+        if File.Exists(globalJsonPath) then
+            File.Delete(globalJsonPath)
+    
+    let executeDotnetProcess (command: string) (workingDir: string) (clearDotnetRoot: bool) =
+        let psi = ProcessStartInfo()
+        // For net9 scenarios, use full path to system dotnet to bypass repo's .dotnet
+        // This ensures the spawned process uses system SDKs instead of repo's local SDK
+        let dotnetExe =
+            if clearDotnetRoot then
+                if System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.Windows) then
+                    @"C:\Program Files\dotnet\dotnet.exe"
+                elif System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.OSX) then
+                    "/usr/local/share/dotnet/dotnet"
+                else // Linux
+                    "/usr/share/dotnet/dotnet"
+            else
+                "dotnet"
         
-        if exitCode <> 0 then
-            failwith $"Build failed with exit code {exitCode}. Output: {output}. Error: {error}"
+        psi.FileName <- dotnetExe
+        psi.WorkingDirectory <- workingDir
+        psi.RedirectStandardOutput <- true
+        psi.RedirectStandardError <- true
+        psi.Arguments <- command
+        psi.CreateNoWindow <- true
+        psi.EnvironmentVariables["DOTNET_ROLL_FORWARD"] <- "LatestMajor"
+        psi.EnvironmentVariables["DOTNET_ROLL_FORWARD_TO_PRERELEASE"] <- "1"
+        psi.EnvironmentVariables.Remove("MSBuildSDKsPath")
         
-        output
+        // For net9 scenarios, remove DOTNET_ROOT so dotnet looks in its default locations
+        if clearDotnetRoot then
+            psi.EnvironmentVariables.Remove("DOTNET_ROOT")
+        
+        psi.UseShellExecute <- false
+
+        use p = new Process()
+        p.StartInfo <- psi
+
+        if not (p.Start()) then failwith "new process did not start"
+
+        let readOutput = backgroundTask { return! p.StandardOutput.ReadToEndAsync() }
+        let readErrors = backgroundTask { return! p.StandardError.ReadToEndAsync() }
+
+        p.WaitForExit()
+
+        p.ExitCode, readOutput.Result, readErrors.Result
+    
+    let runDotnetCommand (command: string) (workingDir: string) (compilerVersion: string) =
+        let clearDotnetRoot = (compilerVersion = "net9")
+        executeDotnetProcess command workingDir clearDotnetRoot
+        |> fun (exitCode, stdout, stderr) ->
+            if exitCode <> 0 then
+                failwith $"Command failed with exit code {exitCode}:\nCommand: dotnet {command}\nStdout:\n{stdout}\nStderr:\n{stderr}"
+            stdout
+    
+    let buildProject (projectPath: string) (compilerVersion: string) =
+        // Use the same configuration as the test project itself
+#if DEBUG
+        let configuration = "Debug"
+#else
+        let configuration = "Release"
+#endif
+        let projectDir = Path.GetDirectoryName(projectPath)
+        
+        // For net9, create a global.json to pin SDK version
+        if compilerVersion = "net9" then
+            createGlobalJson projectDir "9.0.306" |> ignore
+        
+        let buildArgs =
+            if compilerVersion = "local" then
+                $"build \"{projectPath}\" -c {configuration} --no-restore -p:LoadLocalFSharpBuild=true -p:LocalFSharpCompilerConfiguration={configuration}"
+            else
+                $"build \"{projectPath}\" -c {configuration} --no-restore"
+        
+        try
+            runDotnetCommand buildArgs projectDir compilerVersion
+        finally
+            // Clean up global.json after build
+            if compilerVersion = "net9" then
+                deleteGlobalJson projectDir
+    
+    let packProject (projectPath: string) (compilerVersion: string) (outputDir: string) =
+        // Use the same configuration as the test project itself
+#if DEBUG
+        let configuration = "Debug"
+#else
+        let configuration = "Release"
+#endif
+        let projectDir = Path.GetDirectoryName(projectPath)
+        
+        // For net9, create a global.json to pin SDK version
+        if compilerVersion = "net9" then
+            createGlobalJson projectDir "9.0.306" |> ignore
+        
+        let packArgs =
+            if compilerVersion = "local" then
+                $"pack \"{projectPath}\" -c {configuration} -p:LoadLocalFSharpBuild=true -p:LocalFSharpCompilerConfiguration={configuration} -o \"{outputDir}\""
+            else
+                $"pack \"{projectPath}\" -c {configuration} -o \"{outputDir}\""
+        
+        try
+            runDotnetCommand packArgs projectDir compilerVersion
+        finally
+            // Clean up global.json after pack
+            if compilerVersion = "net9" then
+                deleteGlobalJson projectDir
     
     let runApp appBinaryPath =
         Commands.executeProcess "dotnet" appBinaryPath (Path.GetDirectoryName(appBinaryPath))
@@ -38,31 +145,89 @@ type CompilerCompatibilityTests() =
             Directory.Delete(objPath, true)
 
     let getAppDllPath () =
-        // The app is built to artifacts directory due to Directory.Build.props
-        Path.Combine(__SOURCE_DIRECTORY__, "..", "..", "artifacts", "bin", "CompilerCompatApp", "Release", "net8.0", "CompilerCompatApp.dll")
+        // The app is built to its local bin directory (not artifacts) due to isolated Directory.Build.props
+        // Use the same configuration as the test project itself
+#if DEBUG
+        let configuration = "Debug"
+#else
+        let configuration = "Release"
+#endif
+        Path.Combine(appProjectPath, "bin", configuration, "net8.0", "CompilerCompatApp.dll")
 
     [<Theory>]
     [<InlineData("local", "local", "Baseline scenario - Both library and app built with local compiler")>]
     [<InlineData("latest", "local", "Forward compatibility - Library built with latest SDK, app with local compiler")>]
     [<InlineData("local", "latest", "Backward compatibility - Library built with local compiler, app with latest SDK")>]
+    [<InlineData("net9", "local", "Cross-version compatibility - Library built with .NET 9, app with local compiler")>]
+    [<InlineData("local", "net9", "Cross-version compatibility - Library built with local compiler, app with .NET 9")>]
     member _.``Compiler compatibility test``(libCompilerVersion: string, appCompilerVersion: string, scenarioDescription: string) =
-        // Clean previous builds
+        // Clean previous builds (no artifacts directory due to isolated Directory.Build.props)
         cleanBinObjDirectories libProjectPath
         cleanBinObjDirectories appProjectPath
         
-        // Build library with specified compiler version
-        let libOutput = runDotnetBuild libProjectPath libCompilerVersion
-        Assert.Contains("CompilerCompatLib -> ", libOutput)
+        // Create a local NuGet packages directory for this test
+        let localNuGetDir = Path.Combine(projectsPath, "local-nuget-packages")
+        if Directory.Exists(localNuGetDir) then Directory.Delete(localNuGetDir, true)
+        Directory.CreateDirectory(localNuGetDir) |> ignore
+        
+        // Step 1: Pack the library with the specified compiler version (which will also build it)
+        let libProjectFile = Path.Combine(libProjectPath, "CompilerCompatLib.fsproj")
+        
+        let packOutput = packProject libProjectFile libCompilerVersion localNuGetDir
+        Assert.Contains("Successfully created package", packOutput)
+        
+        // Verify the nupkg file was created
+        let nupkgFiles = Directory.GetFiles(localNuGetDir, "CompilerCompatLib.*.nupkg")
+        Assert.True(nupkgFiles.Length > 0, $"No .nupkg file found in {localNuGetDir}")
         
-        // Build app with specified compiler version
-        let appOutput = runDotnetBuild appProjectPath appCompilerVersion
-        Assert.Contains("CompilerCompatApp -> ", appOutput)
+        // Step 2: Configure app to use the local NuGet package
+        // Create a temporary nuget.config that points to our local package directory
+        let appNuGetConfig = Path.Combine(appProjectPath, "nuget.config")
+        let nuGetConfigContent = $"""<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <packageSources>
+    <clear />
+    <add key="local" value="{localNuGetDir}" />
+    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
+  </packageSources>
+</configuration>"""
+        File.WriteAllText(appNuGetConfig, nuGetConfigContent)
         
-        // Run app and verify it works
+        // For net9, create global.json before restore
+        if appCompilerVersion = "net9" then
+            createGlobalJson appProjectPath "9.0.306" |> ignore
+        
+        try
+            // Step 3: Clear global packages cache to ensure we get the fresh package, then restore the app  
+            let appProjectFile = Path.Combine(appProjectPath, "CompilerCompatApp.fsproj")
+            let _ = runDotnetCommand "nuget locals global-packages --clear" appProjectPath appCompilerVersion
+            let restoreOutput = runDotnetCommand $"restore \"{appProjectFile}\" --force --no-cache" appProjectPath appCompilerVersion
+            // Restore may say "Restore complete", "Restored", or "All projects are up-to-date" depending on state
+            Assert.True(
+                restoreOutput.Contains("Restore complete") || restoreOutput.Contains("Restored") || restoreOutput.Contains("up-to-date"),
+                $"Restore did not complete successfully. Output:\n{restoreOutput}")
+            
+            // Step 4: Build the app with the specified compiler version
+            // The app will use the NuGet package we just created and restored
+            let appOutput = buildProject appProjectFile appCompilerVersion
+            Assert.Contains("CompilerCompatApp -> ", appOutput)
+        finally
+            // Clean up global.json if we created it
+            if appCompilerVersion = "net9" then
+                deleteGlobalJson appProjectPath
+        
+        // Clean up the temporary nuget.config
+        File.Delete(appNuGetConfig)
+        
+        // Step 5: Run the app and verify it works
         let appDllPath = getAppDllPath()
         Assert.True(File.Exists(appDllPath), $"App DLL not found at {appDllPath} for scenario: {scenarioDescription}")
         
-        let (exitCode, output, _error) = runApp appDllPath
+        let (exitCode, output, error) = runApp appDllPath
+        if exitCode <> 0 then
+            printfn $"App failed with exit code {exitCode}"
+            printfn $"Output:\n{output}"
+            printfn $"Error:\n{error}"
         Assert.Equal(0, exitCode)
         Assert.Contains("SUCCESS: All compiler compatibility tests passed", output)
         
@@ -106,12 +271,47 @@ type CompilerCompatibilityTests() =
         Assert.True((lines |> Array.exists (fun l -> l.Contains("F# Compiler Path:") && not (l.Contains("Unknown")))), 
             "F# Compiler Path should be captured from build-time, not show 'Unknown'")
         
-        // Validate that local builds have artifacts path and non-local builds don't
+        // Extract F# Compiler Paths to compare
+        let extractCompilerPath (sectionHeader: string) =
+            lines 
+            |> Array.tryFindIndex (fun l -> l.StartsWith(sectionHeader))
+            |> Option.bind (fun startIdx ->
+                lines
+                |> Array.skip (startIdx + 1)
+                |> Array.tryFind (fun l -> l.Contains("F# Compiler Path:"))
+                |> Option.map (fun l -> l.Trim()))
+        
+        let libCompilerPath = extractCompilerPath "Library Build Info:"
+        let appCompilerPath = extractCompilerPath "Application Build Info:"
+        
+        // Validate that F# Compiler Path consistency matches compiler version consistency
+        match libCompilerPath, appCompilerPath with
+        | Some libPath, Some appPath ->
+            if libCompilerVersion = appCompilerVersion then
+                Assert.True((libPath = appPath), 
+                    $"Same compiler version ('{libCompilerVersion}') should have same F# Compiler Path, but lib has '{libPath}' and app has '{appPath}'")
+            else
+                Assert.True((libPath <> appPath), 
+                    $"Different compiler versions (lib='{libCompilerVersion}', app='{appCompilerVersion}') should have different F# Compiler Paths, but both have '{libPath}'")
+        | _ -> Assert.True(false, "Could not extract F# Compiler Path from output")
+        
+        // Validate that local builds have artifacts path
+        // Look for the section header, then check if any subsequent lines contain artifacts
+        let hasArtifactsInSection (sectionHeader: string) =
+            lines 
+            |> Array.tryFindIndex (fun (l: string) -> l.StartsWith(sectionHeader))
+            |> Option.map (fun startIdx ->
+                lines
+                |> Array.skip startIdx
+                |> Array.take (min 10 (lines.Length - startIdx)) // Look in next 10 lines
+                |> Array.exists (fun l -> l.Contains("artifacts")))
+            |> Option.defaultValue false
+        
         if expectedLibIsLocal then
-            Assert.True((lines |> Array.exists (fun l -> l.Contains("Library") && l.Contains("artifacts"))), 
+            Assert.True(hasArtifactsInSection "Library Build Info:", 
                 "Local library build should reference artifacts path")
         if expectedAppIsLocal then
-            Assert.True((lines |> Array.exists (fun l -> l.Contains("Application") && l.Contains("artifacts"))), 
+            Assert.True(hasArtifactsInSection "Application Build Info:", 
                 "Local app build should reference artifacts path")
         
         // Ensure build verification section is present
diff --git a/tests/projects/CompilerCompat/CompilerCompatApp/CompilerCompatApp.fsproj b/tests/projects/CompilerCompat/CompilerCompatApp/CompilerCompatApp.fsproj
@@ -3,8 +3,6 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>net8.0</TargetFramework>
-    <DirectoryBuildPropsPath Condition="'$(LoadLocalFSharpBuild)' == 'True'">../../../../UseLocalCompiler.Directory.Build.props</DirectoryBuildPropsPath>
-    <DirectoryBuildPropsPath Condition="'$(LoadLocalFSharpBuild)' != 'True'"></DirectoryBuildPropsPath>
   </PropertyGroup>
 
   <ItemGroup>
@@ -13,7 +11,9 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="../CompilerCompatLib/CompilerCompatLib.fsproj" />
+    <!-- Reference the library as a NuGet package instead of a project reference -->
+    <!-- This allows testing cross-compiler scenarios where lib and app use different compilers -->
+    <PackageReference Include="CompilerCompatLib" Version="1.0.0" />
   </ItemGroup>
 
   <Target Name="GenerateAppBuildInfo" BeforeTargets="BeforeCompile">
diff --git a/tests/projects/CompilerCompat/CompilerCompatApp/Program.fs b/tests/projects/CompilerCompat/CompilerCompatApp/Program.fs
@@ -5,17 +5,19 @@ open System
 [<EntryPoint>]
 let main _argv =
     try
+        // Helper to get the actual compiler path (prefer dotnetFscCompilerPath when using local build)
+        let getActualCompilerPath (dotnetPath: string) (fallbackPath: string) =
+            if dotnetPath <> "N/A" && dotnetPath <> "" then dotnetPath else fallbackPath
+        
         // Print detailed build information to verify which compiler was used
         printfn "=== BUILD VERIFICATION ==="
         printfn "Library Build Info:"
         printfn "  SDK Version: %s" LibBuildInfo.sdkVersion
-        printfn "  F# Compiler Path: %s" LibBuildInfo.fsharpCompilerPath
-        printfn "  .NET FSC Compiler Path: %s" LibBuildInfo.dotnetFscCompilerPath
+        printfn "  F# Compiler Path: %s" (getActualCompilerPath LibBuildInfo.dotnetFscCompilerPath LibBuildInfo.fsharpCompilerPath)
         printfn "  Is Local Build: %b" LibBuildInfo.isLocalBuild
         printfn "Application Build Info:"
         printfn "  SDK Version: %s" AppBuildInfo.sdkVersion
-        printfn "  F# Compiler Path: %s" AppBuildInfo.fsharpCompilerPath
-        printfn "  .NET FSC Compiler Path: %s" AppBuildInfo.dotnetFscCompilerPath
+        printfn "  F# Compiler Path: %s" (getActualCompilerPath AppBuildInfo.dotnetFscCompilerPath AppBuildInfo.fsharpCompilerPath)
         printfn "  Is Local Build: %b" AppBuildInfo.isLocalBuild
         printfn "=========================="
         
diff --git a/tests/projects/CompilerCompat/CompilerCompatLib/CompilerCompatLib.fsproj b/tests/projects/CompilerCompat/CompilerCompatLib/CompilerCompatLib.fsproj
@@ -3,15 +3,29 @@
   <PropertyGroup>
     <TargetFramework>net8.0</TargetFramework>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
-    <DirectoryBuildPropsPath Condition="'$(LoadLocalFSharpBuild)' == 'True'">../../../../UseLocalCompiler.Directory.Build.props</DirectoryBuildPropsPath>
-    <DirectoryBuildPropsPath Condition="'$(LoadLocalFSharpBuild)' != 'True'"></DirectoryBuildPropsPath>
+    
+    <!-- Package properties for NuGet pack -->
+    <IsPackable>true</IsPackable>
+    <PackageId>CompilerCompatLib</PackageId>
+    <Version>1.0.0</Version>
+    <Authors>Test</Authors>
+    <Description>Test library for compiler compatibility tests</Description>
   </PropertyGroup>
 
   <ItemGroup>
     <Compile Include="LibBuildInfo.fs" />
     <Compile Include="Library.fs" />
   </ItemGroup>
 
+  <!-- When building with local compiler, include FSharp.Core in the package so consumers can find it -->
+  <ItemGroup Condition="'$(LoadLocalFSharpBuild)' == 'True'">
+    <Content Include="$(LocalFSharpCompilerPath)/artifacts/bin/FSharp.Core/$(LocalFSharpCompilerConfiguration)/netstandard2.0/FSharp.Core.dll">
+      <PackagePath>lib/$(TargetFramework)</PackagePath>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      <Pack>true</Pack>
+    </Content>
+  </ItemGroup>
+
   <Target Name="GenerateLibBuildInfo" BeforeTargets="BeforeCompile">
     <PropertyGroup>
       <IsLocalBuildValue Condition="'$(LoadLocalFSharpBuild)' == 'True'">true</IsLocalBuildValue>
diff --git a/tests/projects/CompilerCompat/Directory.Build.props b/tests/projects/CompilerCompat/Directory.Build.props
@@ -0,0 +1,10 @@
+<Project>
+  <!--
+    Isolated Directory.Build.props for CompilerCompat test projects.
+    Prevents import of repository root's Directory.Build.props for isolated build environments.
+  -->
+  
+  <PropertyGroup>
+    <CompilerCompatTestProject>true</CompilerCompatTestProject>
+  </PropertyGroup>
+</Project>
diff --git a/tests/projects/CompilerCompat/Directory.Build.targets b/tests/projects/CompilerCompat/Directory.Build.targets
