False positive `bad-override` in mixin + concrete base multiple inheritance

[lolpack]

Describe the Bug

Pyrefly reports bad-override for a class inheriting from a mixin method using *args/**kwargs and a concrete base method with a concrete signature. Pyright accepts this pattern.

from typing import Any

class LogMixin:
    def execute(self, *args: Any, **kwargs: Any) -> Any:
        pass

class BaseExecutor:
    def execute(self, command: str) -> str:
        return command

class LoggedExecutor(LogMixin, BaseExecutor):
    def execute(self, command: str, log: bool = True) -> str:
        return command

This appears to be a false positive around override signature compatibility in MRO scenarios.

Sandbox Link (Pyrefly)

https://pyrefly.org/sandbox/?project=N4IgZglgNgpgziAXAAlHAhgOwCYCMD2AHgHQAOAnksuAE74C2yALuaRJgObIT2n41NkAQUzkAOpgkBjKOjhxkAGXwcAshELtEE5LuTYYYZDEIwpAVyYwAFHBhQwAGmQAqdDQ5wUI8s5cuAawB3d09vUQBKZABaAD5hUW1MPRTkUjk4CWlZeWQAITkYAFFTCyZ%2BJJSDIxMzSxs7B2cpBnosbBQ4JhoouOQumkrU3RoYJnMaZJb6NpwszBkMpRUOGGwSuvKaa2U1DXZnArsNsv4Iod1q41L623snZGnZjv7u5ygVFAJ8KGQAXmQABUaOYYL14gMLqlRuNJo9Wu0QABfZwgdBSJgQABuMAAYtAYFQQBgcAQSBRkUA

Reference (Pyright)

https://pyright-play.net/?code=GYJw9gtgBALgngBwJYDsDmUkQWEMoCCKcAUCQMYA2AhgM61QAyYaAskgB6oBcJU-UACYBTYFGEdh5AK4xhAClrDKwADRQAVNRBpa3QsXUaNAawDu23fqJwAlFAC0APgNxeAj1AR1aZKj6gAITphAFFJGRhcdwERMQkpWQUlFXVySAhqFEF9WhgQe2coPJAYzygQYRhpEBQodIhM7L8aeiYWNGFBcMSokHlmNk5UdWClHsjcWzKhUXEIpMVlNXqMrJzi-PVKFn0AIzAwSigAXigAFRBpYUKXEpmPSura1cb1oA

Sandbox Link

No response

(Only applicable for extension issues) IDE Information

No response

[grievejia]

I think the error is not a false positive in the technical sense: LogMixin is the immediate successor on LoggedExecutor's MRO. So LoggedExecutor.execute() is indeed overriding LogMixin.execute(). You can check that by changing the *args and **kwargs signature of LogMixin.execute() to something more concrete -- as long as it doesn't match that of LoggedExecutor.execute(), all type checkers would complain.

So technically speaking Pyrefly is pointing out a legit issue: LogMixin.execute() requires that it can take arbitrary arguments, so having subclasses override to take specific arguments would be violating substitution principle. For example,

class LogMixin:
    def execute(self, *args: Any, **kwargs: Any) -> Any:
        pass

class LoggedExecutor(LogMixin):
    def execute(self, command: str, log: bool = True) -> str:
        return command

def test(x: LogMixin) -> str:
  return x.execute(0, 1)  # No type error. But a runtime crash

test(LoggedExecutor())

That said, I'm guessing what happens here is that most type checkers would special-case the *args, **kwargs case and skip override checks on those because too many people intend to use that pattern to mean that "I want to preserve the original signature of the overriding function", not "I want to change the signature of the overriding function to take arbitrary arguments", even though at runtime the latter is what really happens.

Perhaps we could do the same by default, but separating out a different error code so it can be made visible if people really want strict checking?