Do not reuse name scopes built from the simplified AST for an analysed file

FileTypeMapper builds a file's name scopes from defaultAnalysisParser, which
routes a file outside the analysed paths to the cleaning parser. Its AST has
no function bodies, so the name scopes of classes declared inside them are
missing. The ftm- cache entry was validated against the file contents only,
so after a run on other paths a full run reused the incomplete map and the
PHPDoc of such a class resolved to nothing, even with the result cache
cleared.

The entry now records for each file whether its AST was simplified and is
reused only when that still holds, and the key tells the two kinds of entries
of the main file apart so that partial and full runs do not evict each other.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012fzQU5nUgW3pCEZJonVBhv

Author: ondrejmirtes

.github/workflows/e2e-tests.yml

@@ -255,6 +255,15 @@ jobs:
           - script: |
               cd e2e/bug-15231
               ../../bin/phpstan analyze
+          - script: |
+              cd e2e/bug-15475
+              # https://github.com/phpstan/phpstan/issues/15475
+              # A run on other paths builds the name scopes of the scanned file from its
+              # simplified AST, without the anonymous class declared in a function body.
+              # A later full run must not reuse them, even with the result cache cleared.
+              ../../bin/phpstan analyse src/usage.php
+              ../../bin/phpstan clear-result-cache
+              ../../bin/phpstan analyse
           - script: |
               cd e2e/bug-15102
               composer install
@@ -2181,6 +2190,17 @@ jobs:
           cd e2e/bug-15268
           php ../../bin/phpstan analyse --no-progress --error-format=raw
 
+      - name: "Verify name scopes built from the simplified AST are not reused for an analysed file"
+        # A run on other paths builds the name scopes of the scanned file from its
+        # simplified AST, without the anonymous class declared in a function body.
+        # A later full run must not reuse them, even with the result cache cleared -
+        # https://github.com/phpstan/phpstan/issues/15475
+        run: |
+          cd e2e/bug-15475
+          php ../../bin/phpstan analyse --no-progress src/usage.php
+          php ../../bin/phpstan clear-result-cache
+          php ../../bin/phpstan analyse --no-progress
+
       - name: "Test"
         # The arena is a per-run POSIX shared-memory object: shm_open() plus an
         # ftruncate() to 256 MB that tmpfs honours sparsely, committing pages on

e2e/bug-15475/phpstan.neon

@@ -0,0 +1,9 @@
+parameters:
+    level: max
+    tmpDir: tmp
+    # the reproducer declares an anonymous readonly class
+    phpVersion: 80300
+    paths:
+        - src
+    scanFiles:
+        - src/helpers.php

e2e/bug-15475/src/helpers.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+interface Inbox
+{
+    /** @return list<string> */
+    public function search(string $words): array;
+}
+
+/**
+ * @param Closure(string): list<string> $search
+ */
+function inbox(Closure $search): Inbox
+{
+    return new readonly class($search) implements Inbox
+    {
+        /**
+         * @param Closure(string): list<string> $search
+         */
+        public function __construct(private Closure $search) {}
+
+        public function search(string $words): array
+        {
+            return ($this->search)($words);
+        }
+    };
+}

e2e/bug-15475/src/usage.php

@@ -0,0 +1,8 @@
+<?php
+
+declare(strict_types=1);
+
+function usage(): void
+{
+    inbox(static fn (string $words): array => [$words])->search('a b');
+}

e2e/bug-15475/tmp/.gitignore

@@ -0,0 +1,2 @@
+*
+!.*

src/Parser/PathRoutingParser.php

@@ -41,13 +41,32 @@ public function setAnalysedFiles(array $files): void
 	}
 
 	public function parseFile(string $file): array
+	{
+		$parser = $this->getParser($file);
+		if ($parser === $this->php8Parser) {
+			return $parser->parseFile($file);
+		}
+
+		return $parser->parseFile($this->fileHelper->normalizePath($file));
+	}
+
+	/**
+	 * Whether parseFile() returns the simplified AST of the file, without function bodies
+	 * and code for other PHP versions, instead of the full AST of an analysed file.
+	 */
+	public function returnsSimplifiedAst(string $file): bool
+	{
+		return $this->getParser($file) === $this->currentPhpVersionSimpleParser;
+	}
+
+	private function getParser(string $file): Parser
 	{
 		$normalizedPath = $this->fileHelper->normalizePath($file, '/');
 		if (str_contains($normalizedPath, 'vendor/jetbrains/phpstorm-stubs')) {
-			return $this->php8Parser->parseFile($file);
+			return $this->php8Parser;
 		}
 		if (str_contains($normalizedPath, 'vendor/phpstan/php-8-stubs/stubs')) {
-			return $this->php8Parser->parseFile($file);
+			return $this->php8Parser;
 		}
 
 		$file = $this->fileHelper->normalizePath($file);
@@ -64,16 +83,16 @@ public function parseFile(string $file): array
 				if ($realFilePath !== false) {
 					$normalizedRealFilePath = $this->fileHelper->normalizePath($realFilePath);
 					if (isset($this->analysedFiles[$normalizedRealFilePath])) {
-						return $this->currentPhpVersionRichParser->parseFile($file);
+						return $this->currentPhpVersionRichParser;
 					}
 				}
 				break;
 			}
 
-			return $this->currentPhpVersionSimpleParser->parseFile($file);
+			return $this->currentPhpVersionSimpleParser;
 		}
 
-		return $this->currentPhpVersionRichParser->parseFile($file);
+		return $this->currentPhpVersionRichParser;
 	}
 
 	public function parseString(string $sourceCode): array

src/Type/FileTypeMapper.php

@@ -18,6 +18,7 @@
 use PHPStan\Internal\ComposerHelper;
 use PHPStan\Internal\LruCache;
 use PHPStan\Parser\Parser;
+use PHPStan\Parser\PathRoutingParser;
 use PHPStan\PhpDoc\NameScopeAlreadyBeingCreatedException;
 use PHPStan\PhpDoc\PhpDocNodeResolver;
 use PHPStan\PhpDoc\PhpDocStringResolver;
@@ -383,21 +384,26 @@ private function getNameScopeMap(string $fileName): array
 			return $cachedEntry;
 		}
 
-		$cacheKey = sprintf('ftm-%s', $fileName);
+		// a map built from the simplified AST of a file outside the analysed paths lacks
+		// the name scopes of classes declared inside function bodies, so it must not be
+		// reused once the file gets analysed, nor the other way around
+		$cacheKey = sprintf('ftm-%s%s', $this->returnsSimplifiedAst($fileName) ? 'simplified-' : '', $fileName);
 		// v6: v5 entries may be poisoned by the turbo comment-loss bug
 		// (https://github.com/phpstan/phpstan/issues/15037) - a parse that
 		// silently dropped every comment cached PHPDoc-less name-scope maps,
 		// and the content hashes cannot tell them apart from real ones.
 		// v7: IntermediaryNameScope refers to a NamespaceUses shared with the other name scopes
 		// created under the same use statements
-		$variableCacheKey = sprintf('v7-%s', ComposerHelper::getPhpDocParserVersion());
+		// v8: the files are recorded with whether the map was built from their simplified AST;
+		// v7 entries may be built from it even under the key of the full AST
+		$variableCacheKey = sprintf('v8-%s', ComposerHelper::getPhpDocParserVersion());
 		$cached = $this->loadCachedPhpDocNodeMap($cacheKey, $variableCacheKey);
 		if ($cached === null) {
 			[$nameScopeMap, $files] = $this->createPhpDocNodeMap($fileName, null, null, [], $fileName);
 			$filesWithHashes = [];
 			foreach ($files as $file) {
 				$newHash = $this->fileContentHasher->hash($file);
-				$filesWithHashes[$file] = $newHash;
+				$filesWithHashes[$file] = [$newHash, $this->returnsSimplifiedAst($file)];
 			}
 			$this->cache->save($cacheKey, $variableCacheKey, [$nameScopeMap, $filesWithHashes]);
 		} else {
@@ -418,17 +424,17 @@ private function loadCachedPhpDocNodeMap(string $cacheKey, string $variableCache
 		$cached = $this->cache->load($cacheKey, $variableCacheKey);
 		if ($cached !== null) {
 			/**
-			 * @var array<string, string> $filesWithHashes
+			 * @var array<string, array{string, bool}> $filesWithHashes
 			 */
 			[$nameScopeMap, $filesWithHashes] = $cached;
 			$useCache = true;
-			foreach ($filesWithHashes as $file => $hash) {
+			foreach ($filesWithHashes as $file => [$hash, $simplifiedAst]) {
 				$newHash = $this->fileContentHasher->hash($file);
 				if ($newHash === false) {
 					$useCache = false;
 					break;
 				}
-				if ($newHash === $hash) {
+				if ($newHash === $hash && $this->returnsSimplifiedAst($file) === $simplifiedAst) {
 					continue;
 				}
 				$useCache = false;
@@ -443,6 +449,11 @@ private function loadCachedPhpDocNodeMap(string $cacheKey, string $variableCache
 		return null;
 	}
 
+	private function returnsSimplifiedAst(string $fileName): bool
+	{
+		return $this->phpParser instanceof PathRoutingParser && $this->phpParser->returnsSimplifiedAst($fileName);
+	}
+
 	/**
 	 * @param array<string, string> $traitMethodAliases
 	 * @param array<string, true> $activeTraitResolutions