Signature inference for special methods

We have the following

class A:
    def __contains__(self, x: int) -> bool:
        return None  # incompatible return value type

class B:
    def __contains__(self, x: int):
        return None  # no error?

Currently, in order to type-check the return type of special methods such as __contains__ or __len__, it is necessary to explicitly type-annotate them, even though it ought to be "obvious" i.e. bool and int respectively.

Suggestion: Add a configuration like automatic-signature-special-methods that will behave as if every special methods are annotated with the correct types. Together with check-untyped-defs (or maybe a lighter configuration like check-untyped-special-methods)

Note that currently Python official documentation has this statement, regarding type annotation for special methods (https://typing.python.org/en/latest/spec/annotations.html)

(Note that the return type of init ought to be annotated with -> None. The reason for this is subtle. If init assumed a return annotation of -> None, would that mean that an argument-less, un-annotated init method should still be type-checked? Rather than leaving this ambiguous or introducing an exception to the exception, we simply say that init ought to have a return annotation; the default behavior is thus the same as for other methods.)

The advantages are

• Avoid mistakes in annotating these methods https://github.com/sagemath/sage/issues/41500
• Less code to read, less mental overhead

Nell’issue non sono indicati file sorgente né test. Inizia tracciando il modo in cui mypy inferisce le firme dei metodi speciali e come è configurato check-untyped-defs; confronta i comportamenti di automatic-signature-special-methods e check-untyped-special-methods. Il lavoro è considerato completato quando sono definiti i metodi speciali supportati e l’interazione della configurazione, con la verifica dei tipi restituiti dimostrata per gli esempi.