Default argument values in overloaded functions should be taken from actual definition

[Jackenmen]

Is your feature request related to a problem? Please describe.
Currently, the default argument value in the overloaded signatures of the function is used rather than the actual default value that is used which is the default value from the actual function definition.

As an example, for this code the actual default value is None, not ... that is used there just as a placeholder (a common idiom when using @typing.overload):

    @overload
    async def get_shared_api_tokens(self, service_name: str = ...) -> Dict[str, str]:
        ...

    @overload
    async def get_shared_api_tokens(self, service_name: None = ...) -> Dict[str, Dict[str, str]]:
        ...

    async def get_shared_api_tokens(
        self, service_name: Optional[str] = None
    ) -> Union[Dict[str, Dict[str, str]], Dict[str, str]]:
        """Some doc"""
        # actual implementation here

And here's how it's rendered by Sphinx:

Describe the solution you'd like
I would want the function signatures to show the default value used in the actual function definition.

Describe alternatives you've considered
If there's a reason why it could be desired to have the default value from the overloaded function shown, this could be limited to cases where the ellipsis is used as the default value for the overloaded function. I don't think there would be such a reason, but I might be missing something due to how I use these.

Additional context
None

[tk0miya]

(a common idiom when using @typing.overload):

I've not known such an idiom. Could you let me know a pointer about it?

[cleoold]

(a common idiom when using @typing.overload):

I've not known such an idiom. Could you let me know a pointer about it?

Here are some descriptions on mypy website: https://mypy.readthedocs.io/en/stable/stubs.html?highlight=overload#using-stub-file-syntax-at-runtime

Meanwhile in pyright (vs code) library stubs are defined this way.

[Jackenmen]

Wow, looks like this got lost in my read email, sorry for that. What cleoold said is basically what I meant. There's one more thing that I want to present with a bit better code example from what I presented in the issue description.

So, aside from this somewhat being an idiom, some method signatures actually need to do this to avoid runtime effects (either some actual side effect or just some action taking a long time).

Here's an example of what I mean by that (the signature is probably very untypical, but it should be a good enough example presenting the performance cost of defining overload with a default):

@overload
def foo(bar: str) -> int:
    ...

@overload
def foo(bar: Pattern[str] = re.compile("default pattern")) -> str:
    ...

def foo(bar: Union[str, Pattern[str]] = re.compile("default pattern")) -> str:
    """Some doc"""
    # actual implementation

Note: Strictly speaking, re.compile caches patterns so performance cost wouldn't actually be much, but if it didn't cache patterns, it would be more significant

---

Oh, and one issue I noticed with the code I put in the issue description. It doesn't matter much from Sphinx's perspective I guess, but I still want to correct it. The variant with str passed should actually not have a default specified:

    @overload
    async def get_shared_api_tokens(self, service_name: str) -> Dict[str, str]:
        ...
    # everything else as in the issue description

[tk0miya]

Thank you for the pointer. I don't know the technique. Okay, let's adopt the idiom.