Home cleaning with Exacat 😎 (#2676)

* cleanup unused normalized params

* remove unused createClosureFromClassMethod

* early return

* clean assign to array

* skip false postives in phpsta

* clean getTokens()

* remove unused FrameworkName class

* simplify RenameVariableToMatchMethodCallReturnTypeRector

* cleanup remove unused unwrapNullableType()

* apply new RenameVariableToMatchMethodCallReturnTypeRector

* apply new RenameVariableToMatchMethodCallReturnTypeRector

* union type juggling

packages/BetterPhpDocParser/PhpDocParser/BetterPhpDocParser.php

@@ -96,14 +96,14 @@ public function parseTag(TokenIterator $tokenIterator): PhpDocTagNode
     public function parseTagValue(TokenIterator $tokenIterator, string $tag): PhpDocTagValueNode
     {
         $startPosition = $tokenIterator->currentPosition();
-        $tagValueNode = parent::parseTagValue($tokenIterator, $tag);
+        $phpDocTagValueNode = parent::parseTagValue($tokenIterator, $tag);
 
         $endPosition = $tokenIterator->currentPosition();
 
         $startAndEnd = new StartAndEnd($startPosition, $endPosition);
-        $tagValueNode->setAttribute(PhpDocAttributeKey::START_AND_END, $startAndEnd);
+        $phpDocTagValueNode->setAttribute(PhpDocAttributeKey::START_AND_END, $startAndEnd);
 
-        return $tagValueNode;
+        return $phpDocTagValueNode;
     }
 
     /**

packages/BetterPhpDocParser/PhpDocParser/PhpDocFromTypeDeclarationDecorator.php

@@ -18,14 +18,14 @@
 use PHPStan\PhpDocParser\Ast\PhpDoc\ReturnTagValueNode;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
 use PHPStan\Type\UnionType;
 use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory;
 use Rector\BetterPhpDocParser\PhpDocManipulator\PhpDocTypeChanger;
 use Rector\Core\PhpParser\Node\BetterNodeFinder;
 use Rector\NodeNameResolver\NodeNameResolver;
 use Rector\Php80\NodeAnalyzer\PhpAttributeAnalyzer;
 use Rector\PhpAttribute\NodeFactory\PhpAttributeGroupFactory;
-use Rector\PHPStanStaticTypeMapper\Utils\TypeUnwrapper;
 use Rector\StaticTypeMapper\StaticTypeMapper;
 use ReturnTypeWillChange;
 
@@ -56,7 +56,6 @@ public function __construct(
         private readonly PhpDocInfoFactory $phpDocInfoFactory,
         private readonly NodeNameResolver $nodeNameResolver,
         private readonly PhpDocTypeChanger $phpDocTypeChanger,
-        private readonly TypeUnwrapper $typeUnwrapper,
         private readonly BetterNodeFinder $betterNodeFinder,
         private readonly PhpAttributeGroupFactory $phpAttributeGroupFactory,
         private readonly PhpAttributeAnalyzer $phpAttributeAnalyzer
@@ -192,7 +191,7 @@ private function isTypeMatch(ComplexType|Identifier|Name $typeNode, Type $requir
 
         // cover nullable union types
         if ($returnType instanceof UnionType) {
-            $returnType = $this->typeUnwrapper->unwrapNullableType($returnType);
+            $returnType = TypeCombinator::removeNull($returnType);
         }
 
         if ($returnType instanceof ObjectType) {

packages/BetterPhpDocParser/PhpDocParser/StaticDoctrineAnnotationParser/PlainValueParser.php

@@ -63,9 +63,9 @@ public function parseValue(
         $tokenIterator->next();
 
         // normalize value
-        $constantValue = $this->matchConstantValue($currentTokenValue);
-        if ($constantValue !== null) {
-            return $constantValue;
+        $constExprNode = $this->matchConstantValue($currentTokenValue);
+        if ($constExprNode !== null) {
+            return $constExprNode;
         }
 
         while ($tokenIterator->isCurrentTokenType(Lexer::TOKEN_DOUBLE_COLON) ||

packages/BetterPhpDocParser/ValueObject/Parser/BetterTokenIterator.php

@@ -131,7 +131,7 @@ public function currentPosition(): int
     }
 
     /**
-     * @return mixed[]
+     * @return array<array{0: string, 1: int}>
      */
     public function getTokens(): array
     {
@@ -144,18 +144,11 @@ public function count(): int
     }
 
     /**
-     * @return mixed[]
+     * @return array<array{0: string, 1: int}>
      */
     public function partialTokens(int $start, int $end): array
     {
-        $tokens = $this->getTokens();
-
-        $chunkTokens = [];
-        for ($i = $start; $i <= $end; ++$i) {
-            $chunkTokens[$i] = $tokens[$i];
-        }
-
-        return $chunkTokens;
+        return array_slice($this->getTokens(), $start, $end);
     }
 
     public function containsTokenType(int $type): bool

packages/NodeCollector/NodeAnalyzer/ArrayCallableMethodMatcher.php

@@ -182,8 +182,8 @@ private function resolveClassConstFetchType(ClassConstFetch $classConstFetch): M
             return new ObjectType($classConstantReference, null, $classReflection);
         }
 
-        $methodReflection = $classReflection->getMethod(MethodName::CONSTRUCT, $scope);
-        $parametersAcceptor = ParametersAcceptorSelector::selectSingle($methodReflection->getVariants());
+        $extendedMethodReflection = $classReflection->getMethod(MethodName::CONSTRUCT, $scope);
+        $parametersAcceptor = ParametersAcceptorSelector::selectSingle($extendedMethodReflection->getVariants());
 
         foreach ($parametersAcceptor->getParameters() as $parameterReflection) {
             if ($parameterReflection->getDefaultValue() === null) {

packages/NodeCollector/StaticAnalyzer.php

@@ -13,8 +13,8 @@ final class StaticAnalyzer
     public function isStaticMethod(ClassReflection $classReflection, string $methodName): bool
     {
         if ($classReflection->hasNativeMethod($methodName)) {
-            $methodReflection = $classReflection->getNativeMethod($methodName);
-            if ($methodReflection->isStatic()) {
+            $extendedMethodReflection = $classReflection->getNativeMethod($methodName);
+            if ($extendedMethodReflection->isStatic()) {
                 return true;
             }
         }

packages/PHPStanStaticTypeMapper/TypeMapper/UnionTypeMapper.php

@@ -228,9 +228,9 @@ private function matchTypeForUnionedObjectTypes(UnionType $unionType, string $ty
             return new Name('bool');
         }
 
-        $compatibleObjectType = $this->processResolveCompatibleObjectCandidates($unionType);
-        if ($compatibleObjectType instanceof NullableType || $compatibleObjectType instanceof FullyQualified) {
-            return $compatibleObjectType;
+        $compatibleObjectTypeNode = $this->processResolveCompatibleObjectCandidates($unionType);
+        if ($compatibleObjectTypeNode instanceof NullableType || $compatibleObjectTypeNode instanceof FullyQualified) {
+            return $compatibleObjectTypeNode;
         }
 
         return $this->processResolveCompatibleStringCandidates($unionType);

packages/PHPStanStaticTypeMapper/Utils/TypeUnwrapper.php

@@ -5,20 +5,11 @@
 namespace Rector\PHPStanStaticTypeMapper\Utils;
 
 use PHPStan\Type\Type;
-use PHPStan\Type\TypeCombinator;
 use PHPStan\Type\TypeWithClassName;
 use PHPStan\Type\UnionType;
 
 final class TypeUnwrapper
 {
-    /**
-     * E.g. null|ClassType → ClassType
-     */
-    public function unwrapNullableType(Type $type): Type
-    {
-        return TypeCombinator::removeNull($type);
-    }
-
     public function unwrapFirstObjectTypeFromUnionType(Type $type): Type
     {
         if (! $type instanceof UnionType) {

packages/PostRector/Collector/NodesToAddCollector.php

@@ -155,15 +155,15 @@ private function resolveNearestStmtPosition(Node $node): string
             return spl_object_hash($parent);
         }
 
-        $foundNode = $this->betterNodeFinder->findParentType($node, Stmt::class);
+        $foundStmt = $this->betterNodeFinder->findParentType($node, Stmt::class);
 
-        if (! $foundNode instanceof Stmt) {
+        if (! $foundStmt instanceof Stmt) {
             $printedNode = $this->nodePrinter->print($node);
             $errorMessage = sprintf('Could not find parent Stmt of "%s" node', $printedNode);
             throw new ShouldNotHappenException($errorMessage);
         }
 
-        return spl_object_hash($foundNode);
+        return spl_object_hash($foundStmt);
     }
 
     private function wrapToExpression(Expr | Stmt $node): Stmt

packages/StaticTypeMapper/PhpParser/NullableTypeNodeMapper.php

@@ -41,9 +41,7 @@ public function getNodeType(): string
      */
     public function mapToPHPStan(Node $node): Type
     {
-        $types = [];
-        $types[] = $this->phpParserNodeMapper->mapToPHPStanType($node->type);
-        $types[] = new NullType();
+        $types = [$this->phpParserNodeMapper->mapToPHPStanType($node->type), new NullType()];
 
         return $this->typeFactory->createMixedPassedOrUnionType($types);
     }

packages/Testing/PHPUnit/Behavior/MovingFilesTrait.php

@@ -7,31 +7,18 @@
 use Rector\Core\Application\FileSystem\RemovedAndAddedFilesCollector;
 use Rector\Core\PhpParser\Printer\NodesWithFileDestinationPrinter;
 use Rector\FileSystemRector\ValueObject\AddedFileWithContent;
-use Symplify\SmartFileSystem\SmartFileInfo;
 use Webmozart\Assert\Assert;
 
 /**
  * @property-read RemovedAndAddedFilesCollector $removedAndAddedFilesCollector
  */
 trait MovingFilesTrait
 {
-    protected function assertFileWasNotChanged(SmartFileInfo $smartFileInfo): void
-    {
-        $hasFileInfo = $this->removedAndAddedFilesCollector->isFileRemoved($smartFileInfo);
-        $this->assertFalse($hasFileInfo);
-    }
-
     protected function assertFileWasAdded(AddedFileWithContent $addedFileWithContent): void
     {
         $this->assertFilesWereAdded([$addedFileWithContent]);
     }
 
-    protected function assertFileWasRemoved(SmartFileInfo $smartFileInfo): void
-    {
-        $isFileRemoved = $this->removedAndAddedFilesCollector->isFileRemoved($smartFileInfo);
-        $this->assertTrue($isFileRemoved);
-    }
-
     /**
      * @param AddedFileWithContent[] $expectedAddedFileWithContents
      */

phpstan.neon

@@ -386,6 +386,8 @@ parameters:
                 - rules/Composer/Application/FileProcessor/ComposerFileProcessor.php
                 - src/Contract/Processor/FileProcessorInterface.php
                 - packages/Parallel/Application/ParallelFileProcessor.php
+                # tokens
+                - packages/BetterPhpDocParser/ValueObject/Parser/BetterTokenIterator.php
 
         # skipped on purpose, as ctor overrie
         - '#Rector\\StaticTypeMapper\\ValueObject\\Type\\SimpleStaticType\:\:__construct\(\) does not call parent constructor from PHPStan\\Type\\StaticType#'
@@ -680,3 +682,14 @@ parameters:
                 - src/Bootstrap/RectorConfigsResolver.php
                 - src/ValueObject/StaticNonPhpFileSuffixes.php
                 - tests/FileSystem/FilesFinder/FilesFinderTest.php
+
+        -
+            message: '#Parameters should use "PhpParser\\Node\\Expr\\BinaryOp\|string" types as the only types passed to this method#'
+            path: packages/NodeCollector/BinaryOpTreeRootLocator.php
+        -
+            message: '#Parameters should use "string\|PhpParser\\Node\\Expr\\Variable" types as the only types passed to this method#'
+            path: src/PhpParser/Node/NodeFactory.php
+
+        # union booleans
+        - '#Method Rector\\Strict\\NodeFactory\\ExactCompareFactory\:\:createTruthyFromUnionType\(\) should return PhpParser\\Node\\Expr\\BinaryOp\\BooleanOr\|PhpParser\\Node\\Expr\\BinaryOp\\Identical\|PhpParser\\Node\\Expr\\BinaryOp\\NotIdentical\|PhpParser\\Node\\Expr\\BooleanNot\|PhpParser\\Node\\Expr\\Instanceof_\|null but returns PhpParser\\Node\\Expr\\BinaryOp\\BooleanAnd\|PhpParser\\Node\\Expr\\BinaryOp\\BooleanOr\|PhpParser\\Node\\Expr\\BinaryOp\\Identical\|PhpParser\\Node\\Expr\\BinaryOp\\NotIdentical\|PhpParser\\Node\\Expr\\Instanceof_\|null#'
+        - '#Parameter \#1 \$compareExprs of method Rector\\Strict\\NodeFactory\\ExactCompareFactory\:\:resolveTruthyExpr\(\) expects array<PhpParser\\Node\\Expr\\BinaryOp\\BooleanAnd\|PhpParser\\Node\\Expr\\BinaryOp\\BooleanOr\|PhpParser\\Node\\Expr\\BinaryOp\\Identical\|PhpParser\\Node\\Expr\\BinaryOp\\NotIdentical\|PhpParser\\Node\\Expr\\Instanceof_\|null>, array<PhpParser\\Node\\Expr\\BinaryOp\\BooleanOr\|PhpParser\\Node\\Expr\\BinaryOp\\Identical\|PhpParser\\Node\\Expr\\BinaryOp\\NotIdentical\|PhpParser\\Node\\Expr\\BooleanNot\|PhpParser\\Node\\Expr\\Instanceof_\|null> given#'

rules-tests/Naming/Rector/Assign/RenameVariableToMatchMethodCallReturnTypeRector/Fixture/skip_overly_generic.php.inc

@@ -6,7 +6,7 @@ use PhpParser\Node\Expr;
 use PhpParser\Node\Scalar\LNumber;
 use PhpParser\Node\Scalar\String_;
 
-class SkipOverlyGeneric
+final class SkipOverlyGeneric
 {
     public function run()
     {

rules/CodeQuality/Rector/Catch_/ThrowWithPreviousExceptionRector.php

@@ -182,8 +182,8 @@ private function resolveExceptionArgumentPosition(Name $exceptionName): ?int
             return self::DEFAULT_EXCEPTION_ARGUMENT_POSITION;
         }
 
-        $methodReflection = $classReflection->getConstructor();
-        $parametersAcceptor = ParametersAcceptorSelector::selectSingle($methodReflection->getVariants());
+        $extendedMethodReflection = $classReflection->getConstructor();
+        $parametersAcceptor = ParametersAcceptorSelector::selectSingle($extendedMethodReflection->getVariants());
 
         foreach ($parametersAcceptor->getParameters() as $position => $parameterReflection) {
             $parameterType = $parameterReflection->getType();

rules/CodeQuality/Rector/Foreach_/ForeachItemsAssignToEmptyArrayToAssignRector.php

@@ -100,12 +100,12 @@ private function shouldSkip(Foreach_ $foreach, Scope $scope): bool
             return true;
         }
 
-        $previousDeclaration = $this->nodeUsageFinder->findPreviousForeachNodeUsage($foreach, $assignVariable);
-        if (! $previousDeclaration instanceof Node) {
+        $node = $this->nodeUsageFinder->findPreviousForeachNodeUsage($foreach, $assignVariable);
+        if (! $node instanceof Node) {
             return true;
         }
 
-        $previousDeclarationParentNode = $previousDeclaration->getAttribute(AttributeKey::PARENT_NODE);
+        $previousDeclarationParentNode = $node->getAttribute(AttributeKey::PARENT_NODE);
         if (! $previousDeclarationParentNode instanceof Assign) {
             return true;
         }

rules/CodeQuality/Rector/Foreach_/ForeachToInArrayRector.php

@@ -90,12 +90,12 @@ public function refactor(Node $node): ?Node
             return null;
         }
 
-        $comparedNode = $twoNodeMatch->getSecondExpr();
+        $comparedExpr = $twoNodeMatch->getSecondExpr();
         if (! $this->isIfBodyABoolReturnNode($firstNodeInsideForeach)) {
             return null;
         }
 
-        $funcCall = $this->createInArrayFunction($comparedNode, $ifCondition, $node);
+        $funcCall = $this->createInArrayFunction($comparedExpr, $ifCondition, $node);
 
         /** @var Return_ $returnToRemove */
         $returnToRemove = $node->getAttribute(AttributeKey::NEXT_NODE);

rules/CodeQuality/Rector/FunctionLike/RemoveAlwaysTrueConditionSetInConstructorRector.php

@@ -157,10 +157,9 @@ private function resolvePropertyFetchType(PropertyFetch $propertyFetch): Type
         }
 
         // set in constructor + changed in class
-        $propertyTypeFromConstructor = $this->resolvePropertyTypeAfterConstructor($classLike, $propertyName);
+        $propertyType = $this->resolvePropertyTypeAfterConstructor($classLike, $propertyName);
 
-        $resolvedTypes = [];
-        $resolvedTypes[] = $propertyTypeFromConstructor;
+        $resolvedTypes = [$propertyType];
 
         $defaultValue = $property->props[0]->default;
         if ($defaultValue !== null) {

rules/CodeQuality/Rector/Identical/GetClassToInstanceOfRector.php

@@ -76,18 +76,18 @@ public function refactor(Node $node): ?Node
         /** @var ClassConstFetch|String_ $firstExpr */
         $firstExpr = $twoNodeMatch->getFirstExpr();
 
-        /** @var FuncCall $funcCall */
-        $funcCall = $twoNodeMatch->getSecondExpr();
+        /** @var FuncCall $secondExpr */
+        $secondExpr = $twoNodeMatch->getSecondExpr();
 
-        if (! isset($funcCall->args[0])) {
+        if (! isset($secondExpr->args[0])) {
             return null;
         }
 
-        if (! $funcCall->args[0] instanceof Arg) {
+        if (! $secondExpr->args[0] instanceof Arg) {
             return null;
         }
 
-        $varNode = $funcCall->args[0]->value;
+        $varNode = $secondExpr->args[0]->value;
 
         if ($firstExpr instanceof String_) {
             $className = $this->valueResolver->getValue($firstExpr);

rules/CodeQuality/Rector/Identical/SimplifyArraySearchRector.php

@@ -68,10 +68,10 @@ function (Node $node): bool {
             return null;
         }
 
-        /** @var FuncCall $arraySearchFuncCall */
-        $arraySearchFuncCall = $twoNodeMatch->getFirstExpr();
+        /** @var FuncCall $funcCallExpr */
+        $funcCallExpr = $twoNodeMatch->getFirstExpr();
 
-        $inArrayFuncCall = $this->nodeFactory->createFuncCall('in_array', $arraySearchFuncCall->args);
+        $inArrayFuncCall = $this->nodeFactory->createFuncCall('in_array', $funcCallExpr->args);
 
         if ($node instanceof Identical) {
             return new BooleanNot($inArrayFuncCall);

rules/CodeQuality/Rector/Identical/SimplifyConditionsRector.php

@@ -81,15 +81,15 @@ private function processIdenticalAndNotIdentical(Identical $identical): ?Node
             return $twoNodeMatch;
         }
 
-        /** @var Identical|NotIdentical $subBinaryOp */
-        $subBinaryOp = $twoNodeMatch->getFirstExpr();
+        /** @var Identical|NotIdentical $firstExpr */
+        $firstExpr = $twoNodeMatch->getFirstExpr();
 
-        $otherNode = $twoNodeMatch->getSecondExpr();
-        if ($this->valueResolver->isFalse($otherNode)) {
-            return $this->createInversedBooleanOp($subBinaryOp);
+        $otherExpr = $twoNodeMatch->getSecondExpr();
+        if ($this->valueResolver->isFalse($otherExpr)) {
+            return $this->createInversedBooleanOp($firstExpr);
         }
 
-        return $subBinaryOp;
+        return $firstExpr;
     }
 
     /**

rules/CodeQuality/Rector/If_/ExplicitBoolCompareRector.php

@@ -117,18 +117,18 @@ public function refactor(Node $node): ?Node
             return null;
         }
 
-        $newConditionNode = $this->resolveNewConditionNode($conditionNode, $isNegated);
-        if (! $newConditionNode instanceof BinaryOp) {
+        $binaryOp = $this->resolveNewConditionNode($conditionNode, $isNegated);
+        if (! $binaryOp instanceof BinaryOp) {
             return null;
         }
 
         $nextNode = $node->getAttribute(AttributeKey::NEXT_NODE);
         // avoid duplicated ifs when combined with ChangeOrIfReturnToEarlyReturnRector
-        if ($this->shouldSkip($conditionStaticType, $newConditionNode, $nextNode)) {
+        if ($this->shouldSkip($conditionStaticType, $binaryOp, $nextNode)) {
             return null;
         }
 
-        $node->cond = $newConditionNode;
+        $node->cond = $binaryOp;
 
         return $node;
     }

rules/CodeQuality/Rector/If_/SimplifyIfExactValueReturnValueRector.php

@@ -66,12 +66,12 @@ public function refactor(Node $node): ?Return_
             return null;
         }
 
-        $comparedNode = $this->ifManipulator->matchIfValueReturnValue($node);
-        if (! $comparedNode instanceof Expr) {
+        $expr = $this->ifManipulator->matchIfValueReturnValue($node);
+        if (! $expr instanceof Expr) {
             return null;
         }
 
-        if (! $this->nodeComparator->areNodesEqual($comparedNode, $nextNode->expr)) {
+        if (! $this->nodeComparator->areNodesEqual($expr, $nextNode->expr)) {
             return null;
         }