Fixed issue calling base-base class implementation of methods.

rmadsen-ks · rmadsen-ks · commit 9ed94f6cedef · 2022-10-26T15:31:01.000+02:00
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())
+
+

Original file line number	Diff line number	Diff line change
`@@ -42,6 +42,7 @@ static IEnumerable<string[]> PythonTestCases()`
`42`	`42`	`yield return new[] { "test_subclass", "test_class_with_attributes" };`
`43`	`43`	`yield return new[] { "test_subclass", "test_class_with_advanced_attribute" };`
`44`	`44`	`yield return new[] { "test_subclass", "test_more_subclasses" };`
	`45`	`+ yield return new[] { "test_subclass", "test_more_subclasses2" };`
`45`	`46`	`yield return new[] { "test_subclass", "abstract_test" };`
`46`	`47`	`}`
`47`	`48`
Original file line number	Diff line number	Diff line change
`@@ -151,19 +151,29 @@ public TestAttributeAttribute(int x, int y, string z = "x")`
`151`	`151`	`}`
`152`	`152`	`}`
`153`	`153`
	`154`	`+ public abstract class SimpleClassBase`
	`155`	`+ {`
	`156`	`+ private int counter;`
	`157`	`+ public virtual int IncrementThing()`
	`158`	`+ {`
	`159`	`+ return counter++;`
	`160`	`+ }`
`154`	`161`
`155`		`- public class SimpleClass`
	`162`	`+ }`
	`163`	`+`
	`164`	`+ public abstract class SimpleClass : SimpleClassBase`
`156`	`165`	`{`
`157`	`166`	`public bool Initialized;`
`158`	`167`
`159`	`168`	`public SimpleClass()`
`160`	`169`	`{`
`161`	`170`	`Initialized = true;`
`162`	`171`	`}`
`163`		`- private int counter = 0;`
`164`		`- public virtual int IncrementThing()`
	`172`	`+`
	`173`	`+ public int CallIncrementThing()`
`165`	`174`	`{`
`166`		`- return ++counter;`
	`175`	`+ var x = IncrementThing();`
	`176`	`+ return x;`
`167`	`177`	`}`
`168`	`178`
`169`	`179`	`public static void TestObject(object obj)`