Merge release 2.2.3 into 3.0.x (#214)

Author: github-actions[bot]

.github/workflows/release-on-milestone-closed.yml

@@ -8,7 +8,7 @@ on:
 jobs:
   release:
     name: "Git tag, release & create merge-up PR"
-    runs-on: "ubuntu-20.04"
+    runs-on: "ubuntu-latest"
 
     steps:
       - name: "Checkout"

phpstan-baseline.neon

@@ -9,7 +9,7 @@ parameters:
 		-
 			message: '#^Doing instanceof PHPStan\\Type\\ObjectType is error\-prone and deprecated\. Use Type\:\:isObject\(\) or Type\:\:getObjectClassNames\(\) instead\.$#'
 			identifier: phpstanApi.instanceofType
-			count: 3
+			count: 4
 			path: src/Rules/NoDynamicWhereRule.php
 
 		-

src/Rules/NoDynamicWhereRule.php

@@ -7,6 +7,7 @@
 use Illuminate\Database\Eloquent\Builder as EloquentBuilder;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsToMany;
+use Illuminate\Database\Eloquent\Relations\Relation;
 use Illuminate\Database\Query\Builder as QueryBuilder;
 use Larastan\Larastan\Methods\BuilderHelper;
 use PhpParser\Node;
@@ -76,7 +77,8 @@ public function processNode(Node $node, Scope $scope): array
         if (
             $calledOnType->isInstanceOf(Model::class)->no() &&
             $calledOnType->isInstanceOf(EloquentBuilder::class)->no() &&
-            $calledOnType->isInstanceOf(QueryBuilder::class)->no()
+            $calledOnType->isInstanceOf(QueryBuilder::class)->no() &&
+            $calledOnType->isInstanceOf(Relation::class)->no()
         ) {
             return [];
         }
@@ -130,13 +132,7 @@ public function processNode(Node $node, Scope $scope): array
 
     private function getCalledOnType(MethodCall $node, Scope $scope): Type
     {
-        $methodCall = $node;
-
-        while ($methodCall->var instanceof MethodCall) {
-            $methodCall = $methodCall->var;
-        }
-
-        $calledOnType = $scope->getType($methodCall->var);
+        $calledOnType = $scope->getType($node->var);
 
         if ($calledOnType instanceof ThisType) {
             $calledOnType = $calledOnType->getStaticObjectType();
@@ -164,6 +160,19 @@ private function findModel(ClassReflection $calledOnReflection): string|null
             return $modelType->getClassName();
         }
 
+        if (
+            $calledOnReflection->getName() === Relation::class ||
+            $calledOnReflection->isSubclassOf(Relation::class)
+        ) {
+            $modelType = $calledOnReflection->getActiveTemplateTypeMap()->getType('TRelatedModel');
+
+            if (! $modelType instanceof ObjectType) {
+                return null;
+            }
+
+            return $modelType->getClassName();
+        }
+
         return null;
     }
 }

tests/Rules/NoDynamicWhereRuleTest.php

@@ -44,6 +44,10 @@ public function testRule(): void
                 "Dynamic where method 'whereBaz' should not be used.",
                 51,
             ],
+            [
+                "Dynamic where method 'whereIsActive' should not be used.",
+                152,
+            ],
         ]);
     }
 }

tests/Rules/data/dynamic-where.php

@@ -72,41 +72,49 @@ public function whereBar(string $bar): CustomEloquentBuilder
 
 class ModelWithPivotWhereClauses extends Model
 {
+    /** @return BelongsToMany<Foo, $this> */
     public function fooWherePivot(): BelongsToMany
     {
         return $this->belongsToMany(Foo::class)->wherePivot('pivot_field', 1);
     }
 
+    /** @return BelongsToMany<Foo, $this> */
     public function fooWherePivotBetween(): BelongsToMany
     {
         return $this->belongsToMany(Foo::class)->wherePivotBetween('pivot_field', [1, 2]);
     }
 
+    /** @return BelongsToMany<Foo, $this> */
     public function fooWherePivotNotBetween(): BelongsToMany
     {
         return $this->belongsToMany(Foo::class)->wherePivotNotBetween('pivot_field', [1, 2]);
     }
 
+    /** @return BelongsToMany<Foo, $this> */
     public function fooWherePivotIn(): BelongsToMany
     {
         return $this->belongsToMany(Foo::class)->wherePivotIn('pivot_field', [1, 2]);
     }
 
+    /** @return BelongsToMany<Foo, $this> */
     public function fooWithPivotValue(): BelongsToMany
     {
         return $this->belongsToMany(Foo::class)->withPivotValue('pivot_field', 1);
     }
 
+    /** @return BelongsToMany<Foo, $this> */
     public function fooWherePivotNotIn(): BelongsToMany
     {
         return $this->belongsToMany(Foo::class)->wherePivotNotIn('pivot_field', [1, 2]);
     }
 
+    /** @return BelongsToMany<Foo, $this> */
     public function fooWherePivotNull(): BelongsToMany
     {
         return $this->belongsToMany(Foo::class)->wherePivotNull('pivot_field');
     }
 
+    /** @return BelongsToMany<Foo, $this> */
     public function fooWherePivotNotNull(): BelongsToMany
     {
         return $this->belongsToMany(Foo::class)->wherePivotNotNull('pivot_field');
@@ -129,3 +137,29 @@ public function scopeWhereFooBar($query): Builder
         return $query->where('foo', 'bar');
     }
 }
+
+class Account extends Model
+{
+    /** @return \Illuminate\Database\Eloquent\Relations\HasMany<AccountAction, $this> */
+    public function actions(): \Illuminate\Database\Eloquent\Relations\HasMany
+    {
+        return $this->hasMany(AccountAction::class);
+    }
+
+    public function hasActiveActions(): bool
+    {
+        if (rand(0, 100) > 40) {
+            return $this->actions()->whereIsActive()->exists();
+        }
+
+        return $this->actions()->whereActive()->exists();
+    }
+}
+
+class AccountAction extends Model
+{
+    public function scopeWhereActive(Builder $query): Builder
+    {
+        return $query->where('is_active', true);
+    }
+}