Keep the symbols found in directories between runs, checked by stat

OptimizedDirectorySourceLocatorFactory had two ways of finding the symbols
of a directory. Without the turbo extension, or with workers that are not
forked, they were cached, and the cache was checked by hashing every file.
With the extension and forked workers, every file was scanned natively on
every run instead, because hashing cost about as much as the scan - 0.7s on
Drupal core, paid by every run that analyses at least one file.

There is one way now. The cache entry of a directory keeps each file's stat
signature next to its hash (see FileStatSignatures), and a file whose
signature matches is not even hashed. When the signature cannot vouch for
the file, the hash decides, as before. The arena records that shared the
file hashes and the symbol maps between workers that are not forked are
gone - the cache entry itself is still shared through the arena by
Cache::load().

The cache now also keeps the files that declare no symbols, which used to be
scanned again on every run.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GdwtgiEHwkF5BTz73jgHQQ

Author: ondrejmirtes

src/Reflection/BetterReflection/SourceLocator/OptimizedDirectorySourceLocator.php

@@ -14,7 +14,6 @@
 use PHPStan\BetterReflection\Reflector\Reflector;
 use PHPStan\BetterReflection\SourceLocator\Ast\Strategy\NodeToReflection;
 use PHPStan\BetterReflection\SourceLocator\Type\SourceLocator;
-use PHPStan\Cache\ArenaCache;
 use PHPStan\Cache\Cache;
 use PHPStan\File\CouldNotReadFileException;
 use PHPStan\File\FileContentHasher;
@@ -25,31 +24,13 @@
 use function array_key_exists;
 use function array_values;
 use function current;
-use function is_array;
-use function is_string;
 use function sprintf;
 use function strtolower;
 
 final class OptimizedDirectorySourceLocator implements SourceLocator
 {
 
-	/** @var array<string, string|false> */
-	private array $arenaClassLookups = [];
-
-	/** @var array<string, array<int, string>|false> */
-	private array $arenaFunctionLookups = [];
-
-	/** @var array<string, string|false> */
-	private array $arenaConstantLookups = [];
-
-	private bool $hydratedFromArena = false;
-
 	/**
-	 * With $arenaKeyPrefix set, the maps start empty and names resolve lazily
-	 * from the run's shared arena (published by whichever process built this
-	 * directory's index first), so the worker materializes only the names it
-	 * touches instead of the whole index.
-	 *
 	 * @param array<string, string> $classToFile
 	 * @param array<string, array<int, string>> $functionToFiles
 	 * @param array<string, string> $constantToFile
@@ -62,14 +43,13 @@ public function __construct(
 		private array $classToFile,
 		private array $functionToFiles,
 		private array $constantToFile,
-		private ?string $arenaKeyPrefix = null,
 		private bool $awaitingBatchedScan = false,
 	)
 	{
 	}
 
 	/**
-	 * Fills in the symbol maps of a locator created for a batched scan.
+	 * Fills in the symbol maps of a locator created ahead of the scan.
 	 *
 	 * The factory hands these out before the scan that produces their contents
 	 * has run, so that one scan can cover every directory at once
@@ -248,111 +228,20 @@ private function nodeToReflection(Reflector $reflector, FetchedNode $fetchedNode
 
 	private function findFileByClass(string $className): ?string
 	{
-		if (array_key_exists($className, $this->classToFile)) {
-			return $this->classToFile[$className];
-		}
-
-		if ($this->arenaKeyPrefix === null) {
-			return null;
-		}
-
-		if (array_key_exists($className, $this->arenaClassLookups)) {
-			$file = $this->arenaClassLookups[$className];
-		} else {
-			$file = ArenaCache::lookupHash($this->arenaKeyPrefix . '-classes', $className);
-			if (!is_string($file)) {
-				$file = false;
-			}
-			$this->arenaClassLookups[$className] = $file;
-		}
-
-		return $file === false ? null : $file;
+		return $this->classToFile[$className] ?? null;
 	}
 
 	private function findFileByConstant(string $constantName): ?string
 	{
-		if (array_key_exists($constantName, $this->constantToFile)) {
-			return $this->constantToFile[$constantName];
-		}
-
-		if ($this->arenaKeyPrefix === null) {
-			return null;
-		}
-
-		if (array_key_exists($constantName, $this->arenaConstantLookups)) {
-			$file = $this->arenaConstantLookups[$constantName];
-		} else {
-			$file = ArenaCache::lookupHash($this->arenaKeyPrefix . '-constants', $constantName);
-			if (!is_string($file)) {
-				$file = false;
-			}
-			$this->arenaConstantLookups[$constantName] = $file;
-		}
-
-		return $file === false ? null : $file;
+		return $this->constantToFile[$constantName] ?? null;
 	}
 
 	/**
 	 * @return string[]
 	 */
 	private function findFilesByFunction(string $functionName): array
 	{
-		if (array_key_exists($functionName, $this->functionToFiles)) {
-			return $this->functionToFiles[$functionName];
-		}
-
-		if ($this->arenaKeyPrefix === null) {
-			return [];
-		}
-
-		if (array_key_exists($functionName, $this->arenaFunctionLookups)) {
-			$files = $this->arenaFunctionLookups[$functionName];
-		} else {
-			/** @var array<int, string>|mixed $files */
-			$files = ArenaCache::lookupHash($this->arenaKeyPrefix . '-functions', $functionName);
-			if (!is_array($files)) {
-				$files = false;
-			}
-			$this->arenaFunctionLookups[$functionName] = $files;
-		}
-
-		return $files === false ? [] : $files;
-	}
-
-	/**
-	 * Enumeration needs the full maps: hydrates them from the arena records
-	 * in their publication order, which equals the insertion order a locally
-	 * built index would have. A null (a corrupt record — impossible with an
-	 * intact arena, the factory gated on all three records) leaves a map
-	 * empty rather than failing the run.
-	 */
-	private function hydrateSymbolsFromArena(): void
-	{
-		if ($this->arenaKeyPrefix === null || $this->hydratedFromArena) {
-			return;
-		}
-
-		$this->hydratedFromArena = true;
-
-		/** @var array<string, string>|null $classes */
-		$classes = ArenaCache::lookupHashAll($this->arenaKeyPrefix . '-classes');
-		if ($classes !== null) {
-			$this->classToFile = $classes;
-		}
-
-		/** @var array<string, array<int, string>>|null $functions */
-		$functions = ArenaCache::lookupHashAll($this->arenaKeyPrefix . '-functions');
-		if ($functions !== null) {
-			$this->functionToFiles = $functions;
-		}
-
-		/** @var array<string, string>|null $constants */
-		$constants = ArenaCache::lookupHashAll($this->arenaKeyPrefix . '-constants');
-		if ($constants === null) {
-			return;
-		}
-
-		$this->constantToFile = $constants;
+		return $this->functionToFiles[$functionName] ?? [];
 	}
 
 	/**
@@ -365,8 +254,6 @@ public function locateIdentifiersByType(Reflector $reflector, IdentifierType $id
 			throw new ShouldNotHappenException('Symbols were looked up in a directory whose batched scan has not been flushed yet.');
 		}
 
-		$this->hydrateSymbolsFromArena();
-
 		$reflections = [];
 		if ($identifierType->isClass()) {
 			foreach ($this->classToFile as $file) {