Depedently typed function overloads returns are treated as unions

[SlayerOfTheBad]

This is likely related to #1416 , hence the similar naming.

I have the following file

from typing import overload

class Foo:
    pass

class FooBuilder:
    def func_foo(self):
        pass

class Bar:
    pass

class BarBuilder:
    def func_bar(self):
        pass

@overload
def get_obj(input: type[Foo]) -> FooBuilder: ...

@overload
def get_obj(input: type[Bar]) -> BarBuilder: ...

def get_obj(input: type):
    pass

builder = get_obj(Foo)
builder

Using pylsp (which uses Jedi for its completion) in neovim, I get suggested the functions for both FooBuilder and BarBuilder.

The example in #1416 does work, so I know I've got that fix integrated in my system.
Because of this, I assume this has something to do with type[T] resolution, rather than overload resolution.

Version:

jedi                  0.19.1

[PeterJCLaw]

From a quick look I suspect this could be a more general issue with how type is handled. For example the following also fails:

from typing import overload

class Custom: pass

@overload
def func_a(x: type[Custom]) -> int:
    ...

@overload
def func_a(x: float) -> str:
    ...

def func_a(x):
    pass

t: type[Custom]

j = func_a(t)
j

When running this under sith.py with debugging enabled we get a warning which seems to stem from trying to execute type(..) as part of setting up the annotation to t. I'm not sure if that's actually related to the overloads issue though, since just inferring the type of t (again via sith) does seem to get the right result.