Keyword-only protocols are not checked

[mrahtz]

Hi all!

Here's an example of a simple Protocol being used to detect that we're passing a function with the wrong arguments:

from typing import Protocol

class FuncTemplate(Protocol):
  def __call__(self, x: str): pass

def run_func(func: FuncTemplate):
  return func(x='1.0')

def func():
  pass

run_func(func)

As expected, this gives an error:

File "foo.py", line 12, in <module>: Function run_func was called with the wrong arguments [wrong-arg-types]
         Expected: (func: FuncTemplate)
  Actually passed: (func: Callable[[], Any])

But if we make the Protocol kwarg-only:

class FuncTemplate(Protocol):
  def __call__(self, *, x: str): pass

Then the Protocol seems to be ignored:

Success: no errors found

It also seems to be ignored when there's a positional arg in additional to a kwarg-only arg:

class FuncTemplate(Protocol):
  def __call__(self, y: int, *, x: str): pass

def run_func(func: FuncTemplate):
  return func(y=1, x='1.0')

Any idea what might be going on here? Is this a bug, or is there some subtlety about how kwarg-only functions work?

Thanks!

[rchen152]

This is happening because we convert the __call__ method to a Callable type for matching. But if the method contains any elements (like kwonly parameters) that can't be represented with a Callable, we just lose that information. We already have some better method-matching code that we're using for signature compatibility checks; let me see if I can reuse that here instead of the Callable approach.

[rchen152]

This is a little more work than I hoped it would be =/ The signature compatibility checks mostly work as a drop-in replacement, but they don't handle TypeVar substitutions, which are the trickiest part of matching. I'm going to unassign myself for now.

[mrahtz]

Fair enough. Thanks for looking anyway Rebecca!