[BUG] __add__ method gets Python object not cython object as self.

[gentlegiantJGC]

Describe the bug
This may be working as intended if so I will have to find a workaround for it but I just wanted to confirm first.
The __eq__ method of a class in cython is given the cython version of the class even if called from python.
I would expect this behaviour to apply to all dunder methods but it does not apply to the __add__ and __radd__ methods.
These two methods are given the python object from which the internal attributes cannot be accessed.
This may apply to more methods but the add methods are the only ones I have currently tested.

To Reproduce
Code to reproduce the behaviour:

from cython import typeof

cdef class Test:
    def __eq__(self, other):
        print("eq", typeof(self), repr(self))
        return [] == other

    def __add__(self, other):
        print("add", typeof(self), repr(self))
        return [] + other

    def __radd__(self, other):
        print("radd", typeof(self), repr(self))
        return other + []

cdef Test test = Test()
a = test == []  # eq Test <test.Test object at 0x000001267FF376C0>
b = test + []  # add Python object <test.Test object at 0x000001F97E77C6C0>
c = [] + test  # radd Python object <test.Test object at 0x000001C24B3966C0>

Expected behavior
I would expect the add methods to be given the cython version of Test so that the internal attributes can be accessed.

Environment (please complete the following information):

• OS: Windows
• Python version 3.9.1
• Cython version 3.0.0a9

[da-woods]

Thanks - I think this is something we know about but it probably does need fixing. It applies to all of the binary operators.

In the past this was deliberate and documented because add could be called with either self or other being Test.

Now that we implement __radd__ correctly it should be possible to type self (see #2056). It's slightly complicated though because we do still try to support the old behaviour by default. We've discussed this before and I think we decided it was best to add the typing even if it might cause issues.

It's easily worked around though - you just assign self to something typed:

def __add__(self, other):
        cdef Test selft = self
        print("add", typeof(selft), repr(self))
        return [] + other

I'll make this a blocker for Cython 3 I think because it's a potentially incompatible change so we want to do it there. I don't think it'll be large change.

[gentlegiantJGC]

It looks like the same behaviour can be achieved by adding the typing to the method declaration. Is there any disadvantage of doing this? (other than loosing the python object)

def __add__(Test self, other):
        print("add", typeof(self), repr(self))
        return [] + other

[da-woods]

I didn't think that was supported. I have a PR that proposes to support overriding the type of self(#3961), since there's some occasional cases where it's useful. but I'm surprised that this works currently.

However, it it works then there's no problem with you doing that.