**kwargs checked against wrong type with defaults or *args

[kcr]

def a(*args: str, **kw: int) -> None:
    b(**kw)
    b('', **kw)
    c(**kw)
    c('', **kw)

def b(args: str='', **kw: int) -> None:
    pass

def c(*args: str, **kw: int) -> None:
    pass

results, with 0.4.3:

/tmp/minimize.py: note: In function "a":
/tmp/minimize.py:2: error: Argument 1 to "b" has incompatible type **Dict[str, int]; expected "str"
/tmp/minimize.py:4: error: Argument 1 to "c" has incompatible type **Dict[str, int]; expected "str"

[gvanrossum]

Can you try again with the latest revision from the repo? I fixed some things in this area recently.

[gvanrossum]

Never mind. I can still repro this.

[gnprice]

The logic the code might be implementing here, at least in the call to b, is that it's possible 'args' is a key in kw, in which case we'd be passing an int to a parameter of type str.

That logic doesn't seem to apply in the second case, though, which would make that a bug.

In the b case it's possible this is the kind of unsoundness we'd rather allow, because it's probably cumbersome to explicitly prevent it in this code. Even if we do give an error for it, this error message isn't really on point about what the issue is, and if nothing else we should make it clearer.

[gnprice]

And thanks, Karl, for the report!

[gvanrossum]

In particular, calling a(args=0) would end up calling b(args=0) which is a bug in your code. But the same reasoning doesn't apply to c(**kw), so that's a bug in mypy.

[elazarg]

This can be fixed by adding at checkexpr.py#L1980 (right below the comment referring to that situation)

-    if ((callee_names[j] and no_certain_match)
                    or callee_kinds[j] == nodes.ARG_STAR2):
+    if ((callee_names[j] and no_certain_match and callee_kinds[j] != nodes.ARG_STAR)
                    or callee_kinds[j] == nodes.ARG_STAR2):

However, it raises another error for the following file. I wonder whether this is the expected behavior:

def a(**kw: int) -> None:
    a(**kw)
    c(**kw)
    d(**kw)

def b(a: int) -> None: pass
def c(*args: str) -> None: pass
def d() -> None: pass

def x(*args: int) -> None:
    y(*args)
    z(*args)
    q(*args)

def y() -> None: pass
def z(**kw: int) -> None: pass
def q(a: int) -> None: pass

Result:

tmp.py: note: In function "a":
tmp.py:3: error: Too many arguments for "c"
tmp.py:4: error: Too many arguments for "d"
tmp.py: note: In function "x":
tmp.py:16: error: Too many arguments for "y"
tmp.py:17: error: Too many arguments for "z"

Perhaps that's intentional, but I don't see why the empty *args and the empty **kw are discriminated.
The situation with *args is the current behavior, irrelevant to the change. It's explicitly checked for in the code for being an empty tuple, emitting error otherwise. why?

If the suggested solution seems valid, I can open a PR.

[ilevkivskyi]

(This appeared two more times so raise priority to normal)