Fix IInvocation.MethodInvocationTarget for interfaces w/ default impl

Author: stakx

src/Castle.Core/DynamicProxy/Contributors/ClassProxyTargetContributor.cs

@@ -76,10 +76,16 @@ protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEm
 				return ExplicitlyImplementedInterfaceMethodGenerator(method, @class, overrideMethod);
 			}
 
+			// since this contributor is used for class proxies without target,
+			// the invocation type will be derived from `InheritanceInvocation`:
 			var invocation = GetInvocationType(method, @class);
 
 			GetTargetExpressionDelegate getTargetTypeExpression = (c, m) => new TypeTokenExpression(targetType);
 
+			// `MethodWithInvocationGenerator` uses its `getTargetExpression` argument
+			// to determine the first argument to be passed to the received invocation type;
+			// and since `InheritanceInvocation`s' first ctor param is `targetType`,
+			// we pass `getTargetTypeExpression` here:
 			return new MethodWithInvocationGenerator(method,
 			                                         @class.GetField("__interceptors"),
 			                                         invocation,

src/Castle.Core/DynamicProxy/Generators/BaseClassProxyGenerator.cs

@@ -153,7 +153,11 @@ private IEnumerable<Type> GetTypeImplementerMapping(out IEnumerable<ITypeContrib
 			// 3. then additional interfaces
 			if (interfaces.Length > 0)
 			{
-				var additionalInterfacesContributor = new InterfaceProxyWithoutTargetContributor(namingScope, (c, m) => NullExpression.Instance) { Logger = Logger };
+				// this is explained in `InterfaceProxyWithoutTargetGenerator.GetProxyTargetContributor`:
+				GetTargetExpressionDelegate getTargetType =
+					(c, m) => m.IsAbstract ? NullExpression.Instance
+										   : new TypeTokenExpression(m.DeclaringType);
+				var additionalInterfacesContributor = new InterfaceProxyWithoutTargetContributor(namingScope, getTargetType) { Logger = Logger };
 				contributorsList.Add(additionalInterfacesContributor);
 
 				foreach (var @interface in interfaces)

src/Castle.Core/DynamicProxy/Generators/BaseInterfaceProxyGenerator.cs

@@ -145,7 +145,11 @@ protected override Type GenerateType(string typeName, INamingScope namingScope)
 		protected virtual InterfaceProxyWithoutTargetContributor GetContributorForAdditionalInterfaces(
 			INamingScope namingScope)
 		{
-			return new InterfaceProxyWithoutTargetContributor(namingScope, (c, m) => NullExpression.Instance) { Logger = Logger };
+			// this is explained in `InterfaceProxyWithoutTargetGenerator.GetProxyTargetContributor`:
+			GetTargetExpressionDelegate getTargetType =
+				(c, m) => m.IsAbstract ? NullExpression.Instance
+				                       : new TypeTokenExpression(m.DeclaringType);
+			return new InterfaceProxyWithoutTargetContributor(namingScope, getTargetType) { Logger = Logger };
 		}
 
 		protected virtual IEnumerable<Type> GetTypeImplementerMapping(Type proxyTargetType,

src/Castle.Core/DynamicProxy/Generators/InterfaceProxyWithoutTargetGenerator.cs

@@ -35,7 +35,16 @@ public InterfaceProxyWithoutTargetGenerator(ModuleScope scope, Type targetType,
 
 		protected override CompositeTypeContributor GetProxyTargetContributor(Type proxyTargetType, INamingScope namingScope)
 		{
-			return new InterfaceProxyWithoutTargetContributor(namingScope, (c, m) => NullExpression.Instance) { Logger = Logger };
+			// The type of contributor instantiated below will use an inheritance-based invocation type.
+			// Those expect a target type, not a target instance (see first ctor param of `InheritanceInvocation`).
+			// For interface proxies without target, there typically isn't a target at all...
+			// except when an interface method has a default implementation (i.e. isn't abstract).
+			// Then the target type is the method's declaring interface itself.
+			// (Similar scenario: class proxies w/o target inherit method impls from the proxied class.)
+			GetTargetExpressionDelegate getTargetType =
+				(c, m) => m.IsAbstract ? NullExpression.Instance
+				                       : new TypeTokenExpression(m.DeclaringType);
+			return new InterfaceProxyWithoutTargetContributor(namingScope, getTargetType) { Logger = Logger };
 		}
 
 		protected override ProxyTargetAccessorContributor GetProxyTargetAccessorContributor()

src/Castle.Core/DynamicProxy/Internal/InvocationHelper.cs

@@ -65,10 +65,17 @@ private static MethodInfo ObtainMethod(MethodInfo proxiedMethod, Type type)
 			MethodInfo methodOnTarget = null;
 			if (declaringType.IsInterface)
 			{
-				var mapping = type.GetInterfaceMap(declaringType);
-				var index = Array.IndexOf(mapping.InterfaceMethods, proxiedMethod);
-				Debug.Assert(index != -1);
-				methodOnTarget = mapping.TargetMethods[index];
+				if (proxiedMethod.IsAbstract)
+				{
+					var mapping = type.GetInterfaceMap(declaringType);
+					var index = Array.IndexOf(mapping.InterfaceMethods, proxiedMethod);
+					Debug.Assert(index != -1);
+					methodOnTarget = mapping.TargetMethods[index];
+				}
+				else
+				{
+					methodOnTarget = proxiedMethod;
+				}
 			}
 			else
 			{