Correction for #87 Parameter type mismatch is causing missing methods

Author: codingseb

CodingSeb.ExpressionEvaluator.Tests/ExpressionEvaluatorTests.cs

@@ -1548,6 +1548,19 @@ public void Evaluate_WithException_ThrowsExceptionAndDoesNotAssignItInObject()
             objectContainer.AnObjectProperty.ShouldBe(10);
         }
 
+        /// <summary>
+        /// To correct #87 Parameter type mismatch is causing missing methods
+        /// </summary>
+        [Test]
+        [Category("Bug")]
+        [Category("#87")]
+        public void Evaluate_ParameterTypeMismatchAutoAdapt()
+        {
+            var evaluator = new ExpressionEvaluator();
+            evaluator.Evaluate("DateTime.Now.AddDays(1)")
+                .ShouldBeOfType<DateTime>();
+        }
+
         #endregion
 
         #region EvaluateWithSpecificEvaluator
@@ -2240,6 +2253,24 @@ ExpressionEvaluator evaluatorForParamsTests()
                     .Returns("2,3.5,,Hello,True")
                     .SetCategory("ParamsKeywordMethod");
 
+                yield return new TestCaseData(evaluatorForParamsTests()
+                    , "paramsObj.ReturnTrue(2)"
+                    , null)
+                    .Returns(true)
+                    .SetCategory("ParamsKeywordMethod");
+                
+                yield return new TestCaseData(evaluatorForParamsTests()
+                    , "paramsObj.ReturnTrue(2, \"Hello\")"
+                    , null)
+                    .Returns(true)
+                    .SetCategory("ParamsKeywordMethod");
+                
+                yield return new TestCaseData(evaluatorForParamsTests()
+                    , "paramsObj.ReturnTrue(2, \"Hello\", \"Test\")"
+                    , null)
+                    .Returns(true)
+                    .SetCategory("ParamsKeywordMethod");
+
                 #endregion
 
                 #region Bug resolution

CodingSeb.ExpressionEvaluator.Tests/GlobalSuppressions.cs

@@ -11,3 +11,5 @@
 [assembly: SuppressMessage("Redundancy", "RCS1213:Remove unused member declaration.", Justification = "<Pending>", Scope = "namespaceanddescendants", Target = "~N:CodingSeb.ExpressionEvaluator.Tests")]
 [assembly: SuppressMessage("CodeQuality", "IDE0051:Remove unused private members", Justification = "<Pending>", Scope = "namespaceanddescendants", Target = "~N:CodingSeb.ExpressionEvaluator.Tests")]
 [assembly: SuppressMessage("Design", "RCS1170:Use read-only auto-implemented property.", Justification = "<Pending>", Scope = "namespaceanddescendants", Target = "~N:CodingSeb.ExpressionEvaluator.Tests")]
+[assembly: SuppressMessage("Redundancy", "RCS1163:Unused parameter.", Justification = "<Pending>", Scope = "member", Target = "~M:CodingSeb.ExpressionEvaluator.Tests.MethodArgKeywordClass.ReturnTrue(System.Double,System.String[])~System.Boolean")]
+[assembly: SuppressMessage("Style", "IDE0060:Remove unused parameter", Justification = "<Pending>", Scope = "member", Target = "~M:CodingSeb.ExpressionEvaluator.Tests.MethodArgKeywordClass.ReturnTrue(System.Double,System.String[])~System.Boolean")]

CodingSeb.ExpressionEvaluator.Tests/TestsUtils/MethodArgKeywordClass.cs

@@ -28,6 +28,11 @@ public void Join(out string result, string separator, params object[] values)
         {
             result = string.Join(separator, values);
         }
+
+        public bool ReturnTrue(double dValue, params string[] values)
+        {
+            return true;
+        }
     }
 
     public static class MethodArgKeywordClassExtension

CodingSeb.ExpressionEvaluator/ExpressionEvaluator.cs

@@ -130,6 +130,21 @@ protected enum TryBlockEvaluatedState
             { "void", typeof(void) }
         };
 
+        // Based on https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2012/y5b434w4(v=vs.110)?redirectedfrom=MSDN
+        protected static readonly IDictionary<Type, Type[]> implicitCastDict = new Dictionary<Type, Type[]>
+        {
+            { typeof(sbyte), new Type[] { typeof(short), typeof(int), typeof(long), typeof(float), typeof(double), typeof(decimal) } },
+            { typeof(byte), new Type[] { typeof(short), typeof(ushort), typeof(int), typeof(uint), typeof(long), typeof(ulong), typeof(float), typeof(double), typeof(decimal) } },
+            { typeof(short), new Type[] { typeof(int), typeof(long),  typeof(float), typeof(double), typeof(decimal) } },
+            { typeof(ushort), new Type[] { typeof(int), typeof(uint), typeof(long), typeof(ulong), typeof(float), typeof(double), typeof(decimal) } },
+            { typeof(int), new Type[] { typeof(long), typeof(float), typeof(double), typeof(decimal) } },
+            { typeof(uint), new Type[] {typeof(long), typeof(ulong), typeof(float), typeof(double), typeof(decimal) } },
+            { typeof(long), new Type[] { typeof(float), typeof(double), typeof(decimal) } },
+            { typeof(char), new Type[] { typeof(ushort), typeof(int), typeof(uint), typeof(long), typeof(ulong), typeof(float), typeof(double), typeof(decimal) } },
+            { typeof(float), new Type[] { typeof(double) } },
+            { typeof(ulong), new Type[] { typeof(float), typeof(double), typeof(decimal) } },
+        };
+
         protected static readonly IDictionary<string, Func<string, CultureInfo, object>> numberSuffixToParse = new Dictionary<string, Func<string, CultureInfo, object>>(StringComparer.OrdinalIgnoreCase) // Always Case insensitive, like in C#
         {
             { "f", (number, culture) => float.Parse(number, NumberStyles.Any, culture) },
@@ -3150,14 +3165,15 @@ protected virtual MethodInfo GetRealMethod(ref Type type, ref object obj, string
             bool parameterValidate(ParameterInfo p) => p.Position >= modifiedArgs.Count
                 || (testForExtention && p.Position == 0)
                 || modifiedArgs[p.Position] == null
-                || p.ParameterType.IsAssignableFrom(modifiedArgs[p.Position].GetType())
+                || IsCastable(modifiedArgs[p.Position].GetType(), p.ParameterType)
                 || typeof(Delegate).IsAssignableFrom(p.ParameterType)
                 || p.IsDefined(typeof(ParamArrayAttribute))
                 || (p.ParameterType.IsByRef && argsWithKeywords.Any(a => a.Index == p.Position + (testForExtention ? 1 : 0)));
 
             bool methodByNameFilter(MethodInfo m) => m.Name.Equals(func, StringComparisonForCasing)
-                    && (m.GetParameters().Length == modifiedArgs.Count || m.GetParameters().Last().IsDefined(typeof(ParamArrayAttribute), false))
-                    && (typeCopy == typeof(Enumerable) || m.GetParameters().All(parameterValidate));
+                    && (m.GetParameters().Length == modifiedArgs.Count
+                        || (m.GetParameters().Last().IsDefined(typeof(ParamArrayAttribute), false)
+                            && m.GetParameters().All(parameterValidate)));
 
             List<MethodInfo> methodInfos = type.GetMethods(flag)
                 .Where(methodByNameFilter)
@@ -3213,6 +3229,12 @@ bool methodByNameFilter(MethodInfo m) => m.Name.Equals(func, StringComparisonFor
             return methodInfo;
         }
 
+        protected virtual bool IsCastable(Type fromType, Type toType)
+        {
+            return toType.IsAssignableFrom(fromType)
+                || (implicitCastDict.ContainsKey(fromType) && implicitCastDict[fromType].Contains(toType));
+        }
+
         protected virtual MethodInfo TryToCastMethodParametersToMakeItCallable(MethodInfo methodInfoToCast, List<object> modifiedArgs, string genericsTypes, Type[] inferedGenericsTypes)
         {
             MethodInfo methodInfo = null;