skip type override

Author: TomasVotruba

phpstan.neon

@@ -326,6 +326,11 @@ parameters:
         - '#expects array<PhpParser\\Node\\Stmt>, array<PhpParser\\Node> given#'
         - '#should return non\-empty\-string but returns string#'
 
+        # known non-empty class method
+        -
+            message: '#Offset 0 might not exist on array<PhpParser\\Node\\Stmt>\|null#'
+            path: rules/DeadCode/Rector/ClassMethod/RemoveParentDelegatingConstructorRector.php
+
         # false positive, can accept non-class string
         - '#Parameter \#1 \$name of method PHPStan\\BetterReflection\\Reflection\\Adapter\\ReflectionClass\:\:getAttributes\(\) expects class\-string\|null, string given#'
 

rules/DeadCode/Rector/ClassMethod/RemoveParentDelegatingConstructorRector.php

@@ -13,9 +13,12 @@
 use PhpParser\Node\Stmt\Expression;
 use PhpParser\NodeVisitor;
 use PHPStan\Reflection\ClassReflection;
+use PHPStan\Reflection\ExtendedMethodReflection;
 use Rector\Enum\ObjectReference;
 use Rector\PHPStan\ScopeFetcher;
+use Rector\PHPStanStaticTypeMapper\Enum\TypeKind;
 use Rector\Rector\AbstractRector;
+use Rector\StaticTypeMapper\StaticTypeMapper;
 use Rector\ValueObject\MethodName;
 use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
 use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
@@ -25,6 +28,11 @@
  */
 final class RemoveParentDelegatingConstructorRector extends AbstractRector
 {
+    public function __construct(
+        private readonly StaticTypeMapper $staticTypeMapper,
+    ) {
+    }
+
     public function getRuleDefinition(): RuleDefinition
     {
         return new RuleDefinition(
@@ -86,7 +94,8 @@ public function refactor(Node $node): ?int
             return null;
         }
 
-        if (! $this->hasParentClassWithConstructor($node)) {
+        $parentMethodReflection = $this->matchParentConstructorReflection($node);
+        if (! $parentMethodReflection instanceof ExtendedMethodReflection) {
             return null;
         }
 
@@ -96,49 +105,38 @@ public function refactor(Node $node): ?int
             return null;
         }
 
-        $constructorParams = $node->getParams();
-        if (count($constructorParams) !== count($parentCallArgs)) {
+        // match count and order
+        if (! $this->isParameterAndArgCountAndOrderIdentical($node)) {
             return null;
         }
 
-        // match passed names in the same order
-        $paramNames = [];
-        foreach ($constructorParams as $constructorParam) {
-            $paramNames[] = $this->getName($constructorParam->var);
-        }
-
-        $argNames = [];
-        foreach ($parentCallArgs as $parentCallArg) {
-            $argValue = $parentCallArg->value;
-            if (! $argValue instanceof Variable) {
-                return null;
-            }
-
-            $argNames[] = $this->getName($argValue);
-        }
-
-        if ($paramNames !== $argNames) {
+        // match parameter types and parent constructor types
+        if (! $this->areConstructorAndParentParameterTypesMatching($node, $parentMethodReflection)) {
             return null;
         }
 
         return NodeVisitor::REMOVE_NODE;
     }
 
-    private function hasParentClassWithConstructor(ClassMethod $classMethod): bool
+    private function matchParentConstructorReflection(ClassMethod $classMethod): ?ExtendedMethodReflection
     {
         $scope = ScopeFetcher::fetch($classMethod);
 
         $classReflection = $scope->getClassReflection();
         if (! $classReflection instanceof ClassReflection) {
-            return false;
+            return null;
         }
 
         $parentClassReflection = $classReflection->getParentClass();
         if (! $parentClassReflection instanceof ClassReflection) {
-            return false;
+            return null;
+        }
+
+        if (! $parentClassReflection->hasConstructor()) {
+            return null;
         }
 
-        return $parentClassReflection->hasConstructor();
+        return $parentClassReflection->getConstructor();
     }
 
     /**
@@ -167,4 +165,70 @@ private function matchParentConstructorCallArgs(Stmt $stmt): ?array
 
         return $staticCall->getArgs();
     }
+
+    private function isParameterAndArgCountAndOrderIdentical(ClassMethod $classMethod): bool
+    {
+        $soleStmt = $classMethod->stmts[0];
+
+        $parentCallArgs = $this->matchParentConstructorCallArgs($soleStmt);
+        if ($parentCallArgs === null) {
+            return false;
+        }
+
+        $constructorParams = $classMethod->getParams();
+        if (count($constructorParams) !== count($parentCallArgs)) {
+            return false;
+        }
+
+        // match passed names in the same order
+        $paramNames = [];
+        foreach ($constructorParams as $constructorParam) {
+            $paramNames[] = $this->getName($constructorParam->var);
+        }
+
+        $argNames = [];
+        foreach ($parentCallArgs as $parentCallArg) {
+            $argValue = $parentCallArg->value;
+            if (! $argValue instanceof Variable) {
+                return false;
+            }
+
+            $argNames[] = $this->getName($argValue);
+        }
+
+        return $paramNames === $argNames;
+    }
+
+    private function areConstructorAndParentParameterTypesMatching(
+        ClassMethod $classMethod,
+        ExtendedMethodReflection $parentMethodReflection
+    ): bool {
+        foreach ($classMethod->getParams() as $position => $param) {
+            $parameterType = $param->type;
+
+            // no type override
+            if ($parameterType === null) {
+                continue;
+            }
+
+            $parametersSelector = $parentMethodReflection->getOnlyVariant();
+
+            foreach ($parametersSelector->getParameters() as $index => $parameterReflection) {
+                if ($index !== $position) {
+                    continue;
+                }
+
+                $parentParameterType = $this->staticTypeMapper->mapPHPStanTypeToPhpParserNode(
+                    $parameterReflection->getType(),
+                    TypeKind::PARAM
+                );
+
+                if (! $this->nodeComparator->areNodesEqual($parameterType, $parentParameterType)) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
 }