Fix resolving class reflections for self static calls

Author: savinmikhail

src/Reflection/ParameterReflection.php

@@ -11,7 +11,7 @@
 use PhpParser\Node\Expr\StaticCall;
 use PhpParser\Node\Identifier;
 use PhpParser\Node\Name;
-use PHPStan\Reflection\ClassMemberAccessAnswerer;
+use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\ExtendedParameterReflection;
 use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\ShouldNotHappenException;
@@ -56,12 +56,15 @@ private function getStaticMethodArgs(StaticCall $node): array
             return [];
         }
 
-        $className = $this->nodeNameResolver->getName(node: $node->class);
-        if (! $this->reflectionProvider->hasClass($className)) {
+        $scope = $node->getAttribute(key: AttributeKey::SCOPE);
+        if (! $scope instanceof Scope) {
             return [];
         }
 
-        $classReflection = $this->reflectionProvider->getClass($className);
+        $classReflection = $this->resolveClassReflectionFromName(name: $node->class, scope: $scope);
+        if ($classReflection === null) {
+            return [];
+        }
 
         if ($node->name instanceof Identifier) {
             $methodName = $node->name->name;
@@ -75,8 +78,6 @@ private function getStaticMethodArgs(StaticCall $node): array
             return [];
         }
 
-        /** @var ClassMemberAccessAnswerer $scope */
-        $scope = $node->getAttribute(key: AttributeKey::SCOPE);
         $reflection = $classReflection->getMethod(methodName: $methodName, scope: $scope);
 
         try {
@@ -106,7 +107,6 @@ private function getMethodArgs(MethodCall $node): array
             return [];
         }
 
-        /** @var ClassMemberAccessAnswerer $scope */
         $scope = $node->getAttribute(key: AttributeKey::SCOPE);
         $reflection = $callerType->getMethod($methodName, $scope);
 
@@ -201,4 +201,29 @@ private function resolveCalledName(Node $node): ?string
 
         return null;
     }
+
+    private function resolveClassReflectionFromName(Name $name, Scope $scope): ?\PHPStan\Reflection\ClassReflection
+    {
+        $className = $this->nodeNameResolver->getName(node: $name);
+
+        if ($className === null) {
+            return null;
+        }
+
+        $lowerClassName = strtolower($className);
+
+        if (in_array($lowerClassName, ['self', 'static'], true)) {
+            return $scope->getClassReflection();
+        }
+
+        if ($lowerClassName === 'parent') {
+            return $scope->getClassReflection()?->getParentClass();
+        }
+
+        if (! $this->reflectionProvider->hasClass($className)) {
+            return null;
+        }
+
+        return $this->reflectionProvider->getClass($className);
+    }
 }

src/Reflection/Reflection.php

@@ -10,10 +10,12 @@
 use PhpParser\Node\Expr\New_;
 use PhpParser\Node\Expr\StaticCall;
 use PhpParser\Node\Name;
+use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\ClassReflection;
 use PHPStan\Reflection\ExtendedParameterReflection;
 use PHPStan\Reflection\ReflectionProvider;
 use Rector\NodeNameResolver\NodeNameResolver;
+use Rector\NodeTypeResolver\Node\AttributeKey;
 use Rector\NodeTypeResolver\NodeTypeResolver;
 use ReflectionException;
 use ReflectionFunction;
@@ -132,19 +134,35 @@ public function getClassReflection(FuncCall|StaticCall|MethodCall|New_ $node): ?
         }
 
         if ($node instanceof StaticCall && $node->class instanceof Name) {
-            return $this->fetchClass($node->class);
+            return $this->fetchClass($node->class, $node);
         }
 
         if ($node instanceof New_ && $node->class instanceof Name) {
-            return $this->fetchClass($node->class);
+            return $this->fetchClass($node->class, $node);
         }
 
         return null;
     }
 
-    private function fetchClass(Name $name): ?ClassReflection
+    private function fetchClass(Name $name, Node $contextNode): ?ClassReflection
     {
         $className = $this->nodeNameResolver->getName(node: $name);
+        if ($className === null) {
+            return null;
+        }
+
+        $scope = $contextNode->getAttribute(key: AttributeKey::SCOPE);
+        if ($scope instanceof Scope) {
+            $lowerClassName = strtolower($className);
+
+            if (in_array($lowerClassName, ['self', 'static'], true)) {
+                return $scope->getClassReflection();
+            }
+
+            if ($lowerClassName === 'parent') {
+                return $scope->getClassReflection()?->getParentClass();
+            }
+        }
 
         return $this->reflectionProvider->hasClass($className)
             ? $this->reflectionProvider->getClass($className)

tests/DefaultStrategy/Fixture/static_self.php.inc

@@ -0,0 +1,95 @@
+<?php
+
+declare(strict_types=1);
+
+final class Article
+{
+    public const string SLUID_TAG = 'tag';
+
+    private array $newTaxonomyItems = [];
+    private array $currentAccessibleTaxonomyItems = [];
+
+    public function setTaxonomyItems(
+        array $newTaxonomyItems,
+        array $currentAccessibleTaxonomyItems,
+    ): void {
+        $this->newTaxonomyItems = $newTaxonomyItems;
+        $this->currentAccessibleTaxonomyItems = $currentAccessibleTaxonomyItems;
+    }
+}
+
+final class TestCase
+{
+    public static function taxonomyItems(): void
+    {
+        $taxonomyTypeRepository = 'test';
+
+        $article = new Article();
+        $article->setTaxonomyItems(
+            [
+                self::createTaxonomyItemByType(
+                    $taxonomyTypeRepository,
+                    Article::SLUID_TAG,
+                    'new-tag',
+                ),
+            ],
+            [],
+        );
+    }
+
+    public static function createTaxonomyItemByType(
+        string $taxonomyTypeRepository,
+        string $taxonomyTypeSlUid,
+        string $dutchLabel,
+    ): string {
+        return $taxonomyTypeRepository . $taxonomyTypeSlUid . $dutchLabel;
+    }
+}
+-----
+<?php
+
+declare(strict_types=1);
+
+final class Article
+{
+    public const string SLUID_TAG = 'tag';
+
+    private array $newTaxonomyItems = [];
+    private array $currentAccessibleTaxonomyItems = [];
+
+    public function setTaxonomyItems(
+        array $newTaxonomyItems,
+        array $currentAccessibleTaxonomyItems,
+    ): void {
+        $this->newTaxonomyItems = $newTaxonomyItems;
+        $this->currentAccessibleTaxonomyItems = $currentAccessibleTaxonomyItems;
+    }
+}
+
+final class TestCase
+{
+    public static function taxonomyItems(): void
+    {
+        $taxonomyTypeRepository = 'test';
+
+        $article = new Article();
+        $article->setTaxonomyItems(
+            newTaxonomyItems: [
+                self::createTaxonomyItemByType(
+                    taxonomyTypeRepository: $taxonomyTypeRepository,
+                    taxonomyTypeSlUid: Article::SLUID_TAG,
+                    dutchLabel: 'new-tag',
+                ),
+            ],
+            currentAccessibleTaxonomyItems: [],
+        );
+    }
+
+    public static function createTaxonomyItemByType(
+        string $taxonomyTypeRepository,
+        string $taxonomyTypeSlUid,
+        string $dutchLabel,
+    ): string {
+        return $taxonomyTypeRepository . $taxonomyTypeSlUid . $dutchLabel;
+    }
+}