Apr 27, 2022 · Apr 28, 2022 · Apr 29, 2022 · May 3, 2022 · May 3, 2022 · May 5, 2022
diff --git a/src/python_tests_runner/PythonTestRunner.cs b/src/python_tests_runner/PythonTestRunner.cs
            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
            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
        }
    }

    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;
        publicvirtualintIncrementThing()

        public intCallIncrementThing()
        {
            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
            SimpleClass.Pause();
            super().__init__()
        def IncrementThing(self):
            super().IncrementThing()
            return 6;
    SimpleClass.TestOnType(SubClass0)
    SimpleClass.TestOnType(SubClass1)

    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
Expand Up		@@ -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" };
		}

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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;
		publicvirtualintIncrementThing()

		public intCallIncrementThing()
		{
		return ++counter;
		var x = IncrementThing();
		return x;
		}

		public static void TestObject(object obj)
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -396,6 +396,7 @@ def __init__(self):
		SimpleClass.Pause();
		super().__init__()
		def IncrementThing(self):
		super().IncrementThing()
		return 6;
		SimpleClass.TestOnType(SubClass0)
		SimpleClass.TestOnType(SubClass1)
Expand DownExpand Up		@@ -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())