refactor: use new BuilderHelper::getBuilderTypeForModels method

calebdw · calebdw · commit bd76cbcda618 · 2024-09-23T11:44:54.000-05:00
diff --git a/src/Methods/ModelForwardsCallsExtension.php b/src/Methods/ModelForwardsCallsExtension.php
@@ -17,10 +17,8 @@
 use PHPStan\Reflection\ParametersAcceptor;
 use PHPStan\Reflection\ParametersAcceptorSelector;
 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;
@@ -36,7 +34,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)
     {
     }
 
@@ -169,17 +167,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 = ParametersAcceptorSelector::selectSingle($this->transformStaticParameters($reflection, $genericBuilderAndModelType));
+            $parametersAcceptor = ParametersAcceptorSelector::selectSingle($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);
@@ -202,7 +204,7 @@ public function hasSideEffects(): TrinaryLogic
     }
 
     /** @return ParametersAcceptor[] */
-    private function transformStaticParameters(MethodReflection $method, GenericObjectType $builder): array
+    private function transformStaticParameters(MethodReflection $method, ObjectType $builder): array
     {
         return array_map(function (ParametersAcceptor $acceptor) use ($builder): ParametersAcceptor {
             return new FunctionVariant($acceptor->getTemplateTypeMap(), $acceptor->getResolvedTemplateTypeMap(), array_map(function (
@@ -220,7 +222,7 @@ private function transformStaticParameters(MethodReflection $method, GenericObje
         }, $method->getVariants());
     }
 
-    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) {
diff --git a/src/Methods/RelationForwardsCallsExtension.php b/src/Methods/RelationForwardsCallsExtension.php
@@ -76,9 +76,12 @@ private function findMethod(ClassReflection $classReflection, string $methodName
             $modelReflection = $this->reflectionProvider->getClass(Model::class);
         }
 
-        $builderName = $this->builderHelper->determineBuilderName($modelReflection->getName());
+        $builderReflection = $this->builderHelper->getBuilderTypeForModels($modelReflection->getName())
+            ->getClassReflection();
 
-        $builderReflection = $this->reflectionProvider->getClass($builderName)->withTypes([$relatedModel]);
+        if ($builderReflection === null) {
+            return null;
+        }
 
         if ($builderReflection->hasNativeMethod($methodName)) {
             $reflection = $builderReflection->getNativeMethod($methodName);
diff --git a/src/ReturnTypes/ModelDynamicStaticMethodReturnTypeExtension.php b/src/ReturnTypes/ModelDynamicStaticMethodReturnTypeExtension.php
@@ -16,16 +16,16 @@
 use PhpParser\Node\Name;
 use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\MethodReflection;
-use PHPStan\Reflection\MissingMethodFromReflectionException;
 use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Type\DynamicStaticMethodReturnTypeExtension;
-use PHPStan\Type\Generic\GenericObjectType;
-use PHPStan\Type\ObjectType;
+use PHPStan\Type\StaticType;
+use PHPStan\Type\ThisType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
 
 use function array_intersect;
+use function collect;
 use function count;
 use function in_array;
 
@@ -84,34 +84,26 @@ public function getTypeFromStaticMethodCall(
 
         if (count(array_intersect([EloquentBuilder::class], $returnType->getReferencedClasses())) > 0) {
             if ($methodCall->class instanceof Name) {
-                $returnType = new GenericObjectType(
-                    $this->builderHelper->determineBuilderName($scope->resolveName($methodCall->class)),
-                    [new ObjectType($scope->resolveName($methodCall->class))],
-                );
-            } elseif ($methodCall->class instanceof Expr) {
-                $type = $scope->getType($methodCall->class);
+                $type = $scope->resolveTypeByName($methodCall->class);
 
-                $classNames = $type->getObjectClassNames();
-
-                $types = [];
+                if ($type instanceof ThisType) {
+                    $type = new StaticType($type->getClassReflection());
+                }
 
-                foreach ($classNames as $className) {
-                    if (! $this->reflectionProvider->hasClass($className)) {
-                        continue;
-                    }
+                $returnType = $this->builderHelper->getBuilderTypeForModels($type);
+            } elseif ($methodCall->class instanceof Expr) {
+                $type = $scope->getType($methodCall->class);
 
-                    try {
-                        $types[] = new GenericObjectType(
-                            $this->builderHelper->determineBuilderName($className),
-                            [new ObjectType($className)],
-                        );
-                    } catch (MissingMethodFromReflectionException) {
-                    }
-                }
+                $returnType = collect($type->getObjectClassReflections())
+                    ->filter(static fn ($r) => $r->is(Model::class))
+                    ->map(static fn ($r) => $r->getName())
+                    ->pipe(function ($models) use ($returnType) {
+                        if ($models->isEmpty()) {
+                            return $returnType;
+                        }
 
-                if ($types !== []) {
-                    $returnType = TypeCombinator::union(...$types);
-                }
+                        return $this->builderHelper->getBuilderTypeForModels($models->all());
+                    });
             }
         }
 
diff --git a/src/ReturnTypes/NewModelQueryDynamicMethodReturnTypeExtension.php b/src/ReturnTypes/NewModelQueryDynamicMethodReturnTypeExtension.php
@@ -10,11 +10,9 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\MethodReflection;
 use PHPStan\Type\DynamicMethodReturnTypeExtension;
-use PHPStan\Type\Generic\GenericObjectType;
-use PHPStan\Type\ObjectType;
 use PHPStan\Type\Type;
-use PHPStan\Type\TypeCombinator;
 
+use function collect;
 use function in_array;
 
 class NewModelQueryDynamicMethodReturnTypeExtension implements DynamicMethodReturnTypeExtension
@@ -45,30 +43,22 @@ public function getTypeFromMethodCall(
         MethodCall $methodCall,
         Scope $scope,
     ): Type|null {
-        $calledOnType = $scope->getType($methodCall->var);
-
+        $calledOnType     = $scope->getType($methodCall->var);
         $classReflections = $calledOnType->getObjectClassReflections();
 
         if ($classReflections === []) {
             return null;
         }
 
-        $types = [];
-
-        foreach ($classReflections as $classReflection) {
-            if (! $classReflection->isSubclassOf(Model::class)) {
-                continue;
-            }
-
-            $builderName = $this->builderHelper->determineBuilderName($classReflection->getName());
-
-            $types[] = new GenericObjectType($builderName, [new ObjectType($classReflection->getName())]);
-        }
-
-        if ($types === []) {
-            return null;
-        }
+        return collect($classReflections)
+            ->filter(static fn ($r) => $r->is(Model::class))
+            ->map(static fn ($r) => $r->getName())
+            ->pipe(function ($models) {
+                if ($models->isEmpty()) {
+                    return null;
+                }
 
-        return TypeCombinator::union(...$types);
+                return $this->builderHelper->getBuilderTypeForModels($models->all());
+            });
     }
 }
diff --git a/tests/Type/data/eloquent-builder.php b/tests/Type/data/eloquent-builder.php
@@ -344,7 +344,7 @@ class TestModel extends Model
     public function test(): void
     {
         assertType('Illuminate\Database\Eloquent\Collection<int, EloquentBuilder\TestModel>', $this->where('email', 1)->get());
-        assertType('Illuminate\Database\Eloquent\Builder<EloquentBuilder\TestModel>', static::query()->where('email', 'bar'));
+        assertType('Illuminate\Database\Eloquent\Builder<static(EloquentBuilder\TestModel)>', static::query()->where('email', 'bar'));
         assertType('Illuminate\Database\Eloquent\Builder<EloquentBuilder\TestModel>', $this->where('email', 'bar'));
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -344,7 +344,7 @@ class TestModel extends Model`
`344`	`344`	`public function test(): void`
`345`	`345`	`{`
`346`	`346`	`assertType('Illuminate\Database\Eloquent\Collection<int, EloquentBuilder\TestModel>', $this->where('email', 1)->get());`
`347`		`- assertType('Illuminate\Database\Eloquent\Builder<EloquentBuilder\TestModel>', static::query()->where('email', 'bar'));`
	`347`	`+ assertType('Illuminate\Database\Eloquent\Builder<static(EloquentBuilder\TestModel)>', static::query()->where('email', 'bar'));`
`348`	`348`	`assertType('Illuminate\Database\Eloquent\Builder<EloquentBuilder\TestModel>', $this->where('email', 'bar'));`
`349`	`349`	`}`
`350`	`350`	`}`