Reflected __construct should have object as return type

Author: paulbalandan

src/Type/ReflectionHelperGetPrivateMethodInvokerReturnTypeExtension.php

@@ -19,9 +19,12 @@
 use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\Type\ClosureType;
 use PHPStan\Type\DynamicStaticMethodReturnTypeExtension;
+use PHPStan\Type\IntersectionType;
 use PHPStan\Type\NeverType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
+use PHPStan\Type\TypeTraverser;
+use PHPStan\Type\UnionType;
 
 final class ReflectionHelperGetPrivateMethodInvokerReturnTypeExtension implements DynamicStaticMethodReturnTypeExtension
 {
@@ -53,44 +56,57 @@ public function getTypeFromStaticMethodCall(MethodReflection $methodReflection,
         $objectType = $scope->getType($args[0]->value)->getObjectTypeOrClassStringObjectType();
         $methodType = $scope->getType($args[1]->value);
 
-        if ($objectType->getObjectClassReflections() === [] && ! $objectType->isObject()->yes()) {
+        if (! $objectType->isObject()->yes()) {
             return new NeverType(true);
         }
 
-        $closures = [];
+        return TypeTraverser::map($objectType, static function (Type $type, callable $traverse) use ($methodType, $scope, $args, $methodReflection): Type {
+            if ($type instanceof UnionType || $type instanceof IntersectionType) {
+                return $traverse($type);
+            }
+
+            $closures = [];
+
+            foreach ($type->getObjectClassReflections() as $classReflection) {
+                foreach ($methodType->getConstantStrings() as $methodStringType) {
+                    $methodName = $methodStringType->getValue();
+
+                    if (! $classReflection->hasMethod($methodName)) {
+                        $closures[] = new NeverType(true);
+
+                        continue;
+                    }
+
+                    $invokedMethodReflection = $classReflection->getMethod($methodName, $scope);
 
-        foreach ($objectType->getObjectClassReflections() as $classReflection) {
-            foreach ($methodType->getConstantStrings() as $methodStringType) {
-                $methodName = $methodStringType->getValue();
+                    $parametersAcceptor = ParametersAcceptorSelector::selectFromArgs(
+                        $scope,
+                        [],
+                        $invokedMethodReflection->getVariants(),
+                        $invokedMethodReflection->getNamedArgumentsVariants(),
+                    );
 
-                if (! $classReflection->hasMethod($methodName)) {
-                    $closures[] = new NeverType(true);
+                    $returnType = strtolower($methodName) === '__construct' ? $type : $parametersAcceptor->getReturnType();
 
-                    continue;
+                    $closures[] = new ClosureType(
+                        $parametersAcceptor->getParameters(),
+                        $returnType,
+                        $parametersAcceptor->isVariadic(),
+                        $parametersAcceptor->getTemplateTypeMap(),
+                        $parametersAcceptor->getResolvedTemplateTypeMap(),
+                    );
                 }
+            }
 
-                $methodReflection   = $classReflection->getMethod($methodName, $scope);
-                $parametersAcceptor = ParametersAcceptorSelector::selectFromArgs(
+            if ($closures === []) {
+                return ParametersAcceptorSelector::selectFromArgs(
                     $scope,
                     $args,
                     $methodReflection->getVariants(),
-                    $methodReflection->getNamedArgumentsVariants(),
-                );
-
-                $closures[] = new ClosureType(
-                    $parametersAcceptor->getParameters(),
-                    $parametersAcceptor->getReturnType(),
-                    $parametersAcceptor->isVariadic(),
-                    $parametersAcceptor->getTemplateTypeMap(),
-                    $parametersAcceptor->getResolvedTemplateTypeMap(),
-                );
+                )->getReturnType();
             }
-        }
-
-        if ($closures === []) {
-            return null;
-        }
 
-        return TypeCombinator::union(...$closures);
+            return TypeCombinator::union(...$closures);
+        });
     }
 }

tests/Type/data/reflection-helper.php

@@ -59,7 +59,7 @@ public function testObjectAsObjectType(): void
             self::getPrivateMethodInvoker($object, 'run'),
         );
         assertType('Closure(object): string', self::getPrivateMethodInvoker($object, 'getVarDump'));
-        assertType('Closure(object): string', self::getPrivateMethodInvoker($object, 'getKIntD'));
+        assertType('Closure(object): string', self::getPrivateMethodInvoker($object, 'getKintD'));
     }
 
     public function testClassStringAsObjectType(): void
@@ -75,7 +75,7 @@ public function testClassStringAsObjectType(): void
 
         $object = FactoriesFunctionReturnTypeExtension::class;
         assertType(
-            'Closure(CodeIgniter\PHPStan\Type\FactoriesReturnTypeHelper): void',
+            'Closure(CodeIgniter\PHPStan\Type\FactoriesReturnTypeHelper): CodeIgniter\PHPStan\Type\FactoriesFunctionReturnTypeExtension',
             self::getPrivateMethodInvoker($object, '__construct'),
         );
         assertType(
@@ -132,7 +132,7 @@ public function testOnClassString(string $object): void
     public function testOnGenericClassString(string $class): void
     {
         assertType(
-            'Closure(Psr\Log\LoggerInterface, CodeIgniter\CLI\Commands): void',
+            'Closure(Psr\Log\LoggerInterface, CodeIgniter\CLI\Commands): CodeIgniter\Commands\Utilities\ConfigCheck',
             self::getPrivateMethodInvoker($class, '__construct'),
         );
     }
@@ -146,12 +146,12 @@ public function testOnObject(object $object): void
     }
 
     /**
-     * @param self $object
+     * @param $this $object
      */
     public function testOnObjectWithClassType(object $object): void
     {
         assertType(
-            'Closure(non-empty-string): void',
+            'Closure(non-empty-string): $this',
             self::getPrivateMethodInvoker($object, '__construct'),
         );
     }
@@ -162,7 +162,11 @@ public function testOnObjectWithClassType(object $object): void
     public function testOnUnionOfObjects(object|string $object): void
     {
         assertType(
-            '(Closure(CodeIgniter\PHPStan\Type\ServicesReturnTypeHelper): void)|(Closure(non-empty-string): void)',
+            sprintf(
+                '%s|%s',
+                '(Closure(CodeIgniter\PHPStan\Type\ServicesReturnTypeHelper): CodeIgniter\PHPStan\Type\ServicesFunctionReturnTypeExtension)',
+                '(Closure(non-empty-string): CodeIgniter\PHPStan\Tests\Fixtures\Type\ReflectionHelperGetPrivateMethodInvokerTest)',
+            ),
             self::getPrivateMethodInvoker($object, '__construct'),
         );
     }
@@ -184,7 +188,7 @@ public function testOnUnionOfStringObjectsWithOneNonClass(string $object): void
     public function testOnUnionOfMethods(string $method): void
     {
         assertType(
-            '(Closure(): void)|(Closure(non-empty-string): void)',
+            '(Closure(): void)|(Closure(non-empty-string): $this)',
             self::getPrivateMethodInvoker($this, $method),
         );
     }