Merge branch 'main' into allow-and-bang-typed-bindings

Author: edgarfgp

.github/workflows/commands.yml

@@ -5,12 +5,11 @@ on:
     types: [created]
 
 jobs:
-  # This first job by definiton runs user-supplied code - you must NOT elevate its permissions to `write`
-  # Malicious code could change nuget source URL, build targets or even compiler itself to pass a GH token
-  # And use it to create branches, spam issues etc. Any write-actions happen in the second job, which does not allow
-  # user extension points (i.e. plain scripts, must NOT run scripts from within checked-out code)
-  detect-and-run:
+  parsing_job:
     runs-on: ubuntu-latest
+    permissions:
+      issues: write  # Allow adding a reaction via the comment-pipeline
+      pull-requests: write
     outputs:
       command: ${{ steps.parse.outputs.command }}
       arg: ${{ steps.parse.outputs.arguments }}
@@ -28,11 +27,20 @@ jobs:
             /run test-baseline
           github-token: ${{ secrets.GITHUB_TOKEN }}
 
+  # This second job by definiton runs user-supplied code - you must NOT elevate its permissions to `write`
+  # Malicious code could change nuget source URL, build targets or even compiler itself to pass a GH token
+  # And use it to create branches, spam issues etc. Any write-actions happen in the second job, which does not allow
+  # user extension points (i.e. plain scripts, must NOT run scripts from within checked-out code)
+  run-parsed-command:
+    needs: parsing_job
+    runs-on: ubuntu-latest
+    if: needs.parsing_job.outputs.command != ''
+    steps:
+
       - name: Checkout the repository
         uses: actions/checkout@v4
 
       - name: Checkout PR branch
-        if: ${{ steps.parse.outputs.command }}
         run: gh auth setup-git && gh pr checkout ${{ github.event.issue.number }}
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -46,7 +54,7 @@ jobs:
         run: dotnet tool restore
 
       - name: Setup .NET 9.0.0 Runtime for test execution
-        if: ${{ steps.parse.outputs.command == '/run test-baseline' }}
+        if: ${{ needs.parsing_job.outputs.command == '/run test-baseline' }}
         uses: actions/setup-dotnet@v4
         with:
           dotnet-version: '9.0.x'
@@ -57,17 +65,17 @@ jobs:
           TEST_UPDATE_BSL: 1
         continue-on-error: true
         run: |
-          case "${{ steps.parse.outputs.command }}" in
+          case "${{ needs.parsing_job.outputs.command }}" in
             "/run fantomas") dotnet fantomas . ;;
             "/run xlf") dotnet build src/Compiler /t:UpdateXlf ;;
             "/run ilverify") pwsh tests/ILVerify/ilverify.ps1 ;;
-            "/run test-baseline") dotnet test ./FSharp.Compiler.Service.sln --filter "${{ steps.parse.outputs.arguments }}" -c Release || true ;;
+            "/run test-baseline") dotnet test ./FSharp.Compiler.Service.sln --filter "${{ needs.parsing_job.outputs.arg }}" -c Release || true ;;
             *) echo "Unknown command" && exit 1 ;;
           esac
 
       - name: Create patch & metadata
         id: meta
-        if: steps.parse.outputs.command
+        if: needs.parsing_job.outputs.command
         run: |
           echo "run_step_outcome=${{ steps.run-cmd.outcome }}" > result
           if [[ "${{ steps.run-cmd.outcome }}" == "success" ]]; then
@@ -87,12 +95,12 @@ jobs:
             result
 
   apply-and-report:
-    needs: detect-and-run
+    needs: [parsing_job, run-parsed-command]
     runs-on: ubuntu-latest
     permissions:
       contents: write
       pull-requests: write
-    if: needs.detect-and-run.outputs.command != ''
+    if: needs.parsing_job.outputs.command != '' && needs.run-parsed-command.result == 'success'
     steps:
       - name: Checkout the repository
         uses: actions/checkout@v4
@@ -121,7 +129,7 @@ jobs:
           git config user.name "GH Actions"
           git config user.email "actions@github.com"          
           git add -u
-          git commit -m "Apply patch from ${{ needs.detect-and-run.outputs.command }}"
+          git commit -m "Apply patch from ${{ needs.parsing_job.outputs.command }}"
           upstream=$(git rev-parse --abbrev-ref --symbolic-full-name @{u})
           remote=${upstream%%/*}
           branch=${upstream#*/}
@@ -140,7 +148,7 @@ jobs:
       - name: Generate and publish report
         if: always()
         env:
-          COMMAND: ${{ needs.detect-and-run.outputs.command }}
+          COMMAND: ${{ needs.parsing_job.outputs.command }}
           OUTCOME: ${{ steps.read-meta.outputs.run_step_outcome }}
           PATCH: ${{ steps.read-meta.outputs.hasPatch }}
         run: |

src/Compiler/Facilities/LanguageFeatures.fs

@@ -236,10 +236,10 @@ type LanguageVersion(versionText) =
                 LanguageFeature.BetterAnonymousRecordParsing, languageVersion100
                 LanguageFeature.ScopedNowarn, languageVersion100
                 LanguageFeature.AllowTypedLetUseAndBang, languageVersion100
+                LanguageFeature.UnmanagedConstraintCsharpInterop, languageVersion100
                 LanguageFeature.AllowAccessModifiersToAutoPropertiesGettersAndSetters, languageVersion100
 
                 // F# preview (still preview in 10.0)
-                LanguageFeature.UnmanagedConstraintCsharpInterop, previewVersion // not enabled because: https://github.com/dotnet/fsharp/issues/17509
                 LanguageFeature.FromEndSlicing, previewVersion // Unfinished features --- needs work
             ]
 

src/Compiler/TypedTree/TypedTreeOps.fs

@@ -9970,6 +9970,7 @@ let isCompiledOrWitnessPassingConstraint (g: TcGlobals) cx =
       | TyparConstraint.IsNonNullableStruct _ 
       | TyparConstraint.IsReferenceType _
       | TyparConstraint.RequiresDefaultConstructor _
+      | TyparConstraint.IsUnmanaged _ //  implies "struct" and also causes a modreq
       | TyparConstraint.CoercesTo _ -> true
       | TyparConstraint.MayResolveMember _ when g.langVersion.SupportsFeature LanguageFeature.WitnessPassing -> true
       | _ -> false

tests/FSharp.Compiler.ComponentTests/Conformance/Constraints/Unmanaged.fs

@@ -471,21 +471,72 @@ printf "%s" (CsharpStruct<int>.Hi<MultiCaseUnion>())
     IL_0000:  ret
   } """]
 
-    [<Fact>]
-    let ``FSharp does not generate modreq for VBNET to consume in v7`` () = 
+    [<FactForNETCOREAPP>]
+    let ``FSharp generates modreq for CSharp to consume in v9`` () = 
         Fsx "let testMyFunction (x: 'TUnmanaged when 'TUnmanaged : unmanaged) = ()"
-        |> withLangVersion70
+        |> withLangVersion10
         |> compile
         |> shouldSucceed
         |> verifyIL ["""
-      .method public static void  testMyFunction<TUnmanaged>(!!TUnmanaged x) cil managed
+      .method public static void  testMyFunction<valuetype (class [runtime]System.ValueType modreq([runtime]System.Runtime.InteropServices.UnmanagedType)) TUnmanaged>(!!TUnmanaged x) cil managed
   {
+    .param type TUnmanaged 
+      .custom instance void [runtime]System.Runtime.CompilerServices.IsUnmanagedAttribute::.ctor() = ( 01 00 00 00 ) 
     
     .maxstack  8
     IL_0000:  ret
   } """]
 
 
+    [<Fact>]
+    let ``Unmanaged constraint in lambda reproduces issue 17509`` () = 
+        // This test reproduces the issue https://github.com/dotnet/fsharp/issues/17509
+        // When UnmanagedConstraintCsharpInterop is enabled, it generates invalid IL
+        // causing a TypeLoadException at runtime
+        Fsx """
+open System
+
+let printTypeConstraintsNative<'T when 'T : unmanaged> () = printf $"Hello: {typeof<'T>.FullName} is unmanaged"
+
+let Main() =
+    let func (x:int) : 'T when 'T : unmanaged = Unchecked.defaultof<'T>
+    let initFinite = Seq.init<nativeint> 3 func
+    printf "%A" initFinite
+ 
+printTypeConstraintsNative<nativeint>()
+Main()
+        """
+        |> withLangVersionPreview
+        |> asExe
+        |> compileAndRun
+        |> shouldSucceed
+        |> verifyOutput "Hello: System.IntPtr is unmanagedseq [0n; 0n; 0n]"
+
+    [<FactForNETCOREAPP>]
+    let ``Unmanaged constraint in lambda generates invalid IL for Specialize method with preview version`` () = 
+        Fsx """
+let Main() =
+    let func (x:int) : 'T when 'T : unmanaged = Unchecked.defaultof<'T>
+    let initFinite = Seq.init<nativeint> 3 func
+    printfn "%A" initFinite
+Main()
+        """
+        |> withLangVersionPreview
+        |> asExe
+        |> compile
+        |> shouldSucceed
+        |> verifyIL ["""
+    .method assembly strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.FSharpFunc`2<int32,!!T> DirectInvoke<valuetype (class [runtime]System.ValueType modreq([runtime]System.Runtime.InteropServices.UnmanagedType)) T>() cil managed
+    {
+      .param type T 
+        .custom instance void [runtime]System.Runtime.CompilerServices.IsUnmanagedAttribute::.ctor() = ( 01 00 00 00 ) 
+      
+      .maxstack  8
+      IL_0000:  ldsfld     class Test/'func@3-1'<!0> class Test/'func@3-1'<!!T>::@_instance
+      IL_0005:  ret
+    } """]
+
+
     [<Fact>]
     let ``C# can consume F#-defined struct with unmanaged constraint - valid`` () =
         let fsharpLib =