Shouldn't get_args(Literal[...]) be usable for type narrowing?

[ReggX]

Currently, it's possible to use if value in (0, 1, 2, 3) to apply type narrowing for value down to Literal[0, 1, 2, 3].

During runtime, using typing.get_args() on Literal[0, 1, 2, 3] returns (0, 1, 2, 3), so value in get_args(Literal[0, 1, 2, 3]) has the same result as value in (0, 1, 2, 3). Shouldn't type checkers be able to do the same deduction statically?

Here's some simple example code, tested in mypy and pyright, both give builtins.int for the two reveal_type(value) calls.

from typing import Literal
from typing import TypeAlias
from typing import get_args


SUBLIT: TypeAlias = Literal[0, 1, 2]
LIT: TypeAlias = Literal[SUBLIT, 3]

 
def test_function(value: int) -> None:
  reveal_type(value)  # should be and is builtins.int
  if value in get_args(LIT):
    reveal_type(value)  # should be Literal[0, 1, 2, 3], but is builtins.int

print(get_args(LIT))

[erictraut]

The type definition for get_args in typing.pyi is:

    def get_args(tp: Any) -> tuple[Any, ...]: ...

So, unless a type checker were to special-case this function to override the type stub definition, the return result will be tuple[Any, ...]. The get_args call is typically used only for dynamic expressions, so even with special-casing, a static type checker wouldn't be able to determine a more specific return type in most cases.

[ReggX]

Of course typing.pyi wouldn't be able to reflect the complete reality of runtime behaviour. But that's also not what I'm asking for.

I'm specifically asking for the special case of in get_args(Literal[ narrowing down the variable to the Literal, not the general case of statically determining every return type of get_args, that would be overkill.

This only works because Literal contains values instead of just types, so __contains__ can compare the variable against the sequence of values.

[JelleZijlstra]

Type checkers use a variety of patterns for type narrowing and this is generally not standardized. You can request that specific type checkers add narrowing support specifically for get_args(Literal[...]), but the pattern seems too rare for that to be generally useful.