In JavaScriptEngineSwitcher.Jint was made complete unification of using of the AllowReflection configuration property

Author: Taritsyn

src/JavaScriptEngineSwitcher.Jint/CustomTypeResolvers.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+using OriginalTypeResolver = Jint.Runtime.Interop.TypeResolver;
+
+namespace JavaScriptEngineSwitcher.Jint
+{
+	/// <summary>
+	/// Interop strategies for different values of the <see cref="JintSettings.AllowReflection"/> configuration property
+	/// </summary>
+	internal static class CustomTypeResolvers
+	{
+		private static readonly PropertyInfo[] _disallowedProperties =
+		{
+			typeof(Delegate).GetProperty("Method"),
+			typeof(Exception).GetProperty("TargetSite")
+		};
+
+		private static readonly MethodInfo[] _disallowedMethods =
+		{
+			typeof(object).GetMethod("GetType"),
+			typeof(Exception).GetMethod("GetType")
+		};
+
+		private static readonly Lazy<OriginalTypeResolver> _allowingReflection = new Lazy<OriginalTypeResolver>(
+			() => new OriginalTypeResolver() { MemberFilter = _ => true });
+
+		private static readonly Lazy<OriginalTypeResolver> _disallowingReflection = new Lazy<OriginalTypeResolver>(
+			() => new OriginalTypeResolver() { MemberFilter = IsAllowedMember });
+
+		/// <summary>
+		/// Gets a interop strategy that allows the usage of reflection API in the script code
+		/// </summary>
+		public static OriginalTypeResolver AllowingReflection => _allowingReflection.Value;
+
+		/// <summary>
+		/// Gets a interop strategy that disallows the usage of reflection API in the script code
+		/// </summary>
+		public static OriginalTypeResolver DisallowingReflection => _disallowingReflection.Value;
+
+
+		private static bool IsAllowedMember(MemberInfo member)
+		{
+			bool isAllowed = true;
+
+			if (member is PropertyInfo)
+			{
+				isAllowed = IsAllowedProperty((PropertyInfo)member);
+			}
+			else if (member is MethodInfo)
+			{
+				isAllowed = IsAllowedMethod((MethodInfo)member);
+			}
+
+			return isAllowed;
+		}
+
+		[MethodImpl((MethodImplOptions)256 /* AggressiveInlining */)]
+		private static bool IsAllowedProperty(PropertyInfo property)
+		{
+			bool isAllowed = !_disallowedProperties.Contains(property, MemberComparer<PropertyInfo>.Instance);
+
+			return isAllowed;
+		}
+
+		[MethodImpl((MethodImplOptions)256 /* AggressiveInlining */)]
+		private static bool IsAllowedMethod(MethodInfo method)
+		{
+			bool isAllowed = !_disallowedMethods.Contains(method, MemberComparer<MethodInfo>.Instance);
+
+			return isAllowed;
+		}
+
+
+		private sealed class MemberComparer<T> : EqualityComparer<T>
+			where T : MemberInfo
+		{
+			public static MemberComparer<T> Instance { get; } = new MemberComparer<T>();
+
+
+			private MemberComparer()
+			{ }
+
+
+			#region MemberComparer overrides
+
+			public override bool Equals(T x, T y)
+			{
+				return x.Module == y.Module && x.MetadataToken == y.MetadataToken;
+			}
+
+			public override int GetHashCode(T obj)
+			{
+				return obj != null ? obj.GetHashCode() : 0;
+			}
+
+			#endregion
+		}
+	}
+}

src/JavaScriptEngineSwitcher.Jint/JintJsEngine.cs

@@ -119,7 +119,7 @@ public JintJsEngine(JintSettings settings)
 			try
 			{
 				_jsEngine = new OriginalEngine(options => {
-					options.Interop.AllowGetType = jintSettings.AllowReflection;
+					options.Interop.AllowGetType = true;
 					options.Interop.AllowSystemReflection = true;
 
 					options
@@ -142,6 +142,8 @@ public JintJsEngine(JintSettings settings)
 					}
 
 					options.AddObjectConverter(new UndefinedConverter());
+					options.SetTypeResolver(jintSettings.AllowReflection ?
+						CustomTypeResolvers.AllowingReflection : CustomTypeResolvers.DisallowingReflection);
 				});
 				_cancellationConstraint = _jsEngine.FindConstraint<OriginalCancellationConstraint>();
 				if (_debuggerBreakCallback != null)

src/JavaScriptEngineSwitcher.Jint/JintSettings.cs

@@ -13,7 +13,8 @@ public sealed class JintSettings
 		/// Gets or sets a flag for whether to allow the usage of reflection API in the script code
 		/// </summary>
 		/// <remarks>
-		/// This affects <see cref="Object.GetType"/> and <see cref="Exception.GetType"/>.
+		/// This affects <see cref="Object.GetType"/>, <c>Exception.GetType</c>,
+		/// <c>Exception.TargetSite</c> and <c>Delegate.Method</c>.
 		/// </remarks>
 		public bool AllowReflection
 		{

test/JavaScriptEngineSwitcher.Tests/Jint/InteropTests.cs

@@ -426,7 +426,11 @@ string TestAllowReflectionSetting(bool allowReflection)
 
 			// Act and Assert
 			Assert.Null(TestAllowReflectionSetting(true));
+#if NET471
 			Assert.Null(TestAllowReflectionSetting(false));
+#else
+			Assert.Equal("undefined", TestAllowReflectionSetting(false));
+#endif
 		}
 
 		[Fact]
@@ -446,10 +450,14 @@ string TestAllowReflectionSetting(bool allowReflection)
 
 			// Act and Assert
 			Assert.Equal(typeof(LoginFailedException).FullName, TestAllowReflectionSetting(true));
+#if NET471
+			Assert.Equal(typeof(LoginFailedException).FullName, TestAllowReflectionSetting(false));
+#else
 
 			var exception = Assert.Throws<JsRuntimeException>(() => TestAllowReflectionSetting(false));
 			Assert.Equal("Runtime error", exception.Category);
 			Assert.Equal("Property 'GetType' of object is not a function", exception.Description);
+#endif
 		}
 
 		#endregion
@@ -474,13 +482,8 @@ string TestAllowReflectionSetting(bool allowReflection)
 			}
 
 			// Act and Assert
-			var exception1 = Assert.Throws<JsRuntimeException>(() => TestAllowReflectionSetting(false));
-			Assert.Equal("Runtime error", exception1.Category);
-			Assert.Equal("Property 'GetType' of object is not a function", exception1.Description);
-
-			var exception2 = Assert.Throws<JsRuntimeException>(() => TestAllowReflectionSetting(false));
-			Assert.Equal("Runtime error", exception2.Category);
-			Assert.Equal("Property 'GetType' of object is not a function", exception2.Description);
+			Assert.Equal(dateTimeTypeName, TestAllowReflectionSetting(true));
+			Assert.Equal(dateTimeTypeName, TestAllowReflectionSetting(false));
 		}
 
 		[Fact]