Rename ReflectionAstResolver to simple AstResolver (#300)

rules/DeadCode/Rector/MethodCall/RemoveEmptyMethodCallRector.php

@@ -16,8 +16,8 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\ThisType;
+use Rector\Core\PhpParser\AstResolver;
 use Rector\Core\Rector\AbstractRector;
-use Rector\Core\Reflection\ReflectionAstResolver;
 use Rector\NodeTypeResolver\Node\AttributeKey;
 use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
 use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
@@ -28,7 +28,7 @@
 final class RemoveEmptyMethodCallRector extends AbstractRector
 {
     public function __construct(
-        private ReflectionAstResolver $reflectionAstResolver
+        private AstResolver $reflectionAstResolver
     ) {
     }
 
@@ -89,7 +89,7 @@ public function refactor(Node $node): ?Node
             return null;
         }
 
-        $class = $this->reflectionAstResolver->resolveObjectType($type);
+        $class = $this->reflectionAstResolver->resolveClassFromObjectType($type);
         if ($this->shouldSkipClassMethod($class, $node)) {
             return null;
         }

rules/Defluent/NodeAnalyzer/FluentChainMethodCallNodeAnalyzer.php

@@ -17,7 +17,7 @@
 use PHPStan\Type\MixedType;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\Type;
-use Rector\Defluent\Reflection\MethodCallToClassMethodParser;
+use Rector\Core\PhpParser\AstResolver;
 use Rector\NodeNameResolver\NodeNameResolver;
 use Rector\NodeTypeResolver\Node\AttributeKey;
 use Rector\NodeTypeResolver\NodeTypeResolver;
@@ -40,7 +40,7 @@ public function __construct(
         private NodeNameResolver $nodeNameResolver,
         private NodeTypeResolver $nodeTypeResolver,
         private NodeFinder $nodeFinder,
-        private MethodCallToClassMethodParser $methodCallToClassMethodParser
+        private AstResolver $astResolver
     ) {
     }
 
@@ -224,7 +224,7 @@ private function isCall(Expr $expr): bool
 
     private function isMethodCallCreatingNewInstance(MethodCall $methodCall): bool
     {
-        $classMethod = $this->methodCallToClassMethodParser->parseMethodCall($methodCall);
+        $classMethod = $this->astResolver->resolveClassMethodFromMethodCall($methodCall);
         if (! $classMethod instanceof ClassMethod) {
             return false;
         }

rules/Php80/Rector/ClassMethod/OptionalParametersAfterRequiredRector.php

@@ -10,13 +10,13 @@
 use PhpParser\Node\Stmt\ClassMethod;
 use PHPStan\Reflection\MethodReflection;
 use PHPStan\Type\TypeWithClassName;
+use Rector\Core\PhpParser\AstResolver;
 use Rector\Core\PHPStan\Reflection\CallReflectionResolver;
 use Rector\Core\PHPStan\Reflection\ClassMethodReflectionResolver;
 use Rector\Core\Rector\AbstractRector;
 use Rector\Core\ValueObject\MethodName;
 use Rector\Php80\NodeResolver\ArgumentSorter;
 use Rector\Php80\NodeResolver\RequireOptionalParamResolver;
-use Rector\Php80\Reflection\MethodReflectionClassMethodResolver;
 use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
 use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
 
@@ -30,9 +30,9 @@ final class OptionalParametersAfterRequiredRector extends AbstractRector
     public function __construct(
         private RequireOptionalParamResolver $requireOptionalParamResolver,
         private ArgumentSorter $argumentSorter,
-        private MethodReflectionClassMethodResolver $methodReflectionClassMethodResolver,
         private CallReflectionResolver $callReflectionResolver,
-        private ClassMethodReflectionResolver $classMethodReflectionResolver
+        private ClassMethodReflectionResolver $classMethodReflectionResolver,
+        private AstResolver $astResolver
     ) {
     }
 
@@ -126,7 +126,7 @@ private function refactorNew(New_ $new): ?New_
             return null;
         }
 
-        $classMethod = $this->methodReflectionClassMethodResolver->resolve(
+        $classMethod = $this->astResolver->resolveClassMethod(
             $newClassType->getClassName(),
             MethodName::CONSTRUCT
         );

rules/TypeDeclaration/TypeInferer/ReturnTypeInferer/ReturnedNodesReturnTypeInferer.php

@@ -22,9 +22,9 @@
 use PHPStan\Type\MixedType;
 use PHPStan\Type\Type;
 use PHPStan\Type\VoidType;
+use Rector\Core\PhpParser\AstResolver;
 use Rector\Core\PhpParser\Printer\BetterStandardPrinter;
 use Rector\Core\PHPStan\Reflection\CallReflectionResolver;
-use Rector\Core\Reflection\ReflectionAstResolver;
 use Rector\NodeTypeResolver\Node\AttributeKey;
 use Rector\NodeTypeResolver\NodeTypeResolver;
 use Rector\NodeTypeResolver\PHPStan\Type\TypeFactory;
@@ -42,7 +42,7 @@ public function __construct(
         private TypeFactory $typeFactory,
         private SplArrayFixedTypeNarrower $splArrayFixedTypeNarrower,
         private CallReflectionResolver $callReflectionResolver,
-        private ReflectionAstResolver $reflectionAstResolver,
+        private AstResolver $reflectionAstResolver,
         private BetterStandardPrinter $betterStandardPrinter
     ) {
     }
@@ -188,7 +188,7 @@ private function correctWithNestedType(Type $resolvedType, Return_ $return, Func
 
     private function resolveClassMethod(MethodReflection $methodReflection, FunctionLike $originalFunctionLike): Type
     {
-        $classMethod = $this->reflectionAstResolver->resolveMethodReflection($methodReflection);
+        $classMethod = $this->reflectionAstResolver->resolveClassMethodFromMethodReflection($methodReflection);
         if (! $classMethod instanceof ClassMethod) {
             return new MixedType();
         }
@@ -205,7 +205,7 @@ private function resolveClassMethod(MethodReflection $methodReflection, Function
 
     private function resolveFunction(PhpFunctionReflection $phpFunctionReflection, FunctionLike $functionLike): Type
     {
-        $function = $this->reflectionAstResolver->parseFunctionReflection($phpFunctionReflection);
+        $function = $this->reflectionAstResolver->resolveFunctionFromFunctionReflection($phpFunctionReflection);
         if (! $function instanceof Function_) {
             return new MixedType();
         }

src/Reflection/ReflectionAstResolver.php → src/PhpParser/AstResolver.php

@@ -2,9 +2,10 @@
 
 declare(strict_types=1);
 
-namespace Rector\Core\Reflection;
+namespace Rector\Core\PhpParser;
 
 use PhpParser\Node;
+use PhpParser\Node\Expr\MethodCall;
 use PhpParser\Node\Stmt\Class_;
 use PhpParser\Node\Stmt\ClassMethod;
 use PhpParser\Node\Stmt\Function_;
@@ -15,14 +16,21 @@
 use PHPStan\Reflection\Php\PhpFunctionReflection;
 use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Type\ObjectType;
+use PHPStan\Type\TypeWithClassName;
 use Rector\Core\PhpParser\Node\BetterNodeFinder;
+use Rector\Core\Reflection\ReflectionResolver;
 use Rector\Core\ValueObject\Application\File;
 use Rector\NodeNameResolver\NodeNameResolver;
 use Rector\NodeTypeResolver\NodeScopeAndMetadataDecorator;
+use Rector\NodeTypeResolver\NodeTypeResolver;
 use Symplify\SmartFileSystem\SmartFileInfo;
 use Symplify\SmartFileSystem\SmartFileSystem;
 
-final class ReflectionAstResolver
+/**
+ * The nodes provided by this resolver is for read-only analysis only!
+ * They are not part of node tree processed by Rector, so any changes will not make effect in final printed file.
+ */
+final class AstResolver
 {
     public function __construct(
         private Parser $parser,
@@ -31,21 +39,23 @@ public function __construct(
         private NodeScopeAndMetadataDecorator $nodeScopeAndMetadataDecorator,
         private BetterNodeFinder $betterNodeFinder,
         private NodeNameResolver $nodeNameResolver,
-        private ReflectionProvider $reflectionProvider
+        private ReflectionProvider $reflectionProvider,
+        private ReflectionResolver $reflectionResolver,
+        private NodeTypeResolver $nodeTypeResolver,
     ) {
     }
 
-    public function resolveObjectType(ObjectType $objectType): ?Class_
+    public function resolveClassFromObjectType(ObjectType $objectType): ?Class_
     {
         if (! $this->reflectionProvider->hasClass($objectType->getClassName())) {
             return null;
         }
 
         $classReflection = $this->reflectionProvider->getClass($objectType->getClassName());
-        return $this->resolveClassReflection($classReflection, $objectType->getClassName());
+        return $this->resolveClassFromClassReflection($classReflection, $objectType->getClassName());
     }
 
-    public function resolveMethodReflection(MethodReflection $methodReflection): ?ClassMethod
+    public function resolveClassMethodFromMethodReflection(MethodReflection $methodReflection): ?ClassMethod
     {
         $classReflection = $methodReflection->getDeclaringClass();
 
@@ -74,7 +84,7 @@ public function resolveMethodReflection(MethodReflection $methodReflection): ?Cl
         return $class->getMethod($methodReflection->getName());
     }
 
-    public function parseFunctionReflection(PhpFunctionReflection $phpFunctionReflection): ?Function_
+    public function resolveFunctionFromFunctionReflection(PhpFunctionReflection $phpFunctionReflection): ?Function_
     {
         $fileName = $phpFunctionReflection->getFileName();
         if ($fileName === false) {
@@ -106,7 +116,43 @@ public function parseFunctionReflection(PhpFunctionReflection $phpFunctionReflec
         return null;
     }
 
-    private function resolveClassReflection(ClassReflection $classReflection, string $className): ?Class_
+    /**
+     * @param class-string $className
+     */
+    public function resolveClassMethod(string $className, string $methodName): ?ClassMethod
+    {
+        $methodReflection = $this->reflectionResolver->resolveMethodReflection($className, $methodName);
+        if ($methodReflection === null) {
+            return null;
+        }
+
+        return $this->resolveClassMethodFromMethodReflection($methodReflection);
+    }
+
+    public function resolveClassMethodFromMethodCall(MethodCall $methodCall): ?ClassMethod
+    {
+        $callerStaticType = $this->nodeTypeResolver->getStaticType($methodCall->var);
+        if (! $callerStaticType instanceof TypeWithClassName) {
+            return null;
+        }
+
+        $methodName = $this->nodeNameResolver->getName($methodCall->name);
+        if ($methodName === null) {
+            return null;
+        }
+
+        $methodReflection = $this->reflectionResolver->resolveMethodReflection(
+            $callerStaticType->getClassName(),
+            $methodName
+        );
+        if ($methodReflection === null) {
+            return null;
+        }
+
+        return $this->resolveClassMethodFromMethodReflection($methodReflection);
+    }
+
+    private function resolveClassFromClassReflection(ClassReflection $classReflection, string $className): ?Class_
     {
         if ($classReflection->isBuiltin()) {
             return null;
@@ -120,9 +166,6 @@ private function resolveClassReflection(ClassReflection $classReflection, string
 
         /** @var Class_[] $classes */
         $classes = $this->betterNodeFinder->findInstanceOf($contentNodes, Class_::class);
-        if ($classes === []) {
-            return null;
-        }
 
         $reflectionClassName = $classReflection->getName();
         foreach ($classes as $class) {

src/PhpParser/Node/NodeFactory.php

@@ -52,7 +52,7 @@
 use Rector\Core\Exception\NotImplementedYetException;
 use Rector\Core\Exception\ShouldNotHappenException;
 use Rector\Core\Php\PhpVersionProvider;
-use Rector\Core\Reflection\ReflectionAstResolver;
+use Rector\Core\PhpParser\AstResolver;
 use Rector\Core\ValueObject\MethodName;
 use Rector\Core\ValueObject\PhpVersionFeature;
 use Rector\NodeNameResolver\NodeNameResolver;
@@ -101,7 +101,7 @@ public function __construct(
         private NodeNameResolver $nodeNameResolver,
         private PhpDocTypeChanger $phpDocTypeChanger,
         private CurrentNodeProvider $currentNodeProvider,
-        private ReflectionAstResolver $reflectionAstResolver,
+        private AstResolver $reflectionAstResolver,
     ) {
     }
 
@@ -534,7 +534,7 @@ public function createTrue(): ConstFetch
 
     public function createClosureFromMethodReflection(MethodReflection $methodReflection): Closure
     {
-        $classMethod = $this->reflectionAstResolver->resolveMethodReflection($methodReflection);
+        $classMethod = $this->reflectionAstResolver->resolveClassMethodFromMethodReflection($methodReflection);
         if (! $classMethod instanceof ClassMethod) {
             throw new ShouldNotHappenException();
         }