[TASK] Refactor and improve GeneralUtilityDynamicReturnTypeExtension

Author: alexanderschnitzler

phpstan.neon

@@ -6,4 +6,4 @@ parameters:
 
   paths:
     - %currentWorkingDirectory%/src/
-    - %currentWorkingDirectory%/tests/
+    - %currentWorkingDirectory%/tests/Unit/

src/Type/GeneralUtilityDynamicReturnTypeExtension.php

@@ -4,17 +4,19 @@
 
 namespace FriendsOfTYPO3\PHPStan\TYPO3\Type;
 
-use PhpParser\Node\Arg;
-use PhpParser\Node\Expr;
+use PhpParser\Node\Arg as ArgumentNode;
 use PhpParser\Node\Expr\ClassConstFetch;
 use PhpParser\Node\Expr\StaticCall;
 use PhpParser\Node\Name;
+use PhpParser\Node\Scalar\String_ as StringNode;
 use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\ClassReflection;
 use PHPStan\Reflection\MethodReflection;
 use PHPStan\Type\DynamicStaticMethodReturnTypeExtension;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\ObjectWithoutClassType;
-use PHPStan\Type\Type;
+use PHPStan\Type\StaticType;
+use PHPStan\Type\Type as TypeInterface;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
 
 class GeneralUtilityDynamicReturnTypeExtension implements DynamicStaticMethodReturnTypeExtension
@@ -29,32 +31,84 @@ public function isStaticMethodSupported(MethodReflection $methodReflection): boo
         return $methodReflection->getName() === 'makeInstance';
     }
 
-    public function getTypeFromStaticMethodCall(MethodReflection $methodReflection, StaticCall $methodCall, Scope $scope): Type
+    public function getTypeFromStaticMethodCall(MethodReflection $methodReflection, StaticCall $methodCall, Scope $scope): TypeInterface
     {
-        if (empty($methodCall->args)) {
+        try {
+            $classNameArgument = $this->fetchClassNameArgument($methodCall);
+            $classNameArgumentValueExpression = $classNameArgument->value;
+
+            switch (true) {
+                case $classNameArgumentValueExpression instanceof StringNode:
+                    /*
+                     * Examples:
+                     *
+                     * - GeneralUtility::makeInstance('foo')
+                     * - GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\DataHandling\\DataHandler')
+                     */
+                    return $this->createObjectTypeFromString($classNameArgumentValueExpression);
+                case $classNameArgumentValueExpression instanceof ClassConstFetch:
+                    /*
+                     * Examples:
+                     *
+                     * - GeneralUtility::makeInstance(TYPO3\CMS\Core\DataHandling\DataHandler::class)
+                     * - GeneralUtility::makeInstance(self::class)
+                     * - GeneralUtility::makeInstance(static::class)
+                     */
+                    return $this->createObjectTypeFromClassConstFetch($classNameArgumentValueExpression, $scope->getClassReflection());
+                default:
+                    throw new \InvalidArgumentException(
+                        'Argument $className is neither a string nor a class constant',
+                        1584879239
+                    );
+            }
+        } catch (\Throwable $exception) {
             return new ObjectWithoutClassType();
         }
+    }
 
-        /** @var Arg $argument */
-        $argument = $methodCall->args[0];
+    private function fetchClassNameArgument(StaticCall $methodCall): ArgumentNode
+    {
+        if (empty($methodCall->args)) {
+            /*
+             * This usually does not happen as calling GeneralUtility::makeInstance() without the mandatory argument
+             * $className results in a syntax error.
+             */
+            throw new \LogicException('Method makeInstance is called without arguments.', 1584878263);
+        }
 
-        /** @var Expr $argumentValue */
-        $argumentValue = $argument->value;
+        return $methodCall->args[0];
+    }
 
-        if (!$argumentValue instanceof ClassConstFetch) {
-            return new ObjectWithoutClassType();
+    private function createObjectTypeFromString(StringNode $string): TypeInterface
+    {
+        $className = $string->value;
+
+        if (!class_exists($className)) {
+            throw new \LogicException('makeInstance has been called with non class name string', 1584879581);
         }
-        /** @var ClassConstFetch $argumentValue */
 
-        $class = $argumentValue->class;
+        return new ObjectType($className);
+    }
 
+    private function createObjectTypeFromClassConstFetch(ClassConstFetch $expression, ?ClassReflection $classReflection): TypeInterface
+    {
+        $class = $expression->class;
         if (!$class instanceof Name) {
-            return new ObjectWithoutClassType();
+            throw new \LogicException('', 1584878823);
         }
         /** @var Name $class */
 
         $className = $class->toString();
 
+        if ($className === 'self' && $classReflection !== null) {
+            return new ObjectType($classReflection->getName());
+        }
+
+        if ($className === 'static' && $classReflection !== null) {
+            $callingClass = $classReflection->getName();
+            return new StaticType($callingClass);
+        }
+
         return new ObjectType($className);
     }
 }

tests/Fixtures/MakeInstanceCallWithClassConstant.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace FriendsOfTYPO3\PHPStan\TYPO3\Tests\Fixtures;
+
+use TYPO3\CMS\Core\DataHandling\DataHandler;
+use TYPO3\CMS\Core\Utility\GeneralUtility;
+
+$object = GeneralUtility::makeInstance(DataHandler::class);
+$object->storeLogMessages = true;

tests/Fixtures/MakeInstanceCallWithClassString.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace FriendsOfTYPO3\PHPStan\TYPO3\Tests\Fixtures;
+
+use TYPO3\CMS\Core\Utility\GeneralUtility;
+
+$object = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\DataHandling\\DataHandler');
+$object->storeLogMessages = true;

tests/Fixtures/MakeInstanceCallWithSelf.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace FriendsOfTYPO3\PHPStan\TYPO3\Tests\Fixtures;
+
+use TYPO3\CMS\Core\Utility\GeneralUtility;
+
+class MakeInstanceCallWithSelf
+{
+    public function create(): self
+    {
+        return GeneralUtility::makeInstance(self::class);
+    }
+}

tests/Fixtures/MakeInstanceCallWithStatic.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace FriendsOfTYPO3\PHPStan\TYPO3\Tests\Fixtures;
+
+use TYPO3\CMS\Core\Utility\GeneralUtility;
+
+class MakeInstanceCallWithStatic
+{
+    public function create(): self
+    {
+        return GeneralUtility::makeInstance(static::class);
+    }
+}