Allows the conversion of primses to tasks when pasing an async function as argument

Fixes: #2194

Author: REscobar

Jint.Tests/Runtime/AsyncTests.cs

@@ -155,7 +155,72 @@ public void ShouldTaskAwaitCurrentStack()
         Assert.Equal("123", asyncTestClass.StringToAppend);
     }
 
+    [Fact]
+    public void ShouldCompleteWithAsyncTaskCallbacks()
+    {
+        Engine engine = new(options =>
+        {
+            options.ExperimentalFeatures = ExperimentalFeature.TaskInterop;
+            options.Constraints.PromiseTimeout = TimeSpan.FromMilliseconds(-1);
+        });
+        engine.SetValue("asyncTestMethod", new Func<Func<Task>, Task<string>>(async callback => { await Task.Delay(100); await callback(); return "Hello World"; }));
+        engine.SetValue("asyncWork", new Func<Task>(() => Task.Delay(100)));
+        engine.SetValue("assert", new Action<bool>(Assert.True));
+        var result = engine.Evaluate("async function hello() {return await asyncTestMethod(async () =>{ await asyncWork(); })} hello();");
+        result = result.UnwrapIfPromise();
+        Assert.Equal("Hello World", result);
+    }
+
+    [Fact]
+    public void ShouldFromAsyncTaskCallbacks()
+    {
+        Engine engine = new(options =>
+        {
+            options.ExperimentalFeatures = ExperimentalFeature.TaskInterop;
+            options.Constraints.PromiseTimeout = TimeSpan.FromMilliseconds(-1);
+        });
+        engine.SetValue("asyncTestMethod", new Func<Func<Task<string>>, Task<string>>(async callback => { await Task.Delay(100); return await callback(); }));
+        engine.SetValue("asyncWork", new Func<Task<string>>(async () => { await Task.Delay(100); return "Hello World"; }));
+        engine.SetValue("assert", new Action<bool>(Assert.True));
+        var result = engine.Evaluate("async function hello() {return await asyncTestMethod(async () =>{ return await asyncWork(); })} hello();");
+        result = result.UnwrapIfPromise();
+        Assert.Equal("Hello World", result);
+    }
+
 #if NETFRAMEWORK == false
+
+    [Fact]
+    public void ShouldCompleteWithAsyncValueTaskCallbacks()
+    {
+        Engine engine = new(options =>
+        {
+            options.ExperimentalFeatures = ExperimentalFeature.TaskInterop;
+            options.Constraints.PromiseTimeout = TimeSpan.FromMilliseconds(-1);
+        });
+        engine.SetValue("asyncTestMethod", new Func<Func<ValueTask>, Task<string>>(async callback => { await Task.Delay(100); await callback(); return "Hello World"; }));
+        engine.SetValue("asyncWork", new Func<Task>(() => Task.Delay(100)));
+        engine.SetValue("assert", new Action<bool>(Assert.True));
+        var result = engine.Evaluate("async function hello() {return await asyncTestMethod(async () =>{ await asyncWork(); })} hello();");
+        result = result.UnwrapIfPromise();
+        Assert.Equal("Hello World", result);
+    }
+
+    [Fact]
+    public void ShouldFromAsyncValueTaskCallbacks()
+    {
+        Engine engine = new(options =>
+        {
+            options.ExperimentalFeatures = ExperimentalFeature.TaskInterop;
+            options.Constraints.PromiseTimeout = TimeSpan.FromMilliseconds(-1);
+        });
+        engine.SetValue("asyncTestMethod", new Func<Func<ValueTask<string>>, Task<string>>(async callback => { await Task.Delay(100); return await callback(); }));
+        engine.SetValue("asyncWork", new Func<ValueTask<string>>(async () => { await Task.Delay(100); return "Hello World"; }));
+        engine.SetValue("assert", new Action<bool>(Assert.True));
+        var result = engine.Evaluate("async function hello() {return await asyncTestMethod(async () =>{ return await asyncWork(); })} hello();");
+        result = result.UnwrapIfPromise();
+        Assert.Equal("Hello World", result);
+    }
+
     [Fact]
     public void ShouldValueTaskConvertedToPromiseInJS()
     {

Jint/Native/Object/ObjectInstance.cs

@@ -1022,6 +1022,18 @@ private object ToObject(ObjectTraverseStack stack)
             case ObjectClass.Arguments:
             case ObjectClass.Object:
 
+                if ((Engine.Options.ExperimentalFeatures & ExperimentalFeature.TaskInterop) != ExperimentalFeature.None)
+                {
+                    if (this is JsPromise asPromise)
+                    {
+                        var promsiseResult = asPromise.UnwrapIfPromise(Engine.Options.Constraints.PromiseTimeout);
+
+                        converted = promsiseResult is ObjectInstance oi
+                                    ? oi.ToObject(stack)
+                                    : promsiseResult.ToObject();
+                        break;
+                    }
+                }
                 if (this is JsArray arrayInstance)
                 {
                     var result = new object?[arrayInstance.GetLength()];

Jint/Runtime/Interop/DefaultTypeConverter.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Concurrent;
 using System.Collections.ObjectModel;
 using System.Diagnostics.CodeAnalysis;
@@ -25,12 +26,21 @@ public class DefaultTypeConverter : ITypeConverter
     private readonly record struct TypeConversionKey(Type Source, Type Target);
 
     private static readonly ConcurrentDictionary<TypeConversionKey, MethodInfo?> _knownCastOperators = new();
+    private static readonly ConcurrentDictionary<TypeConversionKey, MethodInfo?> _knownFromResultGenerics = new();
 
     private static readonly Type intType = typeof(int);
     private static readonly Type iCallableType = typeof(JsCallDelegate);
     private static readonly Type jsValueType = typeof(JsValue);
     private static readonly Type objectType = typeof(object);
     private static readonly Type engineType = typeof(Engine);
+    private static readonly Type taskType = typeof(Task);
+    private static readonly Type genTaskType = typeof(Task<>);
+    private static readonly MethodInfo taskFromResultInfo = taskType.GetMethod("FromResult")!;
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP
+    private static readonly Type valueTaskType = typeof(ValueTask);
+    private static readonly Type genValueTaskType = typeof(ValueTask<>);
+    private static readonly MethodInfo valueTaskFromResultInfo = valueTaskType.GetMethod("FromResult")!;
+#endif
 
     private static readonly MethodInfo changeTypeIfConvertible = typeof(DefaultTypeConverter).GetMethod(
         nameof(ChangeTypeOnlyIfConvertible), BindingFlags.NonPublic | BindingFlags.Static)!;
@@ -390,12 +400,58 @@ private LambdaExpression BuildDelegate(
     [return: NotNullIfNotNull(nameof(value))]
     private static object? ChangeTypeOnlyIfConvertible(object? value, Type conversionType, IFormatProvider? provider)
     {
+        if (conversionType == taskType)
+        {
+            return Task.CompletedTask;
+        }
+
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP
+        if (conversionType == valueTaskType)
+        {
+            return default(ValueTask);
+        }
+#endif
+
+        if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition() == genTaskType)
+        {
+            var key = new TypeConversionKey(conversionType.GetGenericArguments()[0], genTaskType);
+            var fromResultMethod = _knownFromResultGenerics.GetOrAdd(key, GetFromResultMethod);
+            if (fromResultMethod != null)
+            {
+                return fromResultMethod.Invoke(null, [value]);
+            }
+        }
+
+#if NETCOREAPP
+        if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition() == genValueTaskType)
+        {
+            var key = new TypeConversionKey(conversionType.GetGenericArguments()[0], genValueTaskType);
+            var fromResultMethod = _knownFromResultGenerics.GetOrAdd(key, GetFromResultMethod);
+            if (fromResultMethod != null)
+            {
+                return fromResultMethod.Invoke(null, [value]);
+            }
+        }
+#endif
+
         if (value == null || value is IConvertible)
             return System.Convert.ChangeType(value, conversionType, provider);
 
         return value;
     }
 
+    private static MethodInfo? GetFromResultMethod(TypeConversionKey key)
+    {
+        var (target, taskType) = key;
+#if NETCOREAPP
+        if (taskType == genValueTaskType)
+        {
+            return valueTaskFromResultInfo.MakeGenericMethod(target);
+        }
+#endif
+        return taskFromResultInfo.MakeGenericMethod(target);
+    }
+
     private static bool TryCastWithOperators(object value, Type type, Type valueType, [NotNullWhen(true)] out object? converted)
     {
         var key = new TypeConversionKey(valueType, type);