Cache a class's ancestors without the class itself

getAncestors() cached an array that contained $this, so every
ClassReflection that had answered it referenced itself. PHPStan runs
with gc_disable(), so a ClassReflection the reflection provider does not
keep, like a withTypes() copy, then stayed in memory until the process
ended, together with its template type map.

The cache now leaves the class out, and getAncestors() adds it back
first, so the returned array is the same.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: 2 people

src/Reflection/ClassReflection.php

@@ -2213,18 +2213,20 @@ public function getTemplateTags(): array
 	 */
 	public function getAncestors(): array
 	{
-		$ancestors = $this->ancestors;
-
-		if ($ancestors === null) {
+		if ($this->ancestors === null) {
 			$ancestors = [
 				$this->getName() => $this,
 			];
 			$this->collectAncestors($ancestors);
 
+			// the cached array must not contain $this: that would be a reference
+			// cycle, and with gc_disable() a ClassReflection the reflection provider
+			// does not keep, like a withTypes() copy, would then never be freed
+			unset($ancestors[$this->getName()]);
 			$this->ancestors = $ancestors;
 		}
 
-		return $ancestors;
+		return [$this->getName() => $this] + $this->ancestors;
 	}
 
 	/**

tests/PHPStan/Reflection/ClassReflectionTest.php

@@ -2,6 +2,7 @@
 
 namespace PHPStan\Reflection;
 
+use ArrayObject;
 use Attribute;
 use Attributes\IsAttribute;
 use Attributes\IsAttribute2;
@@ -31,13 +32,19 @@
 use PHPStan\Testing\PHPStanTestCase;
 use PHPStan\Testing\RuleTestCase;
 use PHPStan\Type\IntegerType;
+use PHPStan\Type\StringType;
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\Attributes\RequiresPhp;
 use PHPUnit\Framework\TestCase;
 use ReflectionClass;
+use WeakReference;
 use WrongClassConstantFile\SecuredRouter;
+use function array_key_first;
 use function array_map;
 use function array_values;
+use function gc_disable;
+use function gc_enable;
+use function gc_enabled;
 
 class ClassReflectionTest extends PHPStanTestCase
 {
@@ -375,4 +382,29 @@ public function testDeprecatedAttribute(string $className, bool $expected): void
 		$this->assertSame($expected, $classReflection->isDeprecated());
 	}
 
+	public function testAncestorsDoNotKeepClassReflectionAlive(): void
+	{
+		$reflectionProvider = self::createReflectionProvider();
+		$classReflection = $reflectionProvider->getClass(ArrayObject::class)->withTypes([new IntegerType(), new StringType()]);
+
+		$ancestors = $classReflection->getAncestors();
+		$this->assertSame(ArrayObject::class, array_key_first($ancestors));
+		$this->assertSame($classReflection, $ancestors[ArrayObject::class]);
+		$this->assertSame($ancestors, $classReflection->getAncestors());
+		unset($ancestors);
+
+		// PHPStan runs with gc_disable(), so a reference cycle would keep it alive
+		$gcEnabled = gc_enabled();
+		gc_disable();
+		try {
+			$weakReference = WeakReference::create($classReflection);
+			unset($classReflection);
+			$this->assertNull($weakReference->get());
+		} finally {
+			if ($gcEnabled) {
+				gc_enable();
+			}
+		}
+	}
+
 }