Resolved CustomFunc delegate problems in params registration.

Author: Sergey-Vlasov

Source/ExcelDna.Integration/Registration/ParamsRegistration.cs

@@ -144,8 +144,8 @@ static LambdaExpression WrapMethodParams(LambdaExpression functionLambda)
              * 
              */
 
-            int maxArguments = 125; // Constrained by 255 char registration string, take off 3 type chars, use up to 2 chars per param (before we start doing object...) (& also return)
-                                    // CONSIDER: Might improve this if we generate the delegate based on the max length...
+            int maxArguments = NativeAOT.IsActive ? 16 : 125; // Constrained by 255 char registration string, take off 3 type chars, use up to 2 chars per param (before we start doing object...) (& also return)
+                                                              // CONSIDER: Might improve this if we generate the delegate based on the max length...
 
             var normalParams = functionLambda.Parameters.Take(functionLambda.Parameters.Count() - 1).ToList();
             var normalParamCount = normalParams.Count;
@@ -210,13 +210,19 @@ static LambdaExpression WrapMethodParams(LambdaExpression functionLambda)
             if (maxArguments == 125)
             {
                 delegateType = typeof(CustomFunc125<,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,>)
-                                    .MakeGenericType(allParamTypes.ToArray());
+                .MakeGenericType(allParamTypes.ToArray());
             }
-            else // if (maxArguments == 29)
+            else if (maxArguments == 29)
             {
                 delegateType = typeof(CustomFunc29<,,,,,,,,,,,,,,,,,,,,,,,,,,,,,>)
                                     .MakeGenericType(allParamTypes.ToArray());
             }
+            else // if (maxArguments == 16)
+            {
+                delegateType = typeof(Func<,,,,,,,,,,,,,,,,>)
+                                    .MakeGenericType(allParamTypes.ToArray());
+            }
+
             return Expression.Lambda(delegateType, blockExpr, allParamExprs);
         }
     }

Source/ExcelDna.SourceGenerator.NativeAOT/Generator.cs

@@ -81,12 +81,14 @@ public static short Initialize(void* xlAddInExportInfoAddress, void* hModuleXll,
                     {
                         functions += $"typeRefs.Add(typeof(Func<object, {Util.GetFullTypeName(p.Type)}>));\r\n";
                     }
-                    functions += "\r\n";
 
                     if (i.Parameters.Length > 0 && i.Parameters.Last().IsParams && i.Parameters.Last().Type is IArrayTypeSymbol arrayType)
                     {
                         methods += $"methodRefs.Add(typeof(List<{Util.GetFullTypeName(arrayType.ElementType)}>).GetMethod(\"ToArray\")!);\r\n";
+                        functions += $"typeRefs.Add(typeof(Func<{Util.CreateFunc16Args(i)}>));\r\n";
                     }
+
+                    functions += "\r\n";
                 }
                 source = source.Replace("[FUNCTIONS]", functions + methods);
             }

Source/ExcelDna.SourceGenerator.NativeAOT/Util.cs

@@ -39,6 +39,19 @@ public static string MethodType(IMethodSymbol method)
                 $"Func<{(string.IsNullOrWhiteSpace(parameters) ? null : $"{parameters}, ")}{GetFullTypeName(method.ReturnType)}>";
         }
 
+        public static string CreateFunc16Args(IMethodSymbol method)
+        {
+            List<ITypeSymbol?> allParamTypes = method.Parameters.Take(method.Parameters.Length - 1).Select(p => p.Type).Cast<ITypeSymbol?>().ToList();
+            var toAdd = 16 - allParamTypes.Count;
+            for (int i = 0; i < toAdd; i++)
+            {
+                allParamTypes.Add(null);
+            }
+            allParamTypes.Add(method.ReturnType);
+
+            return string.Join(",", allParamTypes.Select(i => i == null ? "object" : GetFullTypeName(i)));
+        }
+
         private static SymbolDisplayFormat FullNameFormat = new SymbolDisplayFormat(typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces);
     }
 }

Source/Tests/ExcelDna.AddIn.RuntimeTestsAOT/Functions.cs

@@ -141,5 +141,38 @@ public static string NativeStringArray2D(string[,] s)
 
             return $"Native StringArray2D VALS: {result}";
         }
+
+        [ExcelFunction]
+        public static string NativeParamsFunc1(
+            [ExcelArgument(Name = "first.Input", Description = "is a useful start")]
+            object input,
+            [ExcelArgument(Description = "is another param start")]
+            string QtherInpEt,
+            [ExcelArgument(Name = "Value", Description = "gives the Rest")]
+            params object[] args)
+        {
+            return input + "," + QtherInpEt + ", : " + args.Length;
+        }
+
+        [ExcelFunction]
+        public static string NativeParamsFunc2(
+            [ExcelArgument(Name = "first.Input", Description = "is a useful start")]
+            object input,
+            [ExcelArgument(Name = "second.Input", Description = "is some more stuff")]
+            string input2,
+            [ExcelArgument(Description = "is another param ")]
+            string QtherInpEt,
+            [ExcelArgument(Name = "Value", Description = "gives the Rest")]
+            params object[] args)
+        {
+            var content = string.Join(",", args.Select(ValueType => ValueType.ToString()));
+            return input + "," + input2 + "," + QtherInpEt + ", " + $"[{args.Length}: {content}]";
+        }
+
+        [ExcelFunction]
+        public static string NativeParamsJoinString(string separator, params string[] values)
+        {
+            return String.Join(separator, values);
+        }
     }
 }

Source/Tests/ExcelDna.RuntimeTests/NativeAOT.cs

@@ -209,5 +209,25 @@ public void StringArray2D()
 
             Assert.Equal("Native StringArray2D VALS: 15 2.36.7 HelloWorld ", functionRange.Value.ToString());
         }
+
+        [ExcelFact(Workbook = "", AddIn = AddInPath.RuntimeTestsAOT)]
+        public void Params()
+        {
+            {
+                Range functionRange = ((Worksheet)ExcelDna.Testing.Util.Workbook.Sheets[1]).Range["B1"];
+                functionRange.Formula = "=NativeParamsFunc1(1,\"2\",4,5)";
+                Assert.Equal("1,2, : 2", functionRange.Value.ToString());
+            }
+            {
+                Range functionRange = ((Worksheet)ExcelDna.Testing.Util.Workbook.Sheets[1]).Range["B2"];
+                functionRange.Formula = "=NativeParamsFunc2(\"a\",,\"c\",\"d\",,\"f\")";
+                Assert.Equal("a,,c, [3: d,ExcelDna.Integration.ExcelMissing,f]", functionRange.Value.ToString());
+            }
+            {
+                Range functionRange = ((Worksheet)ExcelDna.Testing.Util.Workbook.Sheets[1]).Range["B3"];
+                functionRange.Formula = "=NativeParamsJoinString(\"//\",\"5\",\"4\",\"3\")";
+                Assert.Equal("5//4//3", functionRange.Value.ToString());
+            }
+        }
     }
 }

Source/Tests/ExcelDna.SourceGenerator.NativeAOT.Tests/Generator.cs

@@ -34,6 +34,7 @@ public static string NativeParamsJoinString(string separator, params string[] va
                 typeRefs.Add(typeof(Func<string, string[], string>));
                 typeRefs.Add(typeof(Func<object, string>));
                 typeRefs.Add(typeof(Func<object, string[]>));
+                typeRefs.Add(typeof(Func<string,object,object,object,object,object,object,object,object,object,object,object,object,object,object,object,string>));
                 
                 List<MethodInfo> methodRefs = new List<MethodInfo>();
                 methodRefs.Add(typeof(List<string>).GetMethod("ToArray")!);