forked from symplify/phpstan-rules
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathForbiddenParamTypeRemovalRule.php
122 lines (104 loc) · 3.07 KB
/
ForbiddenParamTypeRemovalRule.php
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
<?php
declare(strict_types=1);
namespace Symplify\PHPStanRules\Rules;
use PhpParser\Node;
use PhpParser\Node\Stmt\ClassMethod;
use PHPStan\Analyser\Scope;
use PHPStan\Reflection\Php\PhpMethodReflection;
use PHPStan\Type\MixedType;
use PHPStan\Type\Type;
use Symplify\PHPStanRules\Reflection\MethodNodeAnalyser;
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
/**
* @see \Symplify\PHPStanRules\Tests\Rules\ForbiddenParamTypeRemovalRule\ForbiddenParamTypeRemovalRuleTest
*/
final class ForbiddenParamTypeRemovalRule extends AbstractSymplifyRule
{
/**
* @var string
*/
public const ERROR_MESSAGE = 'Removing parent param type is forbidden';
public function __construct(
private MethodNodeAnalyser $methodNodeAnalyser
) {
}
/**
* @return array<class-string<Node>>
*/
public function getNodeTypes(): array
{
return [ClassMethod::class];
}
/**
* @param ClassMethod $node
* @return string[]
*/
public function process(Node $node, Scope $scope): array
{
if ($node->params === []) {
return [];
}
$classMethodName = (string) $node->name;
$parentClassMethod = $this->methodNodeAnalyser->matchFirstParentClassMethod($scope, $classMethodName);
if (! $parentClassMethod instanceof PhpMethodReflection) {
return [];
}
foreach ($node->params as $paramPosition => $param) {
if ($param->type !== null) {
continue;
}
$parentParamType = $this->resolveParentParamType($parentClassMethod, $paramPosition);
if ($parentParamType instanceof MixedType) {
continue;
}
// removed param type!
return [self::ERROR_MESSAGE];
}
return [];
}
public function getRuleDefinition(): RuleDefinition
{
return new RuleDefinition(self::ERROR_MESSAGE, [
new CodeSample(
<<<'CODE_SAMPLE'
interface RectorInterface
{
public function refactor(Node $node);
}
final class SomeRector implements RectorInterface
{
public function refactor($node)
{
}
}
CODE_SAMPLE
,
<<<'CODE_SAMPLE'
interface RectorInterface
{
public function refactor(Node $node);
}
final class SomeRector implements RectorInterface
{
public function refactor(Node $node)
{
}
}
CODE_SAMPLE
),
]);
}
private function resolveParentParamType(PhpMethodReflection $phpMethodReflection, int $paramPosition): Type
{
foreach ($phpMethodReflection->getVariants() as $parametersAcceptorWithPhpDoc) {
foreach ($parametersAcceptorWithPhpDoc->getParameters() as $parentParamPosition => $parameterReflectionWithPhpDoc) {
if ($paramPosition !== $parentParamPosition) {
continue;
}
return $parameterReflectionWithPhpDoc->getNativeType();
}
}
return new MixedType();
}
}