Merge pull request #21 from DaveLiddament/feature/must-use-result

Add support for #[MustUseResult]

Author: DaveLiddament

README.md

@@ -14,6 +14,7 @@ This is an extension for [PHPStan](https://phpstan.org) for adding analysis for
 **Language feature added:**
 - [Friend](https://github.com/DaveLiddament/php-language-extensions#friend)
 - [Injectable Version](https://github.com/DaveLiddament/php-language-extensions#injectableVersion)
+- [MustUseResult](https://github.com/DaveLiddament/php-language-extensions#mustUseResult)
 - [NamespaceVisibility](https://github.com/DaveLiddament/php-language-extensions#namespaceVisibility)
 - [Package](https://github.com/DaveLiddament/php-language-extensions#package) 
 - [Test Tag](https://github.com/DaveLiddament/php-language-extensions#testtag)

src/Rules/MustUseResultRule.php

@@ -0,0 +1,86 @@
+<?php
+
+namespace DaveLiddament\PhpstanPhpLanguageExtensions\Rules;
+
+use DaveLiddament\PhpLanguageExtensions\MustUseResult;
+use DaveLiddament\PhpstanPhpLanguageExtensions\AttributeValueReaders\AttributeFinder;
+use DaveLiddament\PhpstanPhpLanguageExtensions\Helpers\Cache;
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\ReflectionProvider;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+
+/**
+ * @implements Rule<Node\Stmt\Expression>
+ */
+final class MustUseResultRule implements Rule
+{
+    /** @var Cache<bool> */
+    private Cache $cache;
+
+    public function __construct(
+        private ReflectionProvider $reflectionProvider,
+    ) {
+        $this->cache = new Cache();
+    }
+
+    public function getNodeType(): string
+    {
+        return Node\Stmt\Expression::class;
+    }
+
+    /** @param Node\Stmt\Expression $node */
+    public function processNode(Node $node, Scope $scope): array
+    {
+        $expr = $node->expr;
+
+        if ($expr instanceof Node\Expr\MethodCall) {
+            $classReflections = $scope->getType($expr->var)->getObjectClassReflections();
+        } elseif ($expr instanceof Node\Expr\StaticCall) {
+            $class = $expr->class;
+            if (!$class instanceof Node\Name) {
+                return [];
+            }
+
+            $classReflections = [
+                $this->reflectionProvider->getClass($class->toCodeString()),
+            ];
+        } else {
+            return [];
+        }
+
+        $methodNameNode = $expr->name;
+        if (!$methodNameNode instanceof Node\Identifier) {
+            return [];
+        }
+
+        $methodName = $methodNameNode->toLowerString();
+
+        foreach ($classReflections as $classReflection) {
+            $className = $classReflection->getName();
+            $fullMethodName = "{$className}::{$methodName}";
+
+            if ($this->cache->hasEntry($fullMethodName)) {
+                $mustUseResult = $this->cache->getEntry($fullMethodName);
+            } else {
+                $mustUseResult = AttributeFinder::hasAttributeOnMethod(
+                    $classReflection->getNativeReflection(),
+                    $methodName,
+                    MustUseResult::class,
+                );
+                $this->cache->addEntry($fullMethodName, $mustUseResult);
+            }
+
+            if ($mustUseResult) {
+                return [
+                    RuleErrorBuilder::message('Result returned by method must be used')
+                        ->identifier('phpExtensionLibrary.mustUseResult')
+                        ->build(),
+                ];
+            }
+        }
+
+        return [];
+    }
+}

tests/Rules/MustUseResultOnMethodTest.php

@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DaveLiddament\PhpstanPhpLanguageExtensions\Tests\Rules;
+
+use DaveLiddament\PhpstanPhpLanguageExtensions\Rules\MustUseResultRule;
+use DaveLiddament\PhpstanRuleTestHelper\AbstractRuleTestCase;
+use PHPStan\Rules\Rule;
+
+/** @extends AbstractRuleTestCase<MustUseResultRule> */
+final class MustUseResultOnMethodTest extends AbstractRuleTestCase
+{
+    protected function getRule(): Rule
+    {
+        return new MustUseResultRule($this->createReflectionProvider());
+    }
+
+    public function testMustUseResultRuleOnMethod(): void
+    {
+        $this->assertIssuesReported(
+            __DIR__.'/data/mustUseResult/mustUseResultOnMethod.php',
+        );
+    }
+
+    public function testMustUseResultRuleOnStaticMethod(): void
+    {
+        $this->assertIssuesReported(
+            __DIR__.'/data/mustUseResult/mustUseResultOnStaticMethod.php',
+        );
+    }
+
+    protected function getErrorFormatter(): string
+    {
+        return 'Result returned by method must be used';
+    }
+}

tests/Rules/data/mustUseResult/mustUseResultOnMethod.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace MustUseResultOnMethod {
+
+
+    use DaveLiddament\PhpLanguageExtensions\MustUseResult;
+
+    class AClass {
+
+        #[MustUseResult]
+        public function mustUseResult(): int
+        {
+            return 1;
+        }
+
+        public function dontNeedToUseResult(): int
+        {
+            return 2;
+        }
+
+    }
+
+
+    $class = new AClass();
+
+    $class->dontNeedToUseResult(); // OK
+
+    $class->mustUseResult(); // ERROR
+
+    echo $class->mustUseResult(); // OK;
+
+    $value = 1 + $class->mustUseResult(); // OK
+}

tests/Rules/data/mustUseResult/mustUseResultOnStaticMethod.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace MustUseResultOnMethod {
+
+
+    use DaveLiddament\PhpLanguageExtensions\MustUseResult;
+
+    class AClass {
+
+        #[MustUseResult]
+        public static function mustUseResult(): int
+        {
+            return 1;
+        }
+
+        public static function dontNeedToUseResult(): int
+        {
+            return 2;
+        }
+
+    }
+
+
+    AClass::dontNeedToUseResult(); // OK
+
+    AClass::mustUseResult(); // ERROR
+
+    echo AClass::mustUseResult(); // OK;
+
+    $value = 1 + AClass::mustUseResult(); // OK
+}