Fix some phpstan findings

SpacePossum · sebastianbergmann · commit da621b838c9d · 2024-07-03T12:43:57.000+02:00
diff --git a/phpstan.neon b/phpstan.neon
@@ -1,5 +1,9 @@
 parameters:
-    level: 2
+    level: 5
     paths:
         - src
         - tests
+    ignoreErrors:
+        -
+            message: '#Method SebastianBergmann\\Diff\\Differ::calculateEstimatedFootprint\(\) never returns float so it can be removed from the return type\.#'
+            path: src/Differ.php
diff --git a/src/Differ.php b/src/Differ.php
@@ -84,11 +84,11 @@ public function diffToArray(array|string $from, array|string $to, ?LongestCommon
         reset($to);
 
         foreach ($common as $token) {
-            while (($fromToken = reset($from)) !== $token) {
+            while ((/* from-token */ reset($from)) !== $token) {
                 $diff[] = [array_shift($from), self::REMOVED];
             }
 
-            while (($toToken = reset($to)) !== $token) {
+            while ((/* to-token */ reset($to)) !== $token) {
                 $diff[] = [array_shift($to), self::ADDED];
             }
 
diff --git a/src/MemoryEfficientLongestCommonSubsequenceCalculator.php b/src/MemoryEfficientLongestCommonSubsequenceCalculator.php
@@ -15,7 +15,6 @@
 use function array_slice;
 use function count;
 use function in_array;
-use function max;
 
 final class MemoryEfficientLongestCommonSubsequenceCalculator implements LongestCommonSubsequenceCalculator
 {
diff --git a/src/Output/AbstractChunkOutputBuilder.php b/src/Output/AbstractChunkOutputBuilder.php
@@ -16,6 +16,8 @@ abstract class AbstractChunkOutputBuilder implements DiffOutputBuilderInterface
     /**
      * Takes input of the diff array and returns the common parts.
      * Iterates through diff line by line.
+     *
+     * @return array<int, positive-int>
      */
     protected function getCommonChunks(array $diff, int $lineThreshold = 5): array
     {
diff --git a/src/Output/DiffOnlyOutputBuilder.php b/src/Output/DiffOnlyOutputBuilder.php
@@ -9,9 +9,11 @@
  */
 namespace SebastianBergmann\Diff\Output;
 
+use function assert;
 use function fclose;
 use function fopen;
 use function fwrite;
+use function is_resource;
 use function str_ends_with;
 use function stream_get_contents;
 use function substr;
@@ -33,6 +35,7 @@ public function __construct(string $header = "--- Original\n+++ New\n")
     public function getDiff(array $diff): string
     {
         $buffer = fopen('php://memory', 'r+b');
+        assert(is_resource($buffer));
 
         if ('' !== $this->header) {
             fwrite($buffer, $this->header);
diff --git a/src/Output/StrictUnifiedDiffOutputBuilder.php b/src/Output/StrictUnifiedDiffOutputBuilder.php
@@ -11,12 +11,14 @@
 
 use function array_merge;
 use function array_splice;
+use function assert;
 use function count;
 use function fclose;
 use function fopen;
 use function fwrite;
 use function is_bool;
 use function is_int;
+use function is_resource;
 use function is_string;
 use function max;
 use function min;
@@ -99,6 +101,8 @@ public function getDiff(array $diff): string
         $this->changed = false;
 
         $buffer = fopen('php://memory', 'r+b');
+        assert(is_resource($buffer));
+
         fwrite($buffer, $this->header);
 
         $this->writeDiffHunks($buffer, $diff);
diff --git a/src/Output/UnifiedDiffOutputBuilder.php b/src/Output/UnifiedDiffOutputBuilder.php
@@ -10,10 +10,12 @@
 namespace SebastianBergmann\Diff\Output;
 
 use function array_splice;
+use function assert;
 use function count;
 use function fclose;
 use function fopen;
 use function fwrite;
+use function is_resource;
 use function max;
 use function min;
 use function str_ends_with;
@@ -45,6 +47,7 @@ public function __construct(string $header = "--- Original\n+++ New\n", bool $ad
     public function getDiff(array $diff): string
     {
         $buffer = fopen('php://memory', 'r+b');
+        assert(is_resource($buffer));
 
         if ('' !== $this->header) {
             fwrite($buffer, $this->header);
diff --git a/src/Parser.php b/src/Parser.php
@@ -71,6 +71,9 @@ public function parse(string $string): array
         return $diffs;
     }
 
+    /**
+     * @param string[] $lines
+     */
     private function parseFileDiff(Diff $diff, array $lines): void
     {
         $chunks    = [];
diff --git a/src/TimeEfficientLongestCommonSubsequenceCalculator.php b/src/TimeEfficientLongestCommonSubsequenceCalculator.php
@@ -11,7 +11,6 @@
 
 use function array_reverse;
 use function count;
-use function max;
 use SplFixedArray;
 
 final class TimeEfficientLongestCommonSubsequenceCalculator implements LongestCommonSubsequenceCalculator
diff --git a/tests/DifferTest.php b/tests/DifferTest.php
@@ -189,6 +189,15 @@ public static function arrayProvider(): array
         ];
     }
 
+    /**
+     * @return array<
+     *     array{
+     *         0: string,
+     *         1: string,
+     *         2: string,
+     *     }
+     * >
+     */
     public static function textProvider(): array
     {
         return [
@@ -255,6 +264,14 @@ public static function textProvider(): array
         ];
     }
 
+    /**
+     * @return array<
+     *     array{
+     *         0: array<string>,
+     *         1: string,
+     *     }
+     * >
+     */
     public static function provideSplitStringByLinesCases(): array
     {
         return [
@@ -368,7 +385,6 @@ public function testSplitStringByLines(array $expected, string $input): void
     {
         $reflection = new ReflectionObject($this->differ);
         $method     = $reflection->getMethod('splitStringByLines');
-        $method->setAccessible(true);
 
         $this->assertSame($expected, $method->invoke($this->differ, $input));
     }
diff --git a/tests/Output/AbstractChunkOutputBuilderTest.php b/tests/Output/AbstractChunkOutputBuilderTest.php
@@ -22,6 +22,16 @@
 #[UsesClass(TimeEfficientLongestCommonSubsequenceCalculator::class)]
 final class AbstractChunkOutputBuilderTest extends TestCase
 {
+    /**
+     * @return array<
+     *     array{
+     *         0: array<int, int>,
+     *         1: string,
+     *         2: string,
+     *         3?: int,
+     *     }
+     * >
+     */
     public static function provideGetCommonChunks(): array
     {
         return [
@@ -122,6 +132,9 @@ public static function provideGetCommonChunks(): array
         ];
     }
 
+    /**
+     * @param array<int, positive-int> $expected
+     */
     #[DataProvider('provideGetCommonChunks')]
     public function testGetCommonChunks(array $expected, string $from, string $to, int $lineThreshold = 5): void
     {
@@ -132,7 +145,10 @@ public function getDiff(array $diff): string
                 return '';
             }
 
-            public function getChunks(array $diff, $lineThreshold)
+            /**
+             * @return array<int, positive-int>
+             */
+            public function getChunks(array $diff, int $lineThreshold): array
             {
                 return $this->getCommonChunks($diff, $lineThreshold);
             }
diff --git a/tests/Output/DiffOnlyOutputBuilderTest.php b/tests/Output/DiffOnlyOutputBuilderTest.php
@@ -21,6 +21,16 @@
 #[UsesClass(TimeEfficientLongestCommonSubsequenceCalculator::class)]
 final class DiffOnlyOutputBuilderTest extends TestCase
 {
+    /**
+     * @return array<
+     *     array{
+     *         0: string,
+     *         1: string,
+     *         2: string,
+     *         3?: string,
+     *     }
+     * >
+     */
     public static function textForNoNonDiffLinesProvider(): array
     {
         return [
diff --git a/tests/Output/Integration/StrictUnifiedDiffOutputBuilderIntegrationTest.php b/tests/Output/Integration/StrictUnifiedDiffOutputBuilderIntegrationTest.php
@@ -63,7 +63,10 @@ public static function provideBasicDiffGeneration(): array
         return StrictUnifiedDiffOutputBuilderDataProvider::provideBasicDiffGeneration();
     }
 
-    public static function provideFilePairs(): array
+    /**
+     * @return iterable<string, array{0: string, 1: string}>
+     */
+    public static function provideFilePairs(): iterable
     {
         $cases     = [];
         $fromFile  = __FILE__;
@@ -77,9 +80,10 @@ public static function provideFilePairs(): array
                 continue;
             }
 
-            $toFile                                                                                      = $file->getPathname();
-            $cases[sprintf("Diff file:\n\"%s\"\nvs.\n\"%s\"\n", realpath($fromFile), realpath($toFile))] = [$fromFile, $toFile];
-            $fromFile                                                                                    = $toFile;
+            $toFile = $file->getPathname();
+
+            yield sprintf("Diff file:\n\"%s\"\nvs.\n\"%s\"\n", realpath($fromFile), realpath($toFile)) => [$fromFile, $toFile];
+            $fromFile = $toFile;
         }
 
         return $cases;
@@ -119,7 +123,7 @@ public function testIntegrationUsingPHPFileInVendorGitApply(string $fileFrom, st
             return;
         }
 
-        $this->doIntegrationTestGitApply($diff, $from, $to);
+        $this->doIntegrationTestGitApply($diff, $from);
     }
 
     #[DataProvider('provideFilePairs')]
@@ -145,7 +149,7 @@ public function testIntegrationUsingPHPFileInVendorPatch(string $fileFrom, strin
     #[DataProvider('provideSample')]
     public function testIntegrationOfUnitTestCasesGitApply(string $expected, string $from, string $to): void
     {
-        $this->doIntegrationTestGitApply($expected, $from, $to);
+        $this->doIntegrationTestGitApply($expected, $from);
     }
 
     #[DataProvider('provideBasicDiffGeneration')]
@@ -191,7 +195,7 @@ public function testIntegrationDiffOutputBuilderVersusDiffCommand(string $diff,
         $this->assertSame($diff, $output);
     }
 
-    private function doIntegrationTestGitApply(string $diff, string $from, string $to): void
+    private function doIntegrationTestGitApply(string $diff, string $from): void
     {
         $this->assertNotSame('', $diff);
         $this->assertValidUnifiedDiffFormat($diff);
diff --git a/tests/Output/Integration/UnifiedDiffOutputBuilderIntegrationTest.php b/tests/Output/Integration/UnifiedDiffOutputBuilderIntegrationTest.php
@@ -13,8 +13,10 @@
 use const PREG_SPLIT_DELIM_CAPTURE;
 use const PREG_SPLIT_NO_EMPTY;
 use function array_filter;
+use function assert;
 use function file_put_contents;
 use function implode;
+use function is_array;
 use function is_string;
 use function preg_replace;
 use function preg_split;
@@ -43,6 +45,15 @@ final class UnifiedDiffOutputBuilderIntegrationTest extends TestCase
     private string $fileFrom;
     private string $filePatch;
 
+    /**
+     * @return array{
+     *     string?: array{
+     *         0: string,
+     *         1: string,
+     *         2: string,
+     *     },
+     * }
+     */
     public static function provideDiffWithLineNumbers(): array
     {
         return array_filter(
@@ -70,15 +81,15 @@ protected function tearDown(): void
     }
 
     #[DataProvider('provideDiffWithLineNumbers')]
-    public function testDiffWithLineNumbersPath($expected, $from, $to): void
+    public function testDiffWithLineNumbersPath(string $expected, string $from, string $to): void
     {
         $this->doIntegrationTestPatch($expected, $from, $to);
     }
 
     #[DataProvider('provideDiffWithLineNumbers')]
-    public function testDiffWithLineNumbersGitApply($expected, $from, $to): void
+    public function testDiffWithLineNumbersGitApply(string $expected, string $from): void
     {
-        $this->doIntegrationTestGitApply($expected, $from, $to);
+        $this->doIntegrationTestGitApply($expected, $from);
     }
 
     private function doIntegrationTestPatch(string $diff, string $from, string $to): void
@@ -109,7 +120,7 @@ private function doIntegrationTestPatch(string $diff, string $from, string $to):
         );
     }
 
-    private function doIntegrationTestGitApply(string $diff, string $from, string $to): void
+    private function doIntegrationTestGitApply(string $diff, string $from): void
     {
         $this->assertNotSame('', $diff);
         $this->assertValidUnifiedDiffFormat($diff);
@@ -154,7 +165,9 @@ private function cleanUpTempFiles(): void
 
     private static function setDiffFileHeader(string $diff, string $file): string
     {
-        $diffLines    = preg_split('/(.*\R)/', $diff, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);
+        $diffLines = preg_split('/(.*\R)/', $diff, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);
+        assert(is_array($diffLines));
+
         $diffLines[0] = preg_replace('#^\-\-\- .*#', '--- /' . $file, $diffLines[0], 1);
         $diffLines[1] = preg_replace('#^\+\+\+ .*#', '+++ /' . $file, $diffLines[1], 1);
 
diff --git a/tests/Output/StrictUnifiedDiffOutputBuilderDataProvider.php b/tests/Output/StrictUnifiedDiffOutputBuilderDataProvider.php
@@ -11,6 +11,22 @@
 
 final class StrictUnifiedDiffOutputBuilderDataProvider
 {
+    /**
+     * @return array<
+     *     array{
+     *         0: string,
+     *         1: string,
+     *         2: string,
+     *         3: array{
+     *             "fromFile": string,
+     *             "toFile": string,
+     *             "collapseRanges"?: bool,
+     *             "fromFileDate"?: string,
+     *             "toFileDate"?: string,
+     *         },
+     *     },
+     * >
+     */
     public static function provideOutputBuildingCases(): array
     {
         return [
@@ -72,6 +88,19 @@ public static function provideOutputBuildingCases(): array
         ];
     }
 
+    /**
+     * @return array<
+     *     array{
+     *         0: string,
+     *         1: string,
+     *         2: string,
+     *         3: array{
+     *             "fromFile": string,
+     *             "toFile": string,
+     *         },
+     *     },
+     * >
+     */
     public static function provideSample(): array
     {
         return [
@@ -97,6 +126,15 @@ public static function provideSample(): array
         ];
     }
 
+    /**
+     * @return array<
+     *     array{
+     *         0: string,
+     *         1: string,
+     *         2: string,
+     *     }
+     * >
+     */
     public static function provideBasicDiffGeneration(): array
     {
         return [
diff --git a/tests/Output/StrictUnifiedDiffOutputBuilderTest.php b/tests/Output/StrictUnifiedDiffOutputBuilderTest.php
diff --git a/tests/Output/UnifiedDiffOutputBuilderDataProvider.php b/tests/Output/UnifiedDiffOutputBuilderDataProvider.php
diff --git a/tests/Output/UnifiedDiffOutputBuilderTest.php b/tests/Output/UnifiedDiffOutputBuilderTest.php
diff --git a/tests/ParserTest.php b/tests/ParserTest.php
diff --git a/tests/Utils/UnifiedDiffAssertTrait.php b/tests/Utils/UnifiedDiffAssertTrait.php
diff --git a/tests/Utils/UnifiedDiffAssertTraitIntegrationTest.php b/tests/Utils/UnifiedDiffAssertTraitIntegrationTest.php
diff --git a/tests/Utils/UnifiedDiffAssertTraitTest.php b/tests/Utils/UnifiedDiffAssertTraitTest.php

Original file line number	Diff line number	Diff line change
`@@ -84,11 +84,11 @@ public function diffToArray(array\|string $from, array\|string $to, ?LongestCommon`
`84`	`84`	`reset($to);`
`85`	`85`
`86`	`86`	`foreach ($common as $token) {`
`87`		`- while (($fromToken = reset($from)) !== $token) {`
	`87`	`+ while ((/* from-token */ reset($from)) !== $token) {`
`88`	`88`	`$diff[] = [array_shift($from), self::REMOVED];`
`89`	`89`	`}`
`90`	`90`
`91`		`- while (($toToken = reset($to)) !== $token) {`
	`91`	`+ while ((/* to-token */ reset($to)) !== $token) {`
`92`	`92`	`$diff[] = [array_shift($to), self::ADDED];`
`93`	`93`	`}`
`94`	`94`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,6 @@`
`15`	`15`	`use function array_slice;`
`16`	`16`	`use function count;`
`17`	`17`	`use function in_array;`
`18`		`-use function max;`
`19`	`18`
`20`	`19`	`final class MemoryEfficientLongestCommonSubsequenceCalculator implements LongestCommonSubsequenceCalculator`
`21`	`20`	`{`
Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,8 @@ abstract class AbstractChunkOutputBuilder implements DiffOutputBuilderInterface`
`16`	`16`	`/**`
`17`	`17`	`* Takes input of the diff array and returns the common parts.`
`18`	`18`	`* Iterates through diff line by line.`
	`19`	`+ *`
	`20`	`+ * @return array<int, positive-int>`
`19`	`21`	`*/`
`20`	`22`	`protected function getCommonChunks(array $diff, int $lineThreshold = 5): array`
`21`	`23`	`{`
Original file line number	Diff line number	Diff line change
`@@ -71,6 +71,9 @@ public function parse(string $string): array`
`71`	`71`	`return $diffs;`
`72`	`72`	`}`
`73`	`73`
	`74`	`+ /**`
	`75`	`+ * @param string[] $lines`
	`76`	`+ */`
`74`	`77`	`private function parseFileDiff(Diff $diff, array $lines): void`
`75`	`78`	`{`
`76`	`79`	`$chunks = [];`
Original file line number	Diff line number	Diff line change
`@@ -189,6 +189,15 @@ public static function arrayProvider(): array`
`189`	`189`	`];`
`190`	`190`	`}`
`191`	`191`
	`192`	`+ /**`
	`193`	`+ * @return array<`
	`194`	`+ * array{`
	`195`	`+ * 0: string,`
	`196`	`+ * 1: string,`
	`197`	`+ * 2: string,`
	`198`	`+ * }`
	`199`	`+ * >`
	`200`	`+ */`
`192`	`201`	`public static function textProvider(): array`
`193`	`202`	`{`
`194`	`203`	`return [`
`@@ -255,6 +264,14 @@ public static function textProvider(): array`
`255`	`264`	`];`
`256`	`265`	`}`
`257`	`266`
	`267`	`+ /**`
	`268`	`+ * @return array<`
	`269`	`+ * array{`
	`270`	`+ * 0: array<string>,`
	`271`	`+ * 1: string,`
	`272`	`+ * }`
	`273`	`+ * >`
	`274`	`+ */`
`258`	`275`	`public static function provideSplitStringByLinesCases(): array`
`259`	`276`	`{`
`260`	`277`	`return [`
`@@ -368,7 +385,6 @@ public function testSplitStringByLines(array $expected, string $input): void`
`368`	`385`	`{`
`369`	`386`	`$reflection = new ReflectionObject($this->differ);`
`370`	`387`	`$method = $reflection->getMethod('splitStringByLines');`
`371`		`- $method->setAccessible(true);`
`372`	`388`
`373`	`389`	`$this->assertSame($expected, $method->invoke($this->differ, $input));`
`374`	`390`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,16 @@`
`22`	`22`	`#[UsesClass(TimeEfficientLongestCommonSubsequenceCalculator::class)]`
`23`	`23`	`final class AbstractChunkOutputBuilderTest extends TestCase`
`24`	`24`	`{`
	`25`	`+ /**`
	`26`	`+ * @return array<`
	`27`	`+ * array{`
	`28`	`+ * 0: array<int, int>,`
	`29`	`+ * 1: string,`
	`30`	`+ * 2: string,`
	`31`	`+ * 3?: int,`
	`32`	`+ * }`
	`33`	`+ * >`
	`34`	`+ */`
`25`	`35`	`public static function provideGetCommonChunks(): array`
`26`	`36`	`{`
`27`	`37`	`return [`
`@@ -122,6 +132,9 @@ public static function provideGetCommonChunks(): array`
`122`	`132`	`];`
`123`	`133`	`}`
`124`	`134`
	`135`	`+ /**`
	`136`	`+ * @param array<int, positive-int> $expected`
	`137`	`+ */`
`125`	`138`	`#[DataProvider('provideGetCommonChunks')]`
`126`	`139`	`public function testGetCommonChunks(array $expected, string $from, string $to, int $lineThreshold = 5): void`
`127`	`140`	`{`
`@@ -132,7 +145,10 @@ public function getDiff(array $diff): string`
`132`	`145`	`return '';`
`133`	`146`	`}`
`134`	`147`
`135`		`- public function getChunks(array $diff, $lineThreshold)`
	`148`	`+ /**`
	`149`	`+ * @return array<int, positive-int>`
	`150`	`+ */`
	`151`	`+ public function getChunks(array $diff, int $lineThreshold): array`
`136`	`152`	`{`
`137`	`153`	`return $this->getCommonChunks($diff, $lineThreshold);`
`138`	`154`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,10 @@ public static function provideBasicDiffGeneration(): array`
`63`	`63`	`return StrictUnifiedDiffOutputBuilderDataProvider::provideBasicDiffGeneration();`
`64`	`64`	`}`
`65`	`65`
`66`		`- public static function provideFilePairs(): array`
	`66`	`+ /**`
	`67`	`+ * @return iterable<string, array{0: string, 1: string}>`
	`68`	`+ */`
	`69`	`+ public static function provideFilePairs(): iterable`
`67`	`70`	`{`
`68`	`71`	`$cases = [];`
`69`	`72`	`$fromFile = __FILE__;`
`@@ -77,9 +80,10 @@ public static function provideFilePairs(): array`
`77`	`80`	`continue;`
`78`	`81`	`}`
`79`	`82`
`80`		`- $toFile = $file->getPathname();`
`81`		`- $cases[sprintf("Diff file:\n\"%s\"\nvs.\n\"%s\"\n", realpath($fromFile), realpath($toFile))] = [$fromFile, $toFile];`
`82`		`- $fromFile = $toFile;`
	`83`	`+ $toFile = $file->getPathname();`
	`84`	`+`
	`85`	`+ yield sprintf("Diff file:\n\"%s\"\nvs.\n\"%s\"\n", realpath($fromFile), realpath($toFile)) => [$fromFile, $toFile];`
	`86`	`+ $fromFile = $toFile;`
`83`	`87`	`}`
`84`	`88`
`85`	`89`	`return $cases;`
`@@ -119,7 +123,7 @@ public function testIntegrationUsingPHPFileInVendorGitApply(string $fileFrom, st`
`119`	`123`	`return;`
`120`	`124`	`}`
`121`	`125`
`122`		`- $this->doIntegrationTestGitApply($diff, $from, $to);`
	`126`	`+ $this->doIntegrationTestGitApply($diff, $from);`
`123`	`127`	`}`
`124`	`128`
`125`	`129`	`#[DataProvider('provideFilePairs')]`
`@@ -145,7 +149,7 @@ public function testIntegrationUsingPHPFileInVendorPatch(string $fileFrom, strin`
`145`	`149`	`#[DataProvider('provideSample')]`
`146`	`150`	`public function testIntegrationOfUnitTestCasesGitApply(string $expected, string $from, string $to): void`
`147`	`151`	`{`
`148`		`- $this->doIntegrationTestGitApply($expected, $from, $to);`
	`152`	`+ $this->doIntegrationTestGitApply($expected, $from);`
`149`	`153`	`}`
`150`	`154`
`151`	`155`	`#[DataProvider('provideBasicDiffGeneration')]`
`@@ -191,7 +195,7 @@ public function testIntegrationDiffOutputBuilderVersusDiffCommand(string $diff,`
`191`	`195`	`$this->assertSame($diff, $output);`
`192`	`196`	`}`
`193`	`197`
`194`		`- private function doIntegrationTestGitApply(string $diff, string $from, string $to): void`
	`198`	`+ private function doIntegrationTestGitApply(string $diff, string $from): void`
`195`	`199`	`{`
`196`	`200`	`$this->assertNotSame('', $diff);`
`197`	`201`	`$this->assertValidUnifiedDiffFormat($diff);`