Support ReflectionClass calls without generic type specified

Author: janedbal

src/Provider/ReflectionUsageProvider.php

@@ -11,7 +11,6 @@
 use PhpParser\Node\Expr\NullsafeMethodCall;
 use PhpParser\Node\Expr\StaticCall;
 use PHPStan\Analyser\Scope;
-use PHPStan\Reflection\ClassReflection;
 use ReflectionClass;
 use ShipMonk\PHPStan\DeadCode\Graph\ClassConstantRef;
 use ShipMonk\PHPStan\DeadCode\Graph\ClassConstantUsage;
@@ -68,14 +67,18 @@ private function processMethodCall(MethodCall $node, Scope $scope): array
                 // ideally, we should check if T is covariant (marks children as used) or invariant (should not mark children as used)
                 // the default changed in PHP 8.4, see: https://github.com/phpstan/phpstan/issues/12459#issuecomment-2607123277
                 foreach ($reflection->getActiveTemplateTypeMap()->getTypes() as $genericType) {
-                    foreach ($genericType->getObjectClassReflections() as $genericReflection) {
+                    $genericClassNames = $genericType->getObjectClassNames() === []
+                        ? [null] // call over ReflectionClass without specifying the generic type
+                        : $genericType->getObjectClassNames();
+
+                    foreach ($genericClassNames as $genericClassName) {
                         $usedConstants = [
                             ...$usedConstants,
-                            ...$this->extractConstantsUsedByReflection($methodName, $genericReflection, $node->getArgs(), $node, $scope),
+                            ...$this->extractConstantsUsedByReflection($genericClassName, $methodName, $node->getArgs(), $node, $scope),
                         ];
                         $usedMethods = [
                             ...$usedMethods,
-                            ...$this->extractMethodsUsedByReflection($methodName, $genericReflection, $node->getArgs(), $node, $scope),
+                            ...$this->extractMethodsUsedByReflection($genericClassName, $methodName, $node->getArgs(), $node, $scope),
                         ];
                     }
                 }
@@ -93,8 +96,8 @@ private function processMethodCall(MethodCall $node, Scope $scope): array
      * @return list<ClassConstantUsage>
      */
     private function extractConstantsUsedByReflection(
+        ?string $genericClassName,
         string $methodName,
-        ClassReflection $genericReflection,
         array $args,
         Node $node,
         Scope $scope
@@ -103,14 +106,14 @@ private function extractConstantsUsedByReflection(
         $usedConstants = [];
 
         if ($methodName === 'getConstants' || $methodName === 'getReflectionConstants') {
-            $usedConstants[] = $this->createConstantUsage($node, $scope, $genericReflection->getName(), null);
+            $usedConstants[] = $this->createConstantUsage($node, $scope, $genericClassName, null);
         }
 
         if (($methodName === 'getConstant' || $methodName === 'getReflectionConstant') && count($args) === 1) {
             $firstArg = $args[array_key_first($args)];
 
             foreach ($scope->getType($firstArg->value)->getConstantStrings() as $constantString) {
-                $usedConstants[] = $this->createConstantUsage($node, $scope, $genericReflection->getName(), $constantString->getValue());
+                $usedConstants[] = $this->createConstantUsage($node, $scope, $genericClassName, $constantString->getValue());
             }
         }
 
@@ -122,8 +125,8 @@ private function extractConstantsUsedByReflection(
      * @return list<ClassMethodUsage>
      */
     private function extractMethodsUsedByReflection(
+        ?string $genericClassName,
         string $methodName,
-        ClassReflection $genericReflection,
         array $args,
         Node $node,
         Scope $scope
@@ -132,23 +135,19 @@ private function extractMethodsUsedByReflection(
         $usedMethods = [];
 
         if ($methodName === 'getMethods') {
-            $usedMethods[] = $this->createMethodUsage($node, $scope, $genericReflection->getName(), null);
+            $usedMethods[] = $this->createMethodUsage($node, $scope, $genericClassName, null);
         }
 
         if ($methodName === 'getMethod' && count($args) === 1) {
             $firstArg = $args[array_key_first($args)];
 
             foreach ($scope->getType($firstArg->value)->getConstantStrings() as $constantString) {
-                $usedMethods[] = $this->createMethodUsage($node, $scope, $genericReflection->getName(), $constantString->getValue());
+                $usedMethods[] = $this->createMethodUsage($node, $scope, $genericClassName, $constantString->getValue());
             }
         }
 
         if (in_array($methodName, ['getConstructor', 'newInstance', 'newInstanceArgs'], true)) {
-            $constructor = $genericReflection->getNativeReflection()->getConstructor();
-
-            if ($constructor !== null) {
-                $usedMethods[] = $this->createMethodUsage($node, $scope, $constructor->getDeclaringClass()->getName(), '__construct');
-            }
+            $usedMethods[] = $this->createMethodUsage($node, $scope, $genericClassName, '__construct');
         }
 
         return $usedMethods;
@@ -180,7 +179,7 @@ private function getMethodNames(CallLike $call, Scope $scope): array
     private function createConstantUsage(
         Node $node,
         Scope $scope,
-        string $className,
+        ?string $className,
         ?string $constantName
     ): ClassConstantUsage
     {
@@ -197,7 +196,7 @@ private function createConstantUsage(
     private function createMethodUsage(
         Node $node,
         Scope $scope,
-        string $className,
+        ?string $className,
         ?string $methodName
     ): ClassMethodUsage
     {

tests/Rule/DeadCodeRuleTest.php

@@ -678,6 +678,7 @@ public static function provideFiles(): Traversable
         // providers
         yield 'provider-vendor' => [__DIR__ . '/data/providers/vendor.php'];
         yield 'provider-reflection' => [__DIR__ . '/data/providers/reflection.php', self::requiresPhp(8_01_00)];
+        yield 'provider-reflection-no-t' => [__DIR__ . '/data/providers/reflection-no-generics.php'];
         yield 'provider-symfony' => [__DIR__ . '/data/providers/symfony.php', self::requiresPhp(8_00_00)];
         yield 'provider-symfony-7.1' => [__DIR__ . '/data/providers/symfony-gte71.php', self::requiresPhp(8_00_00) && self::requiresPackage('symfony/dependency-injection', '>= 7.1')];
         yield 'provider-phpunit' => [__DIR__ . '/data/providers/phpunit.php', self::requiresPhp(8_00_00)];

tests/Rule/data/providers/reflection-no-generics.php

@@ -0,0 +1,32 @@
+<?php declare(strict_types = 1);
+
+namespace ReflectionNoGenerics;
+
+interface MyParent
+{
+    const CONST1 = 1;
+
+    public function bar();
+}
+
+class Holder2
+{
+    const CONST1 = 1;
+    const CONST2 = 2; // error: Unused ReflectionNoGenerics\Holder2::CONST2
+
+    public function foo() {} // error: Unused ReflectionNoGenerics\Holder2::foo
+}
+
+class Holder3
+{
+    const CONST1 = 1;
+    const CONST2 = 2; // error: Unused ReflectionNoGenerics\Holder3::CONST2
+
+    public function bar() {}
+}
+
+function testNoGenericTypeKnown(\ReflectionClass $reflection) {
+    echo $reflection->getConstant('CONST1'); // marks all constants named CONST1 as used
+    echo $reflection->getMethod('bar'); // marks all methods named bar as used
+    echo $reflection->getMethods(); // we ignore mixed over mixed calls
+}

tests/Rule/data/providers/reflection.php

@@ -127,3 +127,14 @@ function testMemberOnlyInDescendant(string $fqn) {
         echo $classReflection->getConstant('NOT_IN_PARENT');
     }
 }
+
+/**
+ * @param class-string<HolderParent> $fqn
+ */
+function testNoGenericTypeKnown(string $fqn) {
+    $classReflection = new \ReflectionClass($fqn);
+
+    if ($classReflection->hasConstant('NOT_IN_PARENT')) {
+        echo $classReflection->getConstant('NOT_IN_PARENT');
+    }
+}