[symfony] Add RouteGenerateControllerClassRequireNameRule

Author: TomasVotruba

src/Reflection/InvokeClassMethodResolver.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Symplify\PHPStanRules\Reflection;
+
+use PHPStan\Reflection\ClassReflection;
+use ReflectionMethod;
+
+final class InvokeClassMethodResolver
+{
+    public static function resolve(ClassReflection $controllerClassReflection): null|ReflectionMethod
+    {
+        if (! $controllerClassReflection->hasMethod('__invoke')) {
+            return null;
+        }
+
+        $nativeReflectionClass = $controllerClassReflection->getNativeReflection();
+        return $nativeReflectionClass->getMethod('__invoke');
+    }
+}

src/Rules/Symfony/RouteGenerateControllerClassRequireNameRule.php

@@ -0,0 +1,156 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Symplify\PHPStanRules\Rules\Symfony;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\Identifier;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\ClassReflection;
+use PHPStan\Reflection\ReflectionProvider;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleError;
+use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\Type\Constant\ConstantStringType;
+use PHPStan\Type\ObjectType;
+use ReflectionAttribute;
+use ReflectionMethod;
+use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
+use Symfony\Component\Routing\Route;
+
+/**
+ * To pass a controller class in $this->router->generate(SomeController::class),
+ * the controller must be present #[Route(name:: self::class)
+ *
+ * @see https://symfony.com/blog/new-in-symfony-6-4-fqcn-based-routes
+ *
+ * @implements Rule<MethodCall>
+ *
+ * @see \Symplify\PHPStanRules\Tests\Rules\Symfony\RouteGenerateControllerClassRequireNameRule\RouteGenerateControllerClassRequireNameRuleTest
+ */
+final readonly class RouteGenerateControllerClassRequireNameRule implements Rule
+{
+    /**
+     * @api
+     * @var string
+     */
+    public const ERROR_MESSAGE = 'To pass a controller class to generate() method, the controller must have "#[Route(name: self::class)]" above the __invoke() method';
+
+    /**
+     * @var string
+     */
+    private const IDENTIFIER = 'be5.routeGenerateControllerName';
+
+    public function __construct(
+        private ReflectionProvider $reflectionProvider,
+    ) {
+    }
+
+    public function getNodeType(): string
+    {
+        return MethodCall::class;
+    }
+
+    /**
+     * @param MethodCall $node
+     * @return RuleError[]
+     */
+    public function processNode(Node $node, Scope $scope): array
+    {
+        if (! $this->isRouterGenerateMethodCall($node, $scope)) {
+            return [];
+        }
+
+        $controllerClassReflection = $this->matchControllerFirstArgClassReflection($node, $scope);
+
+        // the used argument is not a class reference
+        if (! $controllerClassReflection instanceof ClassReflection) {
+            return [];
+        }
+
+        $invokeClassMethodReflection = \Symplify\PHPStanRules\Reflection\InvokeClassMethodResolver::resolve($controllerClassReflection);
+
+        // there must be __invoke() method
+        if (! $invokeClassMethodReflection instanceof ReflectionMethod) {
+            return [RuleErrorBuilder::message(self::ERROR_MESSAGE)->identifier(self::IDENTIFIER)->build()];
+        }
+
+        $routeAttributes = $this->findRouteAttributes($invokeClassMethodReflection);
+        if ($this->hasAtLeastOneRouteWithSelfClassName($routeAttributes, $controllerClassReflection)) {
+            return [];
+        }
+
+        return [RuleErrorBuilder::message(self::ERROR_MESSAGE)->identifier(self::IDENTIFIER)->build()];
+    }
+
+    private function isRouterGenerateMethodCall(MethodCall $methodCall, Scope $scope): bool
+    {
+        if ($methodCall->isFirstClassCallable()) {
+            return false;
+        }
+
+        if (! $methodCall->name instanceof Identifier) {
+            return false;
+        }
+
+        if ($methodCall->name->toString() !== 'generate') {
+            return false;
+        }
+
+        $callerType = $scope->getType($methodCall->var);
+        if (! $callerType instanceof ObjectType) {
+            return false;
+        }
+
+        return $callerType->isInstanceOf(UrlGeneratorInterface::class)->yes();
+    }
+
+    private function matchControllerFirstArgClassReflection(MethodCall $methodCall, Scope $scope): ?ClassReflection
+    {
+        $firstArg = $methodCall->getArgs()[0];
+        $argType = $scope->getType($firstArg->value);
+
+        // we look for a controller class reference
+        if (! $argType instanceof ConstantStringType) {
+            return null;
+        }
+
+        $controllerClass = $argType->getValue();
+        if (! $this->reflectionProvider->hasClass($controllerClass)) {
+            return null;
+        }
+
+        return $this->reflectionProvider->getClass($controllerClass);
+    }
+
+    /**
+     * @return ReflectionAttribute[]
+     */
+    private function findRouteAttributes(ReflectionMethod $reflectionMethod): array
+    {
+        return array_merge(
+            $reflectionMethod->getAttributes(\Symfony\Component\Routing\Attribute\Route::class),
+            $reflectionMethod->getAttributes(Route::class),
+            $reflectionMethod->getAttributes(\Symfony\Component\Routing\Annotation\Route::class)
+        );
+    }
+
+    /**
+     * @param ReflectionAttribute[] $routeAttributes
+     */
+    private function hasAtLeastOneRouteWithSelfClassName(array $routeAttributes, ClassReflection $classReflection): bool
+    {
+        foreach ($routeAttributes as $routeAttribute) {
+            $routeName = $routeAttribute->getArguments()['name'] ?? null;
+
+            // name must be same as current controller class
+            if ($routeName === $classReflection->getName()) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

tests/Rules/Symfony/RouteGenerateControllerClassRequireNameRule/Fixture/CallingControllerWithWrongString.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Symplify\PHPStanRules\Tests\Rules\Symfony\RouteGenerateControllerClassRequireNameRule\Fixture;
+
+use Symfony\Component\Routing\RouterInterface;
+use Symplify\PHPStanRules\Tests\Rules\Symfony\RouteGenerateControllerClassRequireNameRule\Source\SomeControllerWithStringNameClass;
+
+final class CallingControllerWithWrongString
+{
+    public function run(RouterInterface $router)
+    {
+        $url = $router->generate(SomeControllerWithStringNameClass::class);
+    }
+}

tests/Rules/Symfony/RouteGenerateControllerClassRequireNameRule/Fixture/CallingControllerWithoutInvoke.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Symplify\PHPStanRules\Tests\Rules\Symfony\RouteGenerateControllerClassRequireNameRule\Fixture;
+
+use Symfony\Component\Routing\RouterInterface;
+use Symplify\PHPStanRules\Tests\Rules\Symfony\RouteGenerateControllerClassRequireNameRule\Source\WithoutInvokeController;
+
+final class CallingControllerWithoutInvoke
+{
+    public function run(RouterInterface $router)
+    {
+        $url = $router->generate(WithoutInvokeController::class);
+    }
+}

tests/Rules/Symfony/RouteGenerateControllerClassRequireNameRule/Fixture/CallingCorrectController.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Symplify\PHPStanRules\Tests\Rules\Symfony\RouteGenerateControllerClassRequireNameRule\Fixture;
+
+use Symfony\Component\Routing\RouterInterface;
+use Symplify\PHPStanRules\Tests\Rules\Symfony\RouteGenerateControllerClassRequireNameRule\Source\SomeControllerWithRouteClass;
+
+final class CallingCorrectController
+{
+    public function run(RouterInterface $router)
+    {
+        $url = $router->generate(SomeControllerWithRouteClass::class);
+    }
+}

tests/Rules/Symfony/RouteGenerateControllerClassRequireNameRule/Fixture/CallingWrongController.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Symplify\PHPStanRules\Tests\Rules\Symfony\RouteGenerateControllerClassRequireNameRule\Fixture;
+
+use Symfony\Component\Routing\RouterInterface;
+use Symplify\PHPStanRules\Tests\Rules\Symfony\RouteGenerateControllerClassRequireNameRule\Source\SomeControllerWIthoutRouteClass;
+
+final class CallingWrongController
+{
+    public function run(RouterInterface $router)
+    {
+        $url = $router->generate(SomeControllerWIthoutRouteClass::class);
+    }
+}

tests/Rules/Symfony/RouteGenerateControllerClassRequireNameRule/Fixture/TwoRoutes.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Symplify\PHPStanRules\Tests\Rules\Symfony\RouteGenerateControllerClassRequireNameRule\Fixture;
+
+use Symfony\Component\Routing\RouterInterface;
+use Symplify\PHPStanRules\Tests\Rules\Symfony\RouteGenerateControllerClassRequireNameRule\Source\TwoRoutesController;
+
+final class TwoRoutes
+{
+    public function run(RouterInterface $router)
+    {
+        $url = $router->generate(TwoRoutesController::class);
+    }
+}

tests/Rules/Symfony/RouteGenerateControllerClassRequireNameRule/RouteGenerateControllerClassRequireNameRuleTest.php

@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Symplify\PHPStanRules\Tests\Rules\Symfony\RouteGenerateControllerClassRequireNameRule;
+
+use Iterator;
+use PHPStan\Reflection\ReflectionProvider;
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Symplify\PHPStanRules\Rules\Symfony\RouteGenerateControllerClassRequireNameRule;
+
+/**
+ * @extends RuleTestCase<RouteGenerateControllerClassRequireNameRule>
+ */
+final class RouteGenerateControllerClassRequireNameRuleTest extends RuleTestCase
+{
+    /**
+     * @param mixed[] $expectedErrorMessagesWithLines
+     */
+    #[DataProvider('provideData')]
+    public function testRule(string $filePath, array $expectedErrorMessagesWithLines): void
+    {
+        $this->analyse([$filePath], $expectedErrorMessagesWithLines);
+    }
+
+    public static function provideData(): Iterator
+    {
+        yield [__DIR__ . '/Fixture/CallingCorrectController.php', []];
+        yield [__DIR__ . '/Fixture/TwoRoutes.php', []];
+
+        yield [__DIR__ . '/Fixture/CallingWrongController.php', [
+            [RouteGenerateControllerClassRequireNameRule::ERROR_MESSAGE, 14],
+        ]];
+
+        yield [__DIR__ . '/Fixture/CallingControllerWithoutInvoke.php', [
+            [RouteGenerateControllerClassRequireNameRule::ERROR_MESSAGE, 14],
+        ]];
+
+        yield [__DIR__ . '/Fixture/CallingControllerWithWrongString.php', [
+            [RouteGenerateControllerClassRequireNameRule::ERROR_MESSAGE, 14],
+        ]];
+    }
+
+    protected function getRule(): Rule
+    {
+        $reflectionProvider = self::getContainer()->getByType(ReflectionProvider::class);
+
+        return new RouteGenerateControllerClassRequireNameRule($reflectionProvider);
+    }
+}

tests/Rules/Symfony/RouteGenerateControllerClassRequireNameRule/Source/SomeControllerWIthoutRouteClass.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Symplify\PHPStanRules\Tests\Rules\Symfony\RouteGenerateControllerClassRequireNameRule\Source;
+
+use Symfony\Component\Routing\Attribute\Route;
+
+class SomeControllerWIthoutRouteClass
+{
+    #[Route()]
+    public function __invoke()
+    {
+    }
+}

tests/Rules/Symfony/RouteGenerateControllerClassRequireNameRule/Source/SomeControllerWithRouteClass.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Symplify\PHPStanRules\Tests\Rules\Symfony\RouteGenerateControllerClassRequireNameRule\Source;
+
+use Symfony\Component\Routing\Attribute\Route;
+
+class SomeControllerWithRouteClass
+{
+    #[Route(name: self::class)]
+    public function __invoke()
+    {
+    }
+}