[wasm] Handle pinvokes with function pointers

- For pinvokes with function pointers, *no* declaration is added to
  `pinvoke-table.h`, and a warning is raised:

```
warning : DllImports with function pointers are not supported. Calling them will fail. Managed DllImports:  [/Users/radical/dev/r2/artifacts/bin/Wasm.Build.Tests/net6.0-Release/browser-wasm/g3acrk4b.a0o/variadic_g3acrk4b.a0o.csproj]
warning :    Type: Test, Method: System.Int32 using_sum_one(?) [/Users/radical/dev/r2/artifacts/bin/Wasm.Build.Tests/net6.0-Release/browser-wasm/g3acrk4b.a0o/variadic_g3acrk4b.a0o.csproj]
```

- Also, handle multiple pinvokes with the same number of params, but
  different types

src/tasks/WasmAppBuilder/PInvokeTableGenerator.cs

@@ -122,23 +122,39 @@ private void EmitPInvokeTable(StreamWriter w, Dictionary<string, string> modules
         w.WriteLine();
 
         var decls = new HashSet<string>();
-        // FIXME: handle sigs with different first args
-        foreach (var group in pinvokes.OrderBy(l => l.EntryPoint).GroupBy(l => l.EntryPoint))
+        foreach (var group in pinvokes.GroupBy(l => l.EntryPoint))
         {
-            IEnumerable<string?>? uniqueSigs = group.Select(l => l.Method.ToString()).Distinct();
-            bool treatAsVariadic = uniqueSigs.Count() > 1;
-            if (treatAsVariadic)
+            bool treatAsVariadic = false;
+            PInvoke first = group.First();
+
+            if (!ShouldApplyHackForMethodWithFunctionPointers(first.Method))
             {
-                w.WriteLine($"// Variadic signature created for");
-                foreach (string? method in uniqueSigs)
-                    w.WriteLine($"//   {method}");
+                if (HasFunctionPointerParams(first.Method))
+                {
+                    Log.LogWarning($"DllImports with function pointers are not supported. Calling them will fail. Managed DllImports: {Environment.NewLine}{GroupToString(group)}");
+                    foreach (var pinvoke in group)
+                        pinvoke.Skip = true;
+
+                    continue;
+                }
+
+                int numArgs = first.Method.GetParameters().Length;
+                treatAsVariadic = group.Count() > 1 && group.Any(p => p.Method.GetParameters().Length != numArgs);
+                if (treatAsVariadic)
+                {
+                    w.WriteLine($"// Variadic signature created for");
+                    foreach (PInvoke pinvoke in group)
+                        w.WriteLine($"//   {pinvoke.Method}");
+
+                    Log.LogWarning($"Found a native function ({first.EntryPoint}) with varargs, which is not supported. Calling it will fail at runtime. Module: {first.Module}." +
+                                    $" Managed DllImports: {Environment.NewLine}{GroupToString(group)}");
+                }
             }
 
-            PInvoke pinvoke = group.First();
-            if (modules.ContainsKey(pinvoke.Module)) {
+            if (modules.ContainsKey(first.Module)) {
                 try
                 {
-                    var decl = GenPInvokeDecl(pinvoke, treatAsVariadic);
+                    var decl = GenPInvokeDecl(first, treatAsVariadic);
                     if (decls.Contains(decl))
                         continue;
 
@@ -148,8 +164,8 @@ private void EmitPInvokeTable(StreamWriter w, Dictionary<string, string> modules
                 catch (NotSupportedException)
                 {
                     // See the FIXME in GenPInvokeDecl
-                    Log.LogWarning($"Cannot handle function pointer arguments/return value in pinvoke method '{pinvoke.Method}' in type '{pinvoke.Method.DeclaringType}'.");
-                    pinvoke.Skip = true;
+                    Log.LogWarning($"Cannot handle function pointer arguments/return value in pinvoke method '{first.Method}' in type '{first.Method.DeclaringType}'.");
+                    first.Skip = true;
                 }
             }
         }
@@ -197,6 +213,27 @@ static string ModuleNameToId(string name)
 
             return fixedName;
         }
+
+        static bool HasFunctionPointerParams(MethodInfo method)
+        {
+            try
+            {
+                method.GetParameters();
+            }
+            catch (NotSupportedException nse) when (nse.Message.Contains("function pointer types in signatures is not supported"))
+            {
+                return true;
+            }
+            catch
+            {
+                // not concerned with other exceptions
+            }
+
+            return false;
+        }
+
+        static string GroupToString(IGrouping<string, PInvoke> group)
+            => string.Join(Environment.NewLine, group.Select(p => $"   Type: {p.Method.DeclaringType}, Method: {p.Method}"));
     }
 
     private string MapType (Type t)
@@ -216,11 +253,14 @@ private string MapType (Type t)
             return "int";
     }
 
+    private static bool ShouldApplyHackForMethodWithFunctionPointers(MethodInfo method) => method.Name == "EnumCalendarInfo";
+
     private string GenPInvokeDecl(PInvoke pinvoke, bool treatAsVariadic=false)
     {
         var sb = new StringBuilder();
         var method = pinvoke.Method;
-        if (method.Name == "EnumCalendarInfo") {
+        if (ShouldApplyHackForMethodWithFunctionPointers(method))
+        {
             // FIXME: System.Reflection.MetadataLoadContext can't decode function pointer types
             // https://github.com/dotnet/runtime/issues/43791
             sb.Append($"int {pinvoke.EntryPoint} (int, int, int, int, int);");
@@ -242,6 +282,7 @@ private string GenPInvokeDecl(PInvoke pinvoke, bool treatAsVariadic=false)
         }
         else
         {
+            // FIXME: handle sigs with different first args
             ParameterInfo firstParam = method.GetParameters()[0];
             sb.Append(MapType(firstParam.ParameterType));
             sb.Append(", ...");

src/tests/BuildWasmApps/Wasm.Build.Tests/NativeLibraryTests.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System;
 using System.IO;
 using Xunit;
 using Xunit.Abstractions;
@@ -91,5 +92,93 @@ public static int Main()
 
             Assert.Contains("Size: 26462 Height: 599, Width: 499", output);
         }
+
+        [ConditionalTheory(typeof(BuildTestBase), nameof(IsUsingWorkloads))]
+        [BuildAndRun(host: RunHost.V8)]
+        public void NativeLibraryWithVariadicFunctions(BuildArgs buildArgs, RunHost host, string id)
+        {
+            string projectName = $"variadic_{id}";
+            string code = @"
+using System;
+using System.Runtime.InteropServices;
+public class Test
+{
+    public static int Main(string[] args)
+    {
+        Console.WriteLine($""Main running"");
+        if (args.Length > 0)
+        {
+            // We don't want to run this, because we can't call variadic functions
+            Console.WriteLine($""sum_three: {sum_three(7, 14, 21)}"");
+            Console.WriteLine($""sum_two: {sum_two(3, 6)}"");
+            Console.WriteLine($""sum_one: {sum_one(5)}"");
+        }
+        return 42;
+    }
+
+    [DllImport(""variadic"", EntryPoint=""sum"")] public static extern int sum_one(int a);
+    [DllImport(""variadic"", EntryPoint=""sum"")] public static extern int sum_two(int a, int b);
+    [DllImport(""variadic"", EntryPoint=""sum"")] public static extern int sum_three(int a, int b, int c);
+}";
+            string filename = "variadic.o";
+            buildArgs = buildArgs with { ProjectName = projectName };
+            buildArgs = ExpandBuildArgs(buildArgs, extraItems: $"<NativeFileReference Include=\"{filename}\" />");
+
+            BuildProject(buildArgs,
+                        initProject: () =>
+                        {
+                            File.WriteAllText(Path.Combine(_projectDir!, "Program.cs"), code);
+                            File.Copy(Path.Combine(BuildEnvironment.TestAssetsPath, "native-libs", filename),
+                                        Path.Combine(_projectDir!, filename));
+                        },
+                        publish: false,
+                        id: id,
+                        dotnetWasmFromRuntimePack: false);
+
+            string output = RunAndTestWasmApp(buildArgs, buildDir: _projectDir, expectedExitCode: 42, host: host, id: id);
+            Assert.Contains("Main running", output);
+        }
+
+        [ConditionalTheory(typeof(BuildTestBase), nameof(IsUsingWorkloads))]
+        [BuildAndRun(host: RunHost.V8)]
+        public void DllImportWithFunctionPointersCompilesWithWarning(BuildArgs buildArgs, RunHost host, string id)
+        {
+            string projectName = $"variadic_{id}";
+            string code = @"
+using System;
+using System.Runtime.InteropServices;
+public class Test
+{
+    public static int Main()
+    {
+        Console.WriteLine($""Main running"");
+        return 42;
+    }
+
+    [DllImport(""variadic"", EntryPoint=""sum"")] public unsafe static extern int using_sum_one(delegate* unmanaged<char*, IntPtr, void> callback);
+}";
+            string filename = "variadic.o";
+            buildArgs = buildArgs with { ProjectName = projectName };
+            buildArgs = ExpandBuildArgs(buildArgs, extraItems: $"<NativeFileReference Include=\"{filename}\" />", extraProperties: "<AllowUnsafeBlocks>true</AllowUnsafeBlocks>");
+
+            Console.WriteLine ($"-- args: {buildArgs}, name: {projectName}");
+
+            (_, string output) = BuildProject(buildArgs,
+                                        initProject: () =>
+                                        {
+                                            File.WriteAllText(Path.Combine(_projectDir!, "Program.cs"), code);
+                                            File.Copy(Path.Combine(BuildEnvironment.TestAssetsPath, "native-libs", filename),
+                                                        Path.Combine(_projectDir!, filename));
+                                        },
+                                        publish: false,
+                                        id: id,
+                                        dotnetWasmFromRuntimePack: false);
+
+            Assert.Matches("warning.*function pointers", output);
+            Assert.Matches("warning.*using_sum_one", output);
+
+            output = RunAndTestWasmApp(buildArgs, buildDir: _projectDir, expectedExitCode: 42, host: host, id: id);
+            Assert.Contains("Main running", output);
+        }
     }
 }