Fixed issue calling base-base class implementation of methods.

pythonnet · rmadsen-ks · Apr 27, 2022 · Apr 28, 2022 · Apr 29, 2022 · May 3, 2022
commit 9ed94f6cedef014918d8bdf7886f57cb15d2002b
diff --git a/src/python_tests_runner/PythonTestRunner.cs b/src/python_tests_runner/PythonTestRunner.cs
@@ -42,6 +42,7 @@ static IEnumerable<string[]> PythonTestCases()
             yield return new[] { "test_subclass", "test_class_with_attributes" };
             yield return new[] { "test_subclass", "test_class_with_advanced_attribute" };
             yield return new[] { "test_subclass", "test_more_subclasses" };
+            yield return new[] { "test_subclass", "test_more_subclasses2" };
             yield return new[] { "test_subclass", "abstract_test" };
         }
 

diff --git a/src/runtime/Types/ClassDerived.cs b/src/runtime/Types/ClassDerived.cs
@@ -522,23 +522,26 @@ private static void AddVirtualMethod(MethodInfo method, Type baseType, TypeBuild
             string? baseMethodName = null;
             if (!method.IsAbstract)
             {
-                baseMethodName = "_" + baseType.Name + "__" + method.Name;
-                MethodBuilder baseMethodBuilder = typeBuilder.DefineMethod(baseMethodName,
-                    MethodAttributes.Public |
-                    MethodAttributes.Final |
-                    MethodAttributes.HideBySig,
-                    method.ReturnType,
-                    parameterTypes);
-
-                // emit the assembly for calling the original method using call instead of callvirt
-                ILGenerator baseIl = baseMethodBuilder.GetILGenerator();
-                baseIl.Emit(OpCodes.Ldarg_0);
-                for (var i = 0; i < parameters.Length; ++i)
+                baseMethodName = "_" + method.DeclaringType.Name + "__" + method.Name;
+                if (baseType.GetMethod(baseMethodName) == null)
                 {
-                    baseIl.Emit(OpCodes.Ldarg, i + 1);
+                    MethodBuilder baseMethodBuilder = typeBuilder.DefineMethod(baseMethodName,
+                        MethodAttributes.Public |
+                        MethodAttributes.Final |
+                        MethodAttributes.HideBySig,
+                        method.ReturnType,
+                        parameterTypes);
+
+                    // emit the assembly for calling the original method using call instead of callvirt
+                    ILGenerator baseIl = baseMethodBuilder.GetILGenerator();
+                    baseIl.Emit(OpCodes.Ldarg_0);
+                    for (var i = 0; i < parameters.Length; ++i)
+                    {
+                        baseIl.Emit(OpCodes.Ldarg, i + 1);
+                    }
+                    baseIl.Emit(OpCodes.Call, method);
+                    baseIl.Emit(OpCodes.Ret);
                 }
-                baseIl.Emit(OpCodes.Call, method);
-                baseIl.Emit(OpCodes.Ret);
             }
 
             // override the original method with a new one that dispatches to python

diff --git a/src/testing/subclasstest.cs b/src/testing/subclasstest.cs
@@ -151,19 +151,29 @@ public TestAttributeAttribute(int x, int y, string z = "x")
         }
     }
 
+    public abstract class SimpleClassBase
+    {
+        private int counter;
+            public virtual int IncrementThing()
+            {
+                return counter++;
+            }
 
-    public class SimpleClass
+    }
+
+    public abstract class SimpleClass : SimpleClassBase
     {
         public bool Initialized;
 
         public SimpleClass()
         {
             Initialized = true;
         }
-        private int counter = 0;
-        public virtual int IncrementThing()
+
+        public int CallIncrementThing()
         {
-            return ++counter;
+            var x = IncrementThing();
+            return x;
         }
 
         public static void TestObject(object obj)

diff --git a/tests/test_subclass.py b/tests/test_subclass.py
@@ -396,6 +396,7 @@ def __init__(self):
             SimpleClass.Pause();
             super().__init__()
         def IncrementThing(self):
+            super().IncrementThing()
             return 6;
     SimpleClass.TestOnType(SubClass0)
     SimpleClass.TestOnType(SubClass1)
@@ -465,3 +466,26 @@ class Derived(BaseClass):
 
     import gc
     gc.collect()
+def test_more_subclasses2():
+    import clr
+    class SubClass50(SimpleClass):
+        def __init__(self):
+           super().__init__()
+        def IncrementThing(self):
+           return super().IncrementThing()
+
+    @clr.attribute(DebuggerDisplay("X"))
+
+    class SubClass51(SubClass50):
+        __namespace__ = "TestModule"
+        def __init__(self):
+            super().__init__()
+
+        def IncrementThing(self):
+            return super().IncrementThing() + 10
+    x = SubClass51()
+    print(x.CallIncrementThing())
+    print(x.CallIncrementThing())
+    print(x.CallIncrementThing())
+
+