[code-quality] Add attribute support (#702)

Author: TomasVotruba

rules-tests/CodeQuality/Rector/Class_/InlineClassRoutePrefixRector/Fixture/attribute_routing_class.php.inc

@@ -0,0 +1,34 @@
+<?php
+
+namespace Rector\Symfony\Tests\CodeQuality\Rector\Class_\InlineClassRoutePrefixRector\Fixture;
+
+use Symfony\Bundle\FrameworkBundle\Controller\Controller;
+use Symfony\Component\Routing\Annotation\Route;
+
+#[\Symfony\Component\Routing\Attribute\Route("/city")]
+final class AttributeRoutingClass extends Controller
+{
+    #[\Symfony\Component\Routing\Attribute\Route("/street")]
+    public function some()
+    {
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Symfony\Tests\CodeQuality\Rector\Class_\InlineClassRoutePrefixRector\Fixture;
+
+use Symfony\Bundle\FrameworkBundle\Controller\Controller;
+use Symfony\Component\Routing\Annotation\Route;
+
+final class AttributeRoutingClass extends Controller
+{
+    #[\Symfony\Component\Routing\Attribute\Route('/city/street')]
+    public function some()
+    {
+    }
+}
+
+?>

rules/CodeQuality/Rector/Class_/InlineClassRoutePrefixRector.php

@@ -5,18 +5,20 @@
 namespace Rector\Symfony\CodeQuality\Rector\Class_;
 
 use PhpParser\Node;
-use PhpParser\Node\Name;
+use PhpParser\Node\Attribute;
+use PhpParser\Node\Scalar\String_;
 use PhpParser\Node\Stmt\Class_;
 use Rector\BetterPhpDocParser\PhpDoc\ArrayItemNode;
 use Rector\BetterPhpDocParser\PhpDoc\DoctrineAnnotationTagValueNode;
 use Rector\BetterPhpDocParser\PhpDoc\StringNode;
-use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfo;
 use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory;
 use Rector\BetterPhpDocParser\PhpDocManipulator\PhpDocTagRemover;
 use Rector\Comments\NodeDocBlock\DocBlockUpdater;
+use Rector\Doctrine\NodeAnalyzer\AttrinationFinder;
 use Rector\Rector\AbstractRector;
 use Rector\Symfony\Enum\FosAnnotation;
 use Rector\Symfony\Enum\SymfonyAnnotation;
+use Rector\Symfony\Enum\SymfonyAttribute;
 use Rector\Symfony\TypeAnalyzer\ControllerAnalyzer;
 use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
 use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
@@ -29,17 +31,23 @@ final class InlineClassRoutePrefixRector extends AbstractRector
     /**
      * @var string[]
      */
-    private const SKIPPED_ANNOTATIONS = [
+    private const FOS_REST_ANNOTATIONS = [
         FosAnnotation::REST_POST,
         FosAnnotation::REST_GET,
         FosAnnotation::REST_ROUTE,
     ];
 
+    /**
+     * @var string
+     */
+    private const PATH = 'path';
+
     public function __construct(
         private readonly PhpDocInfoFactory $phpDocInfoFactory,
         private readonly PhpDocTagRemover $phpDocTagRemover,
         private readonly DocBlockUpdater $docBlockUpdater,
         private readonly ControllerAnalyzer $controllerAnalyzer,
+        private readonly AttrinationFinder $attrinationFinder
     ) {
     }
 
@@ -80,7 +88,6 @@ public function action()
 }
 CODE_SAMPLE
                 ),
-
             ]
         );
     }
@@ -99,109 +106,150 @@ public function refactor(Node $node): ?Class_
             return null;
         }
 
-        // 1. detect and remove class-level Route annotation
-        $classPhpDocInfo = $this->phpDocInfoFactory->createFromNode($node);
-        if (! $classPhpDocInfo instanceof PhpDocInfo) {
-            return null;
-        }
+        $classRoutePath = null;
 
-        $classRouteTagValueNode = $classPhpDocInfo->getByAnnotationClass(SymfonyAnnotation::ROUTE);
-        if (! $classRouteTagValueNode instanceof DoctrineAnnotationTagValueNode) {
-            return null;
-        }
+        // 1. detect attribute
+        $routeAttributeOrAnnotation = $this->attrinationFinder->getByMany(
+            $node,
+            [SymfonyAttribute::ROUTE, SymfonyAnnotation::ROUTE]
+        );
 
-        $classRoutePathNode = $classRouteTagValueNode->getSilentValue() ?: $classRouteTagValueNode->getValue('path');
-        if (! $classRoutePathNode instanceof ArrayItemNode) {
-            return null;
+        if ($routeAttributeOrAnnotation instanceof DoctrineAnnotationTagValueNode) {
+            $classRoutePath = $this->resolveRoutePath($routeAttributeOrAnnotation);
+        } elseif ($routeAttributeOrAnnotation instanceof Attribute) {
+            $classRoutePath = $this->resolveRoutePathFromAttribute($routeAttributeOrAnnotation);
         }
 
-        if (! $classRoutePathNode->value instanceof StringNode) {
+        if ($classRoutePath === null) {
             return null;
         }
 
-        $classRoutePath = $classRoutePathNode->value->value;
-
         // 2. inline prefix to all method routes
         $hasChanged = false;
 
         foreach ($node->getMethods() as $classMethod) {
-            if (! $classMethod->isPublic()) {
-                continue;
-            }
-
-            if ($classMethod->isMagic()) {
+            if (! $classMethod->isPublic() || $classMethod->isMagic()) {
                 continue;
             }
 
             // can be route method
-            $methodPhpDocInfo = $this->phpDocInfoFactory->createFromNode($classMethod);
-            if (! $methodPhpDocInfo instanceof PhpDocInfo) {
-                continue;
-            }
-
-            $methodRouteTagValueNodes = $methodPhpDocInfo->findByAnnotationClass(SymfonyAnnotation::ROUTE);
-            foreach ($methodRouteTagValueNodes as $methodRouteTagValueNode) {
-                $routePathArrayItemNode = $methodRouteTagValueNode->getSilentValue() ?? $methodRouteTagValueNode->getValue(
-                    'path'
-                );
-                if (! $routePathArrayItemNode instanceof ArrayItemNode) {
-                    continue;
-                }
-
-                if (! $routePathArrayItemNode->value instanceof StringNode) {
-                    continue;
+            $methodRouteAnnotationOrAttributes = $this->attrinationFinder->findManyByMany(
+                $classMethod,
+                [SymfonyAttribute::ROUTE, SymfonyAnnotation::ROUTE]
+            );
+
+            foreach ($methodRouteAnnotationOrAttributes as $methodRouteAnnotationOrAttribute) {
+                if ($methodRouteAnnotationOrAttribute instanceof DoctrineAnnotationTagValueNode) {
+                    $routePathArrayItemNode = $methodRouteAnnotationOrAttribute->getSilentValue() ?? $methodRouteAnnotationOrAttribute->getValue(
+                        self::PATH
+                    );
+                    if (! $routePathArrayItemNode instanceof ArrayItemNode) {
+                        continue;
+                    }
+
+                    if (! $routePathArrayItemNode->value instanceof StringNode) {
+                        continue;
+                    }
+
+                    $methodPrefix = $routePathArrayItemNode->value;
+                    $newMethodPath = $classRoutePath . $methodPrefix->value;
+
+                    $routePathArrayItemNode->value = new StringNode($newMethodPath);
+                    $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($classMethod);
+
+                    $hasChanged = true;
+                } elseif ($methodRouteAnnotationOrAttribute instanceof Attribute) {
+                    foreach ($methodRouteAnnotationOrAttribute->args as $methodRouteArg) {
+                        if ($methodRouteArg->name === null || $methodRouteArg->name->toString() === self::PATH) {
+                            if (! $methodRouteArg->value instanceof String_) {
+                                continue;
+                            }
+
+                            $methodRouteString = $methodRouteArg->value;
+                            $methodRouteArg->value = new String_(sprintf(
+                                '%s%s',
+                                $classRoutePath,
+                                $methodRouteString->value
+                            ));
+
+                            $hasChanged = true;
+                        }
+                    }
                 }
-
-                $methodPrefix = $routePathArrayItemNode->value;
-                $newMethodPath = $classRoutePath . $methodPrefix->value;
-
-                $routePathArrayItemNode->value = new StringNode($newMethodPath);
-                $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($classMethod);
-
-                $hasChanged = true;
             }
         }
 
         if (! $hasChanged) {
             return null;
         }
 
-        $this->phpDocTagRemover->removeTagValueFromNode($classPhpDocInfo, $classRouteTagValueNode);
-        $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($node);
+        if ($routeAttributeOrAnnotation instanceof DoctrineAnnotationTagValueNode) {
+            $classPhpDocInfo = $this->phpDocInfoFactory->createFromNodeOrEmpty($node);
+
+            $this->phpDocTagRemover->removeTagValueFromNode($classPhpDocInfo, $routeAttributeOrAnnotation);
+            $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($node);
+        } else {
+            foreach ($node->attrGroups as $attrGroupKey => $attrGroup) {
+                foreach ($attrGroup->attrs as $attribute) {
+                    if ($attribute === $routeAttributeOrAnnotation) {
+                        unset($node->attrGroups[$attrGroupKey]);
+                    }
+                }
+            }
+        }
 
         return $node;
     }
 
     private function shouldSkipClass(Class_ $class): bool
     {
-        if (! $class->extends instanceof Name) {
-            return true;
-        }
-
         if (! $this->controllerAnalyzer->isController($class)) {
             return true;
         }
 
         foreach ($class->getMethods() as $classMethod) {
-            if (! $classMethod->isPublic()) {
-                continue;
-            }
-
-            if ($classMethod->isMagic()) {
-                continue;
-            }
-
-            $classMethodPhpDocInfo = $this->phpDocInfoFactory->createFromNode($classMethod);
-            if (! $classMethodPhpDocInfo instanceof PhpDocInfo) {
+            if (! $classMethod->isPublic() || $classMethod->isMagic()) {
                 continue;
             }
 
             // special cases for FOS rest that should be skipped
-            if ($classMethodPhpDocInfo->hasByAnnotationClasses(self::SKIPPED_ANNOTATIONS)) {
+            if ($this->attrinationFinder->hasByMany($class, self::FOS_REST_ANNOTATIONS)) {
                 return true;
             }
         }
 
         return false;
     }
+
+    private function resolveRoutePath(DoctrineAnnotationTagValueNode $doctrineAnnotationTagValueNode): ?string
+    {
+        $classRoutePathNode = $doctrineAnnotationTagValueNode->getSilentValue() ?: $doctrineAnnotationTagValueNode->getValue(
+            self::PATH
+        );
+
+        if (! $classRoutePathNode instanceof ArrayItemNode) {
+            return null;
+        }
+
+        if (! $classRoutePathNode->value instanceof StringNode) {
+            return null;
+        }
+
+        return $classRoutePathNode->value->value;
+    }
+
+    private function resolveRoutePathFromAttribute(Attribute $attribute): ?string
+    {
+        foreach ($attribute->args as $arg) {
+            // silent or "path"
+            if ($arg->name === null || $arg->name->toString() === self::PATH) {
+                $routeExpr = $arg->value;
+                if ($routeExpr instanceof String_) {
+                    return $routeExpr->value;
+                }
+            }
+        }
+
+        return null;
+    }
 }

src/Enum/SymfonyAttribute.php

@@ -15,4 +15,9 @@ final class SymfonyAttribute
      * @var string
      */
     public const EVENT_LISTENER_ATTRIBUTE = 'Symfony\Component\EventDispatcher\Attribute\AsEventListener';
+
+    /**
+     * @var string
+     */
+    public const ROUTE = 'Symfony\Component\Routing\Attribute\Route';
 }