Merge 'main' and resolve conflicts.

Author: kpreisser

src/Function.FromCallback.cs

@@ -155,7 +155,7 @@ for (int hasCaller = 0; hasCaller < 2; hasCaller++)
             var parameterKinds = new List<ValueKind>();
             var resultKinds = new List<ValueKind>();
 
-            using var funcType = Function.GetFunctionType(callback.GetType(), parameterKinds, resultKinds, allowCaller: <#= (hasCaller > 0) ? "true" : "false" #>, allowTuple: <#= (resultCount > 1) ? "true" : "false" #>, out var hasCaller);
+            using var funcType = Function.GetFunctionType(callback.GetType(), parameterKinds, resultKinds, allowCaller: <#= (hasCaller > 0) ? "true" : "false" #>, allowTuple: <#= (resultCount > 1) ? "true" : "false" #>, out _, out _);
 
 <#= parameterConverters
 #>

src/Function.FromCallback.tt

@@ -35,14 +35,15 @@ public static Function FromCallback(IStore store, Delegate callback)
             var parameterKinds = new List<ValueKind>();
             var resultKinds = new List<ValueKind>();
 
-            using var funcType = GetFunctionType(callback.GetType(), parameterKinds, resultKinds, allowCaller: true, allowTuple: true, out var hasCaller);
+            using var funcType = GetFunctionType(callback.GetType(), parameterKinds, resultKinds, allowCaller: true, allowTuple: true, out var hasCaller, out var returnsTuple);
+            var callbackInvokeMethod = callback.GetType().GetMethod(nameof(Action.Invoke))!;
 
             unsafe
             {
                 Native.WasmtimeFuncCallback? func = (env, callerPtr, args, nargs, results, nresults) =>
                 {
                     using var caller = new Caller(callerPtr);
-                    return InvokeCallback(callback, caller, hasCaller, args, (int)nargs, results, (int)nresults, resultKinds);
+                    return InvokeCallback(callback, callbackInvokeMethod, caller, hasCaller, args, (int)nargs, results, (int)nresults, resultKinds, returnsTuple);
                 };
 
                 Native.wasmtime_func_new(
@@ -1800,32 +1801,42 @@ private Function(IStore store, ExternFunc func, List<ValueKind> parameters, List
             this.results = results;
         }
 
-        private static IEnumerable<Type> EnumerateReturnTypes(Type? returnType)
+        private static IEnumerable<Type> EnumerateReturnTypes(Type? returnType, out bool isTuple)
         {
+            isTuple = false;
+
             if (returnType is null)
             {
-                yield break;
+                return Array.Empty<Type>();
             }
 
             if (IsTuple(returnType))
             {
-                foreach (var type in returnType
-                    .GetGenericArguments()
-                    .SelectMany(type =>
+                isTuple = true;
+                return EnumerateTupleTypes(returnType);
+
+                static IEnumerable<Type> EnumerateTupleTypes(Type tupleType)
+                {
+                    foreach (var (typeArgument, idx) in tupleType.GenericTypeArguments.Select((e, idx) => (e, idx)))
+                    {
+                        if (idx is 7 && IsTuple(typeArgument))
                         {
-                            if (type.IsConstructedGenericType)
+                            // Recursively enumerate the nested tuple's type arguments.
+                            foreach (var type in EnumerateTupleTypes(typeArgument))
                             {
-                                return type.GenericTypeArguments;
+                                yield return type;
                             }
-                            return Enumerable.Repeat(type, 1);
-                        }))
-                {
-                    yield return type;
+                        }
+                        else
+                        {
+                            yield return typeArgument;
+                        }
+                    }
                 }
             }
             else
             {
-                yield return returnType;
+                return new Type[] { returnType };
             }
         }
 
@@ -1849,7 +1860,7 @@ private static bool IsTuple(Type type)
                    definition == typeof(ValueTuple<,,,,,,,>);
         }
 
-        internal static TypeHandle GetFunctionType(Type type, List<ValueKind> parameters, List<ValueKind> results, bool allowCaller, bool allowTuple, out bool hasCaller)
+        internal static TypeHandle GetFunctionType(Type type, List<ValueKind> parameters, List<ValueKind> results, bool allowCaller, bool allowTuple, out bool hasCaller, out bool returnsTuple)
         {
             if (!typeof(Delegate).IsAssignableFrom(type))
                 throw new ArgumentException("The specified type must be a Delegate type.");
@@ -1886,7 +1897,7 @@ internal static TypeHandle GetFunctionType(Type type, List<ValueKind> parameters
                 parameters.Add(kind);
             }
 
-            results.AddRange(EnumerateReturnTypes(returnType).Select(t =>
+            results.AddRange(EnumerateReturnTypes(returnType, out returnsTuple).Select(t =>
             {
                 if (!Value.TryGetKind(t, out var kind))
                 {
@@ -1895,16 +1906,15 @@ internal static TypeHandle GetFunctionType(Type type, List<ValueKind> parameters
                 return kind;
             }));
 
-            // TODO: Once PR #161 is merged, uncomment this
-            //if (returnsTuple &&!allowTuple)
-            //{
-            //    throw new ArgumentException("Use a different overload that implicitly returns ValueTuple.");
-            //}
+            if (returnsTuple && !allowTuple)
+            {
+                throw new ArgumentException("Use a different overload that implicitly returns ValueTuple.");
+            }
 
             return new Function.TypeHandle(Function.Native.wasm_functype_new(new ValueTypeArray(parameters), new ValueTypeArray(results)));
         }
 
-        internal unsafe static IntPtr InvokeCallback(Delegate callback, Caller caller, bool passCaller, Value* args, int nargs, Value* results, int nresults, IReadOnlyList<ValueKind> resultKinds)
+        internal unsafe static IntPtr InvokeCallback(Delegate callback, MethodInfo callbackInvokeMethod, Caller caller, bool passCaller, Value* args, int nargs, Value* results, int nresults, IReadOnlyList<ValueKind> resultKinds, bool returnsTuple)
         {
             try
             {
@@ -1924,23 +1934,21 @@ internal unsafe static IntPtr InvokeCallback(Delegate callback, Caller caller, b
 
                 // NOTE: reflection is extremely slow for invoking methods. in the future, perhaps this could be replaced with
                 // source generators, system.linq.expressions, or generate IL with DynamicMethods or something
-                var result = callback.Method.Invoke(callback.Target, BindingFlags.DoNotWrapExceptions, null, invokeArgs, null);
+                var result = callbackInvokeMethod.Invoke(callback, BindingFlags.DoNotWrapExceptions, null, invokeArgs, null);
 
-                if (resultKinds.Count > 0)
+                if (returnsTuple)
                 {
-                    var tuple = result as ITuple;
-                    if (tuple is null)
+                    var tuple = (ITuple)result!;
+
+                    for (int i = 0; i < tuple.Length; ++i)
                     {
-                        results[0] = Value.FromObject(result, resultKinds[0]);
-                    }
-                    else
-                    {
-                        for (int i = 0; i < tuple.Length; ++i)
-                        {
-                            results[i] = Value.FromObject(tuple[i], resultKinds[i]);
-                        }
+                        results[i] = Value.FromObject(tuple[i], resultKinds[i]);
                     }
                 }
+                else if (resultKinds.Count == 1)
+                {
+                    results[0] = Value.FromObject(result, resultKinds[0]);
+                }
                 return IntPtr.Zero;
             }
             catch (Exception ex)