Introduce QueryInterface as a generic type

Also implement some ReflectionExtensions to infer the model types from
repository names

Author: MK-42

extension.neon

@@ -31,6 +31,14 @@ services:
             contextApiGetAspectMapping: %typo3.contextApiGetAspectMapping%
         tags:
             - phpstan.rules.rule
+    -
+        class: SaschaEgerer\PhpstanTypo3\Type\RepositoryQueryDynamicReturnTypeExtension
+        tags:
+            - phpstan.broker.dynamicMethodReturnTypeExtension
+    -
+        class: SaschaEgerer\PhpstanTypo3\Type\RepositoryFindAllDynamicReturnTypeExtension
+        tags:
+            - phpstan.broker.dynamicMethodReturnTypeExtension
 parameters:
     bootstrapFiles:
         - phpstan.bootstrap.php
@@ -46,6 +54,9 @@ parameters:
     stubFiles:
         - stubs/GeneralUtility.stub
         - stubs/ObjectStorage.stub
+        - stubs/QueryInterface.stub
+        - stubs/QueryResultInterface.stub
+        - stubs/QueryResult.stub
     dynamicConstantNames:
         - TYPO3_MODE
         - TYPO3_REQUESTTYPE

src/Reflection/RepositoryMethodsClassReflectionExtension.php

@@ -7,6 +7,7 @@
 use PHPStan\Reflection\ClassReflection;
 use PHPStan\Reflection\MethodReflection;
 use PHPStan\Reflection\MethodsClassReflectionExtension;
+use TYPO3\CMS\Core\Utility\ClassNamingUtility;
 use TYPO3\CMS\Extbase\Persistence\Repository;
 
 class RepositoryMethodsClassReflectionExtension implements MethodsClassReflectionExtension, BrokerAwareExtension
@@ -26,7 +27,24 @@ public function hasMethod(ClassReflection $classReflection, string $methodName):
 			!$classReflection->hasNativeMethod($methodName)
 			&& in_array(Repository::class, $classReflection->getParentClassesNames(), true)
 		) {
-			return strpos($methodName, 'findBy') === 0 || strpos($methodName, 'findOneBy') === 0;
+			if (strpos($methodName, 'findOneBy') === 0) {
+				$propertyName = lcfirst(substr($methodName, 9));
+			} elseif (strpos($methodName, 'findBy') === 0) {
+				$propertyName = lcfirst(substr($methodName, 6));
+			} else {
+				return false;
+			}
+
+			// ensure that a property with that name exists on the model, as there might
+			//  be methods starting with find[One]By... with custom implementations on
+			//  inherited repositories
+			$className = $classReflection->getName();
+			$modelName = ClassNamingUtility::translateRepositoryNameToModelName($className);
+
+			$modelReflection = $this->broker->getClass($modelName);
+			if ($modelReflection->hasProperty($propertyName)) {
+				return true;
+			}
 		}
 		return false;
 	}

src/Type/QueryInterfaceDynamicReturnTypeExtension.php

@@ -8,6 +8,7 @@
 use PHPStan\Type\ArrayType;
 use PHPStan\Type\Constant\ConstantBooleanType;
 use PHPStan\Type\DynamicMethodReturnTypeExtension;
+use PHPStan\Type\Generic\GenericObjectType;
 use PHPStan\Type\IntegerType;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\Type;
@@ -38,20 +39,20 @@ public function getTypeFromMethodCall(
 	{
 		$argument = $methodCall->getArgs()[0] ?? null;
 
+		$classReflection = $scope->getClassReflection();
+		$modelName = ClassNamingUtility::translateRepositoryNameToModelName(
+			$classReflection->getName()
+		);
+
 		if ($argument !== null) {
 			$argType = $scope->getType($argument->value);
-			$classReflection = $scope->getClassReflection();
 
 			if ($classReflection !== null && $argType instanceof ConstantBooleanType && $argType->getValue() === true) {
-				$modelName = ClassNamingUtility::translateRepositoryNameToModelName(
-					$classReflection->getName()
-				);
-
 				return new ArrayType(new IntegerType(), new ObjectType($modelName));
 			}
 		}
 
-		return new ObjectType(QueryResult::class);
+		return new GenericObjectType(QueryResult::class, [new ObjectType($modelName)]);
 	}
 
 }

src/Type/RepositoryFindAllDynamicReturnTypeExtension.php

@@ -0,0 +1,49 @@
+<?php declare(strict_types = 1);
+
+namespace SaschaEgerer\PhpstanTypo3\Type;
+
+use PhpParser\Node\Expr\MethodCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Reflection\ParametersAcceptorSelector;
+use PHPStan\Type\DynamicMethodReturnTypeExtension;
+use PHPStan\Type\Generic\GenericObjectType;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
+use TYPO3\CMS\Core\Utility\ClassNamingUtility;
+use TYPO3\CMS\Extbase\Persistence\QueryResultInterface;
+
+class RepositoryFindAllDynamicReturnTypeExtension implements DynamicMethodReturnTypeExtension
+{
+
+	public function getClass(): string
+	{
+		return \TYPO3\CMS\Extbase\Persistence\RepositoryInterface::class;
+	}
+
+	public function isMethodSupported(
+		MethodReflection $methodReflection
+	): bool
+	{
+		return in_array($methodReflection->getName(), ['findAll'], true);
+	}
+
+	public function getTypeFromMethodCall(
+		MethodReflection $methodReflection,
+		MethodCall $methodCall,
+		Scope $scope
+	): Type
+	{
+		$variableType = $scope->getType($methodCall->var);
+
+		if (!($variableType instanceof ObjectType) || !is_subclass_of($variableType->getClassName(), $this->getClass())) {
+			return ParametersAcceptorSelector::selectSingle($methodReflection->getVariants())->getReturnType();
+		}
+
+		$modelName = ClassNamingUtility::translateRepositoryNameToModelName($variableType->getClassName());
+
+		return new GenericObjectType(QueryResultInterface::class, [new ObjectType($modelName)]);
+	}
+
+}

src/Type/RepositoryQueryDynamicReturnTypeExtension.php

@@ -0,0 +1,45 @@
+<?php declare(strict_types = 1);
+
+namespace SaschaEgerer\PhpstanTypo3\Type;
+
+use PhpParser\Node\Expr\MethodCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Reflection\ParametersAcceptorSelector;
+use PHPStan\Type\DynamicMethodReturnTypeExtension;
+use PHPStan\Type\Generic\GenericObjectType;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
+use TYPO3\CMS\Core\Utility\ClassNamingUtility;
+use TYPO3\CMS\Extbase\Persistence\QueryInterface;
+
+class RepositoryQueryDynamicReturnTypeExtension implements DynamicMethodReturnTypeExtension
+{
+
+	public function getClass(): string
+	{
+		return \TYPO3\CMS\Extbase\Persistence\RepositoryInterface::class;
+	}
+
+	public function isMethodSupported(
+		MethodReflection $methodReflection
+	): bool
+	{
+		return $methodReflection->getName() === 'createQuery';
+	}
+
+	public function getTypeFromMethodCall(
+		MethodReflection $methodReflection,
+		MethodCall $methodCall,
+		Scope $scope
+	): Type
+	{
+		$variableType = $scope->getType($methodCall->var);
+
+		$modelName = ClassNamingUtility::translateRepositoryNameToModelName($variableType->getClassName());
+
+		return new GenericObjectType(QueryInterface::class, [new ObjectType($modelName)]);
+	}
+
+}

stubs/QueryInterface.stub

@@ -0,0 +1,20 @@
+<?php
+namespace TYPO3\CMS\Extbase\Persistence;
+
+/**
+ * @template ModelType
+ */
+interface QueryInterface
+{
+    /**
+     * @param bool $returnRawQueryResult
+     * @return \TYPO3\CMS\Extbase\Persistence\QueryResultInterface<ModelType>|array<string, mixed>
+     */
+    public function execute($returnRawQueryResult = false);
+
+    /**
+     * @param mixed $constraint
+     * @return \TYPO3\CMS\Extbase\Persistence\QueryInterface<ModelType>
+     */
+    public function matching($constraint);
+}

stubs/QueryResult.stub

@@ -0,0 +1,13 @@
+<?php
+namespace TYPO3\CMS\Extbase\Persistence\Generic;
+
+/**
+ * @template ModelType
+ */
+class QueryResult
+{
+    /**
+     * @return ModelType
+     */
+    public function getFirst();
+}

stubs/QueryResultInterface.stub

@@ -0,0 +1,13 @@
+<?php
+namespace TYPO3\CMS\Extbase\Persistence;
+
+/**
+ * @template ModelType
+ */
+interface QueryResultInterface
+{
+    /**
+     * @return ModelType
+     */
+    public function getFirst();
+}