Should non-overlapping comparisons allowed in assertions?

[JukkaL]

The following assertion generates an error when using --strict-equality, but perhaps it should be allowed, since an assertion can test something that should be impossible?

from typing import List

def f(x: List[int]) -> None:
    assert 'foo' not in x  # Error, but should this be okay?
    ...

I saw a few examples similar to the above in production code and had to use # type: ignore[...] with them, which didn't feel optimal.

@ilevkivskyi What do you think?

[JelleZijlstra]

A similar pattern I have seen is:

def f(x: int) -> None:
    if x is None:
        raise TypeError("you fooled the typechecker")  # unreachable code
    ...

[ilevkivskyi]

I think we can allow these patterns, but I didn't see many of them (also IIRC None is already special-cased with --strict-equality to avoid such false positives). Also some of these may be a bit tricky to implement.

Potentially we can focus on allowing the negative asserts (i.e. not in, !=, is not) for non-overlapping types.

[JukkaL]

Potentially we can focus on allowing the negative asserts (i.e. not in, !=, is not) for non-overlapping types.

Since these cases seem pretty rare, I'd prefer to only tweak these quite selectively to avoid real false negatives (e.g., only in assertions and/or when raising an exception).