Merge pull request #75 from lofcz/master

Check whether extension method is defined and no overload found

Author: codingseb

CodingSeb.ExpressionEvaluator/ExpressionEvaluator.cs

@@ -18,6 +18,7 @@
 using System.Runtime.InteropServices;
 using System.Text;
 using System.Text.RegularExpressions;
+using System.Runtime.CompilerServices;
 
 namespace CodingSeb.ExpressionEvaluator
 {
@@ -836,6 +837,13 @@ public bool OptionNewFunctionEvaluationActive
         /// </summary>
         public bool OptionAllowNonPublicMembersAccess { get; set; }
 
+        /// <summary>
+        /// If <c>true</c> On unsuccessful call to an extension method, all defined overloads of that method are detected to resolve whether method is defined and called with wrong arguments or method is not defined.
+        /// If <c>false</c> Unsucessful call to an extension method will always result in "Method {name} is not defined on type {type}"
+        /// Default : true
+        /// </summary>
+        public bool OptionDetectExtensionMethodsOverloadsOnExtensionMethodNotFound { get; set; } = true;
+
         #endregion
 
         #region Reflection flags
@@ -1954,6 +1962,33 @@ protected virtual bool EvaluateVarOrFunc(string expression, Stack<object> stack,
                                             }
                                             else
                                             {
+                                                if (OptionDetectExtensionMethodsOverloadsOnExtensionMethodNotFound)
+                                                {
+                                                    IEnumerable<MethodInfo> query = from type in StaticTypesForExtensionsMethods
+                                                        where 
+                                                              !type.IsGenericType &&
+                                                              type.IsSealed && 
+                                                              !type.IsNested  
+                                                        from method in type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
+                                                        where method.IsDefined(typeof(ExtensionAttribute), false)
+                                                        where method.GetParameters()[0].ParameterType == objType // static extMethod(this outType, ...)
+                                                        select method;
+
+                                                    if (query.Any())
+                                                    {
+                                                        string fnArgsPrint = string.Join(",", funcArgs);
+                                                        string fnOverloadsPrint = "";
+
+                                                        foreach (MethodInfo mi in query)
+                                                        {
+                                                            ParameterInfo[] parInfo = mi.GetParameters();
+                                                            fnOverloadsPrint += string.Join(",", parInfo.Select(x => x.ParameterType.FullName ?? x.ParameterType.Name)) + "\n";
+                                                        } 
+                                                        
+                                                        throw new ExpressionEvaluatorSyntaxErrorException($"[{objType}] extension method \"{varFuncName}\" has no overload for arguments: {fnArgsPrint}. Candidates: {fnOverloadsPrint}");
+                                                    }
+                                                }
+
                                                 throw new ExpressionEvaluatorSyntaxErrorException($"[{objType}] object has no Method named \"{varFuncName}\".");
                                             }
                                         }