Add compiler compatibility test suite for anonymous records with MSBuild-generated build verification

docs/release-notes/.FSharp.Compiler.Service/10.0.100.md

@@ -6,6 +6,7 @@
 * Diagnostics: add extended data for 'No constructors' error ([PR #18863](https://github.com/dotnet/fsharp/pull/18863))
 * FSharpType.Format: support top-level prefix generic types style. ([PR #18897](https://github.com/dotnet/fsharp/pull/18897))
 * FCS: allow getting captured types ([PR $18878](https://github.com/dotnet/fsharp/pull/18878))
+* Add compiler compatibility test suite to verify anonymous records work across different F# compiler versions. Test projects under tests/projects/CompilerCompat verify backward and forward compatibility scenarios.
 
 ### Fixed
 

tests/FSharp.Compiler.ComponentTests/CompilerCompatibilityTests.fs

@@ -0,0 +1,113 @@
+module FSharp.Compiler.ComponentTests.CompilerCompatibilityTests
+
+open System
+open System.IO
+open Xunit
+open FSharp.Test
+open FSharp.Test.Assert
+open TestFramework
+
+type CompilerCompatibilityTests() =
+
+    let projectsPath = Path.GetFullPath(Path.Combine(__SOURCE_DIRECTORY__, "../projects/CompilerCompat"))
+    let libProjectPath = Path.Combine(projectsPath, "CompilerCompatLib")
+    let appProjectPath = Path.Combine(projectsPath, "CompilerCompatApp")
+
+    let runDotnetBuild projectPath useLocalCompiler =
+        let args = 
+            if useLocalCompiler then
+                "build -c Release -p:LoadLocalFSharpBuild=True"
+            else
+                "build -c Release"
+
+        let (exitCode, output, error) = Commands.executeProcess "dotnet" args projectPath
+
+        if exitCode <> 0 then
+            let outputStr = String.concat "\n" output
+            let errorStr = String.concat "\n" error
+            failwith $"Build failed with exit code {exitCode}. Output: {outputStr}. Error: {errorStr}"
+
+        String.concat "\n" output
+
+    let runApp appBinaryPath =
+        let (exitCode, output, error) = Commands.executeProcess "dotnet" appBinaryPath (Path.GetDirectoryName(appBinaryPath))
+        (exitCode, String.concat "\n" output, String.concat "\n" error)
+
+    let cleanBinObjDirectories projectPath =
+        let binPath = Path.Combine(projectPath, "bin")
+        let objPath = Path.Combine(projectPath, "obj")
+
+        if Directory.Exists(binPath) then
+            Directory.Delete(binPath, true)
+        if Directory.Exists(objPath) then
+            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")
+
+    [<Fact>]
+    member _.``Baseline scenario - Both library and app built with local compiler``() =
+        // Clean previous builds
+        cleanBinObjDirectories libProjectPath
+        cleanBinObjDirectories appProjectPath
+
+        // Build library with local compiler
+        let libOutput = runDotnetBuild libProjectPath true
+        Assert.Contains("CompilerCompatLib -> ", libOutput)
+
+        // Build app with local compiler
+        let appOutput = runDotnetBuild appProjectPath true
+        Assert.Contains("CompilerCompatApp -> ", appOutput)
+
+        // Run app and verify it works
+        let appDllPath = getAppDllPath()
+        Assert.True(File.Exists(appDllPath), $"App DLL not found at {appDllPath}")
+
+        let (exitCode, output, _error) = runApp appDllPath
+        Assert.Equal(0, exitCode)
+        Assert.Contains("✓ All compiler compatibility tests passed", output)
+
+    [<Fact>]
+    member _.``Forward compatibility - Library built with SDK compiler, app with local compiler``() =
+        // Clean previous builds
+        cleanBinObjDirectories libProjectPath
+        cleanBinObjDirectories appProjectPath
+
+        // Build library with SDK compiler
+        let libOutput = runDotnetBuild libProjectPath false
+        Assert.Contains("CompilerCompatLib -> ", libOutput)
+
+        // Build app with local compiler (should use the library built with SDK compiler)
+        let appOutput = runDotnetBuild appProjectPath true  
+        Assert.Contains("CompilerCompatApp -> ", appOutput)
+
+        // Run app and verify it works
+        let appDllPath = getAppDllPath()
+        Assert.True(File.Exists(appDllPath), $"App DLL not found at {appDllPath}")
+
+        let (exitCode, output, _error) = runApp appDllPath
+        Assert.Equal(0, exitCode)
+        Assert.Contains("✓ All compiler compatibility tests passed", output)
+
+    [<Fact>]  
+    member _.``Backward compatibility - Library built with local compiler, app with SDK compiler``() =
+        // Clean previous builds
+        cleanBinObjDirectories libProjectPath
+        cleanBinObjDirectories appProjectPath
+
+        // Build library with local compiler
+        let libOutput = runDotnetBuild libProjectPath true
+        Assert.Contains("CompilerCompatLib -> ", libOutput)
+
+        // Build app with SDK compiler (should use the library built with local compiler)
+        let appOutput = runDotnetBuild appProjectPath false
+        Assert.Contains("CompilerCompatApp -> ", appOutput)
+
+        // Run app and verify it works
+        let appDllPath = getAppDllPath()
+        Assert.True(File.Exists(appDllPath), $"App DLL not found at {appDllPath}")
+
+        let (exitCode, output, _error) = runApp appDllPath
+        Assert.Equal(0, exitCode)
+        Assert.Contains("✓ All compiler compatibility tests passed", output)

tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj

@@ -352,6 +352,7 @@
     <Compile Include="FSharpChecker\SymbolUse.fs" />
     <Compile Include="FSharpChecker\FindReferences.fs" />
     <Compile Include="Attributes\AttributeCtorSetPropAccess.fs" />
+    <Compile Include="CompilerCompatibilityTests.fs" />
   </ItemGroup>
 
   <ItemGroup>

tests/projects/CompilerCompat/CompilerCompatApp/CompilerCompatApp.fsproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../CompilerCompatLib/CompilerCompatLib.fsproj" />
+  </ItemGroup>
+
+</Project>

tests/projects/CompilerCompat/CompilerCompatApp/Program.fs

@@ -0,0 +1,37 @@
+open CompilerCompatLib
+open System
+
+[<EntryPoint>]
+let main _argv =
+    try
+        // Test basic anonymous record functionality
+        let record = Library.getAnonymousRecord()
+        printfn "Basic record: X=%d, Y=%s" record.X record.Y
+
+        // Verify expected values
+        if record.X <> 42 || record.Y <> "hello" then
+            printfn "ERROR: Basic record values don't match expected"
+            1
+        else
+            printfn "✓ Basic record test passed"
+
+            // Test complex anonymous record functionality
+            let complex = Library.getComplexAnonymousRecord()
+            printfn "Complex record: Simple.A=%d, Simple.B=%s" complex.Simple.A complex.Simple.B
+            printfn "Complex record: List has %d items" complex.List.Length
+            printfn "Complex record: Tuple=(%d, Value=%f)" (fst complex.Tuple) (snd complex.Tuple).Value
+
+            // Test function that takes anonymous record
+            let processed = Library.processAnonymousRecord({| X = 123; Y = "test" |})
+            printfn "Processed result: %s" processed
+
+            if processed = "Processed: X=123, Y=test" then
+                printfn "✓ All compiler compatibility tests passed"
+                0
+            else
+                printfn "ERROR: Processed result doesn't match expected"
+                1
+
+    with ex ->
+        printfn "ERROR: Exception occurred: %s" ex.Message
+        1

tests/projects/CompilerCompat/CompilerCompatApp/commandline.txt

@@ -0,0 +1,2 @@
+cd /home/runner/work/fsharp/fsharp/tests/projects/CompilerCompat/CompilerCompatApp
+dotnet build -c Release -p:LoadLocalFSharpBuild=True /bl

tests/projects/CompilerCompat/CompilerCompatLib/CompilerCompatLib.fsproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="Library.fs" />
+  </ItemGroup>
+
+</Project>

tests/projects/CompilerCompat/CompilerCompatLib/Library.fs

@@ -0,0 +1,17 @@
+namespace CompilerCompatLib
+
+module Library =
+    /// Returns an anonymous record to test compiler compatibility
+    let getAnonymousRecord () = {| X = 42; Y = "hello" |}
+
+    /// Returns a more complex anonymous record with nested structure
+    let getComplexAnonymousRecord () = 
+        {| 
+            Simple = {| A = 1; B = "test" |};
+            List = [ {| Id = 1; Name = "first" |}; {| Id = 2; Name = "second" |} ];
+            Tuple = (42, {| Value = 3.14; Label = "pi" |})
+        |}
+
+    /// Function that takes an anonymous record as parameter
+    let processAnonymousRecord (record: {| X: int; Y: string |}) =
+        sprintf "Processed: X=%d, Y=%s" record.X record.Y

tests/projects/CompilerCompat/CompilerCompatLib/commandline.txt

@@ -0,0 +1,2 @@
+cd /home/runner/work/fsharp/fsharp/tests/projects/CompilerCompat/CompilerCompatLib
+dotnet build -c Release -p:LoadLocalFSharpBuild=True /bl