Added dynamic return type extension for Enum::getValue()

Author: adaamz

README.md

@@ -9,7 +9,7 @@
 > It moves PHP closer to compiled languages in the sense that the correctness
 > of each line of the code can be checked before you run the actual line.  
 
-This PHPStan extension makes enumerator accessor methods known to PHPStan.
+This PHPStan extension makes enumerator accessor methods and enum possible values known to PHPStan.
 
 ## Install
 

extension.neon

@@ -2,3 +2,7 @@ services:
   - class: MabeEnumPHPStan\EnumMethodsClassReflectionExtension
     tags:
       - phpstan.broker.methodsClassReflectionExtension
+
+  - class: MabeEnumPHPStan\EnumGetValueDynamicReturnTypeExtension
+    tags:
+      - phpstan.broker.dynamicMethodReturnTypeExtension

src/EnumGetValueDynamicReturnTypeExtension.php

@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace MabeEnumPHPStan;
+
+use MabeEnum\Enum;
+use PhpParser\Node\Expr\MethodCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Reflection\ParametersAcceptorSelector;
+use PHPStan\ShouldNotHappenException;
+use PHPStan\Type\BooleanType;
+use PHPStan\Type\DynamicMethodReturnTypeExtension;
+use PHPStan\Type\FloatType;
+use PHPStan\Type\IntegerType;
+use PHPStan\Type\StringType;
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
+use PHPStan\Type\VerbosityLevel;
+
+class EnumGetValueDynamicReturnTypeExtension implements DynamicMethodReturnTypeExtension
+{
+    /** @var \PHPStan\Type\Type[] */
+    private $enumTypes = [];
+
+    public function getClass(): string
+    {
+        return Enum::class;
+    }
+
+    public function isMethodSupported(MethodReflection $methodReflection): bool
+    {
+        // version 1.x has visibility bug in getConstants()
+        return method_exists(Enum::class, 'getValues') && $methodReflection->getName() === 'getValue';
+    }
+
+    public function getTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, Scope $scope): Type
+    {
+        $enumType = $scope->getType($methodCall->var);
+        if (count($enumType->getReferencedClasses()) !== 1) {
+            return ParametersAcceptorSelector::selectSingle($methodReflection->getVariants())->getReturnType();
+        }
+
+        /** @var string $enumClass */
+        $enumClass = $enumType->getReferencedClasses()[0];
+        if (array_key_exists($enumClass, $this->enumTypes)) {
+            return $this->enumTypes[$enumClass];
+        }
+        $types = array_map(function ($value) use ($scope): Type {
+            return $scope->getTypeFromValue($value);
+        }, self::getEnumValues($enumClass));
+
+        $this->enumTypes[$enumClass] = TypeCombinator::union(...$types);
+
+        return $this->enumTypes[$enumClass];
+    }
+
+    /**
+     * @phpstan-param class-string<Enum> $enumClass
+     */
+    private static function getEnumValues(string $enumClass): array
+    {
+        if (method_exists($enumClass, 'getValues')) {
+            return $enumClass::getValues();
+        }
+
+        throw new \PHPStan\ShouldNotHappenException();
+    }
+}

tests/Assets/BigStrEnum.php

@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace MabeEnumPHPStanTest\Assets;
+
+use MabeEnum\Enum;
+
+class BigStrEnum extends Enum
+{
+    const C_1 = 'c1';
+    const C_2 = 'c2';
+    const C_3 = 'c3';
+    const C_4 = 'c4';
+    const C_5 = 'c5';
+    const C_6 = 'c6';
+    const C_7 = 'c7';
+    const C_8 = 'c8';
+    const C_9 = 'c9';
+}

tests/EnumGetValueDynamicReturnTypeExtensionTest.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace MabeEnumPHPStanTest;
+
+use MabeEnum\Enum;
+use MabeEnumPHPStan\EnumGetValueDynamicReturnTypeExtension;
+
+final class EnumGetValueDynamicReturnTypeExtensionTest extends ExtensionTestCase
+{
+    /**
+     * @var \PHPStan\Broker\Broker
+     */
+    protected $broker;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        if (!method_exists(Enum::class, 'getValues')) {
+            self::markTestSkipped('Version 1.x is not supported.');
+        }
+    }
+
+    public function testConstantTypes(): void
+    {
+        $this->processFile(__DIR__ . '/data/get_value.php', '$strEnum->getValue()', "'no doc block'|'public str'|'str'", new EnumGetValueDynamicReturnTypeExtension());
+    }
+
+    public function testGeneralizedTypes(): void
+    {
+        $this->processFile(__DIR__ . '/data/get_value.php', '$bigStrEnum->getValue()', "string", new EnumGetValueDynamicReturnTypeExtension());
+    }
+}

tests/ExtensionTestCase.php

@@ -0,0 +1,78 @@
+<?php
+
+declare(strict_types=1);
+
+namespace MabeEnumPHPStanTest;
+
+use PhpParser\Node;
+use PhpParser\PrettyPrinter\Standard;
+use PHPStan\Analyser\NodeScopeResolver;
+use PHPStan\Analyser\Scope;
+use PHPStan\Analyser\ScopeContext;
+use PHPStan\Broker\AnonymousClassNameHelper;
+use PHPStan\Cache\Cache;
+use PHPStan\File\FileHelper;
+use PHPStan\Node\VirtualNode;
+use PHPStan\PhpDoc\PhpDocNodeResolver;
+use PHPStan\PhpDoc\PhpDocStringResolver;
+use PHPStan\Testing\TestCase;
+use PHPStan\Type\DynamicMethodReturnTypeExtension;
+use PHPStan\Type\FileTypeMapper;
+use PHPStan\Type\VerbosityLevel;
+
+abstract class ExtensionTestCase extends TestCase
+{
+    protected function processFile(
+        string $file,
+        string $expression,
+        string $type,
+        DynamicMethodReturnTypeExtension $extension
+    ): void
+    {
+        $broker = $this->createBroker([$extension]);
+        $parser = $this->getParser();
+        $currentWorkingDirectory = $this->getCurrentWorkingDirectory();
+        $fileHelper = new FileHelper($currentWorkingDirectory);
+        $typeSpecifier = $this->createTypeSpecifier(new Standard(), $broker);
+        /** @var \PHPStan\PhpDoc\PhpDocStringResolver $phpDocStringResolver */
+        $phpDocStringResolver = self::getContainer()->getByType(PhpDocStringResolver::class);
+        $resolver = new NodeScopeResolver(
+            $broker,
+            $parser,
+            new FileTypeMapper(
+                $parser,
+                $phpDocStringResolver,
+                self::getContainer()->getByType(PhpDocNodeResolver::class),
+                $this->createMock(Cache::class),
+                $this->createMock(AnonymousClassNameHelper::class)
+            ),
+            $fileHelper,
+            $typeSpecifier,
+            true,
+            true,
+            true,
+            [],
+            []
+        );
+        $resolver->setAnalysedFiles([$fileHelper->normalizePath($file)]);
+
+        $run = false;
+        $resolver->processNodes(
+            $parser->parseFile($file),
+            $this->createScopeFactory($broker, $typeSpecifier)->create(ScopeContext::create($file)),
+            function (Node $node, Scope $scope) use ($expression, $type, &$run): void {
+                if ($node instanceof VirtualNode) {
+                    return;
+                }
+                if ((new Standard())->prettyPrint([$node]) !== 'die') {
+                    return;
+                }
+                /** @var \PhpParser\Node\Stmt\Expression $expNode */
+                $expNode = $this->getParser()->parseString(sprintf('<?php %s;', $expression))[0];
+                self::assertSame($type, $scope->getType($expNode->expr)->describe(VerbosityLevel::precise()));
+                $run = true;
+            }
+        );
+        self::assertTrue($run);
+    }
+}

tests/data/get_value.php

@@ -0,0 +1,8 @@
+<?php
+
+use MabeEnumPHPStanTest\Assets\BigStrEnum;
+use MabeEnumPHPStanTest\Assets\StrEnum;
+
+function f(StrEnum $strEnum, BigStrEnum $bigStrEnum): void {
+    die;
+}