functools.singledispatch doesn't verify annotation is on FIRST parameter

[Dutcho]

BPO	40464
Nosy	@rhettinger, @ambv, @Dutcho, @FFY00, @VismantasD, @AlexWaygood
PRs	bpo-40464: fix return annotation being used as the arg annotation in singledispatch #19871

^{Note: these values reflect the state of the issue at the time it was migrated and might not reflect the current state.}

Show more details

GitHub fields:

assignee = None
closed_at = None
created_at = <Date 2020-05-01.07:04:01.217>
labels = ['type-bug', 'library', '3.9', '3.10', '3.11']
title = "functools.singledispatch doesn't verify annotation is on FIRST parameter"
updated_at = <Date 2021-11-09.22:47:09.886>
user = 'https://github.com/Dutcho'

bugs.python.org fields:

activity = <Date 2021-11-09.22:47:09.886>
actor = 'AlexWaygood'
assignee = 'none'
closed = False
closed_date = None
closer = None
components = ['Library (Lib)']
creation = <Date 2020-05-01.07:04:01.217>
creator = 'Dutcho'
dependencies = []
files = []
hgrepos = []
issue_num = 40464
keywords = ['patch']
message_count = 4.0
messages = ['367824', '368079', '368095', '406062']
nosy_count = 6.0
nosy_names = ['rhettinger', 'lukasz.langa', 'Dutcho', 'FFY00', 'bim_bam', 'AlexWaygood']
pr_nums = ['19871']
priority = 'normal'
resolution = None
stage = 'patch review'
status = 'open'
superseder = None
type = 'behavior'
url = 'https://bugs.python.org/issue40464'
versions = ['Python 3.9', 'Python 3.10', 'Python 3.11']

Linked PRs

• gh-84644: Don't single-dispatch on return types #140255

[Dutcho]

From Python 3.7, functools.singledispatch makes the register() attribute of the generic function infer the type of the first argument automatically for functions annotated with types. That's great for DRY.
However, in 3.7 and 3.8, no check is made that the first parameter of the registered function is actually annotated; any annotation suffices, even the return one.

Example:
```
>>> @functools.singledispatch
... def func(arg):...
>>> @func.register
... def _int(arg) -> int:...
>>> @func.register
... def _str(arg) -> str:...

No errors happen, although the return type, *not* `arg`, is annotated.
This results in:
    ```
    >>> func.registry
    mappingproxy({<class 'object'>: <function func>, <class 'int'>: <function _int>, <class 'str'>: <function _str>})

    ```
Obviously, that doesn't dispatch correctly.

Note that un-annotated functions \*are* caught:
    ```
    >>> @func.register
    ... def _no_annotation(arg): ...
    Traceback (most recent call last):
    ...
    TypeError: Invalid first argument to `register()`: <function _no_annotation at 0x000001D769A43D30>. Use either `@register(some_class)` or plain `@register` on an annotated function.
    ```

[Dutcho]

I'm afraid my "even return" was interpreted in #19871 as "only return", while as stated "any annotation" suffices. To rephrase:
If the *first* parameter of the registered function isn't annotated, any non-first annotation suffices for registering, but will not dispatch correctly.
Example:
```
>>> @functools.singledispatch
... def func(arg, x):...
>>> @func.register
... def _int(arg, x:int):...
>>> @func.register
... def _str(arg, x:str):...

No errors happen, although parameter `x` is annotated, not the first parameter `arg`. So `func()` will dispatch on the type of `arg` according to the annotation of `x`.
So I'm afraid the PR solves the specific "return" example case, but not the flagged general issue.

[FFY00]

Right, forgot about that. We can get the first argument name from inspect.signature and then fetch it from the get_type_hints dictionary, I don't know a better way to do it.

[AlexWaygood]

Reproduced on 3.11.