Add Class_ annotation support to TemplateAnnotationToThisRenderRector

rules-tests/CodeQuality/Rector/ClassMethod/TemplateAnnotationToThisRenderRector/Fixture/class_level_annotation.php.inc

@@ -0,0 +1,36 @@
+<?php
+
+namespace AppBundle\Controller;
+
+use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;
+use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
+
+/**
+ * @Template("items_template")
+ */
+final class ClassLevelAnnotation extends AbstractController
+{
+    public function indexAction()
+    {
+        return [];
+    }
+}
+
+?>
+-----
+<?php
+
+namespace AppBundle\Controller;
+
+use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;
+use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
+
+final class ClassLevelAnnotation extends AbstractController
+{
+    public function indexAction(): \Symfony\Component\HttpFoundation\Response
+    {
+        return $this->render('items_template');
+    }
+}
+
+?>

rules/CodeQuality/Rector/ClassMethod/TemplateAnnotationToThisRenderRector.php

@@ -98,65 +98,103 @@ public function indexAction()
      */
     public function getNodeTypes(): array
     {
-        return [ClassMethod::class, Class_::class];
+        return [Class_::class];
     }
 
     /**
-     * @param Class_|ClassMethod $node
+     * @param Class_ $node
      */
     public function refactor(Node $node): ?Node
     {
-        if ($node instanceof Class_) {
-            return $this->addAbstractControllerParentClassIfMissing($node);
+        if (! $this->annotationAnalyzer->hasClassMethodWithTemplateAnnotation($node)) {
+            return null;
         }
 
-        return $this->replaceTemplateAnnotation($node);
-    }
+        $this->decorateAbstractControllerParentClass($node);
 
-    private function addAbstractControllerParentClassIfMissing(Class_ $class): ?Class_
-    {
-        if ($class->extends instanceof Name) {
-            return null;
+        $hasChanged = false;
+
+        $classDoctrineAnnotationTagValueNode = $this->annotationAnalyzer->getDoctrineAnnotationTagValueNode(
+            $node,
+            SymfonyAnnotation::TEMPLATE
+        );
+
+        foreach ($node->getMethods() as $classMethod) {
+            if (! $classMethod->isPublic()) {
+                continue;
+            }
+
+            $hasClassMethodChanged = $this->replaceTemplateAnnotation(
+                $classMethod,
+                $classDoctrineAnnotationTagValueNode
+            );
+            if ($hasClassMethodChanged) {
+                $hasChanged = true;
+            }
         }
 
-        if (! $this->annotationAnalyzer->hasClassMethodWithTemplateAnnotation($class)) {
+        if (! $hasChanged) {
             return null;
         }
 
-        $class->extends = new FullyQualified('Symfony\Bundle\FrameworkBundle\Controller\AbstractController');
+        // cleanup Class_ @Template annotaion
+        if ($classDoctrineAnnotationTagValueNode instanceof DoctrineAnnotationTagValueNode) {
+            $this->removeDoctrineAnnotationTagValueNode($node, $classDoctrineAnnotationTagValueNode);
+        }
 
-        return $class;
+        return $node;
     }
 
-    private function replaceTemplateAnnotation(ClassMethod $classMethod): ?ClassMethod
+    private function decorateAbstractControllerParentClass(Class_ $class): void
     {
+        if ($class->extends instanceof Name) {
+            return;
+        }
+
+        // this will make $this->render() method available
+        $class->extends = new FullyQualified('Symfony\Bundle\FrameworkBundle\Controller\AbstractController');
+    }
+
+    private function replaceTemplateAnnotation(
+        ClassMethod $classMethod,
+        ?DoctrineAnnotationTagValueNode $classDoctrineAnnotationTagValueNode
+    ): bool {
         if (! $classMethod->isPublic()) {
-            return null;
+            return false;
         }
 
         $doctrineAnnotationTagValueNode = $this->annotationAnalyzer->getDoctrineAnnotationTagValueNode(
             $classMethod,
             SymfonyAnnotation::TEMPLATE
         );
 
-        if (! $doctrineAnnotationTagValueNode instanceof DoctrineAnnotationTagValueNode) {
-            return null;
+        if ($doctrineAnnotationTagValueNode instanceof DoctrineAnnotationTagValueNode) {
+            return $this->refactorClassMethod($classMethod, $doctrineAnnotationTagValueNode);
         }
 
-        return $this->refactorClassMethod($classMethod, $doctrineAnnotationTagValueNode);
+        // global @Template access
+        if ($classDoctrineAnnotationTagValueNode instanceof DoctrineAnnotationTagValueNode) {
+            return $this->refactorClassMethod($classMethod, $classDoctrineAnnotationTagValueNode);
+        }
+
+        return false;
     }
 
     private function refactorClassMethod(
         ClassMethod $classMethod,
         DoctrineAnnotationTagValueNode $templateDoctrineAnnotationTagValueNode
-    ): ?ClassMethod {
+    ): bool {
         $hasThisRenderOrReturnsResponse = $this->hasLastReturnResponse($classMethod);
 
+        $hasChanged = false;
+
         $this->traverseNodesWithCallable($classMethod, function (Node $node) use (
             $templateDoctrineAnnotationTagValueNode,
             $hasThisRenderOrReturnsResponse,
-            $classMethod
+            $classMethod,
+            &$hasChanged
         ): ?int {
+
             // keep as similar type
             if ($node instanceof Closure || $node instanceof Function_) {
                 return NodeTraverser::DONT_TRAVERSE_CURRENT_AND_CHILDREN;
@@ -173,11 +211,13 @@ private function refactorClassMethod(
                 $classMethod
             );
 
+            $hasChanged = true;
+
             return null;
         });
 
         if (! $this->emptyReturnNodeFinder->hasNoOrEmptyReturns($classMethod)) {
-            return null;
+            return $hasChanged;
         }
 
         $thisRenderMethodCall = $this->thisRenderFactory->create(
@@ -188,7 +228,7 @@ private function refactorClassMethod(
 
         $this->refactorNoReturn($classMethod, $thisRenderMethodCall, $templateDoctrineAnnotationTagValueNode);
 
-        return $classMethod;
+        return true;
     }
 
     private function hasLastReturnResponse(ClassMethod $classMethod): bool
@@ -288,13 +328,13 @@ private function refactorReturnWithValue(
     }
 
     private function removeDoctrineAnnotationTagValueNode(
-        ClassMethod $classMethod,
+        Class_|ClassMethod $node,
         DoctrineAnnotationTagValueNode $doctrineAnnotationTagValueNode
     ): void {
-        $phpDocInfo = $this->phpDocInfoFactory->createFromNodeOrEmpty($classMethod);
+        $phpDocInfo = $this->phpDocInfoFactory->createFromNodeOrEmpty($node);
         $this->phpDocTagRemover->removeTagValueFromNode($phpDocInfo, $doctrineAnnotationTagValueNode);
 
-        $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($classMethod);
+        $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($node);
     }
 
     private function refactorStmtsAwareNode(

rules/Configs/Rector/Class_/ParameterBagToAutowireAttributeRector.php

@@ -34,7 +34,7 @@ final class ParameterBagToAutowireAttributeRector extends AbstractRector impleme
     private const PARAMETER_BAG_CLASS = 'Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface';
 
     public function __construct(
-        private AutowiredParamFactory $autowiredParamFactory
+        private readonly AutowiredParamFactory $autowiredParamFactory
     ) {
     }
 

src/Annotation/AnnotationAnalyzer.php

@@ -20,13 +20,18 @@ public function __construct(
 
     public function hasClassMethodWithTemplateAnnotation(Class_ $class): bool
     {
+        $classTemplateAnnotation = $this->getDoctrineAnnotationTagValueNode($class, SymfonyAnnotation::TEMPLATE);
+        if ($classTemplateAnnotation instanceof DoctrineAnnotationTagValueNode) {
+            return true;
+        }
+
         foreach ($class->getMethods() as $classMethod) {
-            $templateDoctrineAnnotationTagValueNode = $this->getDoctrineAnnotationTagValueNode(
+            $classMethodTemplateAnnotation = $this->getDoctrineAnnotationTagValueNode(
                 $classMethod,
                 SymfonyAnnotation::TEMPLATE
             );
 
-            if ($templateDoctrineAnnotationTagValueNode instanceof DoctrineAnnotationTagValueNode) {
+            if ($classMethodTemplateAnnotation instanceof DoctrineAnnotationTagValueNode) {
                 return true;
             }
         }
@@ -35,10 +40,10 @@ public function hasClassMethodWithTemplateAnnotation(Class_ $class): bool
     }
 
     public function getDoctrineAnnotationTagValueNode(
-        ClassMethod $classMethod,
+        Class_|ClassMethod $node,
         string $annotationClass
     ): ?DoctrineAnnotationTagValueNode {
-        $phpDocInfo = $this->phpDocInfoFactory->createFromNode($classMethod);
+        $phpDocInfo = $this->phpDocInfoFactory->createFromNode($node);
         if (! $phpDocInfo instanceof PhpDocInfo) {
             return null;
         }