[red-knot] Narrowing on in tuple[...] and in str

[MatthewMckee4]

Summary

Part of #13694

Seems there a bit more to cover regarding in and other types, but i can cover them in different PRs

Test Plan

Add in.md file in narrowing conditionals folder

[github-actions]

mypy_primer results

No ecosystem changes detected ✅

[MatthewMckee4]

Okay, i realise this is not right

from typing import Literal

def _(x: Literal["a", "b", "c", "d"]):
    if x in "abc":
        reveal_type(x)  # revealed: Literal["a", "b", "c"]
    else:
        reveal_type(x)  # revealed: Literal["d"]

The true type is Literal["a", "b", "c", "ab", "ac", "bc", "abc"]. So i should just infer as str right?

Edit: In fact im wrong in this instance, but if the argument x was str then i think this is the case?

[MatthewMckee4]

Im a bit unsure about if we should support other types in str. For example we have these right now:

def _(x: Literal["a"]) -> None:
    if x in "abc":
        reveal_type(x) # revealed: Literal["a"]

def _(x: Literal["a", "b"]) -> None:
    if x in "abc":
        reveal_type(x) # revealed: Literal["a", "b"]

def _(x: str) -> None:
    if x in "abc":
        reveal_type(x) # revealed: str

but we also have:

def _(x: object) -> None:
    if x in "abc":
        reveal_type(x) # revealed: Literal["a", "b", "c"]

*we also get [unsupported-operator] error here
but i feel like this should be str.

My thinking for all StringLiteral and Union containing only StringLiteral, we can narrow the type, but otherwise we can only infer as str? How does this sounds.

[carljm]

Haven't reviewed the code yet, just the tests, but there are some things we'll have to be a bit more conservative about here.

[MatthewMckee4]

Okay thank you, I'll look over this again

[carljm]

The behavior here looks good! I think we can simplify the implementation and make it a bit more general.

[MatthewMckee4]

Thank you