fix: prevent return type errors when type has been overridden

Author: calebdw

.github/workflows/e2e-tests.yml

@@ -264,6 +264,10 @@ jobs:
               cd e2e/bug-11857
               composer install
               ../../bin/phpstan
+          - script: |
+              cd e2e/bug-12585
+              composer install
+              ../../bin/phpstan
           - script: |
               cd e2e/result-cache-meta-extension
               composer install

e2e/bug-12585/.gitignore

@@ -0,0 +1,2 @@
+/vendor
+composer.lock

e2e/bug-12585/composer.json

@@ -0,0 +1,5 @@
+{
+	"autoload-dev": {
+		"classmap": ["src/"]
+	}
+}

e2e/bug-12585/phpstan.neon

@@ -0,0 +1,10 @@
+parameters:
+	level: 8
+	paths:
+		- src
+
+services:
+	-
+		class: Bug12585\EloquentBuilderRelationParameterExtension
+		tags:
+			- phpstan.dynamicMethodParameterTypeExtension

e2e/bug-12585/src/extension.php

@@ -0,0 +1,255 @@
+<?php
+
+namespace Bug12585;
+
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Reflection\ParameterReflection;
+use PHPStan\Reflection\PassedByReference;
+use PHPStan\Reflection\ReflectionProvider;
+use PHPStan\Type\ClosureType;
+use PHPStan\Type\DynamicMethodParameterTypeExtension;
+use PHPStan\Type\Generic\GenericObjectType;
+use PHPStan\Type\MixedType;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeWithClassName;
+use PHPStan\Type\TypeCombinator;
+use PHPStan\Type\VerbosityLevel;
+use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\VariadicPlaceholder;
+
+use function array_push;
+use function array_shift;
+use function count;
+use function explode;
+use function in_array;
+
+final class EloquentBuilderRelationParameterExtension implements DynamicMethodParameterTypeExtension
+{
+	/** @var list<string> */
+	private array $methods = ['whereHas', 'withWhereHas'];
+
+	public function __construct(private ReflectionProvider $reflectionProvider)
+	{
+	}
+
+	public function isMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool
+	{
+		if (! $methodReflection->getDeclaringClass()->is(Builder::class)) {
+			return false;
+		}
+
+		if (! in_array($methodReflection->getName(), $this->methods, strict: true)) {
+			return false;
+		}
+
+		return $parameter->getName() === 'callback';
+	}
+
+	public function getTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, ParameterReflection $parameter, Scope $scope): Type|null
+	{
+		$method    = $methodReflection->getName();
+		$relations = $this->getRelationsFromMethodCall($methodCall, $scope);
+		$models    = $this->getModelsFromRelations($relations);
+
+		if (count($models) === 0) {
+			return null;
+		}
+
+		$type = $this->getBuilderTypeForModels($models);
+
+		if ($method === 'withWhereHas') {
+			$type = TypeCombinator::union($type, ...$relations);
+		}
+
+		return new ClosureType([new ClosureQueryParameter('query', $type)], new MixedType(), false);
+	}
+
+	/**
+	 * @param array<int, Type> $relations
+	 * @return array<int, string>
+	 */
+	private function getModelsFromRelations(array $relations): array
+	{
+		$models = [];
+
+		foreach ($relations as $relation) {
+			$classNames = $relation->getTemplateType(Relation::class, 'TRelatedModel')->getObjectClassNames();
+			foreach ($classNames as $className) {
+				$models[] = $className;
+			}
+		}
+
+		return $models;
+	}
+
+	/** @return array<int, Type> */
+	private function getRelationsFromMethodCall(MethodCall $methodCall, Scope $scope): array
+	{
+		$relationType = null;
+
+		foreach ($methodCall->args as $arg) {
+			if ($arg instanceof VariadicPlaceholder) {
+				continue;
+			}
+
+			if ($arg->name === null || $arg->name->toString() === 'relation') {
+				$relationType = $scope->getType($arg->value);
+				break;
+			}
+		}
+
+		if ($relationType === null) {
+			return [];
+		}
+
+		$calledOnModels = $scope->getType($methodCall->var)
+			->getTemplateType(Builder::class, 'TModel')
+			->getObjectClassNames();
+
+		$values        = array_map(fn ($type) => $type->getValue(), $relationType->getConstantStrings());
+		$relationTypes = [$relationType];
+
+		foreach ($values as $relation) {
+			$relationTypes = array_merge(
+				$relationTypes,
+				$this->getRelationTypeFromString($calledOnModels, explode('.', $relation), $scope)
+			);
+		}
+
+		return array_values(array_filter(
+			$relationTypes,
+			static fn ($r) => (new ObjectType(Relation::class))->isSuperTypeOf($r)->yes()
+		));
+	}
+
+	/**
+	 * @param list<string> $calledOnModels
+	 * @param list<string> $relationParts
+	 * @return list<Type>
+	 */
+	private function getRelationTypeFromString(array $calledOnModels, array $relationParts, Scope $scope): array
+	{
+		$relations = [];
+
+		while ($relationName = array_shift($relationParts)) {
+			$relations     = [];
+			$relatedModels = [];
+
+			foreach ($calledOnModels as $model) {
+				$modelType = new ObjectType($model);
+
+				if (! $modelType->hasMethod($relationName)->yes()) {
+					continue;
+				}
+
+				$relationType = $modelType->getMethod($relationName, $scope)->getVariants()[0]->getReturnType();
+
+				if (! (new ObjectType(Relation::class))->isSuperTypeOf($relationType)->yes()) {
+					continue;
+				}
+
+				$relations[] = $relationType;
+
+				array_push($relatedModels, ...$relationType->getTemplateType(Relation::class, 'TRelatedModel')->getObjectClassNames());
+			}
+
+			$calledOnModels = $relatedModels;
+		}
+
+		return $relations;
+	}
+
+	private function determineBuilderName(string $modelClassName): string
+	{
+		$method = $this->reflectionProvider->getClass($modelClassName)->getNativeMethod('query');
+
+		$returnType = $method->getVariants()[0]->getReturnType();
+
+		if (in_array(Builder::class, $returnType->getReferencedClasses(), true)) {
+			return Builder::class;
+		}
+
+		$classNames = $returnType->getObjectClassNames();
+
+		if (count($classNames) === 1) {
+			return $classNames[0];
+		}
+
+		return $returnType->describe(VerbosityLevel::value());
+	}
+
+	/**
+	 * @param array<int, string|TypeWithClassName>|string|TypeWithClassName $models
+	 * @return ($models is array<int, string|TypeWithClassName> ? Type : ObjectType)
+	 */
+	private function getBuilderTypeForModels(array|string|TypeWithClassName $models): Type
+	{
+		$models = is_array($models) ? $models : [$models];
+		$models = array_unique($models, SORT_REGULAR);
+
+		$mappedModels = [];
+		foreach ($models as $model) {
+			if (is_string($model)) {
+				$mappedModels[$model] = new ObjectType($model);
+			} else {
+				$mappedModels[$model->getClassName()] = $model;
+			}
+		}
+
+		$groupedByBuilder = [];
+		foreach ($mappedModels as $class => $type) {
+			$builderName = $this->determineBuilderName($class);
+			$groupedByBuilder[$builderName][] = $type;
+		}
+
+		$builderTypes = [];
+		foreach ($groupedByBuilder as $builder => $models) {
+			$builderReflection = $this->reflectionProvider->getClass($builder);
+
+			$builderTypes[] = $builderReflection->isGeneric()
+			? new GenericObjectType($builder, [TypeCombinator::union(...$models)])
+			: new ObjectType($builder);
+		}
+
+		return TypeCombinator::union(...$builderTypes);
+	}
+}
+
+final class ClosureQueryParameter implements ParameterReflection
+{
+	public function __construct(private string $name, private Type $type)
+	{
+	}
+
+	public function getName(): string
+	{
+		return $this->name;
+	}
+
+	public function isOptional(): bool
+	{
+		return false;
+	}
+
+	public function getType(): Type
+	{
+		return $this->type;
+	}
+
+	public function passedByReference(): PassedByReference
+	{
+		return PassedByReference::createNo();
+	}
+
+	public function isVariadic(): bool
+	{
+		return false;
+	}
+
+	public function getDefaultValue(): Type|null
+	{
+		return null;
+	}
+}