remove abstract symplify rule

Author: TomasVotruba

README.md

@@ -28,7 +28,11 @@ includes:
     - vendor/symplify/phpstan-rules/config/naming-rules.neon
     - vendor/symplify/phpstan-rules/config/regex-rules.neon
     - vendor/symplify/phpstan-rules/config/static-rules.neon
+
+    # project specific
     - vendor/symplify/phpstan-rules/config/rector-rules.neon
+    - vendor/symplify/phpstan-rules/config/doctrine-rules.neon
+    - vendor/symplify/phpstan-rules/config/symfony-rules.neon
 ```
 
 <br>

phpstan.neon

@@ -23,9 +23,6 @@ parameters:
         - */Fixture/*
 
     ignoreErrors:
-        # needless generics
-#        - '#Class Symplify\\PHPStanRules\\(.*?)Rule implements generic interface PHPStan\\Rules\\Rule but does not specify its types\: TNodeType#'
-
         - '#Method Symplify\\PHPStanRules\\Reflection\\ReflectionParser\:\:parseNativeClassReflection\(\) has parameter \$reflectionClass with generic class ReflectionClass but does not specify its types\: T#'
 
         # overly detailed
@@ -47,8 +44,7 @@ parameters:
             message: '#Function is_a\(\) is a runtime reflection concept that might not work in PHPStan because it uses fully static reflection engine#'
             path: src/Rules/SeeAnnotationToTestRule.php
 
-        # handle next
-        - '#Method Symplify\\PHPStanRules\\Rules\\AbstractSymplifyRule\:\:processNode\(\) should return list<PHPStan\\Rules\\IdentifierRuleError> but returns array<PHPStan\\Rules\\RuleError\|string>#'
-
         # used in tests
         - '#Public constant "Symplify\\PHPStanRules\\(.*?)Rule\:\:ERROR_MESSAGE" is never used#'
+
+        - '#Although PHPStan\\Node\\InClassNode is covered by backward compatibility promise, this instanceof assumption might break because (.*?) not guaranteed to always stay the same#'

src/Contract/ManyNodeRuleInterface.php

@@ -170,4 +170,11 @@ final class RuleIdentifier
      * @var string
      */
     public const PHPUNIT_NO_DOCUMENT_MOCKING = 'phpunit.noDocumentMocking';
+
+    /**
+     * @var string
+     */
+    public const NO_DYNAMIC_NAME = 'symplify.noDynamicName';
+
+    public const NO_REFERENCE = 'symplify.noReference';
 }

src/Enum/RuleIdentifier.php

@@ -14,13 +14,17 @@
 use PhpParser\Node\Expr\StaticPropertyFetch;
 use PhpParser\Node\Identifier;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
+use Symplify\PHPStanRules\Enum\RuleIdentifier;
 use Symplify\PHPStanRules\TypeAnalyzer\CallableTypeAnalyzer;
 
 /**
  * @see \Symplify\PHPStanRules\Tests\Rules\NoDynamicNameRule\NoDynamicNameRuleTest
+ *
+ * @implements Rule<Node>
  */
-final class NoDynamicNameRule extends AbstractSymplifyRule
+final class NoDynamicNameRule implements Rule
 {
     /**
      * @var string
@@ -32,25 +36,13 @@ public function __construct(
     ) {
     }
 
-    /**
-     * @return array<class-string<Node>>
-     */
-    public function getNodeTypes(): array
+    public function getNodeType(): string
     {
-        return [
-            MethodCall::class,
-            StaticCall::class,
-            FuncCall::class,
-            StaticPropertyFetch::class,
-            PropertyFetch::class,
-            ClassConstFetch::class,
-        ];
+        // trick to allow multiple node types
+        return Node::class;
     }
 
-    /**
-     * @param MethodCall|StaticCall|FuncCall|StaticPropertyFetch|PropertyFetch|ClassConstFetch $node
-     */
-    public function process(Node $node, Scope $scope): array
+    public function processNode(Node $node, Scope $scope): array
     {
         if ($node instanceof ClassConstFetch || $node instanceof StaticPropertyFetch) {
             if (! $node->class instanceof Expr) {
@@ -65,17 +57,30 @@ public function process(Node $node, Scope $scope): array
                 return [];
             }
 
-            return [RuleErrorBuilder::message(self::ERROR_MESSAGE)->build()];
-        }
+            $ruleError = RuleErrorBuilder::message(self::ERROR_MESSAGE)
+                ->identifier(RuleIdentifier::NO_DYNAMIC_NAME)
+                ->build();
 
-        if (! $node->name instanceof Expr) {
-            return [];
+            return [$ruleError];
         }
 
-        if ($this->callableTypeAnalyzer->isClosureOrCallableType($scope, $node->name)) {
-            return [];
+        if ($node instanceof MethodCall || $node instanceof StaticCall || $node instanceof FuncCall || $node instanceof PropertyFetch) {
+
+            if (! $node->name instanceof Expr) {
+                return [];
+            }
+
+            if ($this->callableTypeAnalyzer->isClosureOrCallableType($scope, $node->name)) {
+                return [];
+            }
+
+            $ruleError = RuleErrorBuilder::message(self::ERROR_MESSAGE)
+                ->identifier(RuleIdentifier::NO_DYNAMIC_NAME)
+                ->build();
+
+            return [$ruleError];
         }
 
-        return [RuleErrorBuilder::message(self::ERROR_MESSAGE)->build()];
+        return [];
     }
 }

src/Rules/AbstractSymplifyRule.php

@@ -15,15 +15,18 @@
 use PhpParser\Node\Stmt\Foreach_;
 use PhpParser\Node\Stmt\Function_;
 use PHPStan\Analyser\Scope;
-use PHPStan\Rules\RuleError;
+use PHPStan\Rules\IdentifierRuleError;
+use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
+use Symplify\PHPStanRules\Enum\RuleIdentifier;
 use Symplify\PHPStanRules\ParentClassMethodNodeResolver;
-use function array_map;
 
 /**
  * @see \Symplify\PHPStanRules\Tests\Rules\NoReferenceRule\NoReferenceRuleTest
+ *
+ * @implements Rule<\PhpParser\Node>
  */
-final class NoReferenceRule extends AbstractSymplifyRule
+final class NoReferenceRule implements Rule
 {
     /**
      * @var string
@@ -35,69 +38,65 @@ public function __construct(
     ) {
     }
 
-    public function getNodeTypes(): array
+    public function getNodeType(): string
     {
-        return [
-            ClassMethod::class,
-            Function_::class,
-            AssignRef::class,
-            Arg::class,
-            Foreach_::class,
-            ArrayItem::class,
-            ArrowFunction::class,
-            Closure::class,
-        ];
+        return Node::class;
     }
 
-    /**
-     * @param ClassMethod|Function_|AssignRef|Arg|Foreach_|ArrayItem|ArrowFunction|Closure $node
-     */
-    public function process(Node $node, Scope $scope): array
+    public function processNode(Node $node, Scope $scope): array
     {
         $errorMessages = [];
 
         if ($node instanceof AssignRef) {
-            $errorMessages[] = self::ERROR_MESSAGE;
-        } elseif ($node->byRef) {
-            $errorMessages[] = self::ERROR_MESSAGE;
+            return [$this->createRuleError()];
+        }
+
+        if (! $node instanceof Closure && ! $node instanceof ArrowFunction && ! $node instanceof Function_ && ! $node instanceof ClassMethod && ! $node instanceof Arg && ! $node instanceof Foreach_ && ! $node instanceof ArrayItem) {
+            return [];
+        }
+
+        if ($node->byRef) {
+            $errorMessages[] = $this->createRuleError();
         }
 
-        $paramErrorMessage = $this->collectParamErrorMessages($node, $scope);
-        $errorMessages = array_merge($errorMessages, $paramErrorMessage);
+        if ($node instanceof Function_ || $node instanceof ClassMethod) {
+            $paramErrorMessage = $this->collectParamErrorMessages($node, $scope);
+            $errorMessages = array_merge($errorMessages, $paramErrorMessage);
+        }
 
-        return array_map(
-            static fn ($message): RuleError => RuleErrorBuilder::message($message)->build(),
-            array_unique($errorMessages),
-        );
+        return $errorMessages;
     }
 
     /**
-     * @return string[]
+     * @return list<IdentifierRuleError>
      */
-    private function collectParamErrorMessages(Node $node, Scope $scope): array
+    private function collectParamErrorMessages(Function_|ClassMethod $functionLike, Scope $scope): array
     {
-        if (! $node instanceof Function_ && ! $node instanceof ClassMethod) {
-            return [];
-        }
-
         // has parent method? → skip it as enforced by parent
-        $methodName = (string) $node->name;
+        $methodName = (string) $functionLike->name;
 
         $parentClassMethod = $this->parentClassMethodNodeResolver->resolveParentClassMethod($scope, $methodName);
         if ($parentClassMethod instanceof ClassMethod) {
             return [];
         }
 
         $errorMessages = [];
-        foreach ($node->params as $param) {
+        foreach ($functionLike->params as $param) {
             /** @var Param $param */
             if (! $param->byRef) {
                 continue;
             }
 
-            $errorMessages[] = self::ERROR_MESSAGE;
+            $errorMessages[] = $this->createRuleError();
         }
 
         return $errorMessages;
     }
+
+    private function createRuleError(): IdentifierRuleError
+    {
+        return RuleErrorBuilder::message(self::ERROR_MESSAGE)
+            ->identifier(RuleIdentifier::NO_REFERENCE)
+            ->build();
+    }
 }

src/Rules/NoDynamicNameRule.php

@@ -15,13 +15,16 @@
 use PHPStan\Node\InClassNode;
 use PHPStan\Reflection\ClassReflection;
 use PHPStan\Rules\IdentifierRuleError;
+use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
 use Symplify\PHPStanRules\Enum\RuleIdentifier;
 
 /**
  * @see \Symplify\PHPStanRules\Tests\Rules\PreferredClassRule\PreferredClassRuleTest
+ *
+ * @implements Rule<Node>
  */
-final class PreferredClassRule extends AbstractSymplifyRule
+final class PreferredClassRule implements Rule
 {
     /**
      * @var string
@@ -36,15 +39,7 @@ public function __construct(
     ) {
     }
 
-    public function getNodeTypes(): array
-    {
-        return [New_::class, Name::class, InClassNode::class, StaticCall::class, Instanceof_::class];
-    }
-
-    /**
-     * @param New_|Name|InClassNode|StaticCall|Instanceof_ $node
-     */
-    public function process(Node $node, Scope $scope): array
+    public function processNode(Node $node, Scope $scope): array
     {
         if ($node instanceof New_) {
             return $this->processNew($node);
@@ -58,11 +53,20 @@ public function process(Node $node, Scope $scope): array
             return $this->processExprWithClass($node);
         }
 
-        return $this->processClassName($node->toString());
+        if ($node instanceof Name) {
+            return $this->processClassName($node->toString());
+        }
+
+        return [];
+    }
+
+    public function getNodeType(): string
+    {
+        return Node::class;
     }
 
     /**
-     * @return IdentifierRuleError[]
+     * @return list<IdentifierRuleError>
      */
     private function processNew(New_ $new): array
     {