[jms] Add custom AccessTypeAnnotationToAttributeRector to handle annotation flip to attribute correctly

config/sets/jms/annotations-to-attributes.php

@@ -5,6 +5,7 @@
 use Rector\Config\RectorConfig;
 use Rector\Php80\Rector\Class_\AnnotationToAttributeRector;
 use Rector\Php80\ValueObject\AnnotationToAttribute;
+use Rector\Symfony\JMS\Rector\AccessTypeAnnotationToAttributeRector;
 
 /**
  * @see https://github.com/schmittjoh/serializer/pull/1320
@@ -15,7 +16,6 @@
     $rectorConfig->ruleWithConfiguration(AnnotationToAttributeRector::class, [
         new AnnotationToAttribute('JMS\Serializer\Annotation\Accessor'),
         new AnnotationToAttribute('JMS\Serializer\Annotation\AccessorOrder'),
-        new AnnotationToAttribute('JMS\Serializer\Annotation\AccessType'),
         new AnnotationToAttribute('JMS\Serializer\Annotation\Discriminator'),
         new AnnotationToAttribute('JMS\Serializer\Annotation\Exclude'),
         new AnnotationToAttribute('JMS\Serializer\Annotation\ExclusionPolicy'),
@@ -45,4 +45,6 @@
         new AnnotationToAttribute('JMS\Serializer\Annotation\XmlRoot'),
         new AnnotationToAttribute('JMS\Serializer\Annotation\XmlValue'),
     ]);
+
+    $rectorConfig->rules([AccessTypeAnnotationToAttributeRector::class]);
 };

rules-tests/JMS/Rector/Class_/AccessTypeAnnotationToAttributeRector/AccessTypeAnnotationToAttributeRectorTest.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Symfony\Tests\JMS\Rector\Class_\AccessTypeAnnotationToAttributeRector;
+
+use Iterator;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Rector\Testing\PHPUnit\AbstractRectorTestCase;
+
+final class AccessTypeAnnotationToAttributeRectorTest 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/JMS/Rector/Class_/AccessTypeAnnotationToAttributeRector/Fixture/annotation_types.php.inc

@@ -0,0 +1,33 @@
+<?php
+
+namespace Rector\Symfony\Tests\JMS\Rector\Class_\AccessTypeAnnotationToAttributeRector\Fixture;
+
+use JMS\Serializer\Annotation as Serializer;
+
+/**
+ * @Serializer\AccessType("public_method")
+ */
+final class AnnotationTypes
+{
+    public function run(): void
+    {
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Symfony\Tests\JMS\Rector\Class_\AccessTypeAnnotationToAttributeRector\Fixture;
+
+use JMS\Serializer\Annotation as Serializer;
+
+#[Serializer\AccessType(values: ['public_method'])]
+final class AnnotationTypes
+{
+    public function run(): void
+    {
+    }
+}
+
+?>

rules-tests/JMS/Rector/Class_/AccessTypeAnnotationToAttributeRector/config/configured_rule.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+use Rector\Config\RectorConfig;
+use Rector\Symfony\JMS\Rector\AccessTypeAnnotationToAttributeRector;
+
+return static function (RectorConfig $rectorConfig): void {
+    $rectorConfig->rule(AccessTypeAnnotationToAttributeRector::class);
+};

rules/JMS/Rector/AccessTypeAnnotationToAttributeRector.php

@@ -0,0 +1,180 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Symfony\JMS\Rector;
+
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Expr\Array_;
+use PhpParser\Node\ArrayItem;
+use PhpParser\Node;
+use PhpParser\Node\AttributeGroup;
+use PhpParser\Node\Stmt\Class_;
+use PhpParser\Node\Stmt\Property;
+use PhpParser\Node\Stmt\Use_;
+use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagNode;
+use PHPStan\Reflection\ReflectionProvider;
+use Rector\BetterPhpDocParser\PhpDoc\DoctrineAnnotationTagValueNode;
+use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfo;
+use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory;
+use Rector\BetterPhpDocParser\PhpDocManipulator\PhpDocTagRemover;
+use Rector\Comments\NodeDocBlock\DocBlockUpdater;
+use Rector\Naming\Naming\UseImportsResolver;
+use Rector\Php80\NodeFactory\AttrGroupsFactory;
+use Rector\Php80\ValueObject\AnnotationToAttribute;
+use Rector\Php80\ValueObject\DoctrineTagAndAnnotationToAttribute;
+use Rector\Rector\AbstractRector;
+use Rector\Symfony\Enum\JMSAnnotation;
+use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
+use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
+
+/**
+ * @see https://github.com/schmittjoh/serializer/issues/1531
+ *
+ * @see \Rector\Symfony\Tests\JMS\Rector\Class_\AccessTypeAnnotationToAttributeRector\AccessTypeAnnotationToAttributeRectorTest
+ */
+final class AccessTypeAnnotationToAttributeRector extends AbstractRector
+{
+    private AnnotationToAttribute $annotationToAttribute;
+
+    public function __construct(
+        private readonly PhpDocInfoFactory $phpDocInfoFactory,
+        private readonly UseImportsResolver $useImportsResolver,
+        private readonly DocBlockUpdater $docBlockUpdater,
+        private readonly ReflectionProvider $reflectionProvider,
+        private readonly AttrGroupsFactory $attrGroupsFactory,
+        private readonly PhpDocTagRemover $phpDocTagRemover,
+    ) {
+    }
+
+    public function getRuleDefinition(): RuleDefinition
+    {
+        return new RuleDefinition(
+            'Changes @AccessType annotation to #[AccessType] attribute with specific key',
+            [
+                new CodeSample(
+                    <<<'CODE_SAMPLE'
+use JMS\Serializer\Annotation\AccessType;
+
+/** @AccessType("public_method") */
+class User
+{
+}
+CODE_SAMPLE
+                    ,
+                    <<<'CODE_SAMPLE'
+use JMS\Serializer\Annotation\AccessType;
+
+#[AccessType(values: ['public_method'])]
+class User
+{
+}
+CODE_SAMPLE
+                ),
+            ]
+        );
+    }
+
+    public function getNodeTypes(): array
+    {
+        return [Class_::class, Property::class];
+    }
+
+    /**
+     * @param Class_|Property $node
+     */
+    public function refactor(Node $node): Class_|Property|null
+    {
+        $this->annotationToAttribute = new AnnotationToAttribute(JMSAnnotation::ACCESS_TYPE);
+
+        $phpDocInfo = $this->phpDocInfoFactory->createFromNode($node);
+        if (! $phpDocInfo instanceof PhpDocInfo) {
+            return null;
+        }
+
+        $uses = $this->useImportsResolver->resolveBareUses();
+
+        // 1. Doctrine annotation classes
+        $attributeGroups = $this->processDoctrineAnnotationClasses($phpDocInfo, $uses);
+        if ($attributeGroups === []) {
+            return null;
+        }
+
+        // 2. Reprint docblock
+        $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($node);
+
+        $node->attrGroups = array_merge($node->attrGroups, $attributeGroups);
+
+        return $node;
+    }
+
+    /**
+     * @param Use_[] $uses
+     * @return AttributeGroup[]
+     */
+    private function processDoctrineAnnotationClasses(PhpDocInfo $phpDocInfo, array $uses): array
+    {
+        if ($phpDocInfo->getPhpDocNode()->children === []) {
+            return [];
+        }
+
+        $doctrineTagAndAnnotationToAttributes = [];
+        $doctrineTagValueNodes = [];
+
+        foreach ($phpDocInfo->getPhpDocNode()->children as $phpDocChildNode) {
+            if (! $phpDocChildNode instanceof PhpDocTagNode) {
+                continue;
+            }
+
+            if (! $phpDocChildNode->value instanceof DoctrineAnnotationTagValueNode) {
+                continue;
+            }
+
+            $doctrineTagValueNode = $phpDocChildNode->value;
+            if (! $doctrineTagValueNode->hasClassName(JMSAnnotation::ACCESS_TYPE)) {
+                continue;
+            }
+
+            if (! $this->isExistingAttributeClass($this->annotationToAttribute)) {
+                continue;
+            }
+
+            $doctrineTagAndAnnotationToAttributes[] = new DoctrineTagAndAnnotationToAttribute(
+                $doctrineTagValueNode,
+                $this->annotationToAttribute
+            );
+
+            $doctrineTagValueNodes[] = $doctrineTagValueNode;
+        }
+
+        $attributeGroups = $this->attrGroupsFactory->create($doctrineTagAndAnnotationToAttributes, $uses);
+
+        // correct to array!
+        $attribute = $attributeGroups[0]->attrs[0];
+
+        if (count($attribute->args) === 1) {
+            $soleArg = $attribute->args[0];
+            // wrap to array
+            $soleArg->name = new Identifier('values');
+            $soleArg->value = new Array_([new ArrayItem($soleArg->value)]);
+        }
+
+        foreach ($doctrineTagValueNodes as $doctrineTagValueNode) {
+            $this->phpDocTagRemover->removeTagValueFromNode($phpDocInfo, $doctrineTagValueNode);
+        }
+
+        return $attributeGroups;
+    }
+
+    private function isExistingAttributeClass(AnnotationToAttribute $annotationToAttribute): bool
+    {
+        // make sure the attribute class really exists to avoid error on early upgrade
+        if (! $this->reflectionProvider->hasClass($annotationToAttribute->getAttributeClass())) {
+            return false;
+        }
+
+        // make sure the class is marked as attribute
+        $classReflection = $this->reflectionProvider->getClass($annotationToAttribute->getAttributeClass());
+        return $classReflection->isAttributeClass();
+    }
+}

rules/Symfony73/GetMethodToAsTwigAttributeTransformer.php

@@ -78,7 +78,7 @@ public function transformClassGetMethodToAttributeMarker(
                 }
 
                 $nameArg = $new->getArgs()[0];
-                if (!$nameArg->value instanceof String_) {
+                if (! $nameArg->value instanceof String_) {
                     continue;
                 }
 
@@ -110,9 +110,9 @@ public function transformClassGetMethodToAttributeMarker(
         return $hasChanged;
     }
 
-    private function decorateMethodWithAttribute(ClassMethod $classMethod, string $attributeClass, Arg $name): void
+    private function decorateMethodWithAttribute(ClassMethod $classMethod, string $attributeClass, Arg $arg): void
     {
-        $classMethod->attrGroups[] = new AttributeGroup([new Attribute(new FullyQualified($attributeClass), [$name])]);
+        $classMethod->attrGroups[] = new AttributeGroup([new Attribute(new FullyQualified($attributeClass), [$arg])]);
     }
 
     private function isLocalCallable(Expr $expr): bool

rules/Symfony73/NodeAnalyzer/CommandArgumentsAndOptionsResolver.php

@@ -9,7 +9,6 @@
 use PhpParser\Node\Identifier;
 use PhpParser\Node\Scalar\String_;
 use PhpParser\Node\Stmt\ClassMethod;
-use PhpParser\NodeFinder;
 use Rector\Exception\ShouldNotHappenException;
 use Rector\PhpDocParser\NodeTraverser\SimpleCallableNodeTraverser;
 use Rector\PhpParser\Node\Value\ValueResolver;
@@ -105,7 +104,8 @@ private function findMethodCallsByName(ClassMethod $classMethod, string $desired
 
         $shouldReverse = false;
         $this->simpleCallableNodeTraverser->traverseNodesWithCallable(
-            $classMethod, function (Node $node) use (&$calls, $desiredMethodName, &$shouldReverse) {
+            $classMethod,
+            function (Node $node) use (&$calls, $desiredMethodName, &$shouldReverse): null {
                 if (! $node instanceof MethodCall) {
                     return null;
                 }
@@ -123,7 +123,8 @@ private function findMethodCallsByName(ClassMethod $classMethod, string $desired
                 }
 
                 return null;
-            });
+            }
+        );
 
         return $shouldReverse ? array_reverse($calls) : $calls;
     }

src/Enum/JMSAnnotation.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Symfony\Enum;
+
+final class JMSAnnotation
+{
+    public const ACCESS_TYPE = 'JMS\Serializer\Annotation\AccessType';
+}

stubs/JMS/Serializer/Annotation/AccessType.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace JMS\Serializer\Annotation;
+
+#[\Attribute(\Attribute::TARGET_CLASS | \Attribute::TARGET_PROPERTY)]
+class AccessType
+{
+    public function __construct(array $values = [], ?string $type = null)
+    {
+    }
+}