Merge branch 'dynamic_relation_closures' into 3.x

Author: calebdw

extension.neon

@@ -555,6 +555,19 @@ services:
         tags:
             - phpstan.broker.dynamicFunctionReturnTypeExtension
 
+    -
+        class: Larastan\Larastan\Parameters\EloquentBuilderRelationParameterExtension
+        tags:
+            - phpstan.methodParameterClosureTypeExtension
+
+    -
+        class: Larastan\Larastan\Parameters\ModelRelationParameterExtension
+        tags:
+            - phpstan.staticMethodParameterClosureTypeExtension
+
+    -
+        class: Larastan\Larastan\Parameters\RelationClosureHelper
+
     -
         class: Larastan\Larastan\ReturnTypes\AppMakeHelper
 

src/Methods/BuilderHelper.php

@@ -17,13 +17,18 @@
 use PHPStan\ShouldNotHappenException;
 use PHPStan\TrinaryLogic;
 use PHPStan\Type\Generic\GenericObjectType;
+use PHPStan\Type\ObjectType;
 use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
+use PHPStan\Type\TypeWithClassName;
 use PHPStan\Type\VerbosityLevel;
 
 use function array_key_exists;
 use function array_shift;
+use function collect;
 use function count;
 use function in_array;
+use function is_string;
 use function preg_split;
 use function substr;
 use function ucfirst;
@@ -232,4 +237,33 @@ public function determineBuilderName(string $modelClassName): string
 
         return $returnType->describe(VerbosityLevel::value());
     }
+
+    /**
+     * @param array<int, string|TypeWithClassName>|string|TypeWithClassName $models
+     *
+     * @return ($models is array<int, string|TypeWithClassName> ? Type : ObjectType)
+     */
+    public function getBuilderTypeForModels(array|string|TypeWithClassName $models): Type
+    {
+        return collect()
+            ->wrap($models)
+            ->unique()
+            ->mapWithKeys(static function ($model) {
+                if (is_string($model)) {
+                    return [$model => new ObjectType($model)];
+                }
+
+                return [$model->getClassName() => $model];
+            })
+            ->mapToGroups(fn ($type, $class) => [$this->determineBuilderName($class) => $type])
+            ->map(function ($models, $builder) {
+                $builderReflection = $this->reflectionProvider->getClass($builder);
+
+                return $builderReflection->isGeneric()
+                    ? new GenericObjectType($builder, [TypeCombinator::union(...$models)])
+                    : new ObjectType($builder);
+            })
+            ->values()
+            ->pipe(static fn ($types) => TypeCombinator::union(...$types));
+    }
 }

src/Methods/ModelForwardsCallsExtension.php

@@ -16,10 +16,8 @@
 use PHPStan\Reflection\ParameterReflection;
 use PHPStan\Reflection\ParametersAcceptor;
 use PHPStan\Reflection\Php\DummyParameter;
-use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\ShouldNotHappenException;
 use PHPStan\TrinaryLogic;
-use PHPStan\Type\Generic\GenericObjectType;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\StaticType;
 use PHPStan\Type\Type;
@@ -35,7 +33,7 @@ final class ModelForwardsCallsExtension implements MethodsClassReflectionExtensi
     /** @var array<string, MethodReflection> */
     private array $cache = [];
 
-    public function __construct(private BuilderHelper $builderHelper, private ReflectionProvider $reflectionProvider, private EloquentBuilderForwardsCallsExtension $eloquentBuilderForwardsCallsExtension)
+    public function __construct(private BuilderHelper $builderHelper, private EloquentBuilderForwardsCallsExtension $eloquentBuilderForwardsCallsExtension)
     {
     }
 
@@ -80,8 +78,7 @@ private function findMethod(ClassReflection $classReflection, string $methodName
         if (in_array($methodName, ['increment', 'decrement'], true)) {
             $methodReflection = $classReflection->getNativeMethod($methodName);
 
-            return new class ($classReflection, $methodName, $methodReflection) implements MethodReflection
-            {
+            return new class ($classReflection, $methodName, $methodReflection) implements MethodReflection {
                 private ClassReflection $classReflection;
 
                 private string $methodName;
@@ -168,17 +165,21 @@ public function hasSideEffects(): TrinaryLogic
             };
         }
 
-        $builderReflection          = $this->reflectionProvider->getClass($builderName)->withTypes([new ObjectType($classReflection->getName())]);
-        $genericBuilderAndModelType = new GenericObjectType($builderName, [new ObjectType($classReflection->getName())]);
+        $builderType       = $this->builderHelper->getBuilderTypeForModels($classReflection->getName());
+        $builderReflection = $builderType->getClassReflection();
+
+        if ($builderReflection === null) {
+            return null;
+        }
 
         if ($builderReflection->hasNativeMethod($methodName)) {
             $reflection = $builderReflection->getNativeMethod($methodName);
 
-            $parametersAcceptor = $this->transformStaticParameters($reflection, $genericBuilderAndModelType);
+            $parametersAcceptor = $this->transformStaticParameters($reflection, $builderType);
 
-            $returnType = TypeTraverser::map($parametersAcceptor->getReturnType(), static function (Type $type, callable $traverse) use ($genericBuilderAndModelType) {
+            $returnType = TypeTraverser::map($parametersAcceptor->getReturnType(), static function (Type $type, callable $traverse) use ($builderType) {
                 if ($type instanceof TypeWithClassName && $type->getClassName() === Builder::class) {
-                    return $genericBuilderAndModelType;
+                    return $builderType;
                 }
 
                 return $traverse($type);
@@ -200,7 +201,7 @@ public function hasSideEffects(): TrinaryLogic
         return null;
     }
 
-    private function transformStaticParameters(MethodReflection $method, GenericObjectType $builder): ParametersAcceptor
+    private function transformStaticParameters(MethodReflection $method, ObjectType $builder): ParametersAcceptor
     {
         $acceptor = $method->getVariants()[0];
 
@@ -218,7 +219,7 @@ private function transformStaticParameters(MethodReflection $method, GenericObje
         }, $acceptor->getParameters()), $acceptor->isVariadic(), $this->transformStaticType($acceptor->getReturnType(), $builder));
     }
 
-    private function transformStaticType(Type $type, GenericObjectType $builder): Type
+    private function transformStaticType(Type $type, ObjectType $builder): Type
     {
         return TypeTraverser::map($type, static function (Type $type, callable $traverse) use ($builder): Type {
             if ($type instanceof StaticType) {

src/Methods/RelationForwardsCallsExtension.php

@@ -15,7 +15,6 @@
 use PHPStan\Reflection\MissingMethodFromReflectionException;
 use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\ShouldNotHappenException;
-use PHPStan\Type\Generic\GenericObjectType;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\ThisType;
 
@@ -80,8 +79,7 @@ private function findMethod(ClassReflection $classReflection, string $methodName
             return null;
         }
 
-        $builderName = $this->builderHelper->determineBuilderName($modelReflection->getName());
-        $builderType = new GenericObjectType($builderName, [new ObjectType($modelReflection->getName())]);
+        $builderType = $this->builderHelper->getBuilderTypeForModels($modelReflection->getName());
 
         if (! $builderType->hasMethod($methodName)->yes()) {
             return null;

src/Parameters/ClosureQueryParameter.php

@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Larastan\Larastan\Parameters;
+
+use PHPStan\Reflection\ParameterReflection;
+use PHPStan\Reflection\PassedByReference;
+use PHPStan\Type\Type;
+
+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;
+    }
+}

src/Parameters/EloquentBuilderRelationParameterExtension.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Larastan\Larastan\Parameters;
+
+use PhpParser\Node\Expr\MethodCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Reflection\ParameterReflection;
+use PHPStan\Type\MethodParameterClosureTypeExtension;
+use PHPStan\Type\Type;
+
+final class EloquentBuilderRelationParameterExtension implements MethodParameterClosureTypeExtension
+{
+    public function __construct(private RelationClosureHelper $relationClosureHelper)
+    {
+    }
+
+    public function isMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool
+    {
+        return $this->relationClosureHelper->isMethodSupported($methodReflection, $parameter);
+    }
+
+    public function getTypeFromMethodCall(
+        MethodReflection $methodReflection,
+        MethodCall $methodCall,
+        ParameterReflection $parameter,
+        Scope $scope,
+    ): Type|null {
+        return $this->relationClosureHelper->getTypeFromMethodCall($methodReflection, $methodCall, $parameter, $scope);
+    }
+}

src/Parameters/ModelRelationParameterExtension.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Larastan\Larastan\Parameters;
+
+use PhpParser\Node\Expr\StaticCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Reflection\ParameterReflection;
+use PHPStan\Type\StaticMethodParameterClosureTypeExtension;
+use PHPStan\Type\Type;
+
+final class ModelRelationParameterExtension implements StaticMethodParameterClosureTypeExtension
+{
+    public function __construct(private RelationClosureHelper $relationClosureHelper)
+    {
+    }
+
+    public function isStaticMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool
+    {
+        return $this->relationClosureHelper->isMethodSupported($methodReflection, $parameter);
+    }
+
+    public function getTypeFromStaticMethodCall(
+        MethodReflection $methodReflection,
+        StaticCall $methodCall,
+        ParameterReflection $parameter,
+        Scope $scope,
+    ): Type|null {
+        return $this->relationClosureHelper->getTypeFromMethodCall($methodReflection, $methodCall, $parameter, $scope);
+    }
+}