Resolve template types of method calls on a concrete generic static return type (#6695)

Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>

Author: pawell67

src/Reflection/Type/CalledOnTypeUnresolvedMethodPrototypeReflection.php

@@ -11,6 +11,7 @@
 use PHPStan\Reflection\Php\ExtendedDummyParameter;
 use PHPStan\Reflection\ResolvedMethodReflection;
 use PHPStan\Turbo\ShadowedByTurboExtension;
+use PHPStan\Type\Generic\GenericObjectType;
 use PHPStan\Type\Generic\GenericStaticType;
 use PHPStan\Type\StaticType;
 use PHPStan\Type\ThisType;
@@ -149,7 +150,19 @@ private function transformStaticType(Type $type): Type
 				if (count($calledOnTypeReflections) === 1) {
 					$calledOnTypeReflection = $calledOnTypeReflections[0];
 
-					return $traverse($type->changeBaseClass($calledOnTypeReflection)->getStaticObjectType());
+					$staticObjectType = $type->changeBaseClass($calledOnTypeReflection)->getStaticObjectType();
+					if ($staticObjectType instanceof GenericObjectType) {
+						// do not carry over the class reflection of the declaring class,
+						// it would not know the type arguments of the resolved type
+						$staticObjectType = new GenericObjectType(
+							$staticObjectType->getClassName(),
+							$staticObjectType->getTypes(),
+							$staticObjectType->getSubtractedType(),
+							variances: $staticObjectType->getVariances(),
+						);
+					}
+
+					return $traverse($staticObjectType);
 				}
 
 				return $this->calledOnType;

tests/PHPStan/Analyser/nsrt/bug-12680.php

@@ -0,0 +1,38 @@
+<?php declare(strict_types = 1);
+
+namespace Bug12680;
+
+use function PHPStan\Testing\assertType;
+
+/**
+ * @template TKey of array-key
+ * @template TValue
+ */
+class Collection
+{
+
+	/** @return static<array-key, mixed> */
+	public function pluck(): static
+	{
+		return new static(); // @phpstan-ignore new.static
+	}
+
+	/** @return self<array-key, mixed> */
+	public function pluckSelf(): static // @phpstan-ignore return.type
+	{
+		return new static(); // @phpstan-ignore new.static
+	}
+
+	/** @return TValue */
+	public function first() // @phpstan-ignore missingType.return
+	{
+	}
+
+}
+
+function (Collection $c): void {
+	assertType('mixed', $c->pluck()->first());
+	assertType('mixed', $c->pluckSelf()->first());
+	assertType('mixed', (new Collection())->pluck()->first());
+	assertType('mixed', (new Collection())->pluckSelf()->first());
+};

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

@@ -0,0 +1,49 @@
+<?php declare(strict_types = 1);
+
+namespace GenericStaticConcreteArguments;
+
+use function PHPStan\Testing\assertType;
+
+/**
+ * @template TKey of array-key
+ * @template TValue
+ */
+class Box
+{
+
+	/** @return static<int, string> */
+	public function concrete()
+	{
+		return new static();
+	}
+
+	/** @return static<int, TValue> */
+	public function withTemplate()
+	{
+		return new static();
+	}
+
+	/** @return array<TKey, TValue> */
+	public function all(): array
+	{
+		return [];
+	}
+
+	/** @return TValue */
+	public function first()
+	{
+		return 1;
+	}
+
+}
+
+/**
+ * @param Box<string, bool> $box
+ */
+function test(Box $box): void
+{
+	assertType('GenericStaticConcreteArguments\Box<int, string>', $box->concrete());
+	assertType('array<int, string>', $box->concrete()->all());
+	assertType('string', $box->concrete()->first());
+	assertType('array<int, bool>', $box->withTemplate()->all());
+}

turbo-ext/src/CalledOnTypeUnresolvedMethodPrototypeReflection.cpp

@@ -222,6 +222,29 @@ class CalledOnTypeUnresolvedMethodPrototypeReflection
 				}
 				zv::Val staticObjectType = pt_type_call(Z_OBJ_P(changed.raw()), PT_LC("getstaticobjecttype"), 0, NULL);
 				if (UNEXPECTED(staticObjectType.isUndef())) return;
+				/* a GenericObjectType is rebuilt without the class reflection of the
+				 * declaring class, which would not know the resolved type arguments:
+				 * new GenericObjectType($t->getClassName(), $t->getTypes(), $t->getSubtractedType(), variances: $t->getVariances()) */
+				bool isGenericObject;
+				pt_type_instanceof_ce(staticObjectType.raw(), pt_ce_generic_object_type, isGenericObject);
+				if (isGenericObject) {
+					zend_object *objectType = Z_OBJ_P(staticObjectType.raw());
+					zv::Val className = pt_type_call(objectType, PT_LC("getclassname"), 0, NULL);
+					if (UNEXPECTED(className.isUndef())) return;
+					zv::Val objectTypes = pt_type_call(objectType, PT_LC("gettypes"), 0, NULL);
+					if (UNEXPECTED(objectTypes.isUndef())) return;
+					zv::Val subtracted = pt_type_call(objectType, PT_LC("getsubtractedtype"), 0, NULL);
+					if (UNEXPECTED(subtracted.isUndef())) return;
+					zv::Val objectVariances = pt_type_call(objectType, PT_LC("getvariances"), 0, NULL);
+					if (UNEXPECTED(objectVariances.isUndef())) return;
+					if (UNEXPECTED(Z_TYPE_P(className.raw()) != IS_STRING)) {
+						zend_type_error("phpstan_turbo: getClassName() must return a string");
+						return;
+					}
+					zval rebuiltRaw;
+					if (UNEXPECTED(!pt_generic_object_type_new(&rebuiltRaw, Z_STR_P(className.raw()), objectTypes.raw(), subtracted.raw(), NULL, objectVariances.raw()))) return;
+					staticObjectType = zv::Val::adopt(rebuiltRaw);
+				}
 				zv::Val traversed = pt_type_call_callable(&argv[1], 1, staticObjectType.raw());
 				if (UNEXPECTED(traversed.isUndef())) return;
 				traversed.intoReturnValue(return_value);