LRU-cap resolved local type aliases in UsefulTypeAliasResolver

Every resolved @phpstan-type local alias is cached forever, keyed by
Class::alias. Resolved alias Types transitively pin ClassReflections
(ObjectType::$classReflection, EnumCaseObjectType::$classReflection, ...) and
through them whole BetterReflection trees, so on alias-heavy codebases this
cache quietly retains a large share of the reflection universe. Retention-path
instrumentation on a large project identified it as the single largest
type-level pin: bounding it freed 34 MB end-of-run memory at 2,358 analysed
files — more than any reflection-side cache — with byte-identical error
output and no measurable time cost (interleaved A/B, 100 s vs 95 s).

Cap the cache at 2048 entries with least-recently-used eviction; evicted
aliases are re-resolved on demand. Global aliases are unaffected (bounded by
config).

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

Author: ondrejmirtes

src/Type/UsefulTypeAliasResolver.php

@@ -10,16 +10,20 @@
 use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\ShouldNotHappenException;
 use function array_key_exists;
+use function array_key_first;
+use function count;
 use function sprintf;
 
 #[AutowiredService(as: TypeAliasResolver::class)]
 final class UsefulTypeAliasResolver implements TypeAliasResolver
 {
 
+	private const RESOLVED_LOCAL_TYPE_ALIASES_MAX = 2048;
+
 	/** @var array<string, Type> */
 	private array $resolvedGlobalTypeAliases = [];
 
-	/** @var array<string, Type> */
+	/** @var array<string, Type> LRU; first entry = least recently used */
 	private array $resolvedLocalTypeAliases = [];
 
 	/** @var array<string, true> */
@@ -81,7 +85,11 @@ private function resolveLocalTypeAlias(string $aliasName, NameScope $nameScope):
 		$aliasNameInClassScope = $className . '::' . $aliasName;
 
 		if (array_key_exists($aliasNameInClassScope, $this->resolvedLocalTypeAliases)) {
-			return $this->resolvedLocalTypeAliases[$aliasNameInClassScope];
+			// LRU: move to the most-recently-used position
+			$resolvedAliasType = $this->resolvedLocalTypeAliases[$aliasNameInClassScope];
+			unset($this->resolvedLocalTypeAliases[$aliasNameInClassScope]);
+
+			return $this->resolvedLocalTypeAliases[$aliasNameInClassScope] = $resolvedAliasType;
 		}
 
 		// prevent infinite recursion
@@ -120,6 +128,11 @@ private function resolveLocalTypeAlias(string $aliasName, NameScope $nameScope):
 		}
 
 		$this->resolvedLocalTypeAliases[$aliasNameInClassScope] = $resolvedAliasType;
+		if (count($this->resolvedLocalTypeAliases) > self::RESOLVED_LOCAL_TYPE_ALIASES_MAX) {
+			// resolved alias types transitively pin ClassReflections and their whole
+			// reflection trees — evict the least recently used
+			unset($this->resolvedLocalTypeAliases[array_key_first($this->resolvedLocalTypeAliases)]);
+		}
 		unset($this->inProcess[$aliasNameInClassScope]);
 
 		return $resolvedAliasType;