[code-quality] Extract standalone SortAttributeNamedArgsRector from SortNamedParamRector, to slightly different areas (#7750)

Author: TomasVotruba

rules-tests/CodeQuality/Rector/Attribute/SortAttributeNamedArgsRector/Fixture/attribute.php.inc

@@ -0,0 +1,27 @@
+<?php
+
+namespace Rector\Tests\CodeQuality\Rector\Attribute\SortAttributeNamedArgsRector\Fixture;
+
+use Rector\Tests\CodeQuality\Rector\Attribute\SortAttributeNamedArgsRector\Source\MyAttribute;
+
+#[MyAttribute(bar: 1, foo: 2)]
+#[MyAttribute(1, baz: 2, bar: 3)]
+final class HandleAttribute
+{
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\CodeQuality\Rector\Attribute\SortAttributeNamedArgsRector\Fixture;
+
+use Rector\Tests\CodeQuality\Rector\Attribute\SortAttributeNamedArgsRector\Source\MyAttribute;
+
+#[MyAttribute(foo: 2, bar: 1)]
+#[MyAttribute(1, bar: 3, baz: 2)]
+final class HandleAttribute
+{
+}
+
+?>

rules-tests/CodeQuality/Rector/Attribute/SortAttributeNamedArgsRector/SortAttributeNamedArgsRectorTest.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Tests\CodeQuality\Rector\Attribute\SortAttributeNamedArgsRector;
+
+use Iterator;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Rector\Testing\PHPUnit\AbstractRectorTestCase;
+
+final class SortAttributeNamedArgsRectorTest extends AbstractRectorTestCase
+{
+    #[DataProvider('provideData')]
+    public function test(string $filePath): void
+    {
+        $this->doTestFile($filePath);
+    }
+
+    public static function provideData(): Iterator
+    {
+        return self::yieldFilesFromDirectory(__DIR__ . '/Fixture');
+    }
+
+    public function provideConfigFilePath(): string
+    {
+        return __DIR__ . '/config/configured_rule.php';
+    }
+}

rules-tests/CodeQuality/Rector/Attribute/SortAttributeNamedArgsRector/Source/MyAttribute.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Rector\Tests\CodeQuality\Rector\Attribute\SortAttributeNamedArgsRector\Source;
+
+#[\Attribute]
+class MyAttribute
+{
+    public function __construct($foo = null, $bar = null, $baz = null)
+    {
+    }
+}

rules-tests/CodeQuality/Rector/Attribute/SortAttributeNamedArgsRector/config/configured_rule.php

@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+use Rector\CodeQuality\Rector\Attribute\SortAttributeNamedArgsRector;
+use Rector\Config\RectorConfig;
+
+return RectorConfig::configure()
+    ->withRules([SortAttributeNamedArgsRector::class]);

rules-tests/CodeQuality/Rector/FuncCall/SortNamedParamRector/Fixture/attribute.php.inc

@@ -0,0 +1,11 @@
+<?php
+
+namespace Rector\Tests\CodeQuality\Rector\FuncCall\SortNamedParamRector\Fixture;
+
+use Rector\Tests\CodeQuality\Rector\FuncCall\SortNamedParamRector\Source\MyAttribute;
+
+#[MyAttribute(bar: 1, foo: 2)]
+#[MyAttribute(1, baz: 2, bar: 3)]
+class SkipAttribute
+{
+}

rules-tests/CodeQuality/Rector/FuncCall/SortNamedParamRector/Fixture/skip_attribute.php.inc

@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\CodeQuality\NodeManipulator;
+
+use PhpParser\Node\Arg;
+use PhpParser\Node\Identifier;
+use PHPStan\Reflection\FunctionReflection;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Reflection\ParametersAcceptorSelector;
+
+final class NamedArgsSorter
+{
+    /**
+     * @param Arg[] $currentArgs
+     * @return list<Arg>
+     */
+    public function sortArgsToMatchReflectionParameters(
+        array $currentArgs,
+        FunctionReflection | MethodReflection $functionLikeReflection,
+    ): array {
+        $extendedParametersAcceptor = ParametersAcceptorSelector::combineAcceptors(
+            $functionLikeReflection->getVariants()
+        );
+
+        $parameters = $extendedParametersAcceptor->getParameters();
+
+        $order = [];
+        foreach ($parameters as $key => $parameter) {
+            $order[$parameter->getName()] = $key;
+        }
+
+        $sortedArgs = [];
+        $toSortArgs = [];
+        foreach ($currentArgs as $currentArg) {
+            if (! $currentArg->name instanceof Identifier) {
+                $sortedArgs[] = $currentArg;
+                continue;
+            }
+
+            $toSortArgs[] = $currentArg;
+        }
+
+        usort(
+            $toSortArgs,
+            static function (Arg $arg1, Arg $arg2) use ($order): int {
+                /** @var Identifier $argName1 */
+                $argName1 = $arg1->name;
+                /** @var Identifier $argName2 */
+                $argName2 = $arg2->name;
+
+                $order1 = $order[$argName1->name] ?? PHP_INT_MAX;
+                $order2 = $order[$argName2->name] ?? PHP_INT_MAX;
+
+                return $order1 <=> $order2;
+            }
+        );
+
+        return [...$sortedArgs, ...$toSortArgs];
+    }
+}

rules/CodeQuality/NodeManipulator/NamedArgsSorter.php

@@ -0,0 +1,102 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\CodeQuality\Rector\Attribute;
+
+use PhpParser\Node;
+use PhpParser\Node\Attribute;
+use PHPStan\Reflection\MethodReflection;
+use Rector\CodeQuality\NodeManipulator\NamedArgsSorter;
+use Rector\NodeAnalyzer\ArgsAnalyzer;
+use Rector\Rector\AbstractRector;
+use Rector\Reflection\ReflectionResolver;
+use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
+use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
+
+/**
+ * @see \Rector\Tests\CodeQuality\Rector\Attribute\SortAttributeNamedArgsRector\SortAttributeNamedArgsRectorTest
+ */
+final class SortAttributeNamedArgsRector extends AbstractRector
+{
+    public function __construct(
+        private readonly ArgsAnalyzer $argsAnalyzer,
+        private readonly ReflectionResolver $reflectionResolver,
+        private readonly NamedArgsSorter $namedArgsSorter
+    ) {
+
+    }
+
+    public function getRuleDefinition(): RuleDefinition
+    {
+        return new RuleDefinition('Sort named arguments in PHP 8 attributes to match their declaration order', [
+            new CodeSample(
+                <<<'CODE_SAMPLE'
+#[SomeAttribute(bar: $bar, foo: $foo)]
+class SomeClass
+{
+}
+
+#[Attribute]
+class SomeAttribute
+{
+    public function __construct(public $foo, public $bar)
+    {
+    }
+}
+CODE_SAMPLE
+                ,
+                <<<'CODE_SAMPLE'
+#[SomeAttribute(foo: $foo, bar: $bar)]
+class SomeClass
+{
+}
+
+#[Attribute]
+class SomeAttribute
+{
+    public function __construct(public $foo, public $bar)
+    {
+    }
+}
+CODE_SAMPLE
+            ),
+
+        ]);
+    }
+
+    public function getNodeTypes(): array
+    {
+        return [Attribute::class];
+    }
+
+    /**
+     * @param Node\Attribute $node
+     */
+    public function refactor(Node $node): ?Node
+    {
+        $args = $node->args;
+        if (count($args) <= 1) {
+            return null;
+        }
+
+        if (! $this->argsAnalyzer->hasNamedArg($args)) {
+            return null;
+        }
+
+        $functionLikeReflection = $this->reflectionResolver->resolveConstructorReflectionFromAttribute($node);
+        if (! $functionLikeReflection instanceof MethodReflection) {
+            return null;
+        }
+
+        $args = $this->namedArgsSorter->sortArgsToMatchReflectionParameters($args, $functionLikeReflection);
+        if ($node->args === $args) {
+            return null;
+        }
+
+        $node->args = $args;
+
+        return $node;
+
+    }
+}