Subclassed operator returning Never not recognized

[Dr-Irv]

Bug Report
This came up in pandas-stubs development.

If you have a base class with an operator like __add__() and a subclass that is not allowed to call __add__(), and you notate the subclass as returning Never to indicate that the subclass should not support the operator, mypy does not see the use of the operator as invalid. pyright does pick this up.

To Reproduce

from __future__ import annotations
from typing import Any
from typing_extensions import Never, assert_type


class Base:
    def __add__(self, other: Any) -> Base:
        return Base()


class Sub:
    def __add__(self, other: Any) -> Never:
        pass


b = Base()
s = Sub()
br1 = b + 10
s + 10

Expected Behavior

mypy should report that the last line s+10 is invalid. With pyright, we get "Operator "+" not supported for types "Sub" and "Literal[10]""

Actual Behavior

No output. Actually, we get this:

never.py:12: error: Implicit return in function which does not return  [empty-body]

That's fine - because we actually would be using the line def __add__(self, other: Any) -> Never: in a stubs file.

Your Environment

• Mypy version used: 0.991
• Mypy command-line flags: none
• Mypy configuration options from mypy.ini (and other config files): none
• Python version used: 3.9 and 3.11

[JelleZijlstra]

I would say pyright has the buggy behavior here, not mypy. Calling a function that returns Never isn't an error. If you insert a reveal_type(s + 10), mypy's output is <nothing>, which is correct.

[Dr-Irv]

I would say pyright has the buggy behavior here, not mypy. Calling a function that returns Never isn't an error. If you insert a reveal_type(s + 10), mypy's output is <nothing>, which is correct.

I think it is a bit ambiguous. The python docs say "This can be used to define a function that should never be called, or a function that never returns:".

The example in the docs show the first case as declaring the parameter to be Never. The second case as having Never as the return type.

[JelleZijlstra]

It is correct to have Never as the return type, but it simply indicates that the function does not return, not that the type checker should show an error. The canonical example is sys.exit().

[erictraut]

@Dr-Irv, if you change the definition of Sub.__add__ to the following, I think that will give you the behavior you're looking for.

class Sub:
    def __add__(self, other: Never) -> Never:
        pass

[JelleZijlstra]

I think the canonical way to say that a base class operator is unsupported is to set it to None:

class Sub:
    __add__ = None

Mypy correctly shows an error if you then do Sub() + 10.

[Dr-Irv]

@JelleZijlstra @erictraut

Well, neither of those solutions (using Never as an argument, or setting __add__ = None work in the following case, where you want the subclass to accept some arguments of the parent class, but not all:

from __future__ import annotations
from typing import overload
from typing_extensions import Never, assert_type


class Base:
    def __add__(self, other: int | str) -> Base:
        return Base()


class Sub:
    @overload
    def __add__(self, other: int) -> Never:
        pass

    @overload
    def __add__(self, other: str) -> Sub:
        pass

    def __add__(self, other: int | str) -> Sub:
        pass


b = Base()
s = Sub()
br1 = b + 10
s + 10
x = s + "abc"

In this case, the subclass can take str as an argument, but not int. pyright is reporting that the expression s + 10 is not allowed, which is the desired behavior.

If I should open this up as a separate issue, let me know, or you can just reopen this one.

[JelleZijlstra]

In that case you shouldn't use overloads but simply define

class Sub:
    def __add__(self, other: str) -> Sub:
        pass

You'll get an incompatible override error, but that error is correct and expected, so you should type ignore it. (If you don't want to type ignore it, don't make your base class incompatible with the parent class.)

[Dr-Irv]

@JelleZijlstra OK, I'll get closer to what we are trying with pandas-stubs:

from __future__ import annotations
from typing import Generic, TypeVar, overload
from typing_extensions import Never, assert_type

T = TypeVar("T", int, str)


class Base(Generic[T]):
    def __add__(self, other: int | str | list) -> Base:
        return Base()


class Sub(Base[str]):
    @overload  # type: ignore
    def __add__(self, other: str | list[str]) -> Sub:
        ...

    @overload
    def __add__(self, other: int | list) -> Never:
        ...

    def __add__(self, other: int | str | list) -> Sub | Never:
        return Sub()


b = Base()
s = Sub()
br1 = b + 10
s + 10
x = s + "abc"
y = s + [3.0, 4.0]
z = s + ["abc", "def"]

So now I want the expressions s+10 and s + [3.0, 4.0] to show an error. pyright is doing this for us.

[Dr-Irv]

@JelleZijlstra let me know if I should create a new issue for the example I wrote above that uses Generic (or you can reopen this one, or indicate a workaround). Thanks.

[JelleZijlstra]

As I said already, don't use those overloads with Never. Returning Never is for functions that users expect to never return, not for indicating errors.

[Dr-Irv]

As I said already, don't use those overloads with Never. Returning Never is for functions that users expect to never return, not for indicating errors.

So how do I make things work using the example here: #14424 (comment) . I can't use Never as a parameter there to exclude a subset of parameters?