Analyze super() expressions more precisely #7232
Conversation
tavianator
changed the title
|
I've updated the PR to do much more complete typing of |
There was a problem hiding this comment.
Thanks for the updates! Based on a quick pass, this looks pretty solid.
It would be nice if you could split the long method into at least a few smaller ones, however, before a full review. Generally smaller methods that do one thing make things easier to understand and modify, in my experience. This is up to you though. One idea is to extract some (smaller) parts into helper methods. Another idea would be to split it into 2 or more big methods that are invoked in sequence, similar to the original implementation. What do you think?
|
@JukkaL Good call, I split the implementation up a bit so it should be easier to follow. |
|
The CI failure is a socket timeout in mypy/test/testipc.py which I assume is unrelated to this |
| if e.info and e.info.fallback_to_any and base == mro[-1]: | ||
| # There's an undefined base class, and we're at the end of the | ||
| # chain. That's not an error. | ||
| return AnyType(TypeOfAny.special_form) |
There was a problem hiding this comment.
I think that we could use TypeOfAny.from_another_any as the kind here, since this due to fallback_to_any.
There was a problem hiding this comment.
Probably yeah, this is just what the old code did. Is source_any=mro[-1] fine in this case?
There was a problem hiding this comment.
Looks like not, it's just <TypeInfo builtins.object> in that case. I guess that's why it's a special_form.
There was a problem hiding this comment.
Let's keep as it is since that's how it was previously.
| return AnyType(TypeOfAny.from_error) | ||
|
|
||
| # Use the type of the self argument, in case it was annotated | ||
| method = self.chk.scope.top_function() |
There was a problem hiding this comment.
What if this was a nested function within a method?
There was a problem hiding this comment.
Also copied from the old code, but I wouldn't be surprised if this is wrong in that case. I guess we need to walk the scopes to find the current method?
There was a problem hiding this comment.
Oh actually I think this code is right. The Python interpreter uses the innermost function even if it's not a method. Something like
class A:
def f(self): pass
class B(A):
def f(self):
def g():
super().f()
g()
B().f()
gives
RuntimeError: super(): no arguments
testSuperInMethodWithNoArguments already checks for this.
mypy/checkexpr.py
Outdated
|
|
||
| return type_type, instance_type | ||
|
|
||
| def _type_info(self, typ: Type) -> Optional[TypeInfo]: |
There was a problem hiding this comment.
Style nit: since this doesn't use self in the body, this could be changed to a module-level function. If you do this, the name would have to be changed, since we don't generally use _ prefix at module level. Suggestion: type_info_from_type.
The previous implementation assumed that all super(T, x) expressions were for instances of the current class. This new implementation uses the precise types of T and x to do a more accurate analysis. Fixes #5794
| if e.info and e.info.fallback_to_any and base == mro[-1]: | ||
| # There's an undefined base class, and we're at the end of the | ||
| # chain. That's not an error. | ||
| return AnyType(TypeOfAny.special_form) |
There was a problem hiding this comment.
Let's keep as it is since that's how it was previously.
|
Ah okay, I'll keep that in mind for next time. Thanks for merging! |
|
@tavianator This rejects calls where the instance is of type |
|
@msullivan Do you have an example? There is e.g. the test case [case testSuperWithAny]
class B:
def f(self) -> None: pass
class C(B):
def h(self, x) -> None:
reveal_type(super(x, x).f) # N: Revealed type is 'def ()'
reveal_type(super(C, x).f) # N: Revealed type is 'def ()'
reveal_type(super(C, type(x)).f) # N: Revealed type is 'def (self: __main__.B)'which passes. |
|
I'm going to withdraw my report. The basic case seems to work fine. I tripped over a small number cases in internal code but they had a lot of additional complications and to be honest are all pretty heinous, so I'm not going to worry about it. |
The previous implementation assumed that all super(T, x) expressions
were for instances of the current class. This new implementation uses
the precise types of T and x to do a more accurate analysis.
Fixes #5794