Symfony: Mark enum cases as used in invokable command parameters (#343)

Author: janedbal

src/Provider/SymfonyUsageProvider.php

@@ -30,6 +30,8 @@
 use RecursiveDirectoryIterator;
 use RecursiveIteratorIterator;
 use ReflectionAttribute;
+use ReflectionEnum;
+use ReflectionNamedType;
 use Reflector;
 use ShipMonk\PHPStan\DeadCode\Enum\AccessType;
 use ShipMonk\PHPStan\DeadCode\Graph\ClassConstantRef;
@@ -152,6 +154,7 @@ public function getUsages(
                 ...$this->getMethodUsagesFromReflection($node),
                 ...$this->getPropertyUsagesFromReflection($node),
                 ...$this->getConstantUsages($node->getClassReflection()),
+                ...$this->getInvokableCommandEnumUsages($node),
             ];
         }
 
@@ -1486,6 +1489,81 @@ private function getConstantUsages(ClassReflection $classReflection): array
         return $usages;
     }
 
+    /**
+     * @return list<ClassConstantUsage>
+     */
+    private function getInvokableCommandEnumUsages(InClassNode $node): array
+    {
+        $classReflection = $node->getClassReflection();
+        $nativeReflection = $classReflection->getNativeReflection();
+
+        if ($nativeReflection instanceof ReflectionEnum) {
+            return [];
+        }
+
+        $isCommand = $this->hasAttribute($nativeReflection, 'Symfony\Component\Console\Attribute\AsCommand')
+            || $nativeReflection->isSubclassOf('Symfony\Component\Console\Command\Command');
+
+        if (!$isCommand) {
+            return [];
+        }
+
+        $invokeMethod = null;
+
+        foreach ($nativeReflection->getMethods() as $method) {
+            if ($method->getName() === '__invoke') {
+                $invokeMethod = $method;
+                break;
+            }
+        }
+
+        if ($invokeMethod === null) {
+            return [];
+        }
+
+        $usages = [];
+
+        foreach ($invokeMethod->getParameters() as $parameter) {
+            $type = $parameter->getType();
+
+            if (!$type instanceof ReflectionNamedType || $type->isBuiltin()) {
+                continue;
+            }
+
+            $typeName = $type->getName();
+
+            if (!$this->reflectionProvider->hasClass($typeName)) {
+                continue;
+            }
+
+            $enumReflection = $this->reflectionProvider->getClass($typeName);
+
+            if (!$enumReflection->isBackedEnum()) {
+                continue;
+            }
+
+            $nativeEnumReflection = $enumReflection->getNativeReflection();
+
+            if (!$nativeEnumReflection instanceof ReflectionEnum) {
+                continue;
+            }
+
+            foreach ($nativeEnumReflection->getCases() as $case) {
+                $usages[] = new ClassConstantUsage(
+                    UsageOrigin::createVirtual($this, VirtualUsageData::withNote('Invokable command parameter in ' . $nativeReflection->getShortName())),
+                    new ClassConstantRef(
+                        $typeName,
+                        $case->getName(),
+                        possibleDescendant: false,
+                        isEnumCase: TrinaryLogic::createYes(),
+                    ),
+                );
+            }
+        }
+
+        return $usages;
+    }
+
     private function getContainerXmlPath(Container $container): ?string
     {
         try {

tests/Rule/data/providers/symfony.php

@@ -101,6 +101,39 @@ class HelloCommand
     public function __construct() {}
 }
 
+enum InvokableCommandMode: string {
+    case Dry = 'dry';
+    case Wet = 'wet';
+}
+
+enum InvokableCommandUnused: string {
+    case A = 'a';
+    case B = 'b'; // error: Unused Symfony\InvokableCommandUnused::B
+}
+
+enum InvokableCommandModeViaExtend: string {
+    case Fast = 'fast';
+    case Slow = 'slow';
+}
+
+#[AsCommand('app:invokable')]
+class InvokableCommand
+{
+    public function __invoke(InvokableCommandMode $mode): int
+    {
+        InvokableCommandUnused::A;
+        return 0;
+    }
+}
+
+class InvokableCommandViaExtend extends Command
+{
+    public function __invoke(InvokableCommandModeViaExtend $mode): int
+    {
+        return 0;
+    }
+}
+
 class DicClassParent { // not present in DIC, but ctor is not dead
     public function __construct() {}
 }