DefaultMethodEmitter.cs: When emitting a proxy method, be more careful in how we get the MethodInfo for the target method. The previous code would get the closed generic method on .Net 2.0, but the open generic method definition on .Net 4.0. Now, explicitly reference the type arguments of the generated method, so we always get the closed generic method. This fixes NH-2819, NH-2726.

Author: oskarb

src/NHibernate/Proxy/DynamicProxy/DefaultMethodEmitter.cs

@@ -53,8 +53,10 @@ public DefaultMethodEmitter(IArgumentHandler argumentHandler)
 
 		#region IMethodBodyEmitter Members
 
-		public void EmitMethodBody(ILGenerator IL, MethodInfo method, FieldInfo field)
+		public void EmitMethodBody(MethodBuilder generatedMethod, MethodInfo method, FieldInfo field)
 		{
+			var IL = generatedMethod.GetILGenerator();
+
 			ParameterInfo[] parameters = method.GetParameters();
 			IL.DeclareLocal(typeof (object[]));
 			IL.DeclareLocal(typeof (InvocationInfo));
@@ -73,33 +75,17 @@ public void EmitMethodBody(ILGenerator IL, MethodInfo method, FieldInfo field)
 
 			IL.Emit(OpCodes.Ldarg_0);
 
-			for(int i=0; i<method.GetParameters().Length; i++)
+			for (int i = 0; i < method.GetParameters().Length; i++)
 				IL.Emit(OpCodes.Ldarg_S, (sbyte)(i + 1));
 
 			IL.Emit(OpCodes.Call, method);
 			IL.Emit(OpCodes.Ret);
 
 			IL.MarkLabel(skipBaseCall);
 
-			// Push the 'this' pointer onto the stack
-			IL.Emit(OpCodes.Ldarg_0);
-
-			// Push the MethodInfo onto the stack            
-			System.Type declaringType = method.DeclaringType;
-
-			IL.Emit(OpCodes.Ldtoken, method);
-			if (declaringType.IsGenericType)
-			{
-				IL.Emit(OpCodes.Ldtoken, declaringType);
-				IL.Emit(OpCodes.Call, getGenericMethodFromHandle);
-			}
-			else
-			{
-				IL.Emit(OpCodes.Call, getMethodFromHandle);
-			}
-
-			IL.Emit(OpCodes.Castclass, typeof (MethodInfo));
-
+			// Push arguments for InvocationInfo constructor.
+			IL.Emit(OpCodes.Ldarg_0);  // 'this' pointer
+			PushTargetMethodInfo(IL, generatedMethod, method);
 			PushStackTrace(IL);
 			PushGenericArguments(method, IL);
 			_argumentHandler.PushArguments(parameters, IL, false);
@@ -172,6 +158,44 @@ private static OpCode GetStindInstruction(System.Type parameterType)
 			return OpCodes.Stind_Ref;
 		}
 
+		private static void PushTargetMethodInfo(ILGenerator IL, MethodBuilder generatedMethod, MethodInfo method)
+		{
+			if (method.IsGenericMethodDefinition)
+			{
+				// We want the generated code to load a MethodInfo instantiated with the
+				// current generic type parameters. I.e.:
+				// MethodInfo methodInfo = methodof(TheClass.TheMethod<T>(...)
+				//
+				// We need to instantiate the open generic method definition with the type
+				// arguments from the generated method. Using the open method definition
+				// directly works on .Net 2.0, which might be FW bug, but fails on 4.0.
+				//
+				// Equivalent pseudo-code:
+				// MethodInfo mi = methodof(TheClass.TheMethod<>)
+				// versus
+				// MethodInfo mi = methodof(TheClass.TheMethod<T0>)
+				var instantiatedMethod = method.MakeGenericMethod(generatedMethod.GetGenericArguments());
+				IL.Emit(OpCodes.Ldtoken, instantiatedMethod);
+			}
+			else
+			{
+				IL.Emit(OpCodes.Ldtoken, method);
+			}
+
+			System.Type declaringType = method.DeclaringType;
+			if (declaringType.IsGenericType)
+			{
+				IL.Emit(OpCodes.Ldtoken, declaringType);
+				IL.Emit(OpCodes.Call, getGenericMethodFromHandle);
+			}
+			else
+			{
+				IL.Emit(OpCodes.Call, getMethodFromHandle);
+			}
+
+			IL.Emit(OpCodes.Castclass, typeof(MethodInfo));
+		}
+
 		private void PushStackTrace(ILGenerator IL)
 		{
 			// NOTE: The stack trace has been disabled for performance reasons

src/NHibernate/Proxy/DynamicProxy/DefaultProxyMethodBuilder.cs

@@ -64,11 +64,10 @@ public void CreateProxiedMethod(FieldInfo field, MethodInfo method, TypeBuilder
 					typeArgsBuilder[index].SetInterfaceConstraints(typeArgs[index].GetGenericParameterConstraints());
 				}
 			}
-
-			ILGenerator IL = methodBuilder.GetILGenerator();
+			
 
 			Debug.Assert(MethodBodyEmitter != null);
-			MethodBodyEmitter.EmitMethodBody(IL, method, field);
+			MethodBodyEmitter.EmitMethodBody(methodBuilder, method, field);
 		}
 
 		#endregion

src/NHibernate/Proxy/DynamicProxy/IMethodBodyEmitter.cs

@@ -13,6 +13,6 @@ namespace NHibernate.Proxy.DynamicProxy
 {
 	public interface IMethodBodyEmitter
 	{
-		void EmitMethodBody(ILGenerator IL, MethodInfo method, FieldInfo field);
+		void EmitMethodBody(MethodBuilder generatedMethod, MethodInfo method, FieldInfo field);
 	}
 }