[red-knot] Simplify tuples containing Never

[sharkdp]

Summary

Simplify tuples containing Never to Never:

from typing import Never

def never() -> Never: ...

reveal_type((1, never(), "foo"))  # revealed: Never

I should note that mypy and pyright do not perform this simplification. I don't know why.

There is only one place where we use TupleType::new directly (instead of Type::tuple, which changes behavior here). This appears when creating TypeVar constraints, and it looks to me like it should stay this way, because we're using TupleType to store a list of constraints there, instead of an actual type. We also store tuple[constraint1, constraint2, …] as the type for the constraint1, constraint2, … tuple expression. This would mean that we infer a type of tuple[str, Never] for the following type variable constraints, without simplifying it to Never. This seems like a weird edge case that's maybe not worth looking further into?!

from typing import Never

#         vvvvvvvvvv
def f[T: (str, Never)](x: T):
    pass

Test Plan

• Added a new unit test. Did not add additional Markdown tests as that seems superfluous.
• Tested the example above using red knot, mypy, pyright.
• Verified that this allows us to remove contains_never from the property tests ([red-knot] Property tests #14178 (comment))

[github-actions]

ruff-ecosystem results

Linter (stable)

✅ ecosystem check detected no linter changes.

Linter (preview)

✅ ecosystem check detected no linter changes.

[carljm]

Looks great!

[AlexWaygood]

nit: this method now feels a bit redundant. I'd probably have got rid of it and changed the callsites to use the new TupleType::from_elements() method

[AlexWaygood]

I should note that mypy and pyright do not perform this simplification. I don't know why.

Mypy in general appears not to do much eager simplification at all, e.g. it doesn't even simplify this union:

def f(x: int | int):
    reveal_type(x)  # mypy: revealed type is "Union[builtins.int, builtins.int]"

Pyright does a lot more eager simplification than mypy. But it's important to note, I think, that it's only relatively recently that we formalized the idea that Never/NoReturn constitute the bottom type in Python. Mypy has historically always treated it as such, but I think pyright only started treating it as such relatively recently. So the issue of simplification may just not have been considered. This is just speculation, though!