extract NodeTypeCorrector service to wrap similar logic

Author: TomasVotruba

src/NodeTypeResolver/NodeTypeCorrector.php

@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\NodeTypeResolver;
+
+use PHPStan\Type\Accessory\AccessoryArrayListType;
+use PHPStan\Type\IntersectionType;
+use PHPStan\Type\Type;
+use Rector\NodeTypeResolver\NodeTypeCorrector\AccessoryNonEmptyArrayTypeCorrector;
+use Rector\NodeTypeResolver\NodeTypeCorrector\AccessoryNonEmptyStringTypeCorrector;
+use Rector\NodeTypeResolver\NodeTypeCorrector\GenericClassStringTypeCorrector;
+
+/**
+ * This service correct unnecessary intersection/union types that do not bring any value.
+ * We focus on scalar types like "array", "string", "int" etc.,
+ * to print them as valid type declarations.
+ */
+final readonly class NodeTypeCorrector
+{
+    public function __construct(
+        private AccessoryNonEmptyStringTypeCorrector $accessoryNonEmptyStringTypeCorrector,
+        private GenericClassStringTypeCorrector $genericClassStringTypeCorrector,
+        private AccessoryNonEmptyArrayTypeCorrector $accessoryNonEmptyArrayTypeCorrector,
+    ) {
+    }
+
+    public function correctType(Type $type): Type
+    {
+        $type = $this->accessoryNonEmptyStringTypeCorrector->correct($type);
+        $type = $this->genericClassStringTypeCorrector->correct($type);
+
+        $type = $this->removeAccessoryArrayListType($type);
+
+        return $this->accessoryNonEmptyArrayTypeCorrector->correct($type);
+    }
+
+    private function removeAccessoryArrayListType(Type $type): Type
+    {
+        if (! $type instanceof IntersectionType) {
+            return $type;
+        }
+
+        $cleanTypes = [];
+        foreach ($type->getTypes() as $intersectionType) {
+            if ($intersectionType instanceof AccessoryArrayListType) {
+                continue;
+            }
+
+            $cleanTypes[] = $intersectionType;
+        }
+
+        if (count($cleanTypes) === 1) {
+            return $cleanTypes[0];
+        }
+
+        return new IntersectionType($cleanTypes);
+    }
+}

src/NodeTypeResolver/NodeTypeResolver.php

@@ -29,13 +29,11 @@
 use PHPStan\Reflection\ClassReflection;
 use PHPStan\Reflection\Native\NativeFunctionReflection;
 use PHPStan\Reflection\ReflectionProvider;
-use PHPStan\Type\Accessory\AccessoryArrayListType;
 use PHPStan\Type\ArrayType;
 use PHPStan\Type\Constant\ConstantArrayType;
 use PHPStan\Type\Constant\ConstantBooleanType;
 use PHPStan\Type\Constant\ConstantStringType;
 use PHPStan\Type\ErrorType;
-use PHPStan\Type\IntersectionType;
 use PHPStan\Type\MixedType;
 use PHPStan\Type\NeverType;
 use PHPStan\Type\NullType;
@@ -54,9 +52,6 @@
 use Rector\NodeTypeResolver\Contract\NodeTypeResolverAwareInterface;
 use Rector\NodeTypeResolver\Contract\NodeTypeResolverInterface;
 use Rector\NodeTypeResolver\Node\AttributeKey;
-use Rector\NodeTypeResolver\NodeTypeCorrector\AccessoryNonEmptyArrayTypeCorrector;
-use Rector\NodeTypeResolver\NodeTypeCorrector\AccessoryNonEmptyStringTypeCorrector;
-use Rector\NodeTypeResolver\NodeTypeCorrector\GenericClassStringTypeCorrector;
 use Rector\NodeTypeResolver\PHPStan\ObjectWithoutClassTypeWithParentTypes;
 use Rector\Php\PhpVersionProvider;
 use Rector\StaticTypeMapper\ValueObject\Type\AliasedObjectType;
@@ -82,10 +77,8 @@ final class NodeTypeResolver
     public function __construct(
         private readonly ObjectTypeSpecifier $objectTypeSpecifier,
         private readonly ClassAnalyzer $classAnalyzer,
-        private readonly GenericClassStringTypeCorrector $genericClassStringTypeCorrector,
+        private readonly NodeTypeCorrector $nodeTypeCorrector,
         private readonly ReflectionProvider $reflectionProvider,
-        private readonly AccessoryNonEmptyStringTypeCorrector $accessoryNonEmptyStringTypeCorrector,
-        private readonly AccessoryNonEmptyArrayTypeCorrector $accessoryNonEmptyArrayTypeCorrector,
         private readonly RenamedClassesDataCollector $renamedClassesDataCollector,
         private readonly NodeNameResolver $nodeNameResolver,
         private readonly PhpVersionProvider $phpVersionProvider,
@@ -203,7 +196,7 @@ public function getType(Node $node): Type
         $type = $this->resolveByNodeTypeResolvers($node);
 
         if ($type instanceof Type) {
-            $type = $this->correctType($type);
+            $type = $this->nodeTypeCorrector->correctType($type);
 
             if ($type instanceof ObjectType) {
                 $scope = $node->getAttribute(AttributeKey::SCOPE);
@@ -238,7 +231,7 @@ public function getType(Node $node): Type
             return new MixedType();
         }
 
-        $type = $this->correctType($scope->getType($node));
+        $type = $this->nodeTypeCorrector->correctType($scope->getType($node));
 
         // hot fix for phpstan not resolving chain method calls
         if (! $node instanceof MethodCall) {
@@ -286,7 +279,7 @@ public function getNativeType(Expr $expr): Type
                 return new ObjectWithoutClassType();
             }
 
-            return $this->correctType($type);
+            return $this->nodeTypeCorrector->correctType($type);
         }
 
         return $this->resolveNativeUnionType($type);
@@ -374,16 +367,6 @@ public function isMethodStaticCallOrClassMethodObjectType(Node $node, ObjectType
         return $classReflection->hasTraitUse($objectType->getClassName());
     }
 
-    private function correctType(Type $type): Type
-    {
-        $type = $this->accessoryNonEmptyStringTypeCorrector->correct($type);
-        $type = $this->genericClassStringTypeCorrector->correct($type);
-
-        $type = $this->cleanArrayIntersectionType($type);
-
-        return $this->accessoryNonEmptyArrayTypeCorrector->correct($type);
-    }
-
     /**
      * Allow pull type from
      *
@@ -680,25 +663,25 @@ private function isSubstrOnPHP74(FuncCall $funcCall): bool
         return ! $this->phpVersionProvider->isAtLeastPhpVersion(PhpVersion::PHP_80);
     }
 
-    private function cleanArrayIntersectionType(Type $type): Type
-    {
-        if (! $type instanceof IntersectionType) {
-            return $type;
-        }
-
-        $cleanTypes = [];
-        foreach ($type->getTypes() as $intersectionType) {
-            if ($intersectionType instanceof AccessoryArrayListType) {
-                continue;
-            }
-
-            $cleanTypes[] = $intersectionType;
-        }
-
-        if (count($cleanTypes) === 1) {
-            return $cleanTypes[0];
-        }
-
-        return new IntersectionType($cleanTypes);
-    }
+    //    private function cleanArrayIntersectionType(Type $type): Type
+    //    {
+    //        if (! $type instanceof IntersectionType) {
+    //            return $type;
+    //        }
+    //
+    //        $cleanTypes = [];
+    //        foreach ($type->getTypes() as $intersectionType) {
+    //            if ($intersectionType instanceof AccessoryArrayListType) {
+    //                continue;
+    //            }
+    //
+    //            $cleanTypes[] = $intersectionType;
+    //        }
+    //
+    //        if (count($cleanTypes) === 1) {
+    //            return $cleanTypes[0];
+    //        }
+    //
+    //        return new IntersectionType($cleanTypes);
+    //    }
 }