Flag incomplete implementation on class def instead of instantiation?

[mthuurne]

From the README:

class IAnimal(zope.interface.Interface):
    def say() -> None:
        pass

@zope.interface.implementer(IAnimal)
class Cow(object):
    def say(self) -> None:
        print("Moooo")

The interface IAnimal will be treated as an abstract base class of the implementation Cow: you will not be able to instantiate Cow if interface implementation is incomplete. Incompatible method signatures will be reported as well.

If Cow states it implements IAnimal, and it doesn't implement say(), wouldn't that be an error even if Cow is never instantiated? In other words, I think this error could reported on the class definition instead of on instantiation.

Reporting the error on the implementer's class definition would be an advantage in code bases that don't have 100% type checking coverage: if the code that instantiates the implementer is inside a function that lacks type annotations, mypy will skip that code and the incomplete interface implementation will not be reported.

[kedder]

I agree with that. mypy-zope has a branch protocols, that treats interfaces as typing "protocols", instead of adding them into class hierarchies of implementation. In that world implementation are actually checked against interfaces when they are processed. IOW you would get "incorrect implementation" error on Cow that does not implement say method. It also solves some more issues with current approach, like inconsistent MROs, that happen when complicated interface and implementation class hierarchies met.

Unfortunately I cannot release that branch because mypy is outright rejecting interface adaptation pattern, like IAnimal(context). My attempt to address this in python/mypy#6310 was met with a push-back. Hopefully mypy will grow some mechanisms in the future that would allow to work around this issue, but for now this branch is on hold.