Use unsafe casting hack to make runtime async compatible IL

Author: TheAngryByrd

benchmarks/CSharpTaskBenchmarks/CSharpTaskBenchmarks.csproj

@@ -5,7 +5,7 @@
     <Nullable>enable</Nullable>
     <IsPackable>false</IsPackable>
     <EnablePreviewFeatures>true</EnablePreviewFeatures>
-    <!-- <Features>$(Features);runtime-async=on</Features> -->
+    <Features>$(Features);runtime-async=on</Features>
     <NoWarn>$(NoWarn);SYSLIB5007</NoWarn>
   </PropertyGroup>
 </Project>

benchmarks/FSharpBenchmarks/AsynchonousCompletionBenchmark.fs

@@ -11,6 +11,7 @@ open System.Threading.Tasks
 open IcedTasks
 
 open System.IO
+open System.Runtime.CompilerServices
 
 
 [<AutoOpen>]
@@ -83,6 +84,9 @@ module AsyncHelpers =
             return 100
         }
 #if NET10_0_OR_GREATER
+    [<MethodImpl(MethodImplOptions.Async)>]
+
+    // [<MethodImpl(8192s)>]
     let fsharp_tenBindAsync_TaskBuilderRuntime () =
         IcedTasks.Polyfill.TasksRuntime.TaskBuilder.task {
             do! taskYield ()

examples/ILSpySamples-CSharp/Program.cs

@@ -2,13 +2,13 @@
 
 
 // See https://aka.ms/new-console-template for more information
-Console.WriteLine("Hello, World!");
+Console.WriteLine(Thingy.DoThingAsync().GetAwaiter().GetResult());
 
 
 
 public class Thingy
 {
-    public async Task<int> DoThingAsync()
+    public static async Task<int> DoThingAsync()
     {
         await Task.Yield();
         return 42;

examples/ILSpySamples/Library.fs

@@ -3,7 +3,6 @@
 open System.Threading.Tasks
 open System.Collections.Generic
 
-
 module TaskRuntime =
     open IcedTasks.Polyfill.TasksRuntime
     open System.Runtime.CompilerServices
@@ -77,3 +76,6 @@ module Main =
 
     let main _argv =
         TaskRuntime.doThing().GetAwaiter().GetResult()
+        |> printfn "Result: %d"
+
+        0

src/IcedTasks/TaskBuilderBase_Net10.fs

@@ -7,6 +7,9 @@ open System.Runtime.CompilerServices
 open Microsoft.FSharp.Core.CompilerServices
 open System.Collections.Generic
 open System.Threading
+open System
+
+#nowarn "42"
 
 module internal AsyncHelpers =
 
@@ -19,6 +22,43 @@ module internal AsyncHelpers =
     let inline awaitAwaitable awaiter =
         awaitAwaiter (Awaitable.GetAwaiter awaiter)
 
+    (*
+A big comment explaining the unsafe cast hack
+
+Typically, F# would want to generate IL like this for returning a Task<int> from a method:
+
+  .method public static class [System.Runtime]System.Threading.Tasks.Task`1<int32> 
+          fsharp_tenBindAsync_TaskBuilderRuntime() cil managed async
+  
+    ... stuff in between
+
+
+    IL_01e2:  call       class [System.Runtime]System.Threading.Tasks.Task`1<!!0> [System.Runtime]System.Threading.Tasks.Task::FromResult<int32>(!!0)
+    IL_01e7:  ret
+
+However as noted in https://github.com/dotnet/runtime/blob/main/docs/design/specs/runtime-async.md
+
+> Async methods also do not have matching return type conventions as sync methods. For sync methods, 
+> the stack should contain a value convertible to the stated return type before the ret instruction. 
+> For async methods, the stack should be empty in the case of Task or ValueTask, or the type argument in the case of Task<T> or ValueTask<T>.
+
+Which means we can't return a Task<int> in the IL, we need to return int directly from the async method.
+To achieve this, we use an unsafe cast hack to cast the int directly to Task<int> to make the compiler happy and emit the correct IL.
+
+With this as the return value, the IL generated is:
+
+    IL_0044:  call       instance !0 valuetype [System.Runtime]System.Runtime.CompilerServices.ValueTaskAwaiter`1<int32>::GetResult()
+    IL_0049:  ret
+
+We have the ValueTask because of either .Return or .Zero returning a ValueTask
+
+*)
+
+    module internal Unsafe =
+        let inline cast<'a, 'b> (a: 'a) : 'b =
+
+            (# "" a : 'b #)
+
 type TaskBuilderBaseRuntime() =
 
     member inline _.Return(value: 'T) =
@@ -195,7 +235,7 @@ type TaskBuilderRuntime() =
 
     member inline this.Run([<InlineIfLambda>] f: unit -> 'a) : Task<'T> =
         AsyncHelpers.awaitAwaiter (f ())
-        |> Task.FromResult
+        |> AsyncHelpers.Unsafe.cast
 
     /// Used to force type inference to prefer Task<_> for parameters of functions using the build
     member inline _.Source(task: Task<'T>) = Awaitable.GetTaskAwaiter task
@@ -212,9 +252,11 @@ type BackgroundTaskBuilderRuntime() =
             && obj.ReferenceEquals(TaskScheduler.Current, TaskScheduler.Default)
         then
             AsyncHelpers.awaitAwaiter (f ())
-            |> Task.FromResult
+            |> AsyncHelpers.Unsafe.cast
         else
-            Task.Run<'T>(fun () -> AsyncHelpers.awaitAwaiter (f ()))
+            Task.Run<'T>(Func<'T>(fun () -> AsyncHelpers.awaitAwaiter (f ()))).GetAwaiter()
+            |> AsyncHelpers.awaitAwaiter
+            |> AsyncHelpers.Unsafe.cast
 
 
     /// Used to force type inference to prefer Task<_> for parameters of functions using the build
@@ -226,7 +268,7 @@ type ValueTaskBuilderRuntime() =
 
     member inline this.Run([<InlineIfLambda>] f) : ValueTask<'T> =
         AsyncHelpers.awaitAwaiter (f ())
-        |> ValueTask.FromResult
+        |> AsyncHelpers.Unsafe.cast
 
 
     /// Used to force type inference to prefer ValueTask<_> for parameters of functions using the build