bump phpstan level to 5 (#108)

akondas · web-flow · commit 56c1cd5728a3 · 2024-05-30T09:26:49.000+02:00
diff --git a/phpstan.neon b/phpstan.neon
@@ -2,7 +2,7 @@ includes:
 	- vendor/phpstan/phpstan/conf/bleedingEdge.neon
 parameters:
 	phpVersion: 80100
-	level: 4
+	level: 5
 	paths:
 		- src
 		- tests
diff --git a/src/Collection/Map.php b/src/Collection/Map.php
@@ -285,6 +285,30 @@ public function dropWhile(callable $predicate)
         return self::fromPointer($map);
     }
 
+    /**
+     * @param callable(Tuple2<K, V>):bool $predicate
+     *
+     * @return Map<K,V>
+     */
+    public function dropUntil(callable $predicate)
+    {
+        return parent::dropUntil($predicate);
+    }
+
+    /**
+     * @param callable(V): void $action
+     *
+     * @return Map<K,V>
+     */
+    public function peek(callable $action)
+    {
+        if (!$this->isEmpty()) {
+            $action($this->get()->get());
+        }
+
+        return $this;
+    }
+
     /**
      * Take n next entries of map.
      *
diff --git a/tests/Collection/GenericListTest.php b/tests/Collection/GenericListTest.php
@@ -221,7 +221,7 @@ public function testListContainsAll(): void
         self::assertFalse(GenericList::ofAll([1, 2, 3])->containsAll(GenericList::ofAll([1, 2, 3, 4])));
         self::assertFalse(GenericList::ofAll([1, 2, 3])->containsAll(GenericList::ofAll([1, 2, 4])));
         self::assertFalse(GenericList::ofAll([1, 2, 3])->containsAll(GenericList::ofAll([1, 4])));
-        self::assertFalse(GenericList::ofAll([1, 2, 3])->containsAll(GenericList::ofAll(['a'])));
+        self::assertFalse(GenericList::ofAll([1, 2, 3])->containsAll(GenericList::ofAll([0])));
     }
 
     public function testFlatMap(): void
diff --git a/tests/Collection/MapTest.php b/tests/Collection/MapTest.php
@@ -92,13 +92,13 @@ public function testEmptyMapPeek(): void
     public function testMapPeek(): void
     {
         $counter = 0;
-        Map::fromArray(['a' => 1])->peek(function (Option $head) use (&$counter) {$counter = $head->get(); });
+        Map::fromArray(['a' => 1])->peek(function (int $head) use (&$counter) {$counter = $head; });
         self::assertEquals(1, $counter);
     }
 
     public function testMapTake(): void
     {
-        $map = Map::fromArray(['a' => 'apple', 'b' => 'banana', '42' => 'pear', 'd' => 'orange']);
+        $map = Map::fromArray(['a' => 'apple', 'b' => 'banana', 'a42' => 'pear', 'd' => 'orange']);
 
         self::assertTrue(Map::fromArray(['a' => 'apple', 'b' => 'banana'])->equals($map->take(2)));
         self::assertTrue(Map::fromArray(['a' => 'apple'])->equals($map->take(1)));
@@ -109,9 +109,9 @@ public function testMapTake(): void
 
     public function testMapDrop(): void
     {
-        $map = Map::fromArray(['a' => 'apple', 'b' => 'banana', '42' => 'pear', 'd' => 'orange']);
+        $map = Map::fromArray(['a' => 'apple', 'b' => 'banana', 'a42' => 'pear', 'd' => 'orange']);
 
-        self::assertTrue(Map::fromArray(['42' => 'pear', 'd' => 'orange'])->equals($map->drop(2)));
+        self::assertTrue(Map::fromArray(['a42' => 'pear', 'd' => 'orange'])->equals($map->drop(2)));
         self::assertTrue(Map::fromArray(['d' => 'orange'])->equals($map->drop(3)));
         self::assertTrue($map->equals($map->drop(0)));
         self::assertSame($map, $map->drop(-1));
@@ -120,14 +120,14 @@ public function testMapDrop(): void
 
     public function testMapFilter(): void
     {
-        $map = Map::fromArray(['a' => 'apple', 'b' => 'banana', '42' => 'pear', 'd' => 'orange']);
+        $map = Map::fromArray(['a' => 'apple', 'b' => 'banana', 'a42' => 'pear', 'd' => 'orange']);
 
         self::assertTrue(Map::fromArray(['a' => 'apple'])->equals(
             $map->filter(function ($entry) {return $entry[1] === 'apple'; })
         ));
 
-        self::assertTrue(Map::fromArray(['42' => 'pear'])->equals(
-            $map->filter(function ($entry) {return is_numeric($entry[0]); })
+        self::assertTrue(Map::fromArray(['a42' => 'pear'])->equals(
+            $map->filter(function ($entry) {return $entry[0] === 'a42'; })
         ));
 
         self::assertNotSame($map, $map->filter(function () {return true; }));
@@ -190,8 +190,8 @@ public function testMapContainsValue(): void
         $map = Map::fromArray(['a' => 'b', 'c' => 'd', 'e' => Option::of('munus')]);
 
         self::assertTrue($map->containsValue('d'));
-        self::assertFalse($map->containsValue('a'));
-        self::assertTrue($map->containsValue('munus'));
+        self::assertFalse($map->containsValue('a')); // @phpstan-ignore-line phpstan is too smart and knows what exactly is in map
+        self::assertTrue($map->containsValue('munus')); // @phpstan-ignore-line phpstan is too smart and knows what exactly is in map
     }
 
     public function testMapValues(): void
@@ -231,9 +231,7 @@ public function testMapDropUntil(): void
         self::assertTrue(Map::fromArray(['c' => 3, 'd' => 4])->equals($map->dropUntil(function (Tuple $node): bool {
             return $node[0] === 'c';
         })));
-        self::assertTrue(Map::empty()->equals($map->dropUntil(function (Tuple $node): bool {
-            return false;
-        })));
+        self::assertTrue(Map::empty()->equals($map->dropUntil(fn () => false)));
     }
 
     public function testMapMerge(): void
diff --git a/tests/Collection/SetTest.php b/tests/Collection/SetTest.php
@@ -129,7 +129,7 @@ public function testSetCanHoldObjects(): void
         $set = Set::ofAll([Set::of(1, 2, 3), Set::of(4, 5, 6)]);
 
         self::assertEquals(2, $set->length());
-        self::assertFalse($set->contains(new \stdClass()));
+        self::assertFalse($set->contains(Set::empty()));
         self::assertTrue($set->contains(Set::of(1, 2, 3)));
     }
 
diff --git a/tests/Collection/Stream/CollectorsTest.php b/tests/Collection/Stream/CollectorsTest.php
@@ -30,20 +30,20 @@ public function testToSetCollector(): void
     public function testToMapWithDefaultValueMapperCollector(): void
     {
         $map = Stream::from(1)->take(3)->collect(Collectors::toMap(
-            fn (int $value): string => (string) $value
+            fn (int $value): string => 'a'.$value
         ));
 
-        self::assertTrue(Map::fromArray(['1' => 1, '2' => 2, '3' => 3])->equals($map));
+        self::assertTrue(Map::fromArray(['a1' => 1, 'a2' => 2, 'a3' => 3])->equals($map));
     }
 
     public function testToMapCollector(): void
     {
         $map = Stream::from(1)->take(3)->collect(Collectors::toMap(
-            fn (int $value): string => (string) $value,
+            fn (int $value): string => 'a'.$value,
             fn (int $value): int => $value * 2,
         ));
 
-        self::assertTrue(Map::fromArray(['1' => 2, '2' => 4, '3' => 6])->equals($map));
+        self::assertTrue(Map::fromArray(['a1' => 2, 'a2' => 4, 'a3' => 6])->equals($map));
     }
 
     public function testSummingCollector(): void
diff --git a/tests/Collection/StreamTest.php b/tests/Collection/StreamTest.php
@@ -113,7 +113,7 @@ public function testStreamContainsAll(): void
         self::assertFalse(Stream::ofAll([1, 2, 3])->containsAll(Stream::ofAll([1, 2, 3, 4])));
         self::assertFalse(Stream::ofAll([1, 2, 3])->containsAll(Stream::ofAll([1, 2, 4])));
         self::assertFalse(Stream::ofAll([1, 2, 3])->containsAll(Stream::ofAll([1, 4])));
-        self::assertFalse(Stream::ofAll([1, 2, 3])->containsAll(Stream::ofAll(['a'])));
+        self::assertFalse(Stream::ofAll([1, 2, 3])->containsAll(Stream::ofAll([0])));
     }
 
     public function testStreamMapSingle(): void
diff --git a/tests/Control/OptionTest.php b/tests/Control/OptionTest.php
@@ -53,7 +53,7 @@ public function testGetOrSomething(): void
         /** @var Option<string> $option */
         $option = Option::of(null);
         self::assertNull($option->getOrNull());
-        self::assertTrue($option->getOrElse(true));
+        self::assertSame('string', $option->getOrElse('string'));
     }
 
     public function testMap(): void
diff --git a/tests/Control/TryToTest.php b/tests/Control/TryToTest.php
@@ -59,9 +59,9 @@ public function testMapFailure(): void
 
     public function testMapWithMapperFailure(): void
     {
-        $try = TryTo::run('time');
+        $try = TryTo::run(fn () => 0);
 
-        self::assertInstanceOf(\TypeError::class, $try->map('strtoupper')->getCause());
+        self::assertInstanceOf(\DivisionByZeroError::class, $try->map(fn (int $x) => 1 / $x)->getCause());
     }
 
     public function testMapWitMapperSuccess(): void
diff --git a/tests/LazyTest.php b/tests/LazyTest.php
@@ -47,8 +47,8 @@ public function testMap(): void
     {
         $lazy = Lazy::of(function () {return 4; });
 
-        self::assertInstanceOf(Lazy::class, $lazy->map('range'));
-        self::assertEquals(2, $lazy->map('sqrt')->get());
+        self::assertSame(5, $lazy->map(fn (int $x) => $x + 1)->get());
+        self::assertEquals(2, $lazy->map('sqrt')->get()); // sqrt returns float
     }
 
     public function testCollect(): void

Original file line number	Diff line number	Diff line change
`@@ -221,7 +221,7 @@ public function testListContainsAll(): void`
`221`	`221`	`self::assertFalse(GenericList::ofAll([1, 2, 3])->containsAll(GenericList::ofAll([1, 2, 3, 4])));`
`222`	`222`	`self::assertFalse(GenericList::ofAll([1, 2, 3])->containsAll(GenericList::ofAll([1, 2, 4])));`
`223`	`223`	`self::assertFalse(GenericList::ofAll([1, 2, 3])->containsAll(GenericList::ofAll([1, 4])));`
`224`		`- self::assertFalse(GenericList::ofAll([1, 2, 3])->containsAll(GenericList::ofAll(['a'])));`
	`224`	`+ self::assertFalse(GenericList::ofAll([1, 2, 3])->containsAll(GenericList::ofAll([0])));`
`225`	`225`	`}`
`226`	`226`
`227`	`227`	`public function testFlatMap(): void`
Original file line number	Diff line number	Diff line change
`@@ -129,7 +129,7 @@ public function testSetCanHoldObjects(): void`
`129`	`129`	`$set = Set::ofAll([Set::of(1, 2, 3), Set::of(4, 5, 6)]);`
`130`	`130`
`131`	`131`	`self::assertEquals(2, $set->length());`
`132`		`- self::assertFalse($set->contains(new \stdClass()));`
	`132`	`+ self::assertFalse($set->contains(Set::empty()));`
`133`	`133`	`self::assertTrue($set->contains(Set::of(1, 2, 3)));`
`134`	`134`	`}`
`135`	`135`
Original file line number	Diff line number	Diff line change
`@@ -30,20 +30,20 @@ public function testToSetCollector(): void`
`30`	`30`	`public function testToMapWithDefaultValueMapperCollector(): void`
`31`	`31`	`{`
`32`	`32`	`$map = Stream::from(1)->take(3)->collect(Collectors::toMap(`
`33`		`- fn (int $value): string => (string) $value`
	`33`	`+ fn (int $value): string => 'a'.$value`
`34`	`34`	`));`
`35`	`35`
`36`		`- self::assertTrue(Map::fromArray(['1' => 1, '2' => 2, '3' => 3])->equals($map));`
	`36`	`+ self::assertTrue(Map::fromArray(['a1' => 1, 'a2' => 2, 'a3' => 3])->equals($map));`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`public function testToMapCollector(): void`
`40`	`40`	`{`
`41`	`41`	`$map = Stream::from(1)->take(3)->collect(Collectors::toMap(`
`42`		`- fn (int $value): string => (string) $value,`
	`42`	`+ fn (int $value): string => 'a'.$value,`
`43`	`43`	`fn (int $value): int => $value * 2,`
`44`	`44`	`));`
`45`	`45`
`46`		`- self::assertTrue(Map::fromArray(['1' => 2, '2' => 4, '3' => 6])->equals($map));`
	`46`	`+ self::assertTrue(Map::fromArray(['a1' => 2, 'a2' => 4, 'a3' => 6])->equals($map));`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`public function testSummingCollector(): void`
Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,7 @@ public function testStreamContainsAll(): void`
`113`	`113`	`self::assertFalse(Stream::ofAll([1, 2, 3])->containsAll(Stream::ofAll([1, 2, 3, 4])));`
`114`	`114`	`self::assertFalse(Stream::ofAll([1, 2, 3])->containsAll(Stream::ofAll([1, 2, 4])));`
`115`	`115`	`self::assertFalse(Stream::ofAll([1, 2, 3])->containsAll(Stream::ofAll([1, 4])));`
`116`		`- self::assertFalse(Stream::ofAll([1, 2, 3])->containsAll(Stream::ofAll(['a'])));`
	`116`	`+ self::assertFalse(Stream::ofAll([1, 2, 3])->containsAll(Stream::ofAll([0])));`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`public function testStreamMapSingle(): void`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ public function testGetOrSomething(): void`
`53`	`53`	`/** @var Option<string> $option */`
`54`	`54`	`$option = Option::of(null);`
`55`	`55`	`self::assertNull($option->getOrNull());`
`56`		`- self::assertTrue($option->getOrElse(true));`
	`56`	`+ self::assertSame('string', $option->getOrElse('string'));`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`public function testMap(): void`
Original file line number	Diff line number	Diff line change
`@@ -59,9 +59,9 @@ public function testMapFailure(): void`
`59`	`59`
`60`	`60`	`public function testMapWithMapperFailure(): void`
`61`	`61`	`{`
`62`		`- $try = TryTo::run('time');`
	`62`	`+ $try = TryTo::run(fn () => 0);`
`63`	`63`
`64`		`- self::assertInstanceOf(\TypeError::class, $try->map('strtoupper')->getCause());`
	`64`	`+ self::assertInstanceOf(\DivisionByZeroError::class, $try->map(fn (int $x) => 1 / $x)->getCause());`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`public function testMapWitMapperSuccess(): void`
Original file line number	Diff line number	Diff line change
`@@ -47,8 +47,8 @@ public function testMap(): void`
`47`	`47`	`{`
`48`	`48`	`$lazy = Lazy::of(function () {return 4; });`
`49`	`49`
`50`		`- self::assertInstanceOf(Lazy::class, $lazy->map('range'));`
`51`		`- self::assertEquals(2, $lazy->map('sqrt')->get());`
	`50`	`+ self::assertSame(5, $lazy->map(fn (int $x) => $x + 1)->get());`
	`51`	`+ self::assertEquals(2, $lazy->map('sqrt')->get()); // sqrt returns float`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`public function testCollect(): void`