TASK: Add PropertyMapperReturnTypeExtension

Resolves: #69

Author: sabbelasichon

extension.neon

@@ -77,6 +77,10 @@ services:
             - phpstan.broker.dynamicMethodReturnTypeExtension
     -
         class: SaschaEgerer\PhpstanTypo3\Service\ValidatorClassNameResolver
+    -
+        class: SaschaEgerer\PhpstanTypo3\Type\PropertyMapperReturnTypeExtension
+        tags:
+            - phpstan.broker.dynamicMethodReturnTypeExtension
 
 parameters:
     bootstrapFiles:

src/Type/PropertyMapperReturnTypeExtension.php

@@ -0,0 +1,115 @@
+<?php declare(strict_types = 1);
+
+namespace SaschaEgerer\PhpstanTypo3\Type;
+
+use PhpParser\Node\Expr\ClassConstFetch;
+use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\Name;
+use PhpParser\Node\Scalar\String_;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Reflection\ReflectionProvider;
+use PHPStan\Type\ArrayType;
+use PHPStan\Type\BooleanType;
+use PHPStan\Type\DynamicMethodReturnTypeExtension;
+use PHPStan\Type\IntegerType;
+use PHPStan\Type\MixedType;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\StringType;
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
+use TYPO3\CMS\Extbase\Property\PropertyMapper;
+
+final class PropertyMapperReturnTypeExtension implements DynamicMethodReturnTypeExtension
+{
+
+	/** @var ReflectionProvider */
+	private $reflectionProvider;
+
+	public function __construct(ReflectionProvider $reflectionProvider)
+	{
+		$this->reflectionProvider = $reflectionProvider;
+	}
+
+	public function getClass(): string
+	{
+		return PropertyMapper::class;
+	}
+
+	public function isMethodSupported(MethodReflection $methodReflection): bool
+	{
+		return $methodReflection->getName() === 'convert';
+	}
+
+	public function getTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, Scope $scope): ?Type
+	{
+		$targetTypeArgument = $methodCall->getArgs()[1] ?? null;
+
+		if ($targetTypeArgument === null) {
+			return null;
+		}
+
+		$argumentValue = $targetTypeArgument->value;
+
+		if ($argumentValue instanceof ClassConstFetch) {
+			/** @var Name $class */
+			$class = $argumentValue->class;
+			return TypeCombinator::addNull(new ObjectType((string) $class));
+		}
+
+		if ($argumentValue instanceof String_) {
+			return $this->createTypeFromString($argumentValue);
+		}
+
+		return null;
+	}
+
+	private function createTypeFromString(String_ $node): ?Type
+	{
+		if ($node->value === 'array') {
+			return TypeCombinator::addNull(new ArrayType(new MixedType(), new MixedType()));
+		}
+
+		if ($node->value === 'string') {
+			return TypeCombinator::addNull(new StringType());
+		}
+
+		if ($node->value === 'boolean') {
+			return TypeCombinator::addNull(new BooleanType());
+		}
+
+		if ($node->value === 'integer') {
+			return TypeCombinator::addNull(new IntegerType());
+		}
+
+		return $this->createTypeFromClassNameString($node);
+	}
+
+	private function createTypeFromClassNameString(String_ $node): ?Type
+	{
+		$classLikeName = $node->value;
+
+		// remove leading slash
+		$classLikeName = ltrim($classLikeName, '\\');
+		if ($classLikeName === '') {
+			return null;
+		}
+
+		if (! $this->reflectionProvider->hasClass($classLikeName)) {
+			return null;
+		}
+
+		$classReflection = $this->reflectionProvider->getClass($classLikeName);
+		if ($classReflection->getName() !== $classLikeName) {
+			return null;
+		}
+
+		// possibly string
+		if (ctype_lower($classLikeName[0])) {
+			return null;
+		}
+
+		return TypeCombinator::addNull(new ObjectType($classLikeName));
+	}
+
+}

tests/Unit/Type/PropertyMapperReturnTypeExtension/PropertyMapperReturnTypeExtensionTest.php

@@ -0,0 +1,38 @@
+<?php declare(strict_types = 1);
+
+namespace SaschaEgerer\PhpstanTypo3\Tests\Unit\Type\PropertyMapperReturnTypeExtension;
+
+use PHPStan\Testing\TypeInferenceTestCase;
+
+final class PropertyMapperReturnTypeExtensionTest extends TypeInferenceTestCase
+{
+
+	/**
+	 * @return iterable<mixed>
+	 */
+	public function dataFileAsserts(): iterable
+	{
+		yield from $this->gatherAssertTypes(__DIR__ . '/data/property-converter-types.php');
+	}
+
+	/**
+	 * @dataProvider dataFileAsserts
+	 * @param string $assertType
+	 * @param string $file
+	 * @param mixed ...$args
+	 */
+	public function testFileAsserts(
+		string $assertType,
+		string $file,
+		...$args
+	): void
+	{
+		$this->assertFileAsserts($assertType, $file, ...$args);
+	}
+
+	public static function getAdditionalConfigFiles(): array
+	{
+		return [__DIR__ . '/../../../../extension.neon'];
+	}
+
+}

tests/Unit/Type/PropertyMapperReturnTypeExtension/data/property-converter-types.php

@@ -0,0 +1,44 @@
+<?php declare(strict_types = 1);
+
+// phpcs:disable SlevomatCodingStandard.Namespaces.RequireOneNamespaceInFile.MoreNamespacesInFile
+// phpcs:disable Squiz.Classes.ClassFileName.NoMatch
+// phpcs:disable PSR1.Classes.ClassDeclaration.MultipleClasses
+
+namespace SaschaEgerer\PhpstanTypo3\Tests\Unit\Type\PropertyMapperReturnTypeExtension;
+
+use TYPO3\CMS\Core\Utility\GeneralUtility;
+use TYPO3\CMS\Extbase\Domain\Model\File;
+use TYPO3\CMS\Extbase\Mvc\Controller\ActionController;
+use TYPO3\CMS\Extbase\Property\PropertyMapper;
+use function PHPStan\Testing\assertType;
+
+class MyController extends ActionController
+{
+
+	public function convertProperties(): void
+	{
+		$propertyMapper = GeneralUtility::makeInstance(PropertyMapper::class);
+
+		$frontendUser = $propertyMapper->convert(['username' => 'username'], File::class);
+		assertType(File::class . '|null', $frontendUser);
+
+		$user = $propertyMapper->convert(['username' => 'username'], 'TYPO3\CMS\Extbase\Domain\Model\File');
+		assertType(File::class . '|null', $user);
+
+		$array = $propertyMapper->convert('1,2,3', 'array');
+		assertType('array|null', $array);
+
+		$string = $propertyMapper->convert(1, 'string');
+		assertType('string|null', $string);
+
+		$integer = $propertyMapper->convert('1', 'integer');
+		assertType('int|null', $integer);
+
+		$boolean = $propertyMapper->convert('1', 'boolean');
+		assertType('bool|null', $boolean);
+
+		$mixed = $propertyMapper->convert('1', 'whatever');
+		assertType('mixed', $mixed);
+	}
+
+}