Fix some phpstan findings

sebastianbergmann · Jul 3, 2024 · 4d60e9e · 4d60e9e
1 parent b4ccd85
commit 4d60e9e
Show file tree

Hide file tree

Showing 22 changed files with 250 additions and 48 deletions.
diff --git a/phpstan.neon b/phpstan.neon
@@ -1,5 +1,5 @@
 parameters:
-    level: 2
+    level: 5
     paths:
         - src
         - tests
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 [