fixed return type detection of Enum::getValues and refactored integration tests

Author: marc-mabe

composer.json

@@ -19,7 +19,7 @@
     },
     "autoload-dev": {
         "psr-4": {
-            "MabeEnumPHPStanTest\\": "tests/"
+            "MabeEnum\\PHPStan\\tests\\": "tests/"
         }
     },
     "extra": {

extension.neon

@@ -5,4 +5,5 @@ services:
 
   - class: MabeEnumPHPStan\EnumDynamicReturnTypeExtension
     tags:
+      - phpstan.broker.dynamicStaticMethodReturnTypeExtension
       - phpstan.broker.dynamicMethodReturnTypeExtension

phpunit.xml.dist

@@ -1,11 +1,14 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
 <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:noNamespaceSchemaLocation="http://schema.phpunit.de/6.0/phpunit.xsd"
+         xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/7.0/phpunit.xsd"
          bootstrap="vendor/autoload.php">
     <testsuites>
-        <testsuite name="Enum PHPStan Extension Test Suite">
-            <directory>tests</directory>
+        <testsuite name="Enum PHPStan Extension Unit Test Suite">
+            <directory>tests/unit</directory>
+        </testsuite>
+        <testsuite name="Enum PHPStan Extension Integration Test Suite">
+            <directory>tests/integration</directory>
         </testsuite>
     </testsuites>
 

src/EnumDynamicReturnTypeExtension.php

@@ -1,24 +1,36 @@
-<?php
-
-declare(strict_types=1);
+<?php declare(strict_types=1);
 
 namespace MabeEnumPHPStan;
 
 use MabeEnum\Enum;
 use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\Expr\StaticCall;
 use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\MethodReflection;
-use PHPStan\Reflection\ParametersAcceptorSelector;
-use PHPStan\ShouldNotHappenException;
 use PHPStan\Type\ArrayType;
 use PHPStan\Type\Constant\ConstantArrayType;
 use PHPStan\Type\ConstantTypeHelper;
 use PHPStan\Type\DynamicMethodReturnTypeExtension;
+use PHPStan\Type\DynamicStaticMethodReturnTypeExtension;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
 
-class EnumDynamicReturnTypeExtension implements DynamicMethodReturnTypeExtension
+class EnumDynamicReturnTypeExtension implements DynamicStaticMethodReturnTypeExtension, DynamicMethodReturnTypeExtension
 {
+    /**
+     * Map supported object method to a callable function detecting return type
+     *
+     * @var array<string, callable>
+     */
+    private $objectMethods = [];
+
+    /**
+     * Map supported static method to a callable function detecting return type
+     *
+     * @var array<string, callable>
+     */
+    private $staticMethods = [];
+
     /**
      * Buffer of all types of enumeration values
      * @phpstan-var array<class-string<Enum>, Type[]>
@@ -31,19 +43,48 @@ class EnumDynamicReturnTypeExtension implements DynamicMethodReturnTypeExtension
      */
     private $enumOrdinalTypesBuffer = [];
 
+    public function __construct()
+    {
+        $this->objectMethods['getvalue'] = function (string $class) {
+            return $this->detectGetValueReturnType($class);
+        };
+
+        if (method_exists(Enum::class, 'getvalues')) {
+            $this->staticMethods['getvalues'] = function (string $class) {
+                return $this->detectGetValuesReturnType($class);
+            };
+        }
+
+        // static methods cann be called like object methods
+        $this->objectMethods = array_merge($this->objectMethods, $this->staticMethods);
+    }
+
     public function getClass(): string
     {
         return Enum::class;
     }
 
+    public function isStaticMethodSupported(MethodReflection $methodReflection): bool
+    {
+        $methodLower = strtolower($methodReflection->getName());
+        return array_key_exists($methodLower, $this->staticMethods);
+    }
+
     public function isMethodSupported(MethodReflection $methodReflection): bool
     {
-        $supportedMethods = ['getvalue'];
-        if (method_exists(Enum::class, 'getValues')) {
-            array_push($supportedMethods, 'getvalues');
-        }
+        $methodLower = strtolower($methodReflection->getName());
+        return array_key_exists($methodLower, $this->objectMethods);
+    }
+
+    public function getTypeFromStaticMethodCall(
+        MethodReflection $methodReflection,
+        StaticCall $staticCall,
+        Scope $scope
+    ): Type {
+        $callClass   = $staticCall->class->toString();
+        $methodLower = strtolower($methodReflection->getName());
 
-        return in_array(strtolower($methodReflection->getName()), $supportedMethods, true);
+        return $this->staticMethods[$methodLower]($callClass);
     }
 
     public function getTypeFromMethodCall(
@@ -53,24 +94,10 @@ public function getTypeFromMethodCall(
     ): Type {
         $callType    = $scope->getType($methodCall->var);
         $callClasses = $callType->getReferencedClasses();
-        $methodName  = strtolower($methodReflection->getName());
+        $methodLower = strtolower($methodReflection->getName());
         $returnTypes = [];
         foreach ($callClasses as $callClass) {
-            if (!is_subclass_of($callClass, Enum::class, true)) {
-                $returnTypes[] = ParametersAcceptorSelector::selectSingle($methodReflection->getVariants())
-                    ->getReturnType();
-            } else {
-                switch ($methodName) {
-                    case 'getvalue':
-                        $returnTypes[] = $this->enumGetValueReturnType($callClass);
-                        break;
-                    case 'getvalues':
-                        $returnTypes[] = $this->enumGetValuesReturnType($callClass);
-                        break;
-                    default:
-                        throw new ShouldNotHappenException("Method {$methodName} is not supported");
-                }
-            }
+            $returnTypes[] = $this->objectMethods[$methodLower]($callClass);
         }
 
         return TypeCombinator::union(...$returnTypes);
@@ -114,7 +141,7 @@ private function enumOrdinalTypes(string $enumeration): array
      * Returns return type of Enum::getValue()
      * @phpstan-param class-string<Enum> $enumeration
      */
-    private function enumGetValueReturnType(string $enumeration): Type
+    private function detectGetValueReturnType(string $enumeration): Type
     {
         return TypeCombinator::union(...$this->enumValueTypes($enumeration));
     }
@@ -123,7 +150,7 @@ private function enumGetValueReturnType(string $enumeration): Type
      * Returns return type of Enum::getValues()
      * @phpstan-param class-string<Enum> $enumeration
      */
-    private function enumGetValuesReturnType(string $enumeration): ArrayType
+    private function detectGetValuesReturnType(string $enumeration): ArrayType
     {
         $keyTypes   = $this->enumOrdinalTypes($enumeration);
         $valueTypes = $this->enumValueTypes($enumeration);

src/EnumMethodReflection.php

@@ -1,6 +1,4 @@
-<?php
-
-declare(strict_types=1);
+<?php declare(strict_types=1);
 
 namespace MabeEnumPHPStan;
 

src/EnumMethodsClassReflectionExtension.php

@@ -1,6 +1,4 @@
-<?php
-
-declare(strict_types=1);
+<?php declare(strict_types=1);
 
 namespace MabeEnumPHPStan;