Weird formatting of __new__ signature in error messages

[GoldsteinE]

from typing import Tuple, Dict, Any


class MyMeta(type):
    def __new__(cls, name: str, bases: Tuple[type, ...], dict: Dict[str, Any]) -> type:
        return type.__new__(name, bases, dict)

This MyMeta.__new__ has exactly same signature with type.__new__ in typeshed:
https://github.com/python/typeshed/blob/master/stdlib/3/builtins.pyi#L88
But mypy thinks that it's incorrect and offers me to write two same cls args:

test.py:6: note: Possible overload variants:
test.py:6: note:     def __new__(cls, cls: Any, o: object) -> type
test.py:6: note:     def __new__(cls, cls: Any, name: str, bases: Tuple[type, ...], namespace: Dict[str, Any]) -> type

No mypy flags was used, mypy --version is 0.620

[ilevkivskyi]

First of all mypy is right that there is an error. If you try to use your metaclass, it will fail at runtime:

>>> class C(metaclass=MyMeta): ...
... 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in __new__
TypeError: type.__new__(X): X is not a type object (str)

Mypy doesn't say your signature is wrong, it says the method call is wrong (check the line number).

The only problem here is a weird signature formatting in the error message.

[armooo]

Looking into this bug and it seems to be caused by caching. I can only reproduce the double cls when running mypy twice in a row like example.

> rm -rf .mypy_cache/; ~/src/mypy/env/bin/mypy test.py; ~/src/mypy/env/bin/mypy test.py
test.py:5: error: No overload variant of "__new__" of "type" matches argument types "str", "Tuple[type, ...]", "Dict[str, Any]"
test.py:5: note: Possible overload variants:
test.py:5: note:     def __new__(cls: Type[type], o: object) -> type
test.py:5: note:     def __new__(cls: Type[type], name: str, bases: Tuple[type, ...], namespace: Dict[str, Any]) -> type
test.py:5: error: No overload variant of "__new__" of "type" matches argument types "str", "Tuple[type, ...]", "Dict[str, Any]"
test.py:5: note: Possible overload variants:
test.py:5: note:     def __new__(cls, cls: Type[type], o: object) -> type
test.py:5: note:     def __new__(cls, cls: Type[type], name: str, bases: Tuple[type, ...], namespace: Dict[str, Any]) -> type

[AlexWaygood]

The error message is different on 0.941, but the weird cls, cls thing is still there:

main.py:6: error: Returning Any from function declared to return "type"
main.py:6: error: No overload variant of "__new__" of "type" matches argument types "str", "Tuple[type, ...]", "Dict[str, Any]"
main.py:6: note: Possible overload variants:
main.py:6: note:     def __new__(cls, cls: Type[type], object) -> type
main.py:6: note:     def [_TT <: type] __new__(cls, cls: Type[_TT], str, Tuple[type, ...], Dict[str, Any], **kwds: Any) -> _TT

Contrary to @armooo, I can reproduce this on mypy playground and locally without a cache, so I don't think this is related to caching.