Merge remote-tracking branch 'origin/1.12.x' into 2.1.x

Author: ondrejmirtes

src/Reflection/Type/CalledOnTypeUnresolvedMethodPrototypeReflection.php

@@ -10,9 +10,7 @@
 use PHPStan\Reflection\ExtendedParametersAcceptor;
 use PHPStan\Reflection\Php\ExtendedDummyParameter;
 use PHPStan\Reflection\ResolvedMethodReflection;
-use PHPStan\Type\Generic\GenericObjectType;
 use PHPStan\Type\Generic\GenericStaticType;
-use PHPStan\Type\ObjectType;
 use PHPStan\Type\StaticType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeTraverser;
@@ -118,8 +116,11 @@ private function transformStaticType(Type $type): Type
 	{
 		return TypeTraverser::map($type, function (Type $type, callable $traverse): Type {
 			if ($type instanceof GenericStaticType) {
-				if ($this->calledOnType instanceof ObjectType) {
-					return $traverse(new GenericObjectType($this->calledOnType->getClassName(), $type->getTypes()));
+				$calledOnTypeReflections = $this->calledOnType->getObjectClassReflections();
+				if (count($calledOnTypeReflections) === 1) {
+					$calledOnTypeReflection = $calledOnTypeReflections[0];
+
+					return $traverse($type->changeBaseClass($calledOnTypeReflection)->getStaticObjectType());
 				}
 
 				return $this->calledOnType;

src/Type/Generic/GenericStaticType.php

@@ -6,6 +6,7 @@
 use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode;
 use PHPStan\PhpDocParser\Ast\Type\TypeNode;
 use PHPStan\Reflection\ClassReflection;
+use PHPStan\ShouldNotHappenException;
 use PHPStan\Type\CompoundType;
 use PHPStan\Type\IsSuperTypeOfResult;
 use PHPStan\Type\NeverType;
@@ -36,6 +37,9 @@ public function __construct(
 		private array $variances,
 	)
 	{
+		if (count($this->types) === 0) {
+			throw new ShouldNotHappenException('Cannot create GenericStaticType with zero types.');
+		}
 		parent::__construct($classReflection, $subtractedType);
 	}
 
@@ -72,12 +76,16 @@ public function getStaticObjectType(): ObjectType
 		return $this->staticObjectType;
 	}
 
-	public function changeBaseClass(ClassReflection $classReflection): self
+	public function changeBaseClass(ClassReflection $classReflection): StaticType
 	{
 		if ($classReflection->getName() === $this->getClassName()) {
 			return $this;
 		}
 
+		if (!$classReflection->isGeneric()) {
+			return new StaticType($classReflection);
+		}
+
 		// this template type mapping logic is very similar to mapping logic in MutatingScope::exactInstantiation()
 		// where inferring "new Foo" but with the constructor being only in Foo parent class
 

tests/PHPStan/Analyser/nsrt/generic-static.php

@@ -74,7 +74,7 @@ public function doBar(self $s): void
 
 		assertType('GenericStatic\\FooImpl<float, string>', $s->flip());
 		assertType('GenericStatic\\FooImpl<string, float>', $s->fluent());
-		assertType('GenericStatic\FooImpl<string, GenericStatic\FooImpl<float>>', $s->nested());
+		assertType('GenericStatic\FooImpl<string, GenericStatic\FooImpl<float, mixed>>', $s->nested());
 	}
 
 }
@@ -97,6 +97,7 @@ public function fluent()
 	 */
 	public function test(self $s): void
 	{
+		assertType('static(GenericStatic\Inconsistent<T (class GenericStatic\Inconsistent, argument), U (class GenericStatic\Inconsistent, argument)>)', $this->fluent());
 		assertType('GenericStatic\\Inconsistent<int, string>', $s->fluent());
 	}
 
@@ -119,7 +120,31 @@ public function fluent()
 	 */
 	public function test(self $s): void
 	{
+		assertType('static(GenericStatic\Inconsistent2<T (class GenericStatic\Inconsistent2, argument)>)', $this->fluent());
 		assertType('GenericStatic\\Inconsistent2<int>', $s->fluent());
 	}
 
 }
+
+/**
+ * @template T
+ * @template K
+ */
+class A {
+	/** @return static<T, K> */
+	public function doFoo() {}
+
+}
+
+/** @extends A<int, string> */
+class B extends A {
+	public function doBar(): void
+	{
+		$f = $this->doFoo();
+		assertType('static(GenericStatic\B)', $f);
+	}
+}
+
+function (): void {
+	assertType(B::class, (new B)->doFoo());
+};