Discard a damaged framed cache instead of reading it half way

A cache file that is this format but truncated - which is what a process killed
during the save leaves behind, since the file is streamed to its final path -
was read as far as it went and the missing frames returned as null. `is_array()`
on the assembled array then passed, and the first missing section surfaced as a
TypeError from isMetaDifferent() far away from the cause.

Every format violation now throws, so restore() discards the file and analyses
everything, which is what the var_export format did by way of a ParseError from
the include.

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

Author: SanderMuller

.github/workflows/e2e-tests.yml

@@ -124,6 +124,11 @@ jobs:
               mv src/Foo.php.orig src/Foo.php
               echo -n > phpstan-baseline.neon
               ../../bin/phpstan -vvv
+          - script: |
+              cd e2e/result-cache-truncated
+              ../../bin/phpstan -vvv
+              php truncate.php
+              ../../bin/phpstan -vvv
           - script: |
               cd e2e/bug-14514
               composer install

.gitignore

@@ -15,3 +15,4 @@
 tmp/.memory_limit
 e2e/bashunit
 /.phpbench
+/e2e/result-cache-truncated/tmp

e2e/result-cache-truncated/phpstan.neon

@@ -0,0 +1,5 @@
+parameters:
+	level: 8
+	tmpDir: tmp
+	paths:
+		- src

e2e/result-cache-truncated/src/Bar.php

@@ -0,0 +1,13 @@
+<?php declare(strict_types = 1);
+
+namespace TestResultCacheTruncated;
+
+class Bar
+{
+
+	public function doBar(): string
+	{
+		return 'bar';
+	}
+
+}

e2e/result-cache-truncated/src/Foo.php

@@ -0,0 +1,13 @@
+<?php declare(strict_types = 1);
+
+namespace TestResultCacheTruncated;
+
+class Foo
+{
+
+	public function doFoo(Bar $bar): string
+	{
+		return $bar->doBar();
+	}
+
+}

e2e/result-cache-truncated/truncate.php

@@ -0,0 +1,13 @@
+<?php declare(strict_types = 1);
+
+// A process killed while the result cache is being written leaves a partial file at the final
+// path, because the cache is streamed there rather than written atomically. Cutting the file
+// inside the first section's payload is the shape that used to be read as a half-populated
+// cache instead of a damaged one.
+$file = __DIR__ . '/tmp/resultCache.php';
+$contents = file_get_contents($file);
+if ($contents === false) {
+	throw new RuntimeException('No result cache at ' . $file);
+}
+
+file_put_contents($file, substr($contents, 0, 200));

src/Analyser/ResultCache/ResultCacheManager.php

@@ -28,6 +28,7 @@
 use PHPStan\ShouldNotHappenException;
 use ReflectionClass;
 use ReflectionException;
+use RuntimeException;
 use Throwable;
 use function array_diff;
 use function array_fill_keys;
@@ -1333,7 +1334,7 @@ private function readCacheFile(string $cacheFilePath): ?array
 
 				$parts = explode(' ', $header, 2);
 				if (count($parts) !== 2) {
-					return null;
+					throw new RuntimeException(sprintf('Malformed frame header "%s".', $header));
 				}
 
 				[$name, $size] = $parts;
@@ -1343,12 +1344,7 @@ private function readCacheFile(string $cacheFilePath): ?array
 					continue;
 				}
 
-				$entries = $this->readEntryFrames($handle, (int) $size);
-				if ($entries === null) {
-					return null;
-				}
-
-				$data[substr($name, 0, -1)] = $entries;
+				$data[substr($name, 0, -1)] = $this->readEntryFrames($handle, (int) $size);
 			}
 
 			return $data;
@@ -1359,20 +1355,20 @@ private function readCacheFile(string $cacheFilePath): ?array
 
 	/**
 	 * @param resource $handle
-	 * @return array<mixed>|null
+	 * @return array<mixed>
 	 */
-	private function readEntryFrames($handle, int $count): ?array
+	private function readEntryFrames($handle, int $count): array
 	{
 		$entries = [];
 		for ($i = 0; $i < $count; $i++) {
 			$length = fgets($handle);
 			if ($length === false) {
-				return null;
+				throw new RuntimeException(sprintf('Cache file ended after %d of %d entries.', $i, $count));
 			}
 
 			$entry = $this->readFrame($handle, (int) rtrim($length, "\n"));
 			if (!is_array($entry)) {
-				return null;
+				throw new RuntimeException('An entry frame did not contain an array.');
 			}
 
 			foreach ($entry as $key => $value) {
@@ -1384,17 +1380,41 @@ private function readEntryFrames($handle, int $count): ?array
 	}
 
 	/**
+	 * A frame's payload, or an exception when the file does not hold one.
+	 *
+	 * Every failure here means a cache file that is this format but damaged - a process killed
+	 * mid-save leaves exactly that, since the file is written in place. restore() turns the
+	 * exception into a discarded cache and a full analysis, the same way it handles the parse
+	 * error an incomplete var_export'd file used to produce. Returning a value instead would
+	 * hand a half-read cache to the caller, where the missing pieces surface as type errors far
+	 * from the cause.
+	 *
+	 * false is treated as failure because unserialize() reports failure that way and no value in
+	 * the cache is a bare false: the sections are arrays and lastFullAnalysisTime is an int.
+	 *
 	 * @param resource $handle
 	 */
 	private function readFrame($handle, int $length): mixed
 	{
 		if ($length <= 0) {
-			return null;
+			throw new RuntimeException(sprintf('Frame length %d is not positive.', $length));
 		}
 
 		$blob = fread($handle, $length);
+		if ($blob === false || strlen($blob) !== $length) {
+			throw new RuntimeException(sprintf(
+				'Expected a %d byte frame, read %d bytes.',
+				$length,
+				$blob === false ? 0 : strlen($blob),
+			));
+		}
+
+		$value = @unserialize($blob);
+		if ($value === false) {
+			throw new RuntimeException(sprintf('A %d byte frame could not be unserialized.', $length));
+		}
 
-		return $blob === false ? null : @unserialize($blob);
+		return $value;
 	}
 
 	/**