Add PHPStan to test environment

clue · clue · commit fa2754df8b8b · 2023-06-20T17:43:53.000+02:00
diff --git a/.gitattributes b/.gitattributes
@@ -1,6 +1,7 @@
 /.gitattributes export-ignore
 /.github/ export-ignore
 /.gitignore export-ignore
+/phpstan.neon.dist export-ignore
 /phpunit.xml.dist export-ignore
 /phpunit.xml.legacy export-ignore
 /tests/ export-ignore
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -30,3 +30,25 @@ jobs:
         if: ${{ matrix.php >= 7.3 }}
       - run: vendor/bin/phpunit --coverage-text -c phpunit.xml.legacy
         if: ${{ matrix.php < 7.3 }}
+
+  PHPStan:
+    name: PHPStan (PHP ${{ matrix.php }})
+    runs-on: ubuntu-22.04
+    strategy:
+      matrix:
+        php:
+          - 8.2
+          - 8.1
+          - 8.0
+          - 7.4
+          - 7.3
+          - 7.2
+          - 7.1
+    steps:
+      - uses: actions/checkout@v3
+      - uses: shivammathur/setup-php@v2
+        with:
+          php-version: ${{ matrix.php }}
+          coverage: none
+      - run: composer install
+      - run: vendor/bin/phpstan
diff --git a/README.md b/README.md
@@ -48,8 +48,9 @@ Table of Contents
      * [Rejection forwarding](#rejection-forwarding)
      * [Mixed resolution and rejection forwarding](#mixed-resolution-and-rejection-forwarding)
 5. [Install](#install)
-6. [Credits](#credits)
-7. [License](#license)
+6. [Tests](#tests)
+7. [Credits](#credits)
+8. [License](#license)
 
 Introduction
 ------------
@@ -586,6 +587,27 @@ PHP versions like this:
 composer require "react/promise:^3@dev || ^2 || ^1"
 ```
 
+## Tests
+
+To run the test suite, you first need to clone this repo and then install all
+dependencies [through Composer](https://getcomposer.org/):
+
+```bash
+composer install
+```
+
+To run the test suite, go to the project root and run:
+
+```bash
+vendor/bin/phpunit
+```
+
+On top of this, we use PHPStan on level 3 to ensure type safety across the project:
+
+```bash
+vendor/bin/phpstan
+```
+
 Credits
 -------
 
diff --git a/composer.json b/composer.json
@@ -28,21 +28,27 @@
         "php": ">=7.1.0"
     },
     "require-dev": {
+        "phpstan/phpstan": "1.10.19 || 1.4.10",
         "phpunit/phpunit": "^9.5 || ^7.5"
     },
     "autoload": {
         "psr-4": {
             "React\\Promise\\": "src/"
         },
-        "files": ["src/functions_include.php"]
+        "files": [
+            "src/functions_include.php"
+        ]
     },
     "autoload-dev": {
         "psr-4": {
             "React\\Promise\\": [
                 "tests/fixtures/",
                 "tests/"
             ]
-        }
+        },
+        "files": [
+            "tests/Fiber.php"
+        ]
     },
     "keywords": [
         "promise",
diff --git a/phpstan.neon.dist b/phpstan.neon.dist
@@ -0,0 +1,6 @@
+parameters:
+    level: 3
+
+    paths:
+        - src/
+        - tests/
diff --git a/src/functions.php b/src/functions.php
@@ -256,12 +256,15 @@ function _checkTypehint(callable $callback, \Throwable $reason): bool
 
         if ($type instanceof \ReflectionIntersectionType) {
             foreach ($type->getTypes() as $typeToMatch) {
+                assert($typeToMatch instanceof \ReflectionNamedType);
                 if (!($matches = ($typeToMatch->isBuiltin() && \gettype($reason) === $typeToMatch->getName())
                     || (new \ReflectionClass($typeToMatch->getName()))->isInstance($reason))) {
                     break;
                 }
             }
+            assert(isset($matches));
         } else {
+            assert($type instanceof \ReflectionNamedType);
             $matches = ($type->isBuiltin() && \gettype($reason) === $type->getName())
                 || (new \ReflectionClass($type->getName()))->isInstance($reason);
         }
diff --git a/tests/DeferredTest.php b/tests/DeferredTest.php
@@ -54,7 +54,9 @@ public function shouldRejectWithoutCreatingGarbageCyclesIfCancellerHoldsReferenc
         gc_collect_cycles();
         gc_collect_cycles(); // clear twice to avoid leftovers in PHP 7.4 with ext-xdebug and code coverage turned on
 
-        $deferred = new Deferred(function () use (&$deferred) { });
+        $deferred = new Deferred(function () use (&$deferred) {
+            assert($deferred instanceof Deferred);
+        });
         $deferred->reject(new \Exception('foo'));
         unset($deferred);
 
diff --git a/tests/Fiber.php b/tests/Fiber.php
@@ -0,0 +1,27 @@
+<?php
+
+if (!class_exists(Fiber::class)) {
+    /**
+     * Fiber stub to make PHPStan happy on PHP < 8.1
+     *
+     * @link https://www.php.net/manual/en/class.fiber.php
+     * @copyright Copyright (c) 2023 Christian Lück, taken from https://github.com/clue/framework-x with permission
+     */
+    class Fiber
+    {
+        public static function suspend(mixed $value): void
+        {
+            // NOOP
+        }
+
+        public function __construct(callable $callback)
+        {
+            assert(is_callable($callback));
+        }
+
+        public function start(): int
+        {
+            return 42;
+        }
+    }
+}
diff --git a/tests/FunctionAnyTest.php b/tests/FunctionAnyTest.php
@@ -219,6 +219,6 @@ public function shouldNotCancelOtherPendingInputArrayPromisesIfOnePromiseFulfill
 
         $promise2 = new Promise(function () {}, $this->expectCallableNever());
 
-        any([$deferred->promise(), $promise2], 1)->cancel();
+        any([$deferred->promise(), $promise2])->cancel();
     }
 }
diff --git a/tests/FunctionCheckTypehintTest.php b/tests/FunctionCheckTypehintTest.php
@@ -122,7 +122,7 @@ public function shouldAcceptStaticClassCallbackWithIntersectionTypehint()
     public function shouldAcceptInvokableObjectCallbackWithDNFTypehint()
     {
         self::assertFalse(_checkTypehint(new CallbackWithDNFTypehintClass(), new \RuntimeException()));
-        self::assertTrue(_checkTypehint(new CallbackWithDNFTypehintClass(), new ArrayAccessibleException()));
+        self::assertTrue(_checkTypehint(new CallbackWithDNFTypehintClass(), new IterableException()));
         self::assertTrue(_checkTypehint(new CallbackWithDNFTypehintClass(), new CountableException()));
     }
 
@@ -134,7 +134,7 @@ public function shouldAcceptObjectMethodCallbackWithDNFTypehint()
     {
         self::assertFalse(_checkTypehint([new CallbackWithDNFTypehintClass(), 'testCallback'], new \RuntimeException()));
         self::assertTrue(_checkTypehint([new CallbackWithDNFTypehintClass(), 'testCallback'], new CountableException()));
-        self::assertTrue(_checkTypehint([new CallbackWithDNFTypehintClass(), 'testCallback'], new ArrayAccessibleException()));
+        self::assertTrue(_checkTypehint([new CallbackWithDNFTypehintClass(), 'testCallback'], new IterableException()));
     }
 
     /**
@@ -145,7 +145,7 @@ public function shouldAcceptStaticClassCallbackWithDNFTypehint()
     {
         self::assertFalse(_checkTypehint([CallbackWithDNFTypehintClass::class, 'testCallbackStatic'], new \RuntimeException()));
         self::assertTrue(_checkTypehint([CallbackWithDNFTypehintClass::class, 'testCallbackStatic'], new CountableException()));
-        self::assertTrue(_checkTypehint([CallbackWithDNFTypehintClass::class, 'testCallbackStatic'], new ArrayAccessibleException()));
+        self::assertTrue(_checkTypehint([CallbackWithDNFTypehintClass::class, 'testCallbackStatic'], new IterableException()));
     }
 
     /** @test */
diff --git a/tests/PHP8.php b/tests/PHP8.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace React\Promise;
+
+/**
+ * Dummy attribute used to comment out code for PHP < 8 to ensure compatibility across test matrix
+ *
+ * @copyright Copyright (c) 2023 Christian Lück, taken from https://github.com/clue/framework-x with permission
+ */
+#[\Attribute]
+class PHP8
+{
+    public function __construct()
+    {
+        assert(\PHP_VERSION_ID >= 80000);
+    }
+}
diff --git a/tests/PromiseTest.php b/tests/PromiseTest.php
@@ -138,6 +138,7 @@ public function shouldRejectWithoutCreatingGarbageCyclesIfCancellerWithReference
     {
         gc_collect_cycles();
         $promise = new Promise(function () {}, function () use (&$promise) {
+            assert($promise instanceof Promise);
             throw new \Exception('foo');
         });
         $promise->cancel();
@@ -155,6 +156,7 @@ public function shouldRejectWithoutCreatingGarbageCyclesIfResolverWithReferenceT
     {
         gc_collect_cycles();
         $promise = new Promise(function () use (&$promise) {
+            assert($promise instanceof Promise);
             throw new \Exception('foo');
         });
         unset($promise);
@@ -172,7 +174,9 @@ public function shouldRejectWithoutCreatingGarbageCyclesIfCancellerHoldsReferenc
         gc_collect_cycles();
         $promise = new Promise(function () {
             throw new \Exception('foo');
-        }, function () use (&$promise) { });
+        }, function () use (&$promise) {
+            assert($promise instanceof Promise);
+        });
         unset($promise);
 
         $this->assertSame(0, gc_collect_cycles());
@@ -249,17 +253,6 @@ public function shouldNotLeaveGarbageCyclesWhenRemovingLastReferenceToPendingPro
         $this->assertSame(0, gc_collect_cycles());
     }
 
-    /** @test */
-    public function shouldNotLeaveGarbageCyclesWhenRemovingLastReferenceToPendingPromiseWithProgressFollowers()
-    {
-        gc_collect_cycles();
-        $promise = new Promise(function () { });
-        $promise->then(null, null, function () { });
-        unset($promise);
-
-        $this->assertSame(0, gc_collect_cycles());
-    }
-
     /** @test */
     public function shouldFulfillIfFullfilledWithSimplePromise()
     {
diff --git a/tests/TestCase.php b/tests/TestCase.php
@@ -38,12 +38,13 @@ public function expectCallableNever(): callable
 
     protected function createCallableMock()
     {
-        if (method_exists('PHPUnit\Framework\MockObject\MockBuilder', 'addMethods')) {
+        $builder = $this->getMockBuilder(\stdClass::class);
+        if (method_exists($builder, 'addMethods')) {
             // PHPUnit 9+
-            return $this->getMockBuilder('stdClass')->addMethods(array('__invoke'))->getMock();
+            return $builder->addMethods(['__invoke'])->getMock();
         } else {
             // legacy PHPUnit 4 - PHPUnit 9
-            return $this->getMockBuilder('stdClass')->setMethods(array('__invoke'))->getMock();
+            return $builder->setMethods(['__invoke'])->getMock();
         }
     }
 }
diff --git a/tests/fixtures/ArrayAccessibleException.php b/tests/fixtures/ArrayAccessibleException.php
diff --git a/tests/fixtures/CallbackWithDNFTypehintClass.php b/tests/fixtures/CallbackWithDNFTypehintClass.php
@@ -7,15 +7,9 @@
 
 class CallbackWithDNFTypehintClass
 {
-    public function __invoke((RuntimeException&Countable)|(RuntimeException&\ArrayAccess) $e)
-    {
-    }
+    #[PHP8] public function __invoke((RuntimeException&Countable)|(RuntimeException&\IteratorAggregate) $e) { }
 
-    public function testCallback((RuntimeException&Countable)|(RuntimeException&\ArrayAccess) $e)
-    {
-    }
+    #[PHP8] public function testCallback((RuntimeException&Countable)|(RuntimeException&\IteratorAggregate) $e) { }
 
-    public static function testCallbackStatic((RuntimeException&Countable)|(RuntimeException&\ArrayAccess) $e)
-    {
-    }
+    #[PHP8] public static function testCallbackStatic((RuntimeException&Countable)|(RuntimeException&\IteratorAggregate) $e) { }
 }
diff --git a/tests/fixtures/CallbackWithIntersectionTypehintClass.php b/tests/fixtures/CallbackWithIntersectionTypehintClass.php
@@ -7,15 +7,9 @@
 
 class CallbackWithIntersectionTypehintClass
 {
-    public function __invoke(RuntimeException&Countable $e)
-    {
-    }
+    #[PHP8] public function __invoke(RuntimeException&Countable $e) { }
 
-    public function testCallback(RuntimeException&Countable $e)
-    {
-    }
+    #[PHP8] public function testCallback(RuntimeException&Countable $e) { }
 
-    public static function testCallbackStatic(RuntimeException&Countable $e)
-    {
-    }
+    #[PHP8] public static function testCallbackStatic(RuntimeException&Countable $e) { }
 }
diff --git a/tests/fixtures/CallbackWithUnionTypehintClass.php b/tests/fixtures/CallbackWithUnionTypehintClass.php
@@ -7,15 +7,9 @@
 
 class CallbackWithUnionTypehintClass
 {
-    public function __invoke(RuntimeException|InvalidArgumentException $e)
-    {
-    }
+    #[PHP8] public function __invoke(RuntimeException|InvalidArgumentException $e) { }
 
-    public function testCallback(RuntimeException|InvalidArgumentException $e)
-    {
-    }
+    #[PHP8] public function testCallback(RuntimeException|InvalidArgumentException $e) { }
 
-    public static function testCallbackStatic(RuntimeException|InvalidArgumentException $e)
-    {
-    }
+    #[PHP8] public static function testCallbackStatic(RuntimeException|InvalidArgumentException $e) { }
 }
diff --git a/tests/fixtures/IterableException.php b/tests/fixtures/IterableException.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace React\Promise;
+
+class IterableException extends \RuntimeException implements \IteratorAggregate
+{
+    public function getIterator(): \Traversable
+    {
+        return new \ArrayIterator([]);
+    }
+}

-Original file line number
+Diff line change
@@ @@ -0,0 +1,6 @@ @@
 +parameters:
 +    level: 3
++
 +    paths:
 +        - src/
 +        - tests/
Original file line number	Diff line number	Diff line change
`@@ -256,12 +256,15 @@ function _checkTypehint(callable $callback, \Throwable $reason): bool`
`256`	`256`
`257`	`257`	`if ($type instanceof \ReflectionIntersectionType) {`
`258`	`258`	`foreach ($type->getTypes() as $typeToMatch) {`
	`259`	`+ assert($typeToMatch instanceof \ReflectionNamedType);`
`259`	`260`	`if (!($matches = ($typeToMatch->isBuiltin() && \gettype($reason) === $typeToMatch->getName())`
`260`	`261`	`\|\| (new \ReflectionClass($typeToMatch->getName()))->isInstance($reason))) {`
`261`	`262`	`break;`
`262`	`263`	`}`
`263`	`264`	`}`
	`265`	`+ assert(isset($matches));`
`264`	`266`	`} else {`
	`267`	`+ assert($type instanceof \ReflectionNamedType);`
`265`	`268`	`$matches = ($type->isBuiltin() && \gettype($reason) === $type->getName())`
`266`	`269`	`\|\| (new \ReflectionClass($type->getName()))->isInstance($reason);`
`267`	`270`	`}`
Original file line number	Diff line number	Diff line change
`@@ -219,6 +219,6 @@ public function shouldNotCancelOtherPendingInputArrayPromisesIfOnePromiseFulfill`
`219`	`219`
`220`	`220`	`$promise2 = new Promise(function () {}, $this->expectCallableNever());`
`221`	`221`
`222`		`- any([$deferred->promise(), $promise2], 1)->cancel();`
	`222`	`+ any([$deferred->promise(), $promise2])->cancel();`
`223`	`223`	`}`
`224`	`224`	`}`
Original file line number	Diff line number	Diff line change
`@@ -122,7 +122,7 @@ public function shouldAcceptStaticClassCallbackWithIntersectionTypehint()`
`122`	`122`	`public function shouldAcceptInvokableObjectCallbackWithDNFTypehint()`
`123`	`123`	`{`
`124`	`124`	`self::assertFalse(_checkTypehint(new CallbackWithDNFTypehintClass(), new \RuntimeException()));`
`125`		`- self::assertTrue(_checkTypehint(new CallbackWithDNFTypehintClass(), new ArrayAccessibleException()));`
	`125`	`+ self::assertTrue(_checkTypehint(new CallbackWithDNFTypehintClass(), new IterableException()));`
`126`	`126`	`self::assertTrue(_checkTypehint(new CallbackWithDNFTypehintClass(), new CountableException()));`
`127`	`127`	`}`
`128`	`128`
`@@ -134,7 +134,7 @@ public function shouldAcceptObjectMethodCallbackWithDNFTypehint()`
`134`	`134`	`{`
`135`	`135`	`self::assertFalse(_checkTypehint([new CallbackWithDNFTypehintClass(), 'testCallback'], new \RuntimeException()));`
`136`	`136`	`self::assertTrue(_checkTypehint([new CallbackWithDNFTypehintClass(), 'testCallback'], new CountableException()));`
`137`		`- self::assertTrue(_checkTypehint([new CallbackWithDNFTypehintClass(), 'testCallback'], new ArrayAccessibleException()));`
	`137`	`+ self::assertTrue(_checkTypehint([new CallbackWithDNFTypehintClass(), 'testCallback'], new IterableException()));`
`138`	`138`	`}`
`139`	`139`
`140`	`140`	`/**`
`@@ -145,7 +145,7 @@ public function shouldAcceptStaticClassCallbackWithDNFTypehint()`
`145`	`145`	`{`
`146`	`146`	`self::assertFalse(_checkTypehint([CallbackWithDNFTypehintClass::class, 'testCallbackStatic'], new \RuntimeException()));`
`147`	`147`	`self::assertTrue(_checkTypehint([CallbackWithDNFTypehintClass::class, 'testCallbackStatic'], new CountableException()));`
`148`		`- self::assertTrue(_checkTypehint([CallbackWithDNFTypehintClass::class, 'testCallbackStatic'], new ArrayAccessibleException()));`
	`148`	`+ self::assertTrue(_checkTypehint([CallbackWithDNFTypehintClass::class, 'testCallbackStatic'], new IterableException()));`
`149`	`149`	`}`
`150`	`150`
`151`	`151`	`/** @test */`