Nested sequence type fails to detect errors

[charbonnierg]

A solution has been proposed by @BvB93 in python/mypy#731 (comment) to implement nested sequence type using Protocol.

This solution is used by numpy._typing._nested_sequence._NestedSequence.

When a function argument is annotated as _NestedSequence[int], mypy does not raise errors when literal values are used:

def func1(a: _NestedSequence[int]) -> int: ...


# Fails as expected:
# Incompatible types in assignment (expression has type "int", variable has type "_NestedSequence[int]")  [assignment]mypy(error)
v1 = func1(1)   # type: ignore[arg-type]

# Does not fail as expected
v2 = func1([1])
# Does not fail as expected
v3 = func1([[1]])

# Does not fail, but I expected a failure
v4 = func1(["a"])  # [arg-type] error expected
v5 = func1([["a"]])  # [arg-type] error expected

# Does fail as expected
input_: List[str] = ["a"]
input__: List[List[str]] = [["a"]]
v4_ = func1(input_) # type: ignore[arg-type]
v5 = func1(input__) # type: ignore[arg-type]

I tried to look for more information on github issues or google, but could not find whether this is a known limitation or not, or what would explain this behavior.

If someone can share some thoughts it would be much appreciated !

Thanks

[Akuli]

Minimal reproducer:

from __future__ import annotations
from typing import Iterator, overload, TypeVar, Protocol

_T_co = TypeVar("_T_co", covariant=True)

class _NestedSequence(Protocol[_T_co]):
    def __len__(self, /) -> int: ...
    @overload
    def __getitem__(self, index: int, /) -> _T_co | _NestedSequence[_T_co]: ...
    @overload
    def __getitem__(self, index: slice, /) -> _NestedSequence[_T_co]: ...
    def __iter__(self, /) -> Iterator[_T_co | _NestedSequence[_T_co]]: ...
    def __reversed__(self, /) -> Iterator[_T_co | _NestedSequence[_T_co]]: ...

def foo(x: _NestedSequence[int]) -> None:
    pass

foo(["lol"])  # no error

This appears to be a bug in mypy. With pyright, I get an error from foo(["lol"]) as expected.