Would it be possible to type narrow overloads after the fact?

[JanEricNitschke]

I have a case where i have an overloaded function where the different return types largely overlap. So regardless of which overload is chosen there is a lot of work that can be performed on any of the return types.

The setup is basically like func/func2 in this:

from typing import Literal, overload

@overload
def func(a: Literal[1]) -> str:
    ...

@overload
def func(a: Literal[2]) -> int:
    ...

def func(a: Literal[1, 2]) -> str | int:
    return "1" if a == 1 else 2

def func2(value: Literal[1, 2]) -> None:
    stuff = func(value)
    if value == 1:
        # Do specific stuff1
        reveal_type(stuff)
    else:
        # Do specific stuff2
         reveal_type(stuff)
    # Do general stuff

def func3(value: Literal[1, 2]) -> None:
    if value == 1:
        # Do specific stuff1 AND general stuff
        reveal_type(func(value))
    else:
        # Do specific stuff2 AND general stuff
         reveal_type(func(value))

func2(1)
func2(2)
func3(1)
func3(2)

func2 would allow me to reduce duplication, but does not type check because obviously the type checker does not remember that the narrowing of stuff depends on value. Meanwhile func3 typechecks but i have duplication.

Is there any chance that something like this could be introduced or am i missing (some obvious?) issues that this would introduce (besides the possible enormous work that might have to be done)?

Playground link

[erictraut]

I don't think this is feasible. It's unlikely that this would ever be implemented. See this comment for the reasoning.

The technique you're using in func3 is the approach I recommend. If you have common code in both cases, perhaps you can try to refactor it into a subroutine to avoid duplication.