feat: ignore static mixin/macro calls in facades

Author: calebdw

extension.neon

@@ -698,6 +698,11 @@ services:
         class: Illuminate\Filesystem\Filesystem
         autowired: self
 
+    -
+        class: Larastan\Larastan\Ignore\FacadeStaticCallIgnoreExtension
+        tags:
+            - phpstan.ignoreErrorExtension
+
 rules:
     - Larastan\Larastan\Rules\UselessConstructs\NoUselessWithFunctionCallsRule
     - Larastan\Larastan\Rules\UselessConstructs\NoUselessValueFunctionCallsRule

src/Ignore/FacadeStaticCallIgnoreExtension.php

@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Larastan\Larastan\Ignore;
+
+use Illuminate\Support\Facades\Facade;
+use PhpParser\Node;
+use PhpParser\Node\Expr\StaticCall;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Name;
+use PHPStan\Analyser\Error;
+use PHPStan\Analyser\IgnoreErrorExtension;
+use PHPStan\Analyser\Scope;
+use PHPStan\Type\ObjectType;
+
+final class FacadeStaticCallIgnoreExtension implements IgnoreErrorExtension
+{
+    public function shouldIgnore(Error $error, Node $node, Scope $scope): bool
+    {
+        if ($error->getIdentifier() !== 'method.staticCall') {
+            return false;
+        }
+
+        if (
+            ! $node instanceof StaticCall
+            || ! $node->name instanceof Identifier
+        ) {
+            return false;
+        }
+
+        $type = $node->class instanceof Name
+            ? $scope->resolveTypeByName($node->class)
+            : $scope->getType($node->class);
+
+        if (! (new ObjectType(Facade::class))->isSuperTypeOf($type)->yes()) {
+            return false;
+        }
+
+        $method = $node->name->toString();
+
+        foreach ($type->getObjectClassReflections() as $classReflection) {
+            if ($classReflection->hasNativeMethod($method)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

tests/Integration/IntegrationTest.php

@@ -31,6 +31,7 @@ public static function dataIntegrationTests(): iterable
         yield [__DIR__ . '/data/model-factories.php'];
         yield [__DIR__ . '/data/blade-view.php'];
         yield [__DIR__ . '/data/helpers.php'];
+        yield [__DIR__ . '/data/facade-static-call.php', [9 => ['Static call to instance method App\Facades\Importer::facadeMethod().']]];
 
         yield [
             __DIR__ . '/data/model-property-builder.php',

tests/Integration/data/facade-static-call.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace FacadeStaticCall;
+
+use App\Facades\Importer;
+
+Importer::foo();
+Importer::getKey();
+Importer::facadeMethod();

tests/application/app/Facades/Importer.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Facades;
+
+use App\Importer as Instance;
+use Illuminate\Support\Facades\Facade;
+use Illuminate\Support\Str;
+
+class Importer extends Facade
+{
+    protected static function getFacadeAccessor(): string
+    {
+        return Instance::class;
+    }
+
+    public function facadeMethod(): string
+    {
+        return Str::random(5);
+    }
+}

tests/application/app/Importer.php

@@ -5,9 +5,12 @@
 namespace App;
 
 use Illuminate\Support\Str;
+use Illuminate\Support\Traits\Macroable;
 
 class Importer
 {
+    use Macroable;
+
     /** @var bool */
     public $isImported;
 

tests/bootstrap.php

@@ -2,6 +2,7 @@
 
 declare(strict_types=1);
 
+use App\Importer;
 use Illuminate\Auth\RequestGuard;
 use Illuminate\Auth\SessionGuard;
 use Illuminate\Database\Eloquent\Builder;
@@ -36,6 +37,8 @@
 
 Cache::macro('rememberIf', static fn ($cond, $key, $ttl, $callback): mixed => $cond ? Cache::remember($key, $ttl, $callback) : $callback());
 
+Importer::macro('foo', fn () => $this);
+
 class CustomCollectionMacro
 {
     public function registerMacro(): void