Skip to content

Commit 3d7d4e2

Browse files
TomasVotrubaTomasVotruba
committed
Updated Rector to commit 749a17546633e5ce82c9b4b15ea0cd4d7acb8ec7
rectorphp/rector-src@749a175 feat: Add AddNameToNullArgumentRector (#8000)
1 parent 4661c58 commit 3d7d4e2

6 files changed

Lines changed: 220 additions & 125 deletions

File tree

‎rules/CodeQuality/Rector/CallLike/AddNameToBooleanArgumentRector.php‎

Lines changed: 5 additions & 123 deletions
Original file line numberDiff line numberDiff line change
@@ -4,17 +4,10 @@
44
namespace Rector\CodeQuality\Rector\CallLike;
55

66
use PhpParser\Node;
7-
use PhpParser\Node\Arg;
87
use PhpParser\Node\Expr\CallLike;
9-
use PhpParser\Node\Identifier;
10-
use PHPStan\Reflection\FunctionReflection;
11-
use PHPStan\Reflection\MethodReflection;
12-
use PHPStan\Reflection\ParameterReflection;
13-
use Rector\NodeTypeResolver\PHPStan\ParametersAcceptorSelectorVariantsWrapper;
8+
use Rector\NodeAnalyzer\CallLikeArgumentNameAdder;
149
use Rector\PhpParser\Node\Value\ValueResolver;
15-
use Rector\PHPStan\ScopeFetcher;
1610
use Rector\Rector\AbstractRector;
17-
use Rector\Reflection\ReflectionResolver;
1811
use Rector\ValueObject\PhpVersionFeature;
1912
use Rector\VersionBonding\Contract\MinPhpVersionInterface;
2013
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
@@ -27,14 +20,14 @@ final class AddNameToBooleanArgumentRector extends AbstractRector implements Min
2720
/**
2821
* @readonly
2922
*/
30-
private ReflectionResolver $reflectionResolver;
23+
private CallLikeArgumentNameAdder $callLikeArgumentNameAdder;
3124
/**
3225
* @readonly
3326
*/
3427
private ValueResolver $valueResolver;
35-
public function __construct(ReflectionResolver $reflectionResolver, ValueResolver $valueResolver)
28+
public function __construct(CallLikeArgumentNameAdder $callLikeArgumentNameAdder, ValueResolver $valueResolver)
3629
{
37-
$this->reflectionResolver = $reflectionResolver;
30+
$this->callLikeArgumentNameAdder = $callLikeArgumentNameAdder;
3831
$this->valueResolver = $valueResolver;
3932
}
4033
public function getRuleDefinition(): RuleDefinition
@@ -59,121 +52,10 @@ public function getNodeTypes(): array
5952
*/
6053
public function refactor(Node $node): ?Node
6154
{
62-
if ($this->shouldSkip($node)) {
63-
return null;
64-
}
65-
$reflection = $this->reflectionResolver->resolveFunctionLikeReflectionFromCall($node);
66-
if (!$reflection instanceof FunctionReflection && !$reflection instanceof MethodReflection) {
67-
return null;
68-
}
69-
$scope = ScopeFetcher::fetch($node);
70-
$args = $node->getArgs();
71-
$parameters = ParametersAcceptorSelectorVariantsWrapper::select($reflection, $node, $scope)->getParameters();
72-
$position = $this->resolveFirstPositionToName($args, $parameters);
73-
if ($position === null) {
74-
return null;
75-
}
76-
$wasChanged = \false;
77-
$counter = count($args);
78-
for ($i = $position; $i < $counter; ++$i) {
79-
$arg = $args[$i];
80-
if ($arg->name instanceof Identifier) {
81-
continue;
82-
}
83-
$parameterReflection = $this->resolveParameterReflection($arg, $i, $parameters);
84-
if (!$parameterReflection instanceof ParameterReflection) {
85-
return null;
86-
}
87-
$arg->name = new Identifier($parameterReflection->getName());
88-
$wasChanged = \true;
89-
}
90-
if (!$wasChanged) {
91-
return null;
92-
}
93-
return $node;
55+
return $this->callLikeArgumentNameAdder->addNamesToArgs($node, fn($expr): bool => $this->valueResolver->isTrueOrFalse($expr));
9456
}
9557
public function provideMinPhpVersion(): int
9658
{
9759
return PhpVersionFeature::NAMED_ARGUMENTS;
9860
}
99-
private function shouldSkip(CallLike $callLike): bool
100-
{
101-
if ($callLike->isFirstClassCallable()) {
102-
return \true;
103-
}
104-
$args = $callLike->getArgs();
105-
if ($args === []) {
106-
return \true;
107-
}
108-
foreach ($args as $arg) {
109-
if ($arg->unpack) {
110-
return \true;
111-
}
112-
}
113-
return \false;
114-
}
115-
/**
116-
* @param Arg[] $args
117-
* @param ParameterReflection[] $parameters
118-
*/
119-
private function resolveFirstPositionToName(array $args, array $parameters): ?int
120-
{
121-
foreach ($args as $position => $arg) {
122-
if ($arg->name instanceof Identifier) {
123-
continue;
124-
}
125-
if (!$this->valueResolver->isTrueOrFalse($arg->value)) {
126-
continue;
127-
}
128-
if ($this->canNameArgsFromPosition($args, $parameters, $position)) {
129-
return $position;
130-
}
131-
}
132-
return null;
133-
}
134-
/**
135-
* @param Arg[] $args
136-
* @param ParameterReflection[] $parameters
137-
*/
138-
private function canNameArgsFromPosition(array $args, array $parameters, int $position): bool
139-
{
140-
$count = count($args);
141-
for ($i = $position; $i < $count; ++$i) {
142-
$arg = $args[$i];
143-
if ($arg->name instanceof Identifier) {
144-
continue;
145-
}
146-
$parameterReflection = $this->resolveParameterReflection($arg, $i, $parameters);
147-
if (!$parameterReflection instanceof ParameterReflection) {
148-
return \false;
149-
}
150-
if ($parameterReflection->isVariadic()) {
151-
return \false;
152-
}
153-
}
154-
return \true;
155-
}
156-
/**
157-
* @param ParameterReflection[] $parameters
158-
*/
159-
private function resolveParameterReflection(Arg $arg, int $position, array $parameters): ?ParameterReflection
160-
{
161-
if ($arg->name instanceof Identifier) {
162-
foreach ($parameters as $parameter) {
163-
if ($parameter->getName() === $arg->name->toString()) {
164-
return $parameter;
165-
}
166-
}
167-
return null;
168-
}
169-
$parameter = $parameters[$position] ?? null;
170-
if ($parameter instanceof ParameterReflection) {
171-
return $parameter;
172-
}
173-
$lastParameter = end($parameters);
174-
if ($lastParameter instanceof ParameterReflection && $lastParameter->isVariadic()) {
175-
return $lastParameter;
176-
}
177-
return null;
178-
}
17961
}

‎rules/CodeQuality/Rector/CallLike/AddNameToNullArgumentRector.php‎

Lines changed: 61 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,61 @@
1+
<?php
2+
3+
declare (strict_types=1);
4+
namespace Rector\CodeQuality\Rector\CallLike;
5+
6+
use PhpParser\Node;
7+
use PhpParser\Node\Expr\CallLike;
8+
use Rector\NodeAnalyzer\CallLikeArgumentNameAdder;
9+
use Rector\PhpParser\Node\Value\ValueResolver;
10+
use Rector\Rector\AbstractRector;
11+
use Rector\ValueObject\PhpVersionFeature;
12+
use Rector\VersionBonding\Contract\MinPhpVersionInterface;
13+
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
14+
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
15+
/**
16+
* @see \Rector\Tests\CodeQuality\Rector\CallLike\AddNameToNullArgumentRector\AddNameToNullArgumentRectorTest
17+
*/
18+
final class AddNameToNullArgumentRector extends AbstractRector implements MinPhpVersionInterface
19+
{
20+
/**
21+
* @readonly
22+
*/
23+
private CallLikeArgumentNameAdder $callLikeArgumentNameAdder;
24+
/**
25+
* @readonly
26+
*/
27+
private ValueResolver $valueResolver;
28+
public function __construct(CallLikeArgumentNameAdder $callLikeArgumentNameAdder, ValueResolver $valueResolver)
29+
{
30+
$this->callLikeArgumentNameAdder = $callLikeArgumentNameAdder;
31+
$this->valueResolver = $valueResolver;
32+
}
33+
public function getRuleDefinition(): RuleDefinition
34+
{
35+
return new RuleDefinition('Add parameter names to null arguments.', [new CodeSample(<<<'CODE_SAMPLE'
36+
some_function($value, null);
37+
CODE_SAMPLE
38+
, <<<'CODE_SAMPLE'
39+
some_function($value, default: null);
40+
CODE_SAMPLE
41+
)]);
42+
}
43+
/**
44+
* @return array<class-string<Node>>
45+
*/
46+
public function getNodeTypes(): array
47+
{
48+
return [CallLike::class];
49+
}
50+
/**
51+
* @param CallLike $node
52+
*/
53+
public function refactor(Node $node): ?Node
54+
{
55+
return $this->callLikeArgumentNameAdder->addNamesToArgs($node, fn($expr): bool => $this->valueResolver->isNull($expr));
56+
}
57+
public function provideMinPhpVersion(): int
58+
{
59+
return PhpVersionFeature::NAMED_ARGUMENTS;
60+
}
61+
}

‎src/Application/VersionResolver.php‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -19,12 +19,12 @@ final class VersionResolver
1919
* @api
2020
* @var string
2121
*/
22-
public const PACKAGE_VERSION = '2.4.4';
22+
public const PACKAGE_VERSION = '749a17546633e5ce82c9b4b15ea0cd4d7acb8ec7';
2323
/**
2424
* @api
2525
* @var string
2626
*/
27-
public const RELEASE_DATE = '2026-05-21 02:19:06';
27+
public const RELEASE_DATE = '2026-05-21 10:44:14';
2828
/**
2929
* @var int
3030
*/

‎src/NodeAnalyzer/CallLikeArgumentNameAdder.php‎

Lines changed: 148 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,148 @@
1+
<?php
2+
3+
declare (strict_types=1);
4+
namespace Rector\NodeAnalyzer;
5+
6+
use PhpParser\Node\Arg;
7+
use PhpParser\Node\Expr\CallLike;
8+
use PhpParser\Node\Identifier;
9+
use PHPStan\Reflection\FunctionReflection;
10+
use PHPStan\Reflection\MethodReflection;
11+
use PHPStan\Reflection\ParameterReflection;
12+
use Rector\NodeTypeResolver\PHPStan\ParametersAcceptorSelectorVariantsWrapper;
13+
use Rector\PHPStan\ScopeFetcher;
14+
use Rector\Reflection\ReflectionResolver;
15+
final class CallLikeArgumentNameAdder
16+
{
17+
/**
18+
* @readonly
19+
*/
20+
private ReflectionResolver $reflectionResolver;
21+
public function __construct(ReflectionResolver $reflectionResolver)
22+
{
23+
$this->reflectionResolver = $reflectionResolver;
24+
}
25+
/**
26+
* Add named arguments to a call-like node starting from the first positional
27+
* argument whose value satisfies $shouldNameArgValue. All subsequent positional
28+
* arguments receive names too (required by PHP named-arg semantics).
29+
*
30+
* @param callable(\PhpParser\Node\Expr): bool $shouldNameArgValue
31+
*/
32+
public function addNamesToArgs(CallLike $node, callable $shouldNameArgValue): ?CallLike
33+
{
34+
if ($this->shouldSkip($node)) {
35+
return null;
36+
}
37+
$reflection = $this->reflectionResolver->resolveFunctionLikeReflectionFromCall($node);
38+
if (!$reflection instanceof FunctionReflection && !$reflection instanceof MethodReflection) {
39+
return null;
40+
}
41+
$scope = ScopeFetcher::fetch($node);
42+
$args = $node->getArgs();
43+
$parameters = ParametersAcceptorSelectorVariantsWrapper::select($reflection, $node, $scope)->getParameters();
44+
$position = $this->resolveFirstPositionToName($args, $parameters, $shouldNameArgValue);
45+
if ($position === null) {
46+
return null;
47+
}
48+
$wasChanged = \false;
49+
$counter = count($args);
50+
for ($i = $position; $i < $counter; ++$i) {
51+
$arg = $args[$i];
52+
if ($arg->name instanceof Identifier) {
53+
continue;
54+
}
55+
$parameterReflection = $this->resolveParameterReflection($arg, $i, $parameters);
56+
if (!$parameterReflection instanceof ParameterReflection) {
57+
return null;
58+
}
59+
$arg->name = new Identifier($parameterReflection->getName());
60+
$wasChanged = \true;
61+
}
62+
if (!$wasChanged) {
63+
return null;
64+
}
65+
return $node;
66+
}
67+
private function shouldSkip(CallLike $callLike): bool
68+
{
69+
if ($callLike->isFirstClassCallable()) {
70+
return \true;
71+
}
72+
$args = $callLike->getArgs();
73+
if ($args === []) {
74+
return \true;
75+
}
76+
foreach ($args as $arg) {
77+
if ($arg->unpack) {
78+
return \true;
79+
}
80+
}
81+
return \false;
82+
}
83+
/**
84+
* @param Arg[] $args
85+
* @param ParameterReflection[] $parameters
86+
* @param callable(\PhpParser\Node\Expr): bool $shouldNameArgValue
87+
*/
88+
private function resolveFirstPositionToName(array $args, array $parameters, callable $shouldNameArgValue): ?int
89+
{
90+
foreach ($args as $position => $arg) {
91+
if ($arg->name instanceof Identifier) {
92+
continue;
93+
}
94+
if (!$shouldNameArgValue($arg->value)) {
95+
continue;
96+
}
97+
if ($this->canNameArgsFromPosition($args, $parameters, $position)) {
98+
return $position;
99+
}
100+
}
101+
return null;
102+
}
103+
/**
104+
* @param Arg[] $args
105+
* @param ParameterReflection[] $parameters
106+
*/
107+
private function canNameArgsFromPosition(array $args, array $parameters, int $position): bool
108+
{
109+
$count = count($args);
110+
for ($i = $position; $i < $count; ++$i) {
111+
$arg = $args[$i];
112+
if ($arg->name instanceof Identifier) {
113+
continue;
114+
}
115+
$parameterReflection = $this->resolveParameterReflection($arg, $i, $parameters);
116+
if (!$parameterReflection instanceof ParameterReflection) {
117+
return \false;
118+
}
119+
if ($parameterReflection->isVariadic()) {
120+
return \false;
121+
}
122+
}
123+
return \true;
124+
}
125+
/**
126+
* @param ParameterReflection[] $parameters
127+
*/
128+
private function resolveParameterReflection(Arg $arg, int $position, array $parameters): ?ParameterReflection
129+
{
130+
if ($arg->name instanceof Identifier) {
131+
foreach ($parameters as $parameter) {
132+
if ($parameter->getName() === $arg->name->toString()) {
133+
return $parameter;
134+
}
135+
}
136+
return null;
137+
}
138+
$parameter = $parameters[$position] ?? null;
139+
if ($parameter instanceof ParameterReflection) {
140+
return $parameter;
141+
}
142+
$lastParameter = end($parameters);
143+
if ($lastParameter instanceof ParameterReflection && $lastParameter->isVariadic()) {
144+
return $lastParameter;
145+
}
146+
return null;
147+
}
148+
}

0 commit comments

Comments
 (0)