Factory class methods that return instance are hinted incorrectly when called explicitly from subclass

[juanpablos]

Environment data

• Language Server version: 2020.9.5
• OS and version: Windows 10
• Python version (& distribution if applicable, e.g. Anaconda): Python 3.8.5

Expected behaviour

Having a class method that returns an instance of the class, if the class method is called from the subclass the type hint should be the subclass.

Actual behaviour

The type hint is the super class, where the class method is defined.

Code Snippet / Additional information

Here is a trivial example that shows the issue.

T = TypeVar('T', bound='A')

class A:
	@classmethod
	def factory(cls: Type[T]) -> T:
		return cls()

class B(A):
	@classmethod
	def factoryB(cls):
		# with super().factory() happens the same
		return super(B, cls).factory()


# these are OK
a = A() # this is A, hinted as A
a_factory = A.factory() # this is A, hinted as A
b = B() # this is B, hinted as B
b_factory = B.factory() # this is B, hinted as B

# this should be hinted as B
b_factoryB = B.factoryB() # this is B, but it is hinted as A

What I am trying to do is actually override the class method and call the super class one with additional arguments. But I noticed calling the class method of the super class explicitly type hints incorrectly.

[erictraut]

Thanks for the bug report. You are correct. Pylance was not correctly handling the second argument of the two-argument form of the super call. This will be fixed in the next release.

[jakebailey]

This issue has been fixed in version 2020.9.6, which we've just released. You can find the changelog here: https://github.com/microsoft/pylance-release/blob/master/CHANGELOG.md#202096-23-september-2020

[eddy-geek]

I confirm this works (with 2021.3.0 now)

But this looks to me like a workaround -- why do we need to explicitly bind and annotate cls: Type[T]?

Without it, pylance inferred type for factory is (cls: Type[A]) -> A instead of the generic one.
I expect pylance to infer the generic bounds (and then infer B.factory() will return a B) on its own?

My very similar motivating example:

class A:
    @classmethod
    def factory(cls):
        return cls()

class B(A):
    def methodB(self):
        pass

B().factory().methodB()

Output: Cannot access member "methodB" for class "A"

[erictraut]

Internally, Pylance synthesizes generic types for self and cls if they don't have explicit type annotations. In this case, the synthesized type for cls is a type variable that is bound to A. (We don't display this synthesized TypeVar in the hover text because it would be confusing, so it simply appears as A.)

As for the return type of the factory method, that needs to be inferred because there is no specified return type annotation. If you were to change the method body to simply return cls (without the parentheses), you would see that the inferred type of the expression B.factory() is Type[B]. But when cls is instantiated, it's being specialized to its bound type A, so the inferred type of the expression B.factory() is A. I agree that there's no need in this case to specialize the resulting instance, so I've changed the code to retain the generic type for purposes of return type inference. With this change, it will act as you expect. The inferred type of the expression B.factory() is now B. This change will be in the next release.