We claimed that there are two disadvantages to overrides:
it makes code more verbose, and requires developers to update
subclasses when possibly-breaking changes happen to base classes.
In discussion, it was pointed out that the second disadvantage is
kind of strange - it is exactly the same as the advantage of
using @override in the first place because the whole point is that
it is not usually safe to assume subclasses can be unchanged when
a method they override is removed from a base class.
I think just pointing out verbosity is good enough, I think it's
understood that more verbose code potentially requires more edits
to change, and in reality I think the case when it was safe to
ignore invalidated overrides is pretty rare so making that a big
focus seems a little weird.
At this time, Pyre still does not have strict override enforcement.
This (and supporting codemod tools) are still something we want,
but given that we have not yet delivered this and do not have a firm
ETA we should not make claims about specific plans in the PEP text.
We decided to add this for two reasons:
- It was specifically requested by the author of the `overrides`
library, because there there are some handy runtime uses
of override information (such as propagating docstrings, which
we highlight as a concrete example)
- We realized that we actually added `__final__` to
`@typing.final` in spite of it not being specified in PEP 591,
which we felt strongly suggests that even if we omit it we
would later change our minds.
This runtime behavior is currently implemented in typing_extensions
(see https://github.com/python/typing_extensions/pull/86) as well
as pyre_extensions.
Steven Troxler
tk-woven
Brett Cannon
Mikko Korpela
Jelle Zijlstra
Zachary Blackwood