fix: skip StaticCallToMethodCallRector when parent declares final __construct (#8001)

* fix: skip StaticCallToMethodCallRector when parent declares final __construct

When the nearest ancestor constructor is `final`, PHP forbids declaring
any `__construct` in the child class. Previously the rector cloned the
parent's `final __construct` and inserted it into the child, producing
"Cannot override final method ParentClass::__construct()".

Add `ClassDependencyManipulator::hasFinalParentConstructor()` to detect
this condition. `FuncCallStaticCallToMethodCallAnalyzer::matchTypeProvidingExpr()`
now returns `null` (and its return type is widened to include `null`)
when constructor injection is blocked by a final parent constructor.
Both `StaticCallToMethodCallRector` and `FuncCallToMethodCallRector`
skip the transformation when `null` is returned.

Fixes #9766

https://claude.ai/code/session_019aUU1dheeuij6J55RBaYdZ

* [ci-review] Rector Rectify

---------

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: GitHub Action <actions@github.com>

Author: 3 people

rules-tests/Transform/Rector/StaticCall/StaticCallToMethodCallRector/Fixture/skip_when_parent_has_final_construct.php.inc

@@ -0,0 +1,19 @@
+<?php
+
+namespace Rector\Tests\Transform\Rector\StaticCall\StaticCallToMethodCallRector\Fixture;
+
+use Illuminate\Support\Facades\App;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\MissingValue;
+use Rector\Tests\Transform\Rector\StaticCall\StaticCallToMethodCallRector\Source\ResourceWithFinalConstruct;
+
+class SkipWhenParentHasFinalConstruct extends ResourceWithFinalConstruct
+{
+    public function toArray(
+        Request $request,
+    ): array {
+        return [
+            'user_id' => $this->user_id ?? App::get(MissingValue::class),
+        ];
+    }
+}

rules-tests/Transform/Rector/StaticCall/StaticCallToMethodCallRector/Source/ResourceWithFinalConstruct.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Tests\Transform\Rector\StaticCall\StaticCallToMethodCallRector\Source;
+
+class ResourceWithFinalConstruct
+{
+    public $resource;
+
+    final public function __construct($resource)
+    {
+        $this->resource = $resource;
+    }
+}

rules/CodeQuality/Rector/CallLike/AddNameToBooleanArgumentRector.php

@@ -4,6 +4,7 @@
 
 namespace Rector\CodeQuality\Rector\CallLike;
 
+use PhpParser\Node\Expr;
 use PhpParser\Node;
 use PhpParser\Node\Expr\CallLike;
 use Rector\NodeAnalyzer\CallLikeArgumentNameAdder;
@@ -58,7 +59,7 @@ public function refactor(Node $node): ?Node
     {
         return $this->callLikeArgumentNameAdder->addNamesToArgs(
             $node,
-            fn ($expr): bool => $this->valueResolver->isTrueOrFalse($expr),
+            fn (Expr $expr): bool => $this->valueResolver->isTrueOrFalse($expr),
         );
     }
 

rules/CodeQuality/Rector/CallLike/AddNameToNullArgumentRector.php

@@ -4,6 +4,7 @@
 
 namespace Rector\CodeQuality\Rector\CallLike;
 
+use PhpParser\Node\Expr;
 use PhpParser\Node;
 use PhpParser\Node\Expr\CallLike;
 use Rector\NodeAnalyzer\CallLikeArgumentNameAdder;
@@ -58,7 +59,7 @@ public function refactor(Node $node): ?Node
     {
         return $this->callLikeArgumentNameAdder->addNamesToArgs(
             $node,
-            fn ($expr): bool => $this->valueResolver->isNull($expr),
+            fn (Expr $expr): bool => $this->valueResolver->isNull($expr),
         );
     }
 

rules/Transform/NodeAnalyzer/FuncCallStaticCallToMethodCallAnalyzer.php

@@ -36,7 +36,7 @@ public function matchTypeProvidingExpr(
         Class_ $class,
         ClassMethod $classMethod,
         ObjectType $objectType,
-    ): MethodCall | PropertyFetch | Variable {
+    ): MethodCall | PropertyFetch | Variable | null {
         $expr = $this->typeProvidingExprFromClassResolver->resolveTypeProvidingExprFromClass(
             $class,
             $classMethod,
@@ -51,6 +51,11 @@ public function matchTypeProvidingExpr(
             return $expr;
         }
 
+        // Cannot add constructor dependency when nearest parent constructor is final
+        if ($this->classDependencyManipulator->hasFinalParentConstructor($class)) {
+            return null;
+        }
+
         $propertyName = $this->propertyNaming->fqnToVariableName($objectType);
         $this->classDependencyManipulator->addConstructorDependency(
             $class,

rules/Transform/Rector/FuncCall/FuncCallToMethodCallRector.php

@@ -114,6 +114,10 @@ public function refactor(Node $node): ?Node
                         $funcNameToMethodCallName->getNewObjectType(),
                     );
 
+                    if ($expr === null) {
+                        return null;
+                    }
+
                     $hasChanged = true;
 
                     return $this->nodeFactory->createMethodCall(

rules/Transform/Rector/StaticCall/StaticCallToMethodCallRector.php

@@ -127,6 +127,10 @@ public function refactor(Node $node): ?Node
                         $staticCallToMethodCall->getClassObjectType(),
                     );
 
+                    if ($expr === null) {
+                        return null;
+                    }
+
                     $methodName = $this->getMethodName($node, $staticCallToMethodCall);
 
                     $hasChanged = true;

src/NodeAnalyzer/CallLikeArgumentNameAdder.php

@@ -4,6 +4,7 @@
 
 namespace Rector\NodeAnalyzer;
 
+use PhpParser\Node\Expr;
 use PhpParser\Node\Arg;
 use PhpParser\Node\Expr\CallLike;
 use PhpParser\Node\Identifier;
@@ -26,22 +27,22 @@ public function __construct(
      * argument whose value satisfies $shouldNameArgValue. All subsequent positional
      * arguments receive names too (required by PHP named-arg semantics).
      *
-     * @param callable(\PhpParser\Node\Expr): bool $shouldNameArgValue
+     * @param callable(Expr):bool $shouldNameArgValue
      */
-    public function addNamesToArgs(CallLike $node, callable $shouldNameArgValue): ?CallLike
+    public function addNamesToArgs(CallLike $callLike, callable $shouldNameArgValue): ?CallLike
     {
-        if ($this->shouldSkip($node)) {
+        if ($this->shouldSkip($callLike)) {
             return null;
         }
 
-        $reflection = $this->reflectionResolver->resolveFunctionLikeReflectionFromCall($node);
+        $reflection = $this->reflectionResolver->resolveFunctionLikeReflectionFromCall($callLike);
         if (! $reflection instanceof FunctionReflection && ! $reflection instanceof MethodReflection) {
             return null;
         }
 
-        $scope = ScopeFetcher::fetch($node);
-        $args = $node->getArgs();
-        $parameters = ParametersAcceptorSelectorVariantsWrapper::select($reflection, $node, $scope)
+        $scope = ScopeFetcher::fetch($callLike);
+        $args = $callLike->getArgs();
+        $parameters = ParametersAcceptorSelectorVariantsWrapper::select($reflection, $callLike, $scope)
             ->getParameters();
 
         $position = $this->resolveFirstPositionToName($args, $parameters, $shouldNameArgValue);
@@ -70,7 +71,7 @@ public function addNamesToArgs(CallLike $node, callable $shouldNameArgValue): ?C
             return null;
         }
 
-        return $node;
+        return $callLike;
     }
 
     private function shouldSkip(CallLike $callLike): bool
@@ -96,7 +97,7 @@ private function shouldSkip(CallLike $callLike): bool
     /**
      * @param Arg[] $args
      * @param ParameterReflection[] $parameters
-     * @param callable(\PhpParser\Node\Expr): bool $shouldNameArgValue
+     * @param callable(Expr):bool $shouldNameArgValue
      */
     private function resolveFirstPositionToName(array $args, array $parameters, callable $shouldNameArgValue): ?int
     {

src/NodeManipulator/ClassDependencyManipulator.php

@@ -189,6 +189,43 @@ public function addStmtsToConstructorIfNotThereYet(Class_ $class, array $stmts):
         $classMethod->stmts = array_merge($stmts, (array) $classMethod->stmts);
     }
 
+    public function hasFinalParentConstructor(Class_ $class): bool
+    {
+        if ($class->getMethod(MethodName::CONSTRUCT) instanceof ClassMethod) {
+            return false;
+        }
+
+        $classReflection = $this->reflectionResolver->resolveClassReflection($class);
+        if (! $classReflection instanceof ClassReflection) {
+            return false;
+        }
+
+        $ancestors = array_filter(
+            $classReflection->getAncestors(),
+            static fn (ClassReflection $ancestor): bool => $ancestor->getName() !== $classReflection->getName()
+        );
+
+        foreach ($ancestors as $ancestor) {
+            if (! $ancestor->hasNativeMethod(MethodName::CONSTRUCT)) {
+                continue;
+            }
+
+            $parentClass = $this->astResolver->resolveClassFromClassReflection($ancestor);
+            if (! $parentClass instanceof ClassLike) {
+                continue;
+            }
+
+            $parentConstructorMethod = $parentClass->getMethod(MethodName::CONSTRUCT);
+            if (! $parentConstructorMethod instanceof ClassMethod) {
+                continue;
+            }
+
+            return $parentConstructorMethod->isFinal();
+        }
+
+        return false;
+    }
+
     private function resolveConstruct(Class_ $class): ?ClassMethod
     {
         $constructorMethod = $class->getMethod(MethodName::CONSTRUCT);