Feature: Updated phpstan to 2.0 version.

composer.json

@@ -23,7 +23,7 @@
 
     "require-dev": {
         "phpunit/phpunit": "~9.5",
-        "phpstan/phpstan": "~1.10",
+        "phpstan/phpstan": "~2.0",
         "escapestudios/symfony2-coding-standard": "~3.13"
     },
 

src/PhpStan/AbstractNoNamedArgumentUsedRule.php

@@ -16,6 +16,7 @@
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
 
 /**
  * @implements Rule<Node>
@@ -65,16 +66,14 @@
         foreach ($this->forbiddenMethods as $forbiddenClass => $forbiddenMethods) {
             $className = $this->getClassName($node, $scope);
 
             if (null !== $className && \is_a($className, $forbiddenClass, true)) {
                 $methodName = $this->getMethodName($node);
 
                 if ('all' === $forbiddenMethods || \in_array(\strtolower($methodName), $forbiddenMethods, true)) {
                     if ($this->findNullableName($node)) {
-                        $errors[] = \sprintf(
-                            'The method "%s::%s" is forbidden to call without named arguments.',
-                            $className,
-                            $methodName
-                        );
+                        $errors[] = RuleErrorBuilder::message(\sprintf('The method "%s::%s" is forbidden to call without named arguments.', $className, $methodName))
+                            ->identifier('methodCall.withoutNamedArguments.forbidden')
+                            ->build();
                     }
                 }
             }

src/PhpStan/ForbiddenFunctionCallRule.php

@@ -16,6 +16,7 @@
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
 
 /**
  * @implements Rule<Node\Expr\FuncCall>
@@ -58,7 +59,11 @@ public function processNode(Node $node, Scope $scope): array
         $funcName = $node->name->toString();
 
         if (\in_array($funcName, $this->forbiddenFunctions, true)) {
-            return [\sprintf('The function "%s" is forbidden for usage.', $funcName)];
+            return [
+                RuleErrorBuilder::message(\sprintf('The function "%s" is forbidden for usage.', $funcName))
+                    ->identifier('functionCall.forbidden')
+                    ->build(),
+            ];
         }
 
         return [];

src/PhpStan/ForbiddenMethodCallRule.php

@@ -16,6 +16,7 @@
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\ObjectType;
 
 /**
@@ -71,21 +72,18 @@
         foreach ($this->forbiddenMethods as $forbiddenClass => $forbiddenMethods) {
             $varType = $scope->getType($node->var);
 
             if ($varType instanceof ObjectType) {
                 $varClassReflection = $varType->getClassReflection();
 
                 if ($varClassReflection && \is_a($varClassReflection->getName(), $forbiddenClass, true)) {
                     if ('all' === $forbiddenMethods) {
-                        $errors[] = \sprintf(
-                            'Any method call from "%s" is forbidden.',
-                            $forbiddenClass
-                        );
+                        $errors[] = RuleErrorBuilder::message(\sprintf('Any method call from "%s" is forbidden.', $forbiddenClass))
+                            ->identifier('methodCall.forbidden')
+                            ->build();
                     } elseif (\in_array($node->name->toLowerString(), $forbiddenMethods, true)) {
-                        $errors[] = \sprintf(
-                            'The method "%s::%s" is forbidden to call.',
-                            $varClassReflection->getName(),
-                            $node->name->toString()
-                        );
+                        $errors[] = RuleErrorBuilder::message(\sprintf('The method "%s::%s" is forbidden to call.', $varClassReflection->getName(), $node->name->toString()))
+                            ->identifier('methodCall.forbidden')
+                            ->build();
                     }
                 }
             }

src/PhpStan/ForbiddenNodeTypeRule.php

@@ -16,6 +16,7 @@
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
 
 /**
  * @implements Rule<Node>
@@ -40,7 +41,7 @@
      */
     public function __construct(string $nodeType, string $message = null)
     {
         if (!\is_a($nodeType, Node::class, true)) {
             throw new \InvalidArgumentException(\sprintf(
                 'The node type class must implement "%s" interface but "%s" got given.',
                 Node::class,
@@ -66,6 +67,10 @@
 
     public function processNode(Node $node, Scope $scope): array
     {
-        return [$this->message];
+        return [
+            RuleErrorBuilder::message($this->message)
+                ->identifier('nodeCall.forbidden')
+                ->build(),
+        ];
     }
 }

src/PhpStan/ForbiddenPassArgumentAsReferenceRule.php

@@ -16,6 +16,7 @@
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
 
 /**
  * @implements Rule<Node>
@@ -34,7 +35,7 @@
      */
     public function __construct(string $nodeType)
     {
         if (!\is_a($nodeType, Node\Stmt\Function_::class, true) && !\is_a($nodeType, Node\Stmt\ClassMethod::class, true)) {
             throw new \InvalidArgumentException(\sprintf(
                 'Invalid node type "%s". Support only %s or %s.',
                 $nodeType,
@@ -60,7 +61,11 @@
     {
         foreach ($node->getParams() as $param) {
             if ($param->byRef) {
-                return ['Pass arguments by reference is forbidden.'];
+                return [
+                    RuleErrorBuilder::message('Pass arguments by reference is forbidden.')
+                        ->identifier('passArguments.byReference.forbidden')
+                        ->build(),
+                ];
             }
         }
 

src/PhpStan/ForbiddenSuppressErrorRule.php

@@ -21,6 +21,7 @@
 use PhpParser\Node\Expr\MethodCall;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\ObjectType;
 
 /**
@@ -93,12 +94,12 @@
         if ($node->expr instanceof MethodCall) {
             $variableType = $scope->getType($node->expr->var);
 
             if ($variableType instanceof ObjectType) {
                 $varClassReflection = $variableType->getClassReflection();
 
                 if ($varClassReflection) {
                     foreach ($this->allowedMethods as $allowedClass => $allowedMethods) {
                         if (\is_a($varClassReflection->getName(), $allowedClass, true) && \in_array($node->expr->name->toLowerString(), $allowedMethods, true)) {
                             return [];
                         }
                     }
@@ -106,6 +107,10 @@
             }
         }
 
-        return ['Suppress error is forbidden.'];
+        return [
+            RuleErrorBuilder::message('Suppress error is forbidden.')
+                ->identifier('errorSuppress.forbidden')
+                ->build(),
+        ];
     }
 }

tests/PhpStan/ForbiddenFunctionCallRuleTest.php

@@ -18,9 +18,6 @@
 
 class ForbiddenFunctionCallRuleTest extends RuleTestCase
 {
-    /**
-     * @var ForbiddenFunctionCallRule
-     */
     private ForbiddenFunctionCallRule $rule;
 
     protected function getRule(): ForbiddenFunctionCallRule
@@ -43,11 +40,6 @@ public function shouldSuccessProcess(array $functions, array $errors): void
         $this->analyse([__DIR__.'/Resources/forbidden-functions.php'], [...$errors]);
     }
 
-    /**
-     * Provide data for test analyze
-     *
-     * @return array
-     */
     public function provideDataForProcess(): array
     {
         return [

tests/PhpStan/ForbiddenMethodCallRuleTest.php

@@ -19,9 +19,6 @@
 
 class ForbiddenMethodCallRuleTest extends RuleTestCase
 {
-    /**
-     * @var ForbiddenMethodCallRule
-     */
     private ForbiddenMethodCallRule $rule;
 
     protected function getRule(): Rule
@@ -44,11 +41,6 @@ public function shouldSuccessProcess(array $methods, array $errors): void
         $this->analyse([__DIR__.'/Resources/forbidden-methods.php'], [...$errors]);
     }
 
-    /**
-     * Provide data for testing
-     *
-     * @return array
-     */
     public function provideDataForTesting(): array
     {
         return [

tests/PhpStan/ForbiddenNodeTypeRuleTest.php

@@ -21,9 +21,6 @@
 
 class ForbiddenNodeTypeRuleTest extends RuleTestCase
 {
-    /**
-     * @var ForbiddenNodeTypeRule
-     */
     private ForbiddenNodeTypeRule $rule;
 
     protected function getRule(): Rule

tests/PhpStan/ForbiddenPassArgumentAsReferenceRuleTest.php

@@ -20,9 +20,6 @@
 
 class ForbiddenPassArgumentAsReferenceRuleTest extends RuleTestCase
 {
-    /**
-     * @var ForbiddenPassArgumentAsReferenceRule
-     */
     private ForbiddenPassArgumentAsReferenceRule $rule;
 
     protected function getRule(): ForbiddenPassArgumentAsReferenceRule

tests/PhpStan/ForbiddenSuppressErrorRuleTest.php

@@ -18,9 +18,6 @@
 
 class ForbiddenSuppressErrorRuleTest extends RuleTestCase
 {
-    /**
-     * @var ForbiddenSuppressErrorRule
-     */
     private ForbiddenSuppressErrorRule $rule;
 
     protected function getRule(): ForbiddenSuppressErrorRule
@@ -43,11 +40,6 @@ public function shouldSuccessProcess(array $allowed, array $errors): void
         $this->analyse([__DIR__.'/Resources/forbidden-suppress-error.php'], [...$errors]);
     }
 
-    /**
-     * Provide data for testing
-     *
-     * @return array
-     */
     public function provideDataForTesting(): array
     {
         return [

tests/PhpStan/NoNamedArgumentUsedConstructorRuleTest.php

@@ -19,9 +19,6 @@
 
 class NoNamedArgumentUsedConstructorRuleTest extends RuleTestCase
 {
-    /**
-     * @var NoNamedArgumentUsedConstructorRule
-     */
     private NoNamedArgumentUsedConstructorRule $rule;
 
     protected function getRule(): Rule
@@ -44,11 +41,6 @@ public function shouldSuccessProcess(array $methods, array $errors): void
         $this->analyse([__DIR__.'/Resources/no-named-argument-used-new.php'], [...$errors]);
     }
 
-    /**
-     * Provide data for testing
-     *
-     * @return array
-     */
     public function provideDataForTesting(): array
     {
         return [

tests/PhpStan/NoNamedArgumentUsedMethodCallRuleTest.php

@@ -19,9 +19,6 @@
 
 class NoNamedArgumentUsedMethodCallRuleTest extends RuleTestCase
 {
-    /**
-     * @var NoNamedArgumentUsedMethodCallRule
-     */
     private NoNamedArgumentUsedMethodCallRule $rule;
 
     protected function getRule(): Rule
@@ -44,11 +41,6 @@ public function shouldSuccessProcess(array $methods, array $errors): void
         $this->analyse([__DIR__.'/Resources/no-named-argument-used-method-call.php'], [...$errors]);
     }
 
-    /**
-     * Provide data for testing
-     *
-     * @return array
-     */
     public function provideDataForTesting(): array
     {
         return [