Fix attempt to call base method for abstract classes

Previously it was failing PEVerify similarly to #1728 but for abstract classes (this is possible in case of a polymorphic entities). Unlike interfaces the abstract base class can go into a situation when lazy initializer is not yet available, eg. code in a constructor.

Author: hazzik

src/NHibernate.Test/StaticProxyTest/StaticProxyFactoryFixture.cs

@@ -42,6 +42,22 @@ public class PublicInterfaceTestClass : IPublic
 			public virtual int Id { get; set; }
 		}
 
+		[Serializable]
+		public abstract class AbstractTestClass : IPublic
+		{
+			protected AbstractTestClass()
+			{
+				Assert.That(Id, Is.Zero);
+				Assert.That(Name, Is.Null);
+				Id = -1;
+				Name = "Unknown";
+			}
+
+			public abstract int Id { get; set; }
+			
+			public abstract string Name { get; set; } 
+		}
+
 		[Serializable]
 		public class SimpleTestClass
 		{
@@ -157,7 +173,7 @@ public void VerifyProxyForClassWithAdditionalInterface()
 				// lazy entity load proxy instead of the persistentClass can be specified. This is "translated" into
 				// having an additional interface in the interface list, instead of just having INHibernateProxy.
 				// (Quite a loosy semantic...)
-				new HashSet<System.Type> {typeof(INHibernateProxy), typeof(IPublic)},
+				new HashSet<System.Type> { typeof(INHibernateProxy), typeof(IPublic) },
 				null, null, null);
 
 #if NETFX
@@ -219,6 +235,30 @@ public void VerifyProxyForRefOutClass()
 #endif
 		}
 
+		[Test]
+		public void VerifyProxyForAbstractClass()
+		{
+			var factory = new StaticProxyFactory();
+			factory.PostInstantiate(
+				typeof(AbstractTestClass).FullName,
+				typeof(AbstractTestClass),
+				new HashSet<System.Type> { typeof(INHibernateProxy) },
+				null, null, null);
+
+#if NETFX
+			VerifyGeneratedAssembly(
+				() =>
+				{
+#endif
+					var proxy = factory.GetProxy(1, null);
+					Assert.That(proxy, Is.Not.Null);
+					Assert.That(proxy, Is.InstanceOf<IPublic>());
+					Assert.That(proxy, Is.InstanceOf<AbstractTestClass>());
+#if NETFX
+				});
+#endif
+		}
+
 		[Test]
 		public void InitializedProxyStaysInitializedAfterDeserialization()
 		{

src/NHibernate/Proxy/NHibernateProxyBuilder.cs

@@ -369,16 +369,14 @@ private static void EmitCallBaseIfLazyInitializerIsNull(
 			ILGenerator IL, MethodInfo method, FieldInfo lazyInitializerField, System.Type parentType)
 		{
 			/*
-				<if (method.DeclaringType.IsAssignableFrom(parentType))
-				{>
 				if (this.__lazyInitializer == null)
-					return base.<method>(args..)
+				<if (method.IsAbstract)
+				{>
+				return default;
+				<} else {>
+				return base.<method>(args..);
 				<}>
 			 */
-			if (!method.DeclaringType.IsAssignableFrom(parentType))
-				// The proxy does not derive from a type implementing the method, do not attempt
-				// calling its base. In such case, the lazy initializer is never null.
-				return;
 
 			// When deriving from the entity class, the entity class constructor may trigger
 			// virtual calls accessing the proxy state before its own constructor has a chance
@@ -393,9 +391,28 @@ private static void EmitCallBaseIfLazyInitializerIsNull(
 			IL.Emit(OpCodes.Ldnull);
 			IL.Emit(OpCodes.Bne_Un, skipBaseCall);
 
-			IL.Emit(OpCodes.Ldarg_0);
-			EmitCallMethod(IL, OpCodes.Call, method);
-			IL.Emit(OpCodes.Ret);
+			if (method.IsAbstract)
+			{
+				if (!method.ReturnType.IsValueType)
+				{
+					IL.Emit(OpCodes.Ldnull);
+				}
+				else if (method.ReturnType != typeof(void))
+				{
+					var local = IL.DeclareLocal(method.ReturnType);
+					IL.Emit(OpCodes.Ldloca, local);
+					IL.Emit(OpCodes.Initobj, method.ReturnType);
+					IL.Emit(OpCodes.Ldloc, local);
+				}
+
+				IL.Emit(OpCodes.Ret);
+			}
+			else
+			{
+				IL.Emit(OpCodes.Ldarg_0);
+				EmitCallMethod(IL, OpCodes.Call, method);
+				IL.Emit(OpCodes.Ret);
+			}
 
 			IL.MarkLabel(skipBaseCall);
 		}