Replace PhpClassReflectionExtension::evictPrivateSymbols() with a shared LRU over the member caches

The four member caches (methodsIncludingAnnotations, nativeMethods,
propertiesIncludingAnnotations, nativeProperties) were unbounded except for
private members of the just-analysed class. Public/protected member
reflections accumulated for the whole process — measured as the single
largest analysis-growth bucket on a large project (334 MB of a 675 MB
per-process growth at 2,358 files). The private-only eviction also silently
missed the composite `class-scope` cache keys used by getProperty(), because
it compared keys with strict equality against the plain class cache key.

Replace it with a single insertion-ordered LRU over the first-level cache
keys, shared by all four maps: every cache access moves the key to the
most-recently-used position; inserting beyond 2048 keys evicts the least
recently used key's entries from all four maps at once. Misses are pure
recomputation, so eviction cannot change results — verified byte-identical
error output on a 2,358-file project, with no measurable time cost (LRU
bookkeeping is one unset+set per access, and the previous eviction's full
map scan per analysed class is gone).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NrTvR9j1mW2NNNC8RkuTsF

Author: ondrejmirtes

src/Reflection/ClassReflection.php

@@ -716,7 +716,9 @@ public function evictPrivateSymbols(): void
 
 			unset($this->methods[$name]);
 		}
-		$this->classReflectionExtensionRegistryProvider->getRegistry()->getPhpClassReflectionExtension()->evictPrivateSymbols($this->getCacheKey());
+		// PhpClassReflectionExtension's member caches are governed by their own LRU
+		// (see PhpClassReflectionExtension::touchMemberCacheKey()) instead of per-class
+		// private-symbol eviction.
 	}
 
 	/** @deprecated Use getInstanceProperty or getStaticProperty */

src/Reflection/Php/PhpClassReflectionExtension.php

@@ -60,6 +60,7 @@
 use PHPStan\Type\TypehintHelper;
 use PHPStan\Type\UnionType;
 use function array_key_exists;
+use function array_key_first;
 use function array_keys;
 use function array_map;
 use function array_slice;
@@ -73,6 +74,11 @@
 final class PhpClassReflectionExtension
 {
 
+	private const MEMBER_CACHE_KEYS_MAX = 2048;
+
+	/** @var array<string, true> shared LRU over the member cache keys below; first entry = least recently used */
+	private array $memberCacheOrder = [];
+
 	/** @var PhpPropertyReflection[][] */
 	private array $propertiesIncludingAnnotations = [];
 
@@ -112,52 +118,37 @@ public function __construct(
 	{
 	}
 
-	public function evictPrivateSymbols(string $classCacheKey): void
+	/**
+	 * Moves the cache key to the most-recently-used position of the shared LRU governing
+	 * all four member caches; evicts the least recently used key's entries from all of
+	 * them once the limit is reached.
+	 *
+	 * Replaces the former evictPrivateSymbols(): instead of dropping only private members
+	 * of the just-analysed class (public/protected members accumulated for the whole
+	 * process, measured at hundreds of MB on large codebases), classes not used recently
+	 * are evicted wholesale — misses are pure recomputation.
+	 */
+	private function touchMemberCacheKey(string $cacheKey): void
 	{
-		foreach ($this->propertiesIncludingAnnotations as $key => $properties) {
-			if ($key !== $classCacheKey) {
-				continue;
-			}
-			foreach ($properties as $name => $property) {
-				if (!$property->isPrivate()) {
-					continue;
-				}
-				unset($this->propertiesIncludingAnnotations[$key][$name]);
-			}
-		}
-		foreach ($this->nativeProperties as $key => $properties) {
-			if ($key !== $classCacheKey) {
-				continue;
-			}
-			foreach ($properties as $name => $property) {
-				if (!$property->isPrivate()) {
-					continue;
-				}
-				unset($this->nativeProperties[$key][$name]);
-			}
+		if (isset($this->memberCacheOrder[$cacheKey])) {
+			unset($this->memberCacheOrder[$cacheKey]);
+			$this->memberCacheOrder[$cacheKey] = true;
+			return;
 		}
-		foreach ($this->methodsIncludingAnnotations as $key => $methods) {
-			if ($key !== $classCacheKey) {
-				continue;
-			}
-			foreach ($methods as $name => $method) {
-				if (!$method->isPrivate()) {
-					continue;
-				}
-				unset($this->methodsIncludingAnnotations[$key][$name]);
-			}
-		}
-		foreach ($this->nativeMethods as $key => $methods) {
-			if ($key !== $classCacheKey) {
-				continue;
-			}
-			foreach ($methods as $name => $method) {
-				if (!$method->isPrivate()) {
-					continue;
-				}
-				unset($this->nativeMethods[$key][$name]);
-			}
+
+		$this->memberCacheOrder[$cacheKey] = true;
+		if (count($this->memberCacheOrder) <= self::MEMBER_CACHE_KEYS_MAX) {
+			return;
 		}
+
+		$evictKey = array_key_first($this->memberCacheOrder);
+		unset(
+			$this->memberCacheOrder[$evictKey],
+			$this->methodsIncludingAnnotations[$evictKey],
+			$this->nativeMethods[$evictKey],
+			$this->propertiesIncludingAnnotations[$evictKey],
+			$this->nativeProperties[$evictKey],
+		);
 	}
 
 	public function hasProperty(ClassReflection $classReflection, string $propertyName): bool
@@ -171,6 +162,7 @@ public function getProperty(ClassReflection $classReflection, string $propertyNa
 		if ($scope->isInClass()) {
 			$cacheKey = sprintf('%s-%s', $cacheKey, $scope->getClassReflection()->getCacheKey());
 		}
+		$this->touchMemberCacheKey($cacheKey);
 		if (!isset($this->propertiesIncludingAnnotations[$cacheKey][$propertyName])) {
 			$this->propertiesIncludingAnnotations[$cacheKey][$propertyName] = $this->createProperty($classReflection, $propertyName, $scope, true);
 		}
@@ -180,6 +172,7 @@ public function getProperty(ClassReflection $classReflection, string $propertyNa
 
 	public function getNativeProperty(ClassReflection $classReflection, string $propertyName): PhpPropertyReflection
 	{
+		$this->touchMemberCacheKey($classReflection->getCacheKey());
 		if (!isset($this->nativeProperties[$classReflection->getCacheKey()][$propertyName])) {
 			$property = $this->createProperty($classReflection, $propertyName, new OutOfClassScope(), false);
 			$this->nativeProperties[$classReflection->getCacheKey()][$propertyName] = $property;
@@ -535,6 +528,7 @@ public function hasMethod(ClassReflection $classReflection, string $methodName):
 
 	public function getMethod(ClassReflection $classReflection, string $methodName): ExtendedMethodReflection
 	{
+		$this->touchMemberCacheKey($classReflection->getCacheKey());
 		if (isset($this->methodsIncludingAnnotations[$classReflection->getCacheKey()][$methodName])) {
 			return $this->methodsIncludingAnnotations[$classReflection->getCacheKey()][$methodName];
 		}
@@ -558,6 +552,7 @@ public function hasNativeMethod(ClassReflection $classReflection, string $method
 
 	public function getNativeMethod(ClassReflection $classReflection, string $methodName): ExtendedMethodReflection
 	{
+		$this->touchMemberCacheKey($classReflection->getCacheKey());
 		if (isset($this->nativeMethods[$classReflection->getCacheKey()][$methodName])) {
 			return $this->nativeMethods[$classReflection->getCacheKey()][$methodName];
 		}