StackOverflowException on calling super().method()

Environment

• Python.NET version: 3.0.5
• Tested on two configurations:
  • Windows 10, Python 3.12.4, .NET Framework
  • Windows 10, Python 3.12.4, .NET 9.0.201

Details

Code to reproduce the issue is below.

.NET library code:

namespace TestLib
{
    public class BaseClass
    {
        public virtual string Foo()
        {
            return "Foo";
        }

        public virtual string Bar()
        {
            return "Bar";
        }
    }

    public class DerivedClass : BaseClass
    {
        public override string Foo()
        {
            return "DerivedFoo";
        }
    }
}

Python code:

from pathlib import Path

import clr

clr.AddReference(str(Path(__file__).parent / 'TestLib.dll'))

from TestLib import BaseClass, DerivedClass


class TestClass(DerivedClass):
    __namespace__ = 'CrlTest'

    def Foo(self):
        return 'Test' + super().Foo()

    def Bar(self):
        # This work fine
        # return 'Test' + DerivedClass.Bar(self)
        # This calls TestClass::Bar for some reason
        return 'Test' + super().Bar()


if __name__ == '__main__':
    stc = TestClass()
    print('Foo() -> ' + stc.Foo())
    print('Bar() -> ' + stc.Bar())

Python script output:

Foo() -> TestDerivedFoo

Process is terminated due to StackOverflowException.

For some reason calling super().Bar() results in calling TestClass.Bar(self) instead of DerivedClass.Bar(self), which in the end results in infinite recursion. Calling DerivedClass.Bar(self) directly works as expected.

It seem to be related to the fact that the method you try to override in Python is not defined in the immediate parent class, since Foo in the example works fine.

Start with the C# and Python reproducer in the issue and verify the differing behavior of super().Foo() and super().Bar(). Trace Python.NET's dispatch for an overridden method missing from the immediate parent, then confirm that super().Bar() reaches DerivedClass.Bar(self) without recursion and that the script completes with the expected output.