[DX] Move from CLASS_METHOD node attribute to parent finder (#1167)

.phpstorm.meta.php

@@ -48,7 +48,6 @@
     0,
     \Rector\NodeTypeResolver\Node\AttributeKey::SCOPE,
     \Rector\NodeTypeResolver\Node\AttributeKey::CLASS_NAME,
-    \Rector\NodeTypeResolver\Node\AttributeKey::METHOD_NODE,
     \Rector\NodeTypeResolver\Node\AttributeKey::PARENT_NODE,
     \Rector\NodeTypeResolver\Node\AttributeKey::NEXT_NODE,
     \Rector\NodeTypeResolver\Node\AttributeKey::PREVIOUS_NODE,
@@ -73,7 +72,6 @@
     0,
     \Rector\NodeTypeResolver\Node\AttributeKey::SCOPE,
     \Rector\NodeTypeResolver\Node\AttributeKey::CLASS_NAME,
-    \Rector\NodeTypeResolver\Node\AttributeKey::METHOD_NODE,
     \Rector\NodeTypeResolver\Node\AttributeKey::PARENT_NODE,
     \Rector\NodeTypeResolver\Node\AttributeKey::NEXT_NODE,
     \Rector\NodeTypeResolver\Node\AttributeKey::PREVIOUS_NODE,

packages/NodeTypeResolver/Node/AttributeKey.php

@@ -40,7 +40,7 @@ final class AttributeKey
 
     /**
      * @deprecated Use
-     * @see BetterNodeFinder to find your parent nodes.
+     * @see BetterNodeFinder::findParentType($node, ClassLike::class) to find your parent nodes.
      *
      * @var string
      */
@@ -52,6 +52,9 @@ final class AttributeKey
     public const METHOD_NAME = 'methodName';
 
     /**
+     * @deprecated Use
+     * @see BetterNodeFinder::findParentType($node, ClassMethod::class) to find your parent nodes.
+     *
      * @var string
      */
     public const METHOD_NODE = 'methodNode';

packages/NodeTypeResolver/NodeTypeResolver/ParamTypeResolver.php

@@ -16,6 +16,7 @@
 use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfo;
 use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory;
 use Rector\Core\Exception\ShouldNotHappenException;
+use Rector\Core\PhpParser\Node\BetterNodeFinder;
 use Rector\NodeNameResolver\NodeNameResolver;
 use Rector\NodeTypeResolver\Contract\NodeTypeResolverInterface;
 use Rector\NodeTypeResolver\Node\AttributeKey;
@@ -36,7 +37,8 @@ final class ParamTypeResolver implements NodeTypeResolverInterface
     public function __construct(
         private SimpleCallableNodeTraverser $simpleCallableNodeTraverser,
         private NodeNameResolver $nodeNameResolver,
-        private PhpDocInfoFactory $phpDocInfoFactory
+        private PhpDocInfoFactory $phpDocInfoFactory,
+        private BetterNodeFinder $betterNodeFinder,
     ) {
     }
 
@@ -90,7 +92,7 @@ private function resolveFromParamType(Param $param): Type
 
     private function resolveFromFirstVariableUse(Param $param): Type
     {
-        $classMethod = $param->getAttribute(AttributeKey::METHOD_NODE);
+        $classMethod = $this->betterNodeFinder->findParentType($param, ClassMethod::class);
         if (! $classMethod instanceof ClassMethod) {
             return new MixedType();
         }

packages/NodeTypeResolver/NodeTypeResolver/VariableTypeResolver.php

@@ -20,11 +20,6 @@
  */
 final class VariableTypeResolver implements NodeTypeResolverInterface
 {
-    /**
-     * @var string[]
-     */
-    private const PARENT_NODE_ATTRIBUTES = [AttributeKey::PARENT_NODE, AttributeKey::METHOD_NODE];
-
     public function __construct(
         private NodeNameResolver $nodeNameResolver,
         private PhpDocInfoFactory $phpDocInfoFactory
@@ -76,31 +71,21 @@ private function resolveTypesFromScope(Variable $variable, string $variableName)
 
     private function resolveNodeScope(Variable $variable): ?Scope
     {
-        /** @var Scope|null $nodeScope */
-        $nodeScope = $variable->getAttribute(AttributeKey::SCOPE);
-        if ($nodeScope !== null) {
-            return $nodeScope;
+        $scope = $variable->getAttribute(AttributeKey::SCOPE);
+        if ($scope instanceof Scope) {
+            return $scope;
         }
 
         return $this->resolveFromParentNodes($variable);
     }
 
     private function resolveFromParentNodes(Variable $variable): ?Scope
     {
-        foreach (self::PARENT_NODE_ATTRIBUTES as $parentNodeAttribute) {
-            $parentNode = $variable->getAttribute($parentNodeAttribute);
-            if (! $parentNode instanceof Node) {
-                continue;
-            }
-
-            $parentNodeScope = $parentNode->getAttribute(AttributeKey::SCOPE);
-            if (! $parentNodeScope instanceof Scope) {
-                continue;
-            }
-
-            return $parentNodeScope;
+        $parent = $variable->getAttribute(AttributeKey::PARENT_NODE);
+        if (! $parent instanceof Node) {
+            return null;
         }
 
-        return null;
+        return $parent->getAttribute(AttributeKey::SCOPE);
     }
 }

rules/DeadCode/Rector/Assign/RemoveDoubleAssignRector.php

@@ -11,6 +11,7 @@
 use PhpParser\Node\Expr\StaticPropertyFetch;
 use PhpParser\Node\Expr\Ternary;
 use PhpParser\Node\Expr\Variable;
+use PhpParser\Node\Stmt\ClassMethod;
 use PhpParser\Node\Stmt\Expression;
 use Rector\Core\Rector\AbstractRector;
 use Rector\DeadCode\SideEffect\SideEffectNodeDetector;
@@ -120,9 +121,12 @@ private function isSelfReferencing(Assign $assign): bool
 
     private function areInSameClassMethod(Assign $assign, Expression $previousExpression): bool
     {
-        return $this->nodeComparator->areNodesEqual(
-            $assign->getAttribute(AttributeKey::METHOD_NODE),
-            $previousExpression->getAttribute(AttributeKey::METHOD_NODE)
+        $assignClassMethod = $this->betterNodeFinder->findParentType($assign, ClassMethod::class);
+        $previousExpressionClassMethod = $this->betterNodeFinder->findParentType(
+            $previousExpression,
+            ClassMethod::class
         );
+
+        return $this->nodeComparator->areNodesEqual($assignClassMethod, $previousExpressionClassMethod);
     }
 }

rules/DeadCode/Rector/Assign/RemoveUnusedVariableAssignRector.php

@@ -14,6 +14,7 @@
 use PhpParser\Node\Expr\StaticCall;
 use PhpParser\Node\Expr\Variable;
 use PhpParser\Node\FunctionLike;
+use PhpParser\Node\Stmt\ClassMethod;
 use PhpParser\Node\Stmt\Expression;
 use PhpParser\Node\Stmt\If_;
 use Rector\Core\Php\ReservedKeywordAnalyzer;
@@ -114,7 +115,7 @@ public function refactor(Node $node): ?Node
 
     private function shouldSkip(Assign $assign): bool
     {
-        $classMethod = $assign->getAttribute(AttributeKey::METHOD_NODE);
+        $classMethod = $this->betterNodeFinder->findParentType($assign, ClassMethod::class);
         if (! $classMethod instanceof FunctionLike) {
             return true;
         }

rules/DeadCode/Rector/StaticCall/RemoveParentCallWithoutParentRector.php

@@ -95,7 +95,7 @@ public function refactor(Node $node): ?Node
             return null;
         }
 
-        $classMethod = $node->getAttribute(AttributeKey::METHOD_NODE);
+        $classMethod = $this->betterNodeFinder->findParentType($node, ClassMethod::class);
         if (! $classMethod instanceof ClassMethod) {
             return null;
         }

rules/DependencyInjection/NodeAnalyzer/ControllerClassMethodAnalyzer.php

@@ -6,10 +6,16 @@
 
 use PhpParser\Node\Expr\Variable;
 use PhpParser\Node\Stmt\ClassMethod;
+use Rector\Core\PhpParser\Node\BetterNodeFinder;
 use Rector\NodeTypeResolver\Node\AttributeKey;
 
 final class ControllerClassMethodAnalyzer
 {
+    public function __construct(
+        private BetterNodeFinder $betterNodeFinder
+    ) {
+    }
+
     public function isInControllerActionMethod(Variable $variable): bool
     {
         /** @var string|null $className */
@@ -22,7 +28,7 @@ public function isInControllerActionMethod(Variable $variable): bool
             return false;
         }
 
-        $classMethod = $variable->getAttribute(AttributeKey::METHOD_NODE);
+        $classMethod = $this->betterNodeFinder->findParentType($variable, ClassMethod::class);
         if (! $classMethod instanceof ClassMethod) {
             return false;
         }

rules/DowngradePhp80/Rector/Class_/DowngradePropertyPromotionRector.php

@@ -14,6 +14,7 @@
 use PHPStan\Type\MixedType;
 use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfo;
 use Rector\BetterPhpDocParser\PhpDocManipulator\PhpDocTypeChanger;
+use Rector\Core\Exception\ShouldNotHappenException;
 use Rector\Core\NodeManipulator\ClassInsertManipulator;
 use Rector\Core\Rector\AbstractRector;
 use Rector\Core\ValueObject\MethodName;
@@ -219,8 +220,12 @@ private function createPropertiesFromParams(array $params): array
 
     private function decoratePropertyWithParamDocInfo(Param $param, Property $property): void
     {
-        $constructor = $param->getAttribute(AttributeKey::METHOD_NODE);
-        $phpDocInfo = $this->phpDocInfoFactory->createFromNode($constructor);
+        $constructorClassMethod = $this->betterNodeFinder->findParentType($param, ClassMethod::class);
+        if (! $constructorClassMethod instanceof ClassMethod) {
+            throw new ShouldNotHappenException();
+        }
+
+        $phpDocInfo = $this->phpDocInfoFactory->createFromNode($constructorClassMethod);
         if (! $phpDocInfo instanceof PhpDocInfo) {
             return;
         }

rules/PhpSpecToPHPUnit/PhpSpecMockCollector.php

@@ -10,6 +10,7 @@
 use PhpParser\Node\Stmt\Class_;
 use PhpParser\Node\Stmt\ClassMethod;
 use Rector\Core\Exception\ShouldNotHappenException;
+use Rector\Core\PhpParser\Node\BetterNodeFinder;
 use Rector\NodeNameResolver\NodeNameResolver;
 use Rector\NodeTypeResolver\Node\AttributeKey;
 use Symplify\Astral\NodeTraverser\SimpleCallableNodeTraverser;
@@ -33,7 +34,8 @@ final class PhpSpecMockCollector
 
     public function __construct(
         private SimpleCallableNodeTraverser $simpleCallableNodeTraverser,
-        private NodeNameResolver $nodeNameResolver
+        private NodeNameResolver $nodeNameResolver,
+        private BetterNodeFinder $betterNodeFinder,
     ) {
     }
 
@@ -101,7 +103,7 @@ private function addMockFromParam(Param $param): void
         /** @var string $class */
         $class = $param->getAttribute(AttributeKey::CLASS_NAME);
 
-        $classMethod = $param->getAttribute(AttributeKey::METHOD_NODE);
+        $classMethod = $this->betterNodeFinder->findParentType($param, ClassMethod::class);
         if (! $classMethod instanceof ClassMethod) {
             throw new ShouldNotHappenException();
         }

rules/PhpSpecToPHPUnit/Rector/MethodCall/PhpSpecMocksToPHPUnitMocksRector.php

@@ -135,7 +135,7 @@ private function createCreateMockCall(Param $param, Name $name): ?Expression
 
         $variable = $this->getName($param->var);
 
-        $classMethod = $param->getAttribute(AttributeKey::METHOD_NODE);
+        $classMethod = $this->betterNodeFinder->findParentType($param, ClassMethod::class);
         if (! $classMethod instanceof ClassMethod) {
             throw new ShouldNotHappenException();
         }

rules/Privatization/Rector/Class_/ChangeReadOnlyVariableWithDefaultValueToConstantRector.php

@@ -103,7 +103,7 @@ public function refactor(Node $node): ?Node
         }
 
         foreach ($readOnlyVariableAssigns as $readOnlyVariableAssign) {
-            $classMethod = $readOnlyVariableAssign->getAttribute(AttributeKey::METHOD_NODE);
+            $classMethod = $this->betterNodeFinder->findParentType($readOnlyVariableAssign, ClassMethod::class);
             if (! $classMethod instanceof ClassMethod) {
                 throw new ShouldNotHappenException();
             }

rules/Removing/NodeManipulator/ComplexNodeRemover.php

@@ -85,7 +85,7 @@ private function shouldSkipPropertyForClassMethod(
         StaticPropertyFetch | PropertyFetch $expr,
         array $classMethodNamesToSkip
     ): bool {
-        $classMethodNode = $expr->getAttribute(AttributeKey::METHOD_NODE);
+        $classMethodNode = $this->betterNodeFinder->findParentType($expr, ClassMethod::class);
         if (! $classMethodNode instanceof ClassMethod) {
             return false;
         }
@@ -111,7 +111,7 @@ private function resolveAssign(PropertyFetch | StaticPropertyFetch $expr): ?Assi
 
     private function removeConstructorDependency(Assign $assign): void
     {
-        $classMethod = $assign->getAttribute(AttributeKey::METHOD_NODE);
+        $classMethod = $this->betterNodeFinder->findParentType($assign, ClassMethod::class);
         if (! $classMethod instanceof  ClassMethod) {
             return;
         }

rules/RemovingStatic/Rector/ClassMethod/LocallyCalledStaticMethodToNonStaticRector.php

@@ -142,7 +142,7 @@ private function refactorStaticCall(StaticCall $staticCall): ?MethodCall
 
     private function isInStaticClassMethod(StaticCall $staticCall): bool
     {
-        $locationClassMethod = $staticCall->getAttribute(AttributeKey::METHOD_NODE);
+        $locationClassMethod = $this->betterNodeFinder->findParentType($staticCall, ClassMethod::class);
         if (! $locationClassMethod instanceof ClassMethod) {
             return false;
         }

rules/RemovingStatic/Rector/StaticCall/DesiredStaticCallTypeToDynamicRector.php

@@ -9,12 +9,12 @@
 use PhpParser\Node\Expr\PropertyFetch;
 use PhpParser\Node\Expr\StaticCall;
 use PhpParser\Node\Expr\Variable;
+use PhpParser\Node\Stmt\ClassMethod;
 use PHPStan\Type\ObjectType;
 use Rector\Core\Configuration\Option;
 use Rector\Core\Rector\AbstractRector;
 use Rector\Core\ValueObject\MethodName;
 use Rector\Naming\Naming\PropertyNaming;
-use Rector\NodeTypeResolver\Node\AttributeKey;
 use Symplify\PackageBuilder\Parameter\ParameterProvider;
 use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
 use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
@@ -92,7 +92,11 @@ public function refactor(Node $node): ?Node
 
             $propertyName = $this->propertyNaming->fqnToVariableName($staticObjectType);
 
-            $classMethod = $node->getAttribute(AttributeKey::METHOD_NODE);
+            $classMethod = $this->betterNodeFinder->findParentType($node, ClassMethod::class);
+            if (! $classMethod instanceof ClassMethod) {
+                return null;
+            }
+
             if ($this->nodeNameResolver->isName($classMethod, MethodName::CONSTRUCT)) {
                 $propertyFetch = new Variable($propertyName);
             } else {

rules/Transform/Rector/FuncCall/ArgumentFuncCallToMethodCallRector.php

@@ -16,7 +16,6 @@
 use Rector\Core\Rector\AbstractRector;
 use Rector\Naming\Naming\PropertyNaming;
 use Rector\Naming\ValueObject\ExpectedName;
-use Rector\NodeTypeResolver\Node\AttributeKey;
 use Rector\NodeTypeResolver\TypeAnalyzer\ArrayTypeAnalyzer;
 use Rector\PostRector\Collector\PropertyToAddCollector;
 use Rector\PostRector\ValueObject\PropertyMetadata;
@@ -161,10 +160,9 @@ public function configure(array $configuration): void
 
     private function shouldSkipFuncCall(FuncCall $funcCall): bool
     {
-        // we can inject only in injectable class method  context
         // we can inject only in injectable class method  context
         /** @var ClassMethod|null $classMethod */
-        $classMethod = $funcCall->getAttribute(AttributeKey::METHOD_NODE);
+        $classMethod = $this->betterNodeFinder->findParentType($funcCall, ClassMethod::class);
         if (! $classMethod instanceof ClassMethod) {
             return true;
         }

rules/Transform/Rector/FuncCall/FuncCallToMethodCallRector.php

@@ -10,7 +10,6 @@
 use PhpParser\Node\Stmt\ClassMethod;
 use Rector\Core\Contract\Rector\ConfigurableRectorInterface;
 use Rector\Core\Rector\AbstractRector;
-use Rector\NodeTypeResolver\Node\AttributeKey;
 use Rector\Transform\NodeAnalyzer\FuncCallStaticCallToMethodCallAnalyzer;
 use Rector\Transform\ValueObject\FuncCallToMethodCall;
 use Symplify\RuleDocGenerator\ValueObject\CodeSample\ConfiguredCodeSample;
@@ -98,7 +97,7 @@ public function refactor(Node $node): ?Node
             return null;
         }
 
-        $classMethod = $node->getAttribute(AttributeKey::METHOD_NODE);
+        $classMethod = $this->betterNodeFinder->findParentType($node, ClassMethod::class);
         if (! $classMethod instanceof ClassMethod) {
             return null;
         }

rules/Transform/Rector/StaticCall/StaticCallToMethodCallRector.php

@@ -14,7 +14,6 @@
 use Rector\Core\Contract\Rector\ConfigurableRectorInterface;
 use Rector\Core\Exception\ShouldNotHappenException;
 use Rector\Core\Rector\AbstractRector;
-use Rector\NodeTypeResolver\Node\AttributeKey;
 use Rector\Transform\NodeAnalyzer\FuncCallStaticCallToMethodCallAnalyzer;
 use Rector\Transform\ValueObject\StaticCallToMethodCall;
 use Symplify\RuleDocGenerator\ValueObject\CodeSample\ConfiguredCodeSample;
@@ -112,7 +111,7 @@ public function refactor(Node $node): ?Node
             return null;
         }
 
-        $classMethod = $node->getAttribute(AttributeKey::METHOD_NODE);
+        $classMethod = $this->betterNodeFinder->findParentType($node, ClassMethod::class);
         if (! $classMethod instanceof ClassMethod) {
             return null;
         }

rules/TypeDeclaration/TypeInferer/ParamTypeInferer/GetterNodeParamTypeInferer.php

@@ -75,7 +75,7 @@ public function inferParam(Param $param): Type
             }
 
             // what is return type?
-            $classMethod = $node->getAttribute(AttributeKey::METHOD_NODE);
+            $classMethod = $this->betterNodeFinder->findParentType($node, ClassMethod::class);
             if (! $classMethod instanceof ClassMethod) {
                 return null;
             }