[rector] add NoIntegerRefactorReturnRule (#248)

Author: TomasVotruba

config/rector-rules.neon

@@ -7,6 +7,7 @@ rules:
     - Symplify\PHPStanRules\Rules\Rector\NoPropertyNodeAssignRule
     - Symplify\PHPStanRules\Rules\Rector\PreferDirectIsNameRule
     - Symplify\PHPStanRules\Rules\Rector\NoOnlyNullReturnInRefactorRule
+    - Symplify\PHPStanRules\Rules\Rector\NoIntegerRefactorReturnRule
 
 services:
     # $node->getAttribute($1) => Type|null by $1

src/Enum/RuleIdentifier/RectorRuleIdentifier.php

@@ -19,4 +19,6 @@ final class RectorRuleIdentifier
     public const PREFER_DIRECT_IS_NAME = 'rector.preferDirectIsName';
 
     public const NO_ONLY_NULL_RETURN_IN_REFACTOR = 'rector.noOnlyNullReturnInRefactor';
+
+    public const NO_INTEGER_REFACTOR_RETURN = 'rector.noIntegerRefactorReturn';
 }

src/Rules/Rector/NoIntegerRefactorReturnRule.php

@@ -0,0 +1,66 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Symplify\PHPStanRules\Rules\Rector;
+
+use PhpParser\Node;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Stmt\ClassMethod;
+use PhpParser\Node\UnionType;
+use PHPStan\Analyser\Scope;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+use Symplify\PHPStanRules\Enum\RuleIdentifier\RectorRuleIdentifier;
+
+/**
+ * @see \Symplify\PHPStanRules\Tests\Rules\Rector\NoIntegerRefactorReturnRule\NoIntegerRefactorReturnRuleTest
+ *
+ * @implements Rule<ClassMethod>
+ */
+final class NoIntegerRefactorReturnRule implements Rule
+{
+    /**
+     * @var string
+     */
+    public const ERROR_MESSAGE = 'Instead of using int in refactor(), make use of attributes and return always node or a null. Using traverser enums might lead to unexpected results';
+
+    public function getNodeType(): string
+    {
+        return ClassMethod::class;
+    }
+
+    /**
+     * @param ClassMethod $node
+     */
+    public function processNode(Node $node, Scope $scope): array
+    {
+        if (! $node->isPublic()) {
+            return [];
+        }
+
+        if ($node->name->toString() !== 'refactor') {
+            return [];
+        }
+
+        if (! $node->returnType instanceof UnionType) {
+            return [];
+        }
+
+        foreach ($node->returnType->types as $type) {
+            if (! $type instanceof Identifier) {
+                continue;
+            }
+
+            if ($type->name === 'int') {
+                $ruleError = RuleErrorBuilder::message(self::ERROR_MESSAGE)
+                    ->identifier(RectorRuleIdentifier::NO_INTEGER_REFACTOR_RETURN)
+                    ->build();
+
+                return [$ruleError];
+            }
+        }
+
+        return [];
+    }
+}

tests/Rules/Rector/NoIntegerRefactorReturnRule/Fixture/SimpleReturnInt.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Symplify\PHPStanRules\Tests\Rules\Rector\NoIntegerRefactorReturnRule\Fixture;
+
+use PhpParser\Node;
+use PhpParser\Node\Stmt\Class_;
+use PhpParser\Node\Stmt\Interface_;
+use PhpParser\NodeVisitor;
+use Rector\Rector\AbstractRector;
+
+final class SimpleReturnInt extends AbstractRector
+{
+    public function getNodeTypes(): array
+    {
+        return [Class_::class, Interface_::class];
+    }
+
+    public function refactor(Node $node): \PhpParser\Node|int
+    {
+        if ($node instanceof Class_) {
+            return $node;
+        }
+
+        return NodeVisitor::DONT_TRAVERSE_CHILDREN;
+    }
+}

tests/Rules/Rector/NoIntegerRefactorReturnRule/Fixture/SkipBareNodeReturn.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Symplify\PHPStanRules\Tests\Rules\Rector\NoIntegerRefactorReturnRule\Fixture;
+
+use PhpParser\Node;
+use PhpParser\Node\Stmt\Class_;
+use PhpParser\Node\Stmt\Interface_;
+use PhpParser\NodeVisitor;
+use Rector\Rector\AbstractRector;
+
+final class SkipBareNodeReturn extends AbstractRector
+{
+    public function getNodeTypes(): array
+    {
+        return [Class_::class, Interface_::class];
+    }
+
+    public function refactor(Node $node): \PhpParser\Node|null
+    {
+        if ($node instanceof Class_) {
+            return $node;
+        }
+
+        return null;
+    }
+}

tests/Rules/Rector/NoIntegerRefactorReturnRule/NoIntegerRefactorReturnRuleTest.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Symplify\PHPStanRules\Tests\Rules\Rector\NoIntegerRefactorReturnRule;
+
+use Iterator;
+use PHPStan\Testing\RuleTestCase;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Symplify\PHPStanRules\Rules\Rector\NoIntegerRefactorReturnRule;
+
+final class NoIntegerRefactorReturnRuleTest extends RuleTestCase
+{
+    #[DataProvider('provideData')]
+    public function testRule(string $filePath, array $expectedErrorsWithLines): void
+    {
+        $this->analyse([$filePath], $expectedErrorsWithLines);
+    }
+
+    public static function provideData(): Iterator
+    {
+        $errorMessage = NoIntegerRefactorReturnRule::ERROR_MESSAGE;
+        yield [__DIR__ . '/Fixture/SimpleReturnInt.php', [[$errorMessage, 20]]];
+
+        yield [__DIR__ . '/Fixture/SkipBareNodeReturn.php', []];
+    }
+
+    protected function getRule(): NoIntegerRefactorReturnRule
+    {
+        return new NoIntegerRefactorReturnRule();
+    }
+}

tests/Rules/Rector/NoIntegerRefactorReturnRule/config/configured_rule.neon

@@ -0,0 +1,2 @@
+rules:
+    - Symplify\PHPStanRules\Rules\Rector\NoInstanceOfStaticReflectionRule