Fix bug with inferring bad arguments to overloads #5660
Conversation
Currently, it seems that when checking overloads, mypy starts by inferring the argument types in an empty context and swallows any errors generated in the process. Mostly likely what the old overload implementation did next was recheck the arguments against the selected overload variant, regenerating any errors as necessary. However, in the new overload implementation, it's unclear if we consistently do the same thing, mostly due to how we slice and dice the arguments to do things like union math. This pull request does the low-effort thing and just removes the error suppression. This pull request also does some unrelated clean-up -- apparently, the `callee` argument to 'infer_arg_types_in_context` is always 'None'. Fixes python#5659.
|
Note: I haven't tested this in our internal repos yet. |
| arg_types = self.infer_arg_types_in_context(None, args) | ||
| self.msg.enable_errors() | ||
|
|
||
| arg_types = self.infer_arg_types_in_empty_context(args) |
There was a problem hiding this comment.
At first I was sceptical about this, but after some thinking and playing it seems to me this is actually OK. Because under the hood all relevant possibilities (even the union math) go through infer_overload_return_type, that calls check_call with a CallableType item that, in turn, will trigger infer_arg_types_in_context using current matching overload item arg type as context. So it should be fine.
mypy/checkexpr.py
Outdated
| For example, if callee argument 2 has type List[int], infer the | ||
| argument expression with List[int] type context. | ||
| In short, we basically recurse on each argument without considering | ||
| in what context the argument was called. | ||
| """ | ||
| # TODO Always called with callee as None, i.e. empty context. |
|
|
||
| foo(bar('lol').foo()) # E: Argument 1 to "bar" has incompatible type "str"; expected "int" \ | ||
| # E: Item "int" of "Union[A, int]" has no attribute "foo" | ||
|
|
There was a problem hiding this comment.
I would add few tests about situations where absence of context can cause troubles (so that this will not regress). For example something like this:
def g(x: Optional[T] = None) -> List[T]: ...
@overload
def f(x: int) -> int: ...
@overload
def f(x: List[int]) -> List[int]: ...
def f(x):
pass
reveal_type(f(g()))I would also add something like
@overload
def g(x: List[str]) -> List[str]: ...
@overload
def g(x: List[int]) -> List[int]: ...
def g(x):
pass
@overload
def f(x: int) -> int: ...
@overload
def f(x: List[int]) -> List[int]: ...
def f(x):
pass
reveal_type(f(g([])))but this one unfortunately causes an error both on master and with this PR. Probably this is something we should fix, but I am afraid this may depend on #4872 (but this is just a guess).
|
@ilevkivskyi (or maybe @msullivan?) -- this is ready for a second look whenever |
Currently, it seems that when checking overloads, mypy starts by inferring the argument types in an empty context and swallows any errors generated in the process.
Mostly likely what the old overload implementation did next was recheck the arguments against the selected overload variant, regenerating any errors as necessary.
However, in the new overload implementation, it's unclear if we consistently do the same thing, mostly due to how we slice and dice the arguments to do things like union math.
This pull request does the low-effort thing and just removes the error suppression.
This pull request also does some unrelated clean-up -- apparently, the
calleeargument to 'infer_arg_types_in_context` is always 'None'.Fixes #5659.