feat: overwrite hasMorph callback builder with correct type

Author: Neol3108

extension.neon

@@ -1,7 +1,20 @@
+parameters:
+    laravel:
+        morphMap: []
+
+parametersSchema:
+    laravel: structure([
+        morphMap: arrayOf(string())
+    ])
+
 services:
     - class: Recoded\PHPStanLaravel\Extensions\StubExtension
       tags: [phpstan.stubFilesExtension]
     - class: Recoded\PHPStanLaravel\Extensions\Eloquent\Scopes
       tags: [phpstan.broker.methodsClassReflectionExtension]
     - class: Recoded\PHPStanLaravel\Extensions\Eloquent\WhereHasBuilderType
       tags: [phpstan.methodParameterClosureTypeExtension]
+    - class: Recoded\PHPStanLaravel\Extensions\Eloquent\WhereHasMorphBuilderType
+      arguments:
+        morphMap: %laravel.morphMap%
+      tags: [phpstan.methodParameterClosureTypeExtension]

phpstan-baseline.neon

@@ -4,3 +4,13 @@ parameters:
 			message: "#^Creating new PHPStan\\\\Reflection\\\\Native\\\\NativeParameterReflection is not covered by backward compatibility promise\\. The class might change in a minor PHPStan version\\.$#"
 			count: 1
 			path: src/Extensions/Eloquent/WhereHasBuilderType.php
+
+		-
+			message: "#^Creating new PHPStan\\\\Reflection\\\\Native\\\\NativeParameterReflection is not covered by backward compatibility promise\\. The class might change in a minor PHPStan version\\.$#"
+			count: 1
+			path: src/Extensions/Eloquent/WhereHasMorphBuilderType.php
+
+		-
+			message: "#^Doing instanceof PHPStan\\\\Type\\\\Constant\\\\ConstantStringType is error\\-prone and deprecated\\. Use Type\\:\\:getConstantStrings\\(\\) instead\\.$#"
+			count: 1
+			path: src/Extensions/Eloquent/WhereHasMorphBuilderType.php

src/Extensions/Eloquent/WhereHasMorphBuilderType.php

@@ -0,0 +1,109 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Recoded\PHPStanLaravel\Extensions\Eloquent;
+
+use PhpParser\Node\Expr\MethodCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Reflection\Native\NativeParameterReflection;
+use PHPStan\Reflection\ParameterReflection;
+use PHPStan\Reflection\ParametersAcceptorSelector;
+use PHPStan\Reflection\PassedByReference;
+use PHPStan\Type\Constant\ConstantArrayType;
+use PHPStan\Type\Constant\ConstantStringType;
+use PHPStan\Type\ClosureType;
+use PHPStan\Type\Generic\GenericObjectType;
+use PHPStan\Type\MethodParameterClosureTypeExtension;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
+use PHPStan\Type\VoidType;
+
+final class WhereHasMorphBuilderType implements MethodParameterClosureTypeExtension
+{
+    /**
+     * Create a new Extension instance.
+     *
+     * @param array<string, class-string<\Illuminate\Database\Eloquent\Model>> $morphMap
+     * @return void
+     */
+    public function __construct(
+        private array $morphMap
+    ) {
+    }
+
+    public function isMethodSupported(MethodReflection $method, ParameterReflection $parameter): bool
+    {
+        $methods = [
+            'hasMorph',
+        ];
+
+        if (!in_array($method->getName(), $methods, true)) {
+            return false;
+        }
+
+        return $parameter->getName() === 'callback'
+            && $method->getDeclaringClass()->getName() === 'Illuminate\Database\Eloquent\Builder';
+    }
+
+    public function getTypeFromMethodCall(MethodReflection $method, MethodCall $methodCall, ParameterReflection $parameter, Scope $scope): ?Type
+    {
+        $secondType = $scope->getType($methodCall->getArgs()[1]->value);
+
+        $types = $secondType->isConstantArray()->yes()
+            ? array_reduce($secondType->getConstantArrays(), fn (array $carry, ConstantArrayType $array) => [
+                ...$carry,
+                ...$array->getValueTypes(),
+            ], [])
+            : $secondType->getConstantStrings();
+
+        $wildcardsAndNonConstantStrings = array_filter($types, function (Type $type) {
+            return !$type instanceof ConstantStringType || $type->getValue() === '*';
+        });
+
+        if ($wildcardsAndNonConstantStrings !== []) {
+            return null;
+        }
+
+        $classes = array_map(function (ConstantStringType $string) {
+            return $string->isClassStringType()->yes()
+                ? $string->getValue()
+                : $this->morphMap[$string->getValue()] ?? $string->getValue();
+        }, $types);
+
+        $model = $method->getDeclaringClass()
+            ->getActiveTemplateTypeMap()
+            ->getType('TModel');
+
+        if ($model === null || !$model->isObject()->yes()) {
+            return null;
+        }
+
+        /** @var \PHPStan\Type\ObjectType $model */
+
+        $class = $model->getClassReflection();
+
+        if ($class === null) {
+            return null;
+        }
+
+        $builderTypes = array_map(function (string $class) use ($scope) {
+            /** @var \PHPStan\Reflection\ExtendedMethodReflection $newEloquentBuilder */
+            $newEloquentBuilder = $scope->getMethodReflection(new ObjectType($class), 'newEloquentBuilder');
+
+            return ParametersAcceptorSelector::selectSingle($newEloquentBuilder->getVariants())->getReturnType();
+        }, $classes);
+
+        $builderTypes = array_filter($builderTypes);
+
+        $builderType = $builderTypes === []
+            ? new GenericObjectType('Illuminate\Database\Eloquent\Builder', [new ObjectType('Illuminate\Database\Eloquent\Model')])
+            : TypeCombinator::union(...$builderTypes);
+
+        return new ClosureType([
+            new NativeParameterReflection('callback', false, $builderType, PassedByReference::createNo(), false, null),
+        ], new VoidType());
+    }
+}

stubs/database/eloquent/concerns/queries-relationships.stub

@@ -75,4 +75,16 @@ trait QueriesRelationships
      * @return static
      */
     public function orWhereDoesntHave($relation, ?Closure $callback = null);
+
+    /**
+     * @template TBuilder of \Illuminate\Database\Eloquent\Builder<\Illuminate\Database\Eloquent\Model>
+     * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
+     * @param string|string[] $types
+     * @param string $operator
+     * @param int $count
+     * @param string $boolean
+     * @param \Closure(TBuilder): (void|TBuilder)|null $callback
+     * @return static
+     */
+    public function hasMorph($relation, $types, $operator = '>=', $count = 1, $boolean = 'and', ?Closure $callback = null);
 }

tests/Types/Database/Eloquent/BuilderTest.php

@@ -26,6 +26,9 @@ public function testFileAsserts(
 
     public static function getAdditionalConfigFiles(): array
     {
-        return [__DIR__ . '/../../../../extension.neon'];
+        return [
+            __DIR__ . '/../../../../extension.neon',
+            __DIR__ . '/morph-map.neon',
+        ];
     }
 }

tests/Types/Database/Eloquent/morph-map.neon

@@ -0,0 +1,4 @@
+parameters:
+    laravel:
+        morphMap:
+            media: Tests\Types\Fakes\Media

tests/Types/data/database/eloquent/builder.php

@@ -1,5 +1,6 @@
 <?php
 
+use Tests\Types\Fakes\Post;
 use function PHPStan\Testing\assertType;
 
 /** @var \Illuminate\Database\Eloquent\Builder<\Tests\Types\Fakes\User> $builder */
@@ -113,3 +114,6 @@
 assertType('Illuminate\Database\Eloquent\Builder<Tests\Types\Fakes\User>', $builder->orWhereDoesntHave('posts', function ($param1) {
     assertType('Illuminate\Database\Eloquent\Builder<Tests\Types\Fakes\Post>', $param1);
 }));
+assertType('Illuminate\Database\Eloquent\Builder<Tests\Types\Fakes\User>', $builder->hasMorph('related', [Post::class, 'media'], callback: function ($param1) {
+    assertType('Illuminate\Database\Eloquent\Builder<Tests\Types\Fakes\Post>|Tests\Types\Fakes\Builders\MediaBuilder', $param1);
+}));