What should the type of super() be?

[timabbott]

I found this new error that seems to have escaped a type: ignore when trying out the mypy 0.501:

zerver/storage.py:47: error: "super" has no attribute "post_process"

The code in question is https://github.com/zulip/zulip/blob/master/zerver/storage.py, the relevant block is the super_ret line below:

        super_class = super(AddHeaderMixin, self) # type: ignore # https://github.com/JukkaL/mypy/issues/857      
        if hasattr(super_class, 'post_process'):                                                                  
            super_ret = super_class.post_process(paths, dry_run, **kwargs)                                        
        else:                                                                                                     
            super_ret = []                                                                                        

I'll just add another type: ignore on the super_ret line for now, but I think it's a bug that mypy didn't suppress that.

[JelleZijlstra]

I think mypy's behavior is correct here. # type: ignore suppresses type errors on the line it's on, but it doesn't do anything to variables defined on that line. You should instead put # type: Any on that line to make sure mypy doesn't complain about later uses of super_class.

I like using mypy's --warn-unused-ignores option to alert me about redundant # type: ignore comments.

[timabbott]

I thought I posted a reply, but it appears to have been lost.

I can't use the --warn-unused-ignores in general; I just opened #2961 for why.

But the above type: ignore code did pass and was not unused in the last release, so this is a behavior change, and I think it makes sense to investigate why.

(Though for my application, I'd rather someone fix the bug with super() that makes us need to do this in the first place)

[gvanrossum]

Hm, yeah. I can repro this:

class B:
  def bar(self) -> None: pass

class C(B):
  def foo(self) -> None:
    x = super(C, self)
    reveal_type(x)
    x.bar()

It seems you don't need to ignore the super() call any more, but the variable x now has type super which is not what you want. I don't recall when this was changed but it seems likely it was.

[gvanrossum]

Here's the culprit: python/typeshed#867

[gvanrossum]

One problem is that the type of super() is problematic (at least when there's multiple inheritance, which is what it was invented for in the first place): in class C(A, B): ... the type of super() is not representable by an existing class. I guess we could special-case this further and synthesize a class that also derives from A and B but does not have C's attributes.