Add PHPStan to test environment

.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

.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

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
 -------
 

composer.json

@@ -28,21 +28,27 @@
         "php": ">=7.1.0"
     },
     "require-dev": {
+        "phpstan/phpstan": "1.10.20 || 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",

phpstan.neon.dist

@@ -0,0 +1,6 @@
+parameters:
+    level: 3
+
+    paths:
+        - src/
+        - tests/

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);
         }

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);
 

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;
+        }
+    }
+}

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();
     }
 }

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 */

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);
+    }
+}

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()
     {

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();
         }
     }
 }

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) { }
 }

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) { }
 }

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) { }
 }

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([]);
+    }
+}