resolve self/static class name via node type instead of scope reflection

Author: TomasVotruba

phpstan.neon

@@ -84,25 +84,15 @@ parameters:
         -
             identifier: rector.getClassReflectionOnScope
             paths:
-                - rules/CodeQuality/Rector/Class_/ConvertStaticToSelfRector.php
                 - rules/DeadCode/Rector/ClassMethod/RemoveReturnTagIncompatibleWithNativeTypeRector.php
                 - rules/DeadCode/Rector/If_/RemoveAlwaysTrueIfConditionRector.php
                 - rules/Php55/Rector/FuncCall/GetCalledClassToStaticClassRector.php
-                - rules/Php70/Rector/ClassMethod/Php4ConstructorRector.php
-                - rules/Php70/Rector/MethodCall/ThisCallOnStaticMethodToStaticCallRector.php
                 - rules/Php81/Rector/Array_/ArrayToFirstClassCallableRector.php
-                - rules/Php81/Rector/FuncCall/NullToStrictIntPregSlitFuncCallLimitArgRector.php
-                - rules/Php81/Rector/FuncCall/NullToStrictStringFuncCallArgRector.php
                 - rules/Php81/Rector/New_/MyCLabsConstructorCallToEnumFromRector.php
-                - rules/Php82/NodeManipulator/ReadonlyClassManipulator.php
-                - rules/Php85/Rector/FuncCall/ArrayKeyExistsNullToEmptyStringRector.php
                 - rules/Renaming/Rector/MethodCall/RenameMethodRector.php
                 - rules/TypeDeclaration/PHPStan/ObjectTypeSpecifier.php
-                - rules/TypeDeclaration/Rector/ClassMethod/AddVoidReturnTypeWhereNoReturnRector.php
-                - rules/TypeDeclaration/Rector/ClassMethod/ReturnTypeFromMockObjectRector.php
                 - rules/TypeDeclaration/Rector/Closure/ClosureReturnTypeFromAssertInstanceOfRector.php
                 - src/Application/ChangedNodeScopeRefresher.php
-                - src/NodeCollector/ScopeResolver/ParentClassScopeResolver.php
                 - src/NodeTypeResolver/NodeTypeResolver.php
                 - src/NodeTypeResolver/NodeTypeResolver/ClassAndInterfaceTypeResolver.php
                 - src/NodeTypeResolver/NodeTypeResolver/NameTypeResolver.php

rules/TypeDeclaration/Rector/ClassMethod/ReturnTypeFromReturnNewRector.php

@@ -12,7 +12,6 @@
 use PhpParser\Node\Stmt\ClassMethod;
 use PhpParser\Node\Stmt\Function_;
 use PhpParser\Node\Stmt\Return_;
-use PHPStan\Reflection\ClassReflection;
 use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\ObjectWithoutClassType;
@@ -27,9 +26,9 @@
 use Rector\PHPStan\ScopeFetcher;
 use Rector\PHPStanStaticTypeMapper\Enum\TypeKind;
 use Rector\Rector\AbstractRector;
-use Rector\Reflection\ReflectionResolver;
 use Rector\RuleDoc\CodeSample\CodeSample;
 use Rector\RuleDoc\RuleDefinition;
+use Rector\StaticTypeMapper\Resolver\ClassNameFromObjectTypeResolver;
 use Rector\StaticTypeMapper\StaticTypeMapper;
 use Rector\StaticTypeMapper\ValueObject\Type\SelfStaticType;
 use Rector\Symfony\CodeQuality\Enum\ResponseClass;
@@ -48,7 +47,6 @@ final class ReturnTypeFromReturnNewRector extends AbstractRector implements MinP
     public function __construct(
         private readonly TypeFactory $typeFactory,
         private readonly ReflectionProvider $reflectionProvider,
-        private readonly ReflectionResolver $reflectionResolver,
         private readonly StrictReturnNewAnalyzer $strictReturnNewAnalyzer,
         private readonly ClassMethodReturnTypeOverrideGuard $classMethodReturnTypeOverrideGuard,
         private readonly ClassAnalyzer $classAnalyzer,
@@ -156,11 +154,14 @@ private function createObjectTypeFromNew(New_ $new): ObjectType|ObjectWithoutCla
 
         $className = $this->getName($new->class);
         if ($className === ObjectReference::STATIC || $className === ObjectReference::SELF) {
-            $classReflection = $this->reflectionResolver->resolveClassReflection($new);
-            if (! $classReflection instanceof ClassReflection) {
+            $classType = $this->nodeTypeResolver->getType($new->class);
+            $resolvedClassName = ClassNameFromObjectTypeResolver::resolve($classType);
+            if ($resolvedClassName === null || ! $this->reflectionProvider->hasClass($resolvedClassName)) {
                 throw new ShouldNotHappenException();
             }
 
+            $classReflection = $this->reflectionProvider->getClass($resolvedClassName);
+
             if ($className === ObjectReference::SELF) {
                 return new SelfStaticType($classReflection);
             }

src/NodeTypeResolver/NodeTypeResolver/ClassAndInterfaceTypeResolver.php

@@ -7,14 +7,11 @@
 use PhpParser\Node;
 use PhpParser\Node\Stmt\Class_;
 use PhpParser\Node\Stmt\Interface_;
-use PHPStan\Analyser\Scope;
-use PHPStan\Reflection\ClassReflection;
-use PHPStan\Type\MixedType;
+use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\Type;
 use Rector\NodeNameResolver\NodeNameResolver;
 use Rector\NodeTypeResolver\Contract\NodeTypeResolverInterface;
-use Rector\NodeTypeResolver\Node\AttributeKey;
 
 /**
  * @see \Rector\Tests\NodeTypeResolver\PerNodeTypeResolver\ClassAndInterfaceTypeResolver\ClassTypeResolverTest
@@ -25,7 +22,8 @@
 final readonly class ClassAndInterfaceTypeResolver implements NodeTypeResolverInterface
 {
     public function __construct(
-        private NodeNameResolver $nodeNameResolver
+        private NodeNameResolver $nodeNameResolver,
+        private ReflectionProvider $reflectionProvider,
     ) {
     }
 
@@ -42,18 +40,11 @@ public function getNodeClasses(): array
      */
     public function resolve(Node $node): Type
     {
-        $scope = $node->getAttribute(AttributeKey::SCOPE);
-
-        if (! $scope instanceof Scope) {
-            // new node probably
-            return new MixedType();
-        }
-
-        $classReflection = $scope->getClassReflection();
-        if (! $classReflection instanceof ClassReflection) {
-            return new ObjectType((string) $this->nodeNameResolver->getName($node));
+        $className = $this->nodeNameResolver->getName($node);
+        if ($className === null || ! $this->reflectionProvider->hasClass($className)) {
+            return new ObjectType((string) $className);
         }
 
-        return new ObjectType($classReflection->getName(), null, $classReflection);
+        return new ObjectType($className, null, $this->reflectionProvider->getClass($className));
     }
 }

src/PhpParser/Node/Value/ValueResolver.php

@@ -74,9 +74,10 @@ public function getValue(Arg|Expr|InterpolatedStringPart $expr, bool $resolvedCl
             $class = $this->nodeNameResolver->getName($expr->class);
 
             if (in_array($class, [ObjectReference::SELF, ObjectReference::STATIC], true)) {
-                $classReflection = $this->reflectionResolver->resolveClassReflection($expr);
-                if ($classReflection instanceof ClassReflection) {
-                    return $classReflection->getName();
+                $classType = $this->nodeTypeResolver->getType($expr->class);
+                $className = ClassNameFromObjectTypeResolver::resolve($classType);
+                if ($className !== null) {
+                    return $className;
                 }
             }
 
@@ -333,18 +334,20 @@ private function resolveClassFromSelfStaticParent(ClassConstFetch $classConstFet
             return '';
         }
 
-        $classReflection = $this->reflectionResolver->resolveClassReflection($classConstFetch);
-        if (! $classReflection instanceof ClassReflection) {
-            throw new ShouldNotHappenException(
-                'Complete class parent node for to class const fetch, so "self" or "static" references is resolvable to a class name'
-            );
-        }
-
         if ($class !== ObjectReference::PARENT) {
-            return $classReflection->getName();
+            $classType = $this->nodeTypeResolver->getType($classConstFetch->class);
+            $className = ClassNameFromObjectTypeResolver::resolve($classType);
+            if ($className === null) {
+                throw new ShouldNotHappenException(
+                    'Complete class parent node for to class const fetch, so "self" or "static" references is resolvable to a class name'
+                );
+            }
+
+            return $className;
         }
 
-        if (! $classReflection->isClass()) {
+        $classReflection = $this->reflectionResolver->resolveClassReflection($classConstFetch);
+        if (! $classReflection instanceof ClassReflection || ! $classReflection->isClass()) {
             throw new ShouldNotHappenException(
                 'Complete class parent node for to class const fetch, so "parent" references is resolvable to lookup parent class'
             );