feat: support Laravel 11 casts method

closes #1877

src/Properties/ModelCastHelper.php

@@ -15,14 +15,19 @@
 use Illuminate\Database\Eloquent\Casts\AsEncryptedArrayObject;
 use Illuminate\Database\Eloquent\Casts\AsEncryptedCollection;
 use Illuminate\Database\Eloquent\Casts\AsStringable;
+use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Arr;
 use Illuminate\Support\Carbon as IlluminateCarbon;
 use Illuminate\Support\Collection;
 use Illuminate\Support\Facades\Date;
 use Illuminate\Support\Stringable as IlluminateStringable;
+use PHPStan\Analyser\OutOfClassScope;
+use PHPStan\Reflection\ClassReflection;
+use PHPStan\Reflection\MissingMethodFromReflectionException;
 use PHPStan\Reflection\ParameterReflection;
 use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\Reflection\ReflectionProvider;
+use PHPStan\ShouldNotHappenException;
 use PHPStan\Type\Accessory\AccessoryNumericStringType;
 use PHPStan\Type\ArrayType;
 use PHPStan\Type\BenevolentUnionType;
@@ -36,14 +41,24 @@
 use PHPStan\Type\StringType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
+use ReflectionException;
 use stdClass;
 use Stringable;
 
+use function array_combine;
+use function array_key_exists;
+use function array_map;
+use function array_merge;
 use function class_exists;
 use function explode;
+use function str_replace;
+use function version_compare;
 
 class ModelCastHelper
 {
+    /** @var array<string, array<string, string>> */
+    private array $modelCasts = [];
+
     public function __construct(
         protected ReflectionProvider $reflectionProvider,
     ) {
@@ -193,4 +208,63 @@ private function parseCast(string $cast): string
 
         return $cast;
     }
+
+    public function hasCastForProperty(ClassReflection $modelClassReflection, string $propertyName): bool
+    {
+        if (! array_key_exists($modelClassReflection->getName(), $this->modelCasts)) {
+            $modelCasts = $this->getModelCasts($modelClassReflection);
+        } else {
+            $modelCasts = $this->modelCasts[$modelClassReflection->getName()];
+        }
+
+        return array_key_exists($propertyName, $modelCasts);
+    }
+
+    public function getCastForProperty(ClassReflection $modelClassReflection, string $propertyName): string|null
+    {
+        if (! array_key_exists($modelClassReflection->getName(), $this->modelCasts)) {
+            $modelCasts = $this->getModelCasts($modelClassReflection);
+        } else {
+            $modelCasts = $this->modelCasts[$modelClassReflection->getName()];
+        }
+
+        return $modelCasts[$propertyName] ?? null;
+    }
+
+    /**
+     * @return array<string, string>
+     *
+     * @throws ShouldNotHappenException
+     * @throws MissingMethodFromReflectionException
+     */
+    private function getModelCasts(ClassReflection $modelClassReflection): array
+    {
+        try {
+            /** @var Model $modelInstance */
+            $modelInstance = $modelClassReflection->getNativeReflection()->newInstanceWithoutConstructor();
+        } catch (ReflectionException) {
+            throw new ShouldNotHappenException();
+        }
+
+        $modelCasts = $modelInstance->getCasts();
+
+        if (version_compare(LARAVEL_VERSION, '11.0.0', '>=')) { // @phpstan-ignore-line
+            $castsMethodReturnType = ParametersAcceptorSelector::selectSingle($modelClassReflection->getMethod(
+                'casts',
+                new OutOfClassScope(),
+            )->getVariants())->getReturnType();
+
+            if ($castsMethodReturnType->isConstantArray()->yes()) {
+                $modelCasts = array_merge(
+                    $modelCasts,
+                    array_combine(
+                        array_map(static fn ($key) => $key->getValue(), $castsMethodReturnType->getKeyTypes()), // @phpstan-ignore-line
+                        array_map(static fn ($value) => str_replace('\\\\', '\\', $value->getValue()), $castsMethodReturnType->getValueTypes()), // @phpstan-ignore-line
+                    ),
+                );
+            }
+        }
+
+        return $modelCasts;
+    }
 }

src/Properties/ModelPropertyHelper.php

@@ -106,19 +106,19 @@ public function getDatabaseProperty(ClassReflection $classReflection, string $pr
         if ($this->hasDate($modelInstance, $propertyName)) {
             $readableType = $this->modelCastHelper->getDateType();
             $writableType = TypeCombinator::union($this->modelCastHelper->getDateType(), new StringType());
-        } elseif ($modelInstance->hasCast($propertyName)) {
-            $cast = $modelInstance->getCasts()[$propertyName];
-
-            $readableType = $this->modelCastHelper->getReadableType(
-                $cast,
-                $this->stringResolver->resolve($column->readableType),
-            );
-            $writableType = $this->modelCastHelper->getWriteableType(
-                $cast,
-                $this->stringResolver->resolve($column->writeableType),
-            );
         } else {
-            if (in_array($column->readableType, ['enum', 'set'], true)) {
+            $cast = $this->modelCastHelper->getCastForProperty($classReflection, $propertyName);
+
+            if ($cast !== null) {
+                $readableType = $this->modelCastHelper->getReadableType(
+                    $cast,
+                    $this->stringResolver->resolve($column->readableType),
+                );
+                $writableType = $this->modelCastHelper->getWriteableType(
+                    $cast,
+                    $this->stringResolver->resolve($column->writeableType),
+                );
+            } elseif (in_array($column->readableType, ['enum', 'set'], true)) {
                 if ($column->options === null || count($column->options) < 1) {
                     $readableType = $writableType = new StringType();
                 } else {
@@ -227,6 +227,6 @@ private function hasDate(Model $modelInstance, string $propertyName): bool
             $dates[] = $modelInstance->getDeletedAtColumn();
         }
 
-        return in_array($propertyName, $dates);
+        return in_array($propertyName, $dates, true);
     }
 }

tests/Type/GeneralTypeTest.php

@@ -78,6 +78,10 @@ public static function dataFileAsserts(): iterable
             yield from self::gatherAssertTypes(__DIR__ . '/data/bug-1819.php');
         }
 
+        if (version_compare(LARAVEL_VERSION, '11.0.0', '>=')) {
+            yield from self::gatherAssertTypes(__DIR__ . '/data/model-properties-l11.php');
+        }
+
         //##############################################################################################################
 
         // Console Commands

tests/Type/data/model-properties-l11.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace ModelPropertiesL11;
+
+use Illuminate\Database\Eloquent\Casts\AsStringable;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Support\Stringable;
+use function PHPStan\Testing\assertType;
+
+function test(ModelWithCasts $modelWithCasts): void
+{
+    assertType('bool', $modelWithCasts->integer);
+    assertType(Stringable::class, $modelWithCasts->string);
+}
+
+class ModelWithCasts extends Model
+{
+    protected $casts = [
+        'integer' => 'int',
+    ];
+
+    /**
+     * @return array{integer: 'bool', string: 'Illuminate\\Database\\Eloquent\\Casts\\AsStringable:argument'}
+     */
+    public function casts(): array
+    {
+        $argument = 'argument';
+
+        return [
+            'integer' => 'bool', // overrides the cast from the property
+            'string' => AsStringable::class.':'.$argument,
+        ];
+    }
+}

tests/application/database/migrations/2020_01_30_000000_create_model_with_casts_table.php.php

@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Database\Migrations;
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+
+class CreateModelWithCastsTable extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('model_with_casts', static function (Blueprint $table) {
+            $table->bigIncrements('id');
+
+            // Testing property casts
+            $table->integer('int');
+            $table->integer('integer');
+            $table->float('real');
+            $table->float('float');
+            $table->double('double');
+            $table->decimal('decimal');
+            $table->string('string');
+            $table->boolean('bool');
+            $table->boolean('boolean');
+            $table->json('object');
+            $table->json('array');
+            $table->json('json');
+            $table->json('collection');
+            $table->json('nullable_collection')->nullable();
+            $table->date('date');
+            $table->dateTime('datetime');
+            $table->date('immutable_date');
+            $table->dateTime('immutable_datetime');
+            $table->timestamp('timestamp');
+
+            $table->timestamps();
+            $table->softDeletes();
+        });
+    }
+}