[Feature Request]Allow specifically turning off diagnosis Type of parameter "self" must be a supertype of its class

[Azureblade3808]

I'd like to find a way to silence reports of Type of parameter "self" must be a supertype of its class without turning off reportGeneralTypeIssues.

There are many times that I need to restrict the type of self into a smaller subset, mostly with mixins and metaclasses. For mixins, it can be resolved by conforming to typing.Protocol. But for metaclasses, same actions cannot be done because there are conflicts between type and typing.Protocol.

Sample --

# pyright: strict
# pyright: reportUnnecessaryTypeIgnoreComment = true

from __future__ import annotations

from typing import Any, Generic, Self, TypeVar, override

_T = TypeVar("_T")


class _UpcastMetaclass(type):
    @override
    def __call__(
        self: type[_Upcast[_T]],  # pyright: ignore[reportGeneralTypeIssues]
        x: _T,
        /,
    ) -> _T:
        return x


class _Upcast(Generic[_T], metaclass=_UpcastMetaclass):
    def __class_getitem__(cls, key: Any, /) -> type[Self]:
        return cls


upcast = _Upcast


def type_check() -> None:
    from typing_extensions import assert_type

    _ = assert_type([0], "list[int]")
    _ = assert_type([upcast["object"](0)], "list[object]")
    
    # The following line must not pass type-checking.
    _ = upcast["str"](0)  # pyright: ignore[reportArgumentType]

See line 14. The # pyright: ignore[reportGeneralTypeIssues] comment is working, but I feel a bit nervous using it as it sometimes can shadow other real problems.

I have an alternative solution like --

...

class _UpcastMetaclass(type):
    @overload
    def __call__(self: type[_Upcast[_T]], x: _T, /) -> _T: ...  # pyright: ignore[reportInconsistentOverload]

    @override
    def __call__(self, x: Any, /) -> Any:
        return x

...

, but the usage of overload is not intuitive and deviates from its original purpose.

[chdoc]

This would be very much appreciated. I am working with an API of a closed-source software package that requires the user to define decorated "action classes" whose contents are essentially treated like static methods:

@ctx.action_class("user")
class UserActions:
    def code_insert_function(text: str, selection: str):
        <implementation irrelevant>

Thus, this leads to a false positive whenever the first argument of such a function has a type annotation. Further, functions inside these classes tend to be numerous and short, meaning that annotating them individually with @staticmethod would clutter the code base significantly.

Of course, it would be even better if one could inform pyright that these annotations mean that everything in the class is treated as a static method, but this sounds like a much bigger change.