In JavaScriptEngineSwitcher.ChakraCore fixed a error, that occurred during finding a suitable method overload, that receives numeric parameters, of the host object

Author: Taritsyn

NuGet/JavaScriptEngineSwitcher.ChakraCore/JavaScriptEngineSwitcher.ChakraCore.nuspec

@@ -20,9 +20,7 @@ This package does not contain the native implementations of ChakraCore. Therefor
  * JavaScriptEngineSwitcher.ChakraCore.Native.linux-x64
  * JavaScriptEngineSwitcher.ChakraCore.Native.osx-x64</description>
 		<summary>JavaScriptEngineSwitcher.ChakraCore contains adapter `ChakraCoreJsEngine` (wrapper for the ChakraCore).</summary>
-		<releaseNotes>1. Added support of .NET Standard 2.0;
-2. ChakraCore was updated to version 1.7.3;
-3. JavaScriptEngineSwitcher.ChakraCore.Native.debian-x64 package has been replaced by the JavaScriptEngineSwitcher.ChakraCore.Native.linux-x64 package.</releaseNotes>
+		<releaseNotes>Fixed a error, that occurred during finding a suitable method overload, that receives numeric parameters, of the host object.</releaseNotes>
 		<copyright>Copyright (c) 2013-2017 Andrey Taritsyn - http://www.taritsyn.ru</copyright>
 		<language>en-US</language>
 		<tags>JavaScriptEngineSwitcher JavaScript ECMAScript ChakraCore</tags>

NuGet/JavaScriptEngineSwitcher.ChakraCore/readme.txt

@@ -30,10 +30,8 @@
    =============
    RELEASE NOTES
    =============
-   1. Added support of .NET Standard 2.0;
-   2. ChakraCore was updated to version 1.7.3;
-   3. JavaScriptEngineSwitcher.ChakraCore.Native.debian-x64 package has been
-      replaced by the JavaScriptEngineSwitcher.ChakraCore.Native.linux-x64 package.
+   Fixed a error, that occurred during finding a suitable method overload, that
+   receives numeric parameters, of the host object.
 
    =============
    DOCUMENTATION

global.json

@@ -1,5 +1,5 @@
 {
 	"sdk": {
-		"version": "2.0.2"
+		"version": "2.0.3"
 	}
 }

src/JavaScriptEngineSwitcher.ChakraCore/Helpers/ReflectionHelpers.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 
@@ -84,9 +85,8 @@ public static void FixArgumentTypes(ref object[] argValues, ParameterInfo[] para
 
 		public static MethodBase GetBestFitMethod(MethodBase[] methods, object[] argValues)
 		{
-			int argCount = argValues.Length;
-			var methodCandidates = methods
-				.Select(m => new
+			MethodWithMetadata[] methodCandidates = methods
+				.Select(m => new MethodWithMetadata
 				{
 					Method = m,
 					ParameterTypes = m.GetParameters()
@@ -95,12 +95,14 @@ public static MethodBase GetBestFitMethod(MethodBase[] methods, object[] argValu
 				})
 				.ToArray()
 				;
-
-			var methodsWithSameArity = methodCandidates
+			int argCount = argValues.Length;
+			MethodWithMetadata[] sameArityMethods = methodCandidates
 				.Where(m => m.ParameterTypes.Length == argCount)
 				.ToArray()
 				;
-			if (methodsWithSameArity.Length == 0)
+
+			int sameArityMethodCount = sameArityMethods.Length;
+			if (sameArityMethodCount == 0)
 			{
 				return null;
 			}
@@ -109,40 +111,46 @@ public static MethodBase GetBestFitMethod(MethodBase[] methods, object[] argValu
 				.Select(a => a.GetType())
 				.ToArray()
 				;
-			var weaklyCompatibleMethods = methodsWithSameArity
-				.Where(m => CompareParameterTypes(argValues, argTypes, m.ParameterTypes, false))
-				.ToArray()
-				;
+			var compatibleMethods = new List<MethodWithMetadata>();
 
-			int weaklyCompatibleMethodCount = weaklyCompatibleMethods.Length;
-			if (weaklyCompatibleMethodCount > 0)
+			for (int methodIndex = 0; methodIndex < sameArityMethodCount; methodIndex++)
 			{
-				if (weaklyCompatibleMethodCount == 1)
+				MethodWithMetadata method = sameArityMethods[methodIndex];
+				ushort compatibilityScore;
+
+				if (CompareParameterTypes(argValues, argTypes, method.ParameterTypes, out compatibilityScore))
 				{
-					return weaklyCompatibleMethods[0].Method;
+					method.CompatibilityScore = compatibilityScore;
+					compatibleMethods.Add(method);
 				}
+			}
 
-				var strictlyCompatibleMethods = weaklyCompatibleMethods
-					.Where(m => CompareParameterTypes(argValues, argTypes, m.ParameterTypes, true))
-					.ToArray()
-					;
-				if (strictlyCompatibleMethods.Length > 0)
+			int compatibleMethodCount = compatibleMethods.Count;
+			if (compatibleMethodCount > 0)
+			{
+				if (compatibleMethodCount == 1)
 				{
-					return strictlyCompatibleMethods[0].Method;
+					return compatibleMethods[0].Method;
 				}
 
-				return weaklyCompatibleMethods[0].Method;
+				MethodWithMetadata bestFitMethod = compatibleMethods
+					.OrderByDescending(m => m.CompatibilityScore)
+					.First()
+					;
+
+				return bestFitMethod.Method;
 			}
 
 			return null;
 		}
 
 		private static bool CompareParameterTypes(object[] argValues, Type[] argTypes, Type[] parameterTypes,
-			bool strictСompliance)
+			out ushort compatibilityScore)
 		{
 			int argValueCount = argValues.Length;
 			int argTypeCount = argTypes.Length;
 			int parameterCount = parameterTypes.Length;
+			compatibilityScore = 0;
 
 			if (argValueCount != argTypeCount || argTypeCount != parameterCount)
 			{
@@ -155,10 +163,13 @@ private static bool CompareParameterTypes(object[] argValues, Type[] argTypes, T
 				Type argType = argTypes[argIndex];
 				Type parameterType = parameterTypes[argIndex];
 
-				if (argType != parameterType)
+				if (argType == parameterType)
+				{
+					compatibilityScore++;
+				}
+				else
 				{
-					if (!strictСompliance
-						&& NumericHelpers.IsNumericType(argType) && NumericHelpers.IsNumericType(parameterType))
+					if (NumericHelpers.IsNumericType(argType) && NumericHelpers.IsNumericType(parameterType))
 					{
 						object convertedArgValue;
 
@@ -167,11 +178,6 @@ private static bool CompareParameterTypes(object[] argValues, Type[] argTypes, T
 							return false;
 						}
 
-						if (argValue != convertedArgValue)
-						{
-							return false;
-						}
-
 						continue;
 					}
 
@@ -181,5 +187,27 @@ private static bool CompareParameterTypes(object[] argValues, Type[] argTypes, T
 
 			return true;
 		}
+
+
+		private sealed class MethodWithMetadata
+		{
+			public MethodBase Method
+			{
+				get;
+				set;
+			}
+
+			public Type[] ParameterTypes
+			{
+				get;
+				set;
+			}
+
+			public ushort CompatibilityScore
+			{
+				get;
+				set;
+			}
+		}
 	}
 }

test/JavaScriptEngineSwitcher.Tests/Interop/Date.cs

@@ -16,7 +16,7 @@ public static Date Today
 			get
 			{
 				DateTime currentDateTime = DateTime.Today;
-				Date currentDate = new Date(currentDateTime.Year, currentDateTime.Month, currentDateTime.Day);
+				var currentDate = new Date(currentDateTime.Year, currentDateTime.Month, currentDateTime.Day);
 
 				return currentDate;
 			}
@@ -43,5 +43,13 @@ public int GetDayOfYear()
 				(Month > 2 && IsLeapYear(Year) ? 1 : 0)
 				;
 		}
+
+		public Date AddDays(double value)
+		{
+			var dateTime = new DateTime(Year, Month, Day);
+			DateTime newDateTime = dateTime.AddDays(value);
+
+			return new Date(newDateTime.Year, newDateTime.Month, newDateTime.Day);
+		}
 	}
 }

test/JavaScriptEngineSwitcher.Tests/InteropTestsBase.cs

@@ -302,25 +302,32 @@ public virtual void EmbeddingOfInstanceOfBuiltinReferenceTypeWithMethodIsCorrect
 		}
 
 		[Fact]
-		public virtual void EmbeddingOfInstanceOfCustomValueTypeWithMethodIsCorrect()
+		public virtual void EmbeddingOfInstanceOfCustomValueTypeWithMethodsIsCorrect()
 		{
 			// Arrange
 			var programmerDayDate = new Date(2015, 9, 13);
 
-			const string input = "programmerDay.GetDayOfYear()";
-			const int targetOutput = 256;
+			const string input1 = "programmerDay.GetDayOfYear()";
+			const int targetOutput1 = 256;
+
+			const string input2 = @"var smileDay = programmerDay.AddDays(6);
+smileDay.GetDayOfYear();";
+			const int targetOutput2 = 262;
 
 			// Act
-			int output;
+			int output1;
+			int output2;
 
 			using (var jsEngine = CreateJsEngine())
 			{
 				jsEngine.EmbedHostObject("programmerDay", programmerDayDate);
-				output = jsEngine.Evaluate<int>(input);
+				output1 = jsEngine.Evaluate<int>(input1);
+				output2 = jsEngine.Evaluate<int>(input2);
 			}
 
 			// Assert
-			Assert.Equal(targetOutput, output);
+			Assert.Equal(targetOutput1, output1);
+			Assert.Equal(targetOutput2, output2);
 		}
 
 		[Fact]
@@ -849,25 +856,31 @@ public virtual void EmbeddingOfBuiltinValueTypeWithMethodIsCorrect()
 		}
 
 		[Fact]
-		public virtual void EmbeddingOfBuiltinReferenceTypeWithMethodIsCorrect()
+		public virtual void EmbeddingOfBuiltinReferenceTypeWithMethodsIsCorrect()
 		{
 			// Arrange
 			Type mathType = typeof(Math);
 
-			const string input = "Math2.Max(5.37, 5.56)";
-			const double targetOutput = 5.56;
+			const string input1 = "Math2.Max(5.37, 5.56)";
+			const double targetOutput1 = 5.56;
+
+			const string input2 = "Math2.Log10(23)";
+			const double targetOutput2 = 1.36172783601759;
 
 			// Act
-			double output;
+			double output1;
+			double output2;
 
 			using (var jsEngine = CreateJsEngine())
 			{
 				jsEngine.EmbedHostType("Math2", mathType);
-				output = jsEngine.Evaluate<double>(input);
+				output1 = jsEngine.Evaluate<double>(input1);
+				output2 = Math.Round(jsEngine.Evaluate<double>(input2), 14);
 			}
 
 			// Assert
-			Assert.Equal(targetOutput, output);
+			Assert.Equal(targetOutput1, output1);
+			Assert.Equal(targetOutput2, output2);
 		}
 
 		[Fact]

test/JavaScriptEngineSwitcher.Tests/Vroom/InteropTests.cs

@@ -54,7 +54,7 @@ public override void EmbeddingOfBuiltinValueTypeWithFieldIsCorrect()
 
 		#region Types with methods
 
-		public override void EmbeddingOfBuiltinReferenceTypeWithMethodIsCorrect()
+		public override void EmbeddingOfBuiltinReferenceTypeWithMethodsIsCorrect()
 		{ }
 
 		#endregion