Updated Rector to commit dfd048342b

dfd048342b [PHP 8.0] Run union types for filled param type too (#331)

packages/NodeCollector/NodeCollector/ParsedNodeCollector.php

@@ -5,7 +5,6 @@ namespace Rector\NodeCollector\NodeCollector;
 
 use PhpParser\Node;
 use PhpParser\Node\Stmt\Class_;
-use PhpParser\Node\Stmt\ClassLike;
 use PhpParser\Node\Stmt\Interface_;
 use PhpParser\Node\Stmt\Trait_;
 use Rector\Core\Exception\ShouldNotHappenException;
@@ -93,9 +92,9 @@ final class ParsedNodeCollector
         $this->classes[$className] = $class;
     }
     /**
-     * @param Interface_|Trait_ $classLike
+     * @param \PhpParser\Node\Stmt\Interface_|\PhpParser\Node\Stmt\Trait_ $classLike
      */
-    private function collectInterfaceOrTrait(\PhpParser\Node\Stmt\ClassLike $classLike) : void
+    private function collectInterfaceOrTrait($classLike) : void
     {
         $name = $this->nodeNameResolver->getName($classLike);
         if ($name === null) {

packages/NodeNameResolver/Error/InvalidNameNodeReporter.php

@@ -3,7 +3,6 @@
 declare (strict_types=1);
 namespace Rector\NodeNameResolver\Error;
 
-use PhpParser\Node;
 use PhpParser\Node\Expr\MethodCall;
 use PhpParser\Node\Expr\StaticCall;
 use Rector\Core\Contract\Rector\RectorInterface;
@@ -32,9 +31,9 @@ final class InvalidNameNodeReporter
         $this->betterStandardPrinter = $betterStandardPrinter;
     }
     /**
-     * @param MethodCall|StaticCall $node
+     * @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall $node
      */
-    public function reportInvalidNodeForName(\PhpParser\Node $node) : void
+    public function reportInvalidNodeForName($node) : void
     {
         $message = \sprintf('Pick more specific node than "%s", e.g. "$node->name"', \get_class($node));
         $file = $this->currentFileProvider->getFile();

packages/NodeRemoval/NodeRemover.php

@@ -90,9 +90,9 @@ final class NodeRemover
         unset($classMethod->params[$key]);
     }
     /**
-     * @param FuncCall|MethodCall|StaticCall $node
+     * @param \PhpParser\Node\Expr\FuncCall|\PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall $node
      */
-    public function removeArg(\PhpParser\Node $node, int $key) : void
+    public function removeArg($node, int $key) : void
     {
         if ($node->args === null) {
             throw new \Rector\Core\Exception\ShouldNotHappenException();

packages/PostRector/Collector/NodesToAddCollector.php

@@ -133,9 +133,9 @@ final class NodesToAddCollector implements \Rector\PostRector\Contract\Collector
         return \spl_object_hash($foundNode);
     }
     /**
-     * @param Expr|Stmt $node
+     * @param \PhpParser\Node\Expr|\PhpParser\Node\Stmt $node
      */
-    private function wrapToExpression(\PhpParser\Node $node) : \PhpParser\Node\Stmt
+    private function wrapToExpression($node) : \PhpParser\Node\Stmt
     {
         return $node instanceof \PhpParser\Node\Stmt ? $node : new \PhpParser\Node\Stmt\Expression($node);
     }

packages/PostRector/Collector/UseNodesToAddCollector.php

@@ -5,7 +5,6 @@ namespace Rector\PostRector\Collector;
 
 use PhpParser\Node;
 use PhpParser\Node\Stmt\Use_;
-use PHPStan\Type\ObjectType;
 use Rector\Core\Provider\CurrentFileProvider;
 use Rector\Core\ValueObject\Application\File;
 use Rector\NodeTypeResolver\Node\AttributeKey;
@@ -40,9 +39,9 @@ final class UseNodesToAddCollector implements \Rector\PostRector\Contract\Collec
         return $this->useImportTypesInFilePath !== [] || $this->functionUseImportTypesInFilePath !== [];
     }
     /**
-     * @param FullyQualifiedObjectType|AliasedObjectType $objectType
+     * @param \Rector\StaticTypeMapper\ValueObject\Type\FullyQualifiedObjectType|\Rector\StaticTypeMapper\ValueObject\Type\AliasedObjectType $objectType
      */
-    public function addUseImport(\PHPStan\Type\ObjectType $objectType) : void
+    public function addUseImport($objectType) : void
     {
         $file = $this->currentFileProvider->getFile();
         $smartFileInfo = $file->getSmartFileInfo();

packages/StaticTypeMapper/ValueObject/Type/AliasedObjectType.php

@@ -33,9 +33,9 @@ final class AliasedObjectType extends \PHPStan\Type\ObjectType
         return $this->getClassName();
     }
     /**
-     * @param AliasedObjectType|FullyQualifiedObjectType $comparedObjectType
+     * @param $this|\Rector\StaticTypeMapper\ValueObject\Type\FullyQualifiedObjectType $comparedObjectType
      */
-    public function areShortNamesEqual(\PHPStan\Type\ObjectType $comparedObjectType) : bool
+    public function areShortNamesEqual($comparedObjectType) : bool
     {
         return $this->getShortName() === $comparedObjectType->getShortName();
     }

packages/StaticTypeMapper/ValueObject/Type/FullyQualifiedObjectType.php

@@ -16,9 +16,9 @@ final class FullyQualifiedObjectType extends \PHPStan\Type\ObjectType
         return new \Rector\StaticTypeMapper\ValueObject\Type\ShortenedObjectType($this->getShortName(), $this->getClassName());
     }
     /**
-     * @param AliasedObjectType|FullyQualifiedObjectType $comparedObjectType
+     * @param \Rector\StaticTypeMapper\ValueObject\Type\AliasedObjectType|\Rector\StaticTypeMapper\ValueObject\Type\FullyQualifiedObjectType $comparedObjectType
      */
-    public function areShortNamesEqual(\PHPStan\Type\ObjectType $comparedObjectType) : bool
+    public function areShortNamesEqual($comparedObjectType) : bool
     {
         return $this->getShortName() === $comparedObjectType->getShortName();
     }

rules/Arguments/ArgumentDefaultValueReplacer.php

@@ -6,7 +6,6 @@ namespace Rector\Arguments;
 use PhpParser\BuilderHelpers;
 use PhpParser\Node;
 use PhpParser\Node\Arg;
-use PhpParser\Node\Expr;
 use PhpParser\Node\Expr\FuncCall;
 use PhpParser\Node\Expr\MethodCall;
 use PhpParser\Node\Expr\StaticCall;
@@ -44,9 +43,9 @@ final class ArgumentDefaultValueReplacer
         return $node;
     }
     /**
-     * @param MethodCall|StaticCall|FuncCall $expr
+     * @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\FuncCall $expr
      */
-    private function processArgs(\PhpParser\Node\Expr $expr, \Rector\Arguments\Contract\ReplaceArgumentDefaultValueInterface $replaceArgumentDefaultValue) : void
+    private function processArgs($expr, \Rector\Arguments\Contract\ReplaceArgumentDefaultValueInterface $replaceArgumentDefaultValue) : void
     {
         $position = $replaceArgumentDefaultValue->getPosition();
         $argValue = $this->valueResolver->getValue($expr->args[$position]->value);

rules/Arguments/NodeAnalyzer/ArgumentAddingScope.php

@@ -3,7 +3,6 @@
 declare (strict_types=1);
 namespace Rector\Arguments\NodeAnalyzer;
 
-use PhpParser\Node\Expr;
 use PhpParser\Node\Expr\MethodCall;
 use PhpParser\Node\Expr\StaticCall;
 use PhpParser\Node\Name;
@@ -32,9 +31,9 @@ final class ArgumentAddingScope
         $this->nodeNameResolver = $nodeNameResolver;
     }
     /**
-     * @param MethodCall|StaticCall $expr
+     * @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall $expr
      */
-    public function isInCorrectScope(\PhpParser\Node\Expr $expr, \Rector\Arguments\ValueObject\ArgumentAdder $argumentAdder) : bool
+    public function isInCorrectScope($expr, \Rector\Arguments\ValueObject\ArgumentAdder $argumentAdder) : bool
     {
         if ($argumentAdder->getScope() === null) {
             return \true;

rules/Arguments/Rector/ClassMethod/ArgumentAdderRector.php

@@ -108,9 +108,9 @@ CODE_SAMPLE
         $this->addedArguments = $addedArguments;
     }
     /**
-     * @param MethodCall|StaticCall|ClassMethod $node
+     * @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Stmt\ClassMethod $node
      */
-    private function isObjectTypeMatch(\PhpParser\Node $node, \PHPStan\Type\ObjectType $objectType) : bool
+    private function isObjectTypeMatch($node, \PHPStan\Type\ObjectType $objectType) : bool
     {
         if ($node instanceof \PhpParser\Node\Expr\MethodCall) {
             return $this->isObjectType($node->var, $objectType);

rules/CodeQuality/Rector/Assign/SplitListAssignToSeparateLineRector.php

@@ -4,7 +4,6 @@ declare (strict_types=1);
 namespace Rector\CodeQuality\Rector\Assign;
 
 use PhpParser\Node;
-use PhpParser\Node\Expr;
 use PhpParser\Node\Expr\Array_;
 use PhpParser\Node\Expr\ArrayItem;
 use PhpParser\Node\Expr\Assign;
@@ -82,10 +81,10 @@ CODE_SAMPLE
         return $this->isValueSwap($assign->var, $assignExpr);
     }
     /**
-     * @param Array_|List_ $expr
      * @return Assign[]
+     * @param \PhpParser\Node\Expr\Array_|\PhpParser\Node\Expr\List_ $expr
      */
-    private function createStandaloneAssigns(\PhpParser\Node\Expr $expr, \PhpParser\Node\Expr\Array_ $rightArray) : array
+    private function createStandaloneAssigns($expr, \PhpParser\Node\Expr\Array_ $rightArray) : array
     {
         $standaloneAssigns = [];
         foreach ($expr->items as $key => $leftArrayItem) {
@@ -101,18 +100,18 @@ CODE_SAMPLE
         return $standaloneAssigns;
     }
     /**
-     * @param Array_|List_ $expr
+     * @param \PhpParser\Node\Expr\Array_|\PhpParser\Node\Expr\List_ $expr
      */
-    private function isValueSwap(\PhpParser\Node\Expr $expr, \PhpParser\Node\Expr\Array_ $secondArray) : bool
+    private function isValueSwap($expr, \PhpParser\Node\Expr\Array_ $secondArray) : bool
     {
         $firstArrayItemsHash = $this->getArrayItemsHash($expr);
         $secondArrayItemsHash = $this->getArrayItemsHash($secondArray);
         return $firstArrayItemsHash === $secondArrayItemsHash;
     }
     /**
-     * @param Array_|List_ $node
+     * @param \PhpParser\Node\Expr\Array_|\PhpParser\Node\Expr\List_ $node
      */
-    private function getArrayItemsHash(\PhpParser\Node $node) : string
+    private function getArrayItemsHash($node) : string
     {
         $arrayItemsHashes = [];
         foreach ($node->items as $arrayItem) {

rules/CodeQuality/Rector/Foreach_/ForeachToInArrayRector.php

@@ -165,9 +165,9 @@ CODE_SAMPLE
         return $this->valueResolver->isTrueOrFalse($ifStatment->expr);
     }
     /**
-     * @param Identical|Equal $binaryOp
+     * @param \PhpParser\Node\Expr\BinaryOp\Identical|\PhpParser\Node\Expr\BinaryOp\Equal $binaryOp
      */
-    private function createInArrayFunction(\PhpParser\Node\Expr $expr, \PhpParser\Node\Expr\BinaryOp $binaryOp, \PhpParser\Node\Stmt\Foreach_ $foreach) : \PhpParser\Node\Expr\FuncCall
+    private function createInArrayFunction(\PhpParser\Node\Expr $expr, $binaryOp, \PhpParser\Node\Stmt\Foreach_ $foreach) : \PhpParser\Node\Expr\FuncCall
     {
         $arguments = $this->nodeFactory->createArgs([$expr, $foreach->expr]);
         if ($binaryOp instanceof \PhpParser\Node\Expr\BinaryOp\Identical) {

rules/CodeQuality/Rector/If_/SimplifyIfIssetToNullCoalescingRector.php

@@ -137,9 +137,9 @@ CODE_SAMPLE
         return !$this->nodeComparator->areNodesEqual($if->cond->vars[0], $firstElseStmt->expr->var);
     }
     /**
-     * @param If_|Else_ $node
+     * @param \PhpParser\Node\Stmt\If_|\PhpParser\Node\Stmt\Else_ $node
      */
-    private function hasOnlyStatementAssign(\PhpParser\Node $node) : bool
+    private function hasOnlyStatementAssign($node) : bool
     {
         if (\count($node->stmts) !== 1) {
             return \false;

rules/CodeQuality/Rector/Return_/SimplifyUselessVariableRector.php

@@ -137,9 +137,9 @@ CODE_SAMPLE
         return !$phpDocInfo->getVarType() instanceof \PHPStan\Type\MixedType;
     }
     /**
-     * @param AssignOp|Assign $previousNode
+     * @param \PhpParser\Node\Expr\AssignOp|\PhpParser\Node\Expr\Assign $previousNode
      */
-    private function isPreviousExpressionVisuallySimilar(\PhpParser\Node\Stmt\Expression $previousExpression, \PhpParser\Node $previousNode) : bool
+    private function isPreviousExpressionVisuallySimilar(\PhpParser\Node\Stmt\Expression $previousExpression, $previousNode) : bool
     {
         $prePreviousExpression = $previousExpression->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::PREVIOUS_STATEMENT);
         if (!$prePreviousExpression instanceof \PhpParser\Node\Stmt\Expression) {

rules/CodeQualityStrict/NodeFactory/ClassConstFetchFactory.php

@@ -6,7 +6,6 @@ namespace Rector\CodeQualityStrict\NodeFactory;
 use PhpParser\Node\Expr\ClassConstFetch;
 use PhpParser\Node\Name\FullyQualified;
 use PHPStan\Type\ObjectType;
-use PHPStan\Type\Type;
 use PHPStan\Type\TypeWithClassName;
 use PHPStan\Type\UnionType;
 use Rector\Core\Exception\ShouldNotHappenException;
@@ -14,10 +13,10 @@ use Rector\StaticTypeMapper\ValueObject\Type\ShortenedObjectType;
 final class ClassConstFetchFactory
 {
     /**
-     * @param ObjectType|UnionType $type
      * @return ClassConstFetch[]
+     * @param \PHPStan\Type\ObjectType|\PHPStan\Type\UnionType $type
      */
-    public function createFromType(\PHPStan\Type\Type $type) : array
+    public function createFromType($type) : array
     {
         $classConstTypes = [];
         if ($type instanceof \Rector\StaticTypeMapper\ValueObject\Type\ShortenedObjectType) {

rules/CodeQualityStrict/Rector/ClassMethod/ParamTypeToAssertTypeRector.php

@@ -116,10 +116,10 @@ CODE_SAMPLE
     }
     /**
      * @param Param[] $params
-     * @param ObjectType|UnionType $type
      * @return ObjectType|UnionType
+     * @param \PHPStan\Type\ObjectType|\PHPStan\Type\UnionType $type
      */
-    private function getToBeProcessedTypes(array $params, string $key, \PHPStan\Type\Type $type) : ?\PHPStan\Type\Type
+    private function getToBeProcessedTypes(array $params, string $key, $type) : ?\PHPStan\Type\Type
     {
         foreach ($params as $param) {
             $paramName = \ltrim($key, '$');

rules/CodingStyle/Naming/NameRenamer.php

@@ -61,9 +61,9 @@ final class NameRenamer
         }
     }
     /**
-     * @param Name|Identifier $usedNameNode
+     * @param \PhpParser\Node\Name|\PhpParser\Node\Identifier $usedNameNode
      */
-    private function renameTraitUse(string $lastName, \PhpParser\Node\Stmt\TraitUse $traitUse, \PhpParser\Node $usedNameNode) : void
+    private function renameTraitUse(string $lastName, \PhpParser\Node\Stmt\TraitUse $traitUse, $usedNameNode) : void
     {
         foreach ($traitUse->traits as $key => $traitName) {
             if (!$this->nodeNameResolver->areNamesEqual($traitName, $usedNameNode)) {
@@ -73,9 +73,9 @@ final class NameRenamer
         }
     }
     /**
-     * @param Name|Identifier $usedNameNode
+     * @param \PhpParser\Node\Name|\PhpParser\Node\Identifier $usedNameNode
      */
-    private function renameClass(string $lastName, \PhpParser\Node\Stmt\Class_ $class, \PhpParser\Node $usedNameNode) : void
+    private function renameClass(string $lastName, \PhpParser\Node\Stmt\Class_ $class, $usedNameNode) : void
     {
         if ($class->name !== null && $this->nodeNameResolver->areNamesEqual($class->name, $usedNameNode)) {
             $class->name = new \PhpParser\Node\Identifier($lastName);
@@ -90,9 +90,9 @@ final class NameRenamer
         }
     }
     /**
-     * @param Name|Identifier $usedNameNode
+     * @param \PhpParser\Node\Name|\PhpParser\Node\Identifier $usedNameNode
      */
-    private function renameParam(string $lastName, \PhpParser\Node\Param $param, \PhpParser\Node $usedNameNode) : void
+    private function renameParam(string $lastName, \PhpParser\Node\Param $param, $usedNameNode) : void
     {
         if ($param->type === null) {
             return;
@@ -115,18 +115,18 @@ final class NameRenamer
         }
     }
     /**
-     * @param Name|Identifier $usedNameNode
+     * @param \PhpParser\Node\Name|\PhpParser\Node\Identifier $usedNameNode
      */
-    private function renameNew(string $lastName, \PhpParser\Node\Expr\New_ $new, \PhpParser\Node $usedNameNode) : void
+    private function renameNew(string $lastName, \PhpParser\Node\Expr\New_ $new, $usedNameNode) : void
     {
         if ($this->nodeNameResolver->areNamesEqual($new->class, $usedNameNode)) {
             $new->class = new \PhpParser\Node\Name($lastName);
         }
     }
     /**
-     * @param Name|Identifier $usedNameNode
+     * @param \PhpParser\Node\Name|\PhpParser\Node\Identifier $usedNameNode
      */
-    private function renameClassMethod(string $lastName, \PhpParser\Node\Stmt\ClassMethod $classMethod, \PhpParser\Node $usedNameNode) : void
+    private function renameClassMethod(string $lastName, \PhpParser\Node\Stmt\ClassMethod $classMethod, $usedNameNode) : void
     {
         if ($classMethod->returnType === null) {
             return;
@@ -137,9 +137,9 @@ final class NameRenamer
         $classMethod->returnType = new \PhpParser\Node\Name($lastName);
     }
     /**
-     * @param Name|Identifier $usedNameNode
+     * @param \PhpParser\Node\Name|\PhpParser\Node\Identifier $usedNameNode
      */
-    private function renameInterface(string $lastName, \PhpParser\Node\Stmt\Interface_ $interface, \PhpParser\Node $usedNameNode) : void
+    private function renameInterface(string $lastName, \PhpParser\Node\Stmt\Interface_ $interface, $usedNameNode) : void
     {
         foreach ($interface->extends as $key => $extendInterfaceName) {
             if (!$this->nodeNameResolver->areNamesEqual($extendInterfaceName, $usedNameNode)) {

rules/CodingStyle/Rector/Assign/ManualJsonStringToJsonEncodeArrayRector.php

@@ -194,9 +194,9 @@ CODE_SAMPLE
         return $this->jsonEncodeStaticCallFactory->createFromArray($assign->var, $jsonArray);
     }
     /**
-     * @param Assign|ConcatAssign $currentNode
+     * @param \PhpParser\Node\Expr\Assign|ConcatAssign|\PhpParser\Node\Stmt\Expression|\PhpParser\Node $currentNode
      */
-    private function matchNextExprAssignConcatToSameVariable(\PhpParser\Node\Expr $expr, \PhpParser\Node $currentNode) : ?\Rector\CodingStyle\ValueObject\NodeToRemoveAndConcatItem
+    private function matchNextExprAssignConcatToSameVariable(\PhpParser\Node\Expr $expr, $currentNode) : ?\Rector\CodingStyle\ValueObject\NodeToRemoveAndConcatItem
     {
         $nextExpression = $this->getNextExpression($currentNode);
         if (!$nextExpression instanceof \PhpParser\Node\Stmt\Expression) {

rules/CodingStyle/Rector/ClassMethod/NewlineBeforeNewAssignSetRector.php

@@ -121,9 +121,9 @@ CODE_SAMPLE
         return !$this->isPrecededByEmptyLine($node, $key);
     }
     /**
-     * @param Assign|MethodCall $node
+     * @param \PhpParser\Node\Expr\Assign|\PhpParser\Node\Expr\MethodCall $node
      */
-    private function shouldSkipLeftVariable(\PhpParser\Node $node) : bool
+    private function shouldSkipLeftVariable($node) : bool
     {
         if (!$node->var instanceof \PhpParser\Node\Expr\Variable) {
             return \false;

rules/CodingStyle/Rector/MethodCall/PreferThisOrSelfMethodCallRector.php

@@ -87,9 +87,9 @@ CODE_SAMPLE
         $this->typeToPreference = $typeToPreference;
     }
     /**
-     * @param MethodCall|StaticCall $node
+     * @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall $node
      */
-    private function processToSelf(\PhpParser\Node $node) : ?\PhpParser\Node\Expr\StaticCall
+    private function processToSelf($node) : ?\PhpParser\Node\Expr\StaticCall
     {
         if ($node instanceof \PhpParser\Node\Expr\StaticCall && !$this->isNames($node->class, [self::SELF, 'static'])) {
             return null;
@@ -104,9 +104,9 @@ CODE_SAMPLE
         return $this->nodeFactory->createStaticCall(self::SELF, $name, $node->args);
     }
     /**
-     * @param MethodCall|StaticCall $node
+     * @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall $node
      */
-    private function processToThis(\PhpParser\Node $node) : ?\PhpParser\Node\Expr\MethodCall
+    private function processToThis($node) : ?\PhpParser\Node\Expr\MethodCall
     {
         if ($node instanceof \PhpParser\Node\Expr\MethodCall) {
             return null;

rules/CodingStyle/Rector/PostInc/PostIncDecToPreIncDecRector.php

@@ -107,10 +107,10 @@ CODE_SAMPLE
         return $arrayDimFetch->dim;
     }
     /**
-     * @param PostInc|PostDec $node
+     * @param \PhpParser\Node\Expr\PostInc|\PhpParser\Node\Expr\PostDec $node
      * @return \PhpParser\Node\Expr\PreDec|\PhpParser\Node\Expr\PreInc
      */
-    private function processPreFor(\PhpParser\Node $node, \PhpParser\Node\Stmt\For_ $for)
+    private function processPreFor($node, \PhpParser\Node\Stmt\For_ $for)
     {
         $for->loop = [$this->processPrePost($node)];
         return $for->loop[0];

rules/DeadCode/PhpDoc/TagRemover/VarTagRemover.php

@@ -64,9 +64,9 @@ final class VarTagRemover
         $phpDocInfo->removeByType(\PHPStan\PhpDocParser\Ast\PhpDoc\VarTagValueNode::class);
     }
     /**
-     * @param Expression|Property|Param $node
+     * @param \PhpParser\Node\Stmt\Expression|\PhpParser\Node\Stmt\Property|\PhpParser\Node\Param $node
      */
-    public function removeVarPhpTagValueNodeIfNotComment(\PhpParser\Node $node, \PHPStan\Type\Type $type) : void
+    public function removeVarPhpTagValueNodeIfNotComment($node, \PHPStan\Type\Type $type) : void
     {
         // keep doctrine collection narrow type
         if ($this->doctrineTypeAnalyzer->isDoctrineCollectionWithIterableUnionType($type)) {
@@ -92,9 +92,9 @@ final class VarTagRemover
         $phpDocInfo->removeByType(\PHPStan\PhpDocParser\Ast\PhpDoc\VarTagValueNode::class);
     }
     /**
-     * @param Expression|Param|Property $node
+     * @param \PhpParser\Node\Stmt\Expression|\PhpParser\Node\Param|\PhpParser\Node\Stmt\Property $node
      */
-    private function isNonBasicArrayType(\PhpParser\Node $node, \PHPStan\PhpDocParser\Ast\PhpDoc\VarTagValueNode $varTagValueNode) : bool
+    private function isNonBasicArrayType($node, \PHPStan\PhpDocParser\Ast\PhpDoc\VarTagValueNode $varTagValueNode) : bool
     {
         if ($varTagValueNode->type instanceof \Rector\BetterPhpDocParser\ValueObject\Type\BracketsAwareUnionTypeNode) {
             foreach ($varTagValueNode->type->types as $type) {

rules/DeadCode/Rector/Assign/RemoveUnusedVariableAssignRector.php

@@ -169,9 +169,9 @@ CODE_SAMPLE
         });
     }
     /**
-     * @param FuncCall|MethodCall|New_|NullsafeMethodCall|StaticCall $expr
+     * @param \PhpParser\Node\Expr\FuncCall|\PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\New_|\PhpParser\Node\Expr\NullsafeMethodCall|\PhpParser\Node\Expr\StaticCall $expr
      */
-    private function isUsedInAssignExpr(\PhpParser\Node\Expr $expr, \PhpParser\Node\Expr\Assign $assign) : bool
+    private function isUsedInAssignExpr($expr, \PhpParser\Node\Expr\Assign $assign) : bool
     {
         foreach ($expr->args as $arg) {
             $variable = $arg->value;

rules/DeadCode/Rector/Plus/RemoveDeadZeroAndOneOperationRector.php

@@ -121,9 +121,9 @@ CODE_SAMPLE
         return null;
     }
     /**
-     * @param Plus|Minus $binaryOp
+     * @param \PhpParser\Node\Expr\BinaryOp\Plus|\PhpParser\Node\Expr\BinaryOp\Minus $binaryOp
      */
-    private function processBinaryPlusAndMinus(\PhpParser\Node\Expr\BinaryOp $binaryOp) : ?\PhpParser\Node\Expr
+    private function processBinaryPlusAndMinus($binaryOp) : ?\PhpParser\Node\Expr
     {
         if ($this->valueResolver->isValue($binaryOp->left, 0) && $this->nodeTypeResolver->isNumberType($binaryOp->right)) {
             if ($binaryOp instanceof \PhpParser\Node\Expr\BinaryOp\Minus) {
@@ -140,9 +140,9 @@ CODE_SAMPLE
         return $binaryOp->left;
     }
     /**
-     * @param Mul|Div $binaryOp
+     * @param \PhpParser\Node\Expr\BinaryOp\Mul|\PhpParser\Node\Expr\BinaryOp\Div $binaryOp
      */
-    private function processBinaryMulAndDiv(\PhpParser\Node\Expr\BinaryOp $binaryOp) : ?\PhpParser\Node\Expr
+    private function processBinaryMulAndDiv($binaryOp) : ?\PhpParser\Node\Expr
     {
         if ($binaryOp instanceof \PhpParser\Node\Expr\BinaryOp\Mul && $this->valueResolver->isValue($binaryOp->left, 1) && $this->nodeTypeResolver->isNumberType($binaryOp->right)) {
             return $binaryOp->right;

rules/DeadCode/UselessIfCondBeforeForeachDetector.php

@@ -5,7 +5,6 @@ namespace Rector\DeadCode;
 
 use PhpParser\Node\Expr;
 use PhpParser\Node\Expr\Array_;
-use PhpParser\Node\Expr\BinaryOp;
 use PhpParser\Node\Expr\BinaryOp\NotEqual;
 use PhpParser\Node\Expr\BinaryOp\NotIdentical;
 use PhpParser\Node\Expr\BooleanNot;
@@ -68,9 +67,9 @@ final class UselessIfCondBeforeForeachDetector
         return $this->isMatchingNotBinaryOp($notIdentical, $foreachExpr);
     }
     /**
-     * @param NotIdentical|NotEqual $binaryOp
+     * @param \PhpParser\Node\Expr\BinaryOp\NotIdentical|\PhpParser\Node\Expr\BinaryOp\NotEqual $binaryOp
      */
-    private function isMatchingNotBinaryOp(\PhpParser\Node\Expr\BinaryOp $binaryOp, \PhpParser\Node\Expr $foreachExpr) : bool
+    private function isMatchingNotBinaryOp($binaryOp, \PhpParser\Node\Expr $foreachExpr) : bool
     {
         if ($this->isEmptyArrayAndForeachedVariable($binaryOp->left, $binaryOp->right, $foreachExpr)) {
             return \true;

rules/Defluent/NodeResolver/FirstMethodCallVarResolver.php

@@ -4,15 +4,14 @@ declare (strict_types=1);
 namespace Rector\Defluent\NodeResolver;
 
 use PhpParser\Node\Expr;
-use Rector\Defluent\Contract\ValueObject\FirstCallFactoryAwareInterface;
 use Rector\Defluent\ValueObject\AssignAndRootExpr;
 use Rector\Defluent\ValueObject\FirstAssignFluentCall;
 final class FirstMethodCallVarResolver
 {
     /**
-     * @param FirstAssignFluentCall|AssignAndRootExpr $firstCallFactoryAware
+     * @param \Rector\Defluent\ValueObject\FirstAssignFluentCall|\Rector\Defluent\ValueObject\AssignAndRootExpr $firstCallFactoryAware
      */
-    public function resolve(\Rector\Defluent\Contract\ValueObject\FirstCallFactoryAwareInterface $firstCallFactoryAware, int $key) : \PhpParser\Node\Expr
+    public function resolve($firstCallFactoryAware, int $key) : \PhpParser\Node\Expr
     {
         if (!$firstCallFactoryAware->isFirstCallFactory()) {
             return $firstCallFactoryAware->getCallerExpr();

rules/DowngradePhp70/Rector/FunctionLike/DowngradeScalarTypeDeclarationRector.php

@@ -12,7 +12,6 @@ use PhpParser\Node\Expr\Cast\Int_;
 use PhpParser\Node\Expr\Cast\String_;
 use PhpParser\Node\Expr\Closure;
 use PhpParser\Node\Expr\Variable;
-use PhpParser\Node\FunctionLike;
 use PhpParser\Node\Param;
 use PhpParser\Node\Stmt\ClassMethod;
 use PhpParser\Node\Stmt\Expression;
@@ -97,9 +96,9 @@ CODE_SAMPLE
         return $node;
     }
     /**
-     * @param Function_|ClassMethod $functionLike
+     * @param \PhpParser\Node\Stmt\Function_|\PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Expr\Closure $functionLike
      */
-    private function resolveRecastAssign(\PhpParser\Node\Param $param, \PhpParser\Node\FunctionLike $functionLike) : ?\PhpParser\Node\Stmt\Expression
+    private function resolveRecastAssign(\PhpParser\Node\Param $param, $functionLike) : ?\PhpParser\Node\Stmt\Expression
     {
         if ($functionLike->stmts === null) {
             return null;

rules/DowngradePhp71/Rector/List_/DowngradeKeysInListRector.php

@@ -112,10 +112,10 @@ CODE_SAMPLE
         return null;
     }
     /**
-     * @param List_|Array_ $node
      * @return Expression[]
+     * @param \PhpParser\Node\Expr\List_|\PhpParser\Node\Expr\Array_ $node
      */
-    private function processExtractToItsOwnVariable(\PhpParser\Node $node, \PhpParser\Node $parent, \PhpParser\Node $parentExpression) : array
+    private function processExtractToItsOwnVariable($node, \PhpParser\Node $parent, \PhpParser\Node $parentExpression) : array
     {
         $items = $node->items;
         $assignExpressions = [];

rules/DowngradePhp71/Rector/String_/DowngradeNegativeStringOffsetToStrlenRector.php

@@ -54,9 +54,9 @@ CODE_SAMPLE
         return $this->processForStringOrVariableOrProperty($node);
     }
     /**
-     * @param String_|Variable|PropertyFetch|StaticPropertyFetch $expr
+     * @param \PhpParser\Node\Scalar\String_|\PhpParser\Node\Expr\Variable|\PhpParser\Node\Expr\PropertyFetch|\PhpParser\Node\Expr\StaticPropertyFetch $expr
      */
-    private function processForStringOrVariableOrProperty(\PhpParser\Node\Expr $expr) : ?\PhpParser\Node\Expr
+    private function processForStringOrVariableOrProperty($expr) : ?\PhpParser\Node\Expr
     {
         $nextNode = $expr->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::NEXT_NODE);
         if (!$nextNode instanceof \PhpParser\Node\Expr\UnaryMinus) {

rules/DowngradePhp73/Rector/List_/DowngradeListReferenceAssignmentRector.php

@@ -100,10 +100,10 @@ CODE_SAMPLE
      * Remove the right-side-most params by reference or empty from `list()`,
      * since they are not needed anymore.
      * If all of them can be removed, then directly remove `list()`.
-     * @param List_|Array_ $node
      * @return List_|Array_|null
+     * @param \PhpParser\Node\Expr\List_|\PhpParser\Node\Expr\Array_ $node
      */
-    public function removeStaleParams(\PhpParser\Node $node, int $rightSideRemovableParamsCount) : ?\PhpParser\Node
+    public function removeStaleParams($node, int $rightSideRemovableParamsCount) : ?\PhpParser\Node
     {
         $nodeItemsCount = \count($node->items);
         if ($rightSideRemovableParamsCount === $nodeItemsCount) {
@@ -119,9 +119,9 @@ CODE_SAMPLE
         return $node;
     }
     /**
-     * @param List_|Array_ $node
+     * @param \PhpParser\Node\Expr\List_|\PhpParser\Node\Expr\Array_ $node
      */
-    private function shouldRefactor(\PhpParser\Node $node) : bool
+    private function shouldRefactor($node) : bool
     {
         $parentNode = $node->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::PARENT_NODE);
         // Check it follows `list(...) = $foo`

rules/DowngradePhp74/Rector/ClassMethod/DowngradeCovariantReturnTypeRector.php

@@ -4,6 +4,7 @@ declare (strict_types=1);
 namespace Rector\DowngradePhp74\Rector\ClassMethod;
 
 use PhpParser\Node;
+use PhpParser\Node\Identifier;
 use PhpParser\Node\Name;
 use PhpParser\Node\NullableType;
 use PhpParser\Node\Stmt\ClassMethod;
@@ -128,9 +129,9 @@ CODE_SAMPLE
         return $node;
     }
     /**
-     * @param UnionType|NullableType|Name|Node\Identifier $returnTypeNode
+     * @param \PhpParser\Node\UnionType|\PhpParser\Node\NullableType|\PhpParser\Node\Name|\PhpParser\Node\Identifier $returnTypeNode
      */
-    private function resolveDifferentAncestorReturnType(\PhpParser\Node\Stmt\ClassMethod $classMethod, \PhpParser\Node $returnTypeNode) : \PHPStan\Type\Type
+    private function resolveDifferentAncestorReturnType(\PhpParser\Node\Stmt\ClassMethod $classMethod, $returnTypeNode) : \PHPStan\Type\Type
     {
         $scope = $classMethod->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::SCOPE);
         if (!$scope instanceof \PHPStan\Analyser\Scope) {

rules/DowngradePhp74/Rector/FuncCall/DowngradeStripTagsCallWithArrayRector.php

@@ -5,7 +5,6 @@ namespace Rector\DowngradePhp74\Rector\FuncCall;
 
 use PhpParser\Node;
 use PhpParser\Node\Arg;
-use PhpParser\Node\Expr;
 use PhpParser\Node\Expr\Array_;
 use PhpParser\Node\Expr\Assign;
 use PhpParser\Node\Expr\BinaryOp\BooleanAnd;
@@ -133,9 +132,9 @@ CODE_SAMPLE
         return !$this->valueResolver->isNull($allowableTagsParam);
     }
     /**
-     * @param Array_|Variable|PropertyFetch|ConstFetch|ClassConstFetch $expr
+     * @param \PhpParser\Node\Expr\Array_|\PhpParser\Node\Expr\Variable|\PhpParser\Node\Expr\PropertyFetch|\PhpParser\Node\Expr\ConstFetch|\PhpParser\Node\Expr\ClassConstFetch $expr
      */
-    private function createArrayFromString(\PhpParser\Node\Expr $expr) : \PhpParser\Node\Expr\BinaryOp\Concat
+    private function createArrayFromString($expr) : \PhpParser\Node\Expr\BinaryOp\Concat
     {
         $args = [new \PhpParser\Node\Arg(new \PhpParser\Node\Scalar\String_('><')), new \PhpParser\Node\Arg($expr)];
         $implodeFuncCall = new \PhpParser\Node\Expr\FuncCall(new \PhpParser\Node\Name('implode'), $args);
@@ -143,9 +142,9 @@ CODE_SAMPLE
         return new \PhpParser\Node\Expr\BinaryOp\Concat($concat, new \PhpParser\Node\Scalar\String_('>'));
     }
     /**
-     * @param Variable|PropertyFetch|ConstFetch|ClassConstFetch $expr
+     * @param \PhpParser\Node\Expr\Variable|\PhpParser\Node\Expr\PropertyFetch|\PhpParser\Node\Expr\ConstFetch|\PhpParser\Node\Expr\ClassConstFetch $expr
      */
-    private function createIsArrayTernaryFromExpression(\PhpParser\Node\Expr $expr) : \PhpParser\Node\Expr\Ternary
+    private function createIsArrayTernaryFromExpression($expr) : \PhpParser\Node\Expr\Ternary
     {
         $isArrayFuncCall = new \PhpParser\Node\Expr\FuncCall(new \PhpParser\Node\Name('is_array'), [new \PhpParser\Node\Arg($expr)]);
         $nullNotIdentical = new \PhpParser\Node\Expr\BinaryOp\NotIdentical($expr, $this->nodeFactory->createNull());

rules/DowngradePhp74/Rector/LNumber/DowngradeNumericLiteralSeparatorRector.php

@@ -75,9 +75,9 @@ CODE_SAMPLE
         return $node;
     }
     /**
-     * @param LNumber|DNumber $node
+     * @param \PhpParser\Node\Scalar\LNumber|\PhpParser\Node\Scalar\DNumber $node
      */
-    public function shouldRefactor(\PhpParser\Node $node) : bool
+    public function shouldRefactor($node) : bool
     {
         // "_" notation can be applied to decimal numbers only
         if ($node instanceof \PhpParser\Node\Scalar\LNumber) {

rules/DowngradePhp80/Rector/ClassMethod/DowngradeTrailingCommasInParamUseRector.php

@@ -93,9 +93,9 @@ CODE_SAMPLE
         return $this->processParams($node);
     }
     /**
-     * @param FuncCall|MethodCall|StaticCall|New_ $node
+     * @param \PhpParser\Node\Expr\FuncCall|\PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\New_ $node
      */
-    private function processArgs(\PhpParser\Node $node) : ?\PhpParser\Node
+    private function processArgs($node) : ?\PhpParser\Node
     {
         if ($node->args === []) {
             return null;

rules/DowngradePhp80/Rector/Expression/DowngradeMatchToSwitchRector.php

@@ -94,11 +94,11 @@ CODE_SAMPLE
         return new \PhpParser\Node\Stmt\Switch_($match->cond, $switchCases);
     }
     /**
-     * @param Expression|Return_ $node
      * @param MatchArm[] $matchArms
      * @return Case_[]
+     * @param \PhpParser\Node\Stmt\Expression|\PhpParser\Node\Stmt\Return_ $node
      */
-    private function createSwitchCasesFromMatchArms(\PhpParser\Node $node, array $matchArms) : array
+    private function createSwitchCasesFromMatchArms($node, array $matchArms) : array
     {
         $switchCases = [];
         foreach ($matchArms as $matchArm) {
@@ -120,10 +120,10 @@ CODE_SAMPLE
         return $switchCases;
     }
     /**
-     * @param Expression|Return_ $node
      * @return Stmt[]
+     * @param \PhpParser\Node\Stmt\Expression|\PhpParser\Node\Stmt\Return_ $node
      */
-    private function createSwitchStmts(\PhpParser\Node $node, \PhpParser\Node\MatchArm $matchArm) : array
+    private function createSwitchStmts($node, \PhpParser\Node\MatchArm $matchArm) : array
     {
         $stmts = [];
         if ($node instanceof \PhpParser\Node\Stmt\Expression) {

rules/DowngradePhp80/Rector/FuncCall/DowngradeStrContainsRector.php

@@ -4,7 +4,6 @@ declare (strict_types=1);
 namespace Rector\DowngradePhp80\Rector\FuncCall;
 
 use PhpParser\Node;
-use PhpParser\Node\Expr;
 use PhpParser\Node\Expr\BinaryOp\Identical;
 use PhpParser\Node\Expr\BinaryOp\NotIdentical;
 use PhpParser\Node\Expr\BooleanNot;
@@ -67,10 +66,10 @@ CODE_SAMPLE
         return new \PhpParser\Node\Expr\BinaryOp\NotIdentical($funcCall, $this->nodeFactory->createFalse());
     }
     /**
-     * @param FuncCall|BooleanNot $expr
      * @return FuncCall
+     * @param \PhpParser\Node\Expr\FuncCall|\PhpParser\Node\Expr\BooleanNot $expr
      */
-    private function matchStrContainsOrNotStrContains(\PhpParser\Node\Expr $expr) : ?\PhpParser\Node\Expr\FuncCall
+    private function matchStrContainsOrNotStrContains($expr) : ?\PhpParser\Node\Expr\FuncCall
     {
         $expr = $expr instanceof \PhpParser\Node\Expr\BooleanNot ? $expr->expr : $expr;
         if (!$expr instanceof \PhpParser\Node\Expr\FuncCall) {

rules/DowngradePhp80/Rector/MethodCall/DowngradeNamedArgumentRector.php

@@ -104,12 +104,12 @@ CODE_SAMPLE
         return $this->processRemoveNamedArgument($functionLikeReflection, $node, $args);
     }
     /**
-     * @param MethodCall|StaticCall|New_ $node
      * @param Arg[] $args
      * @param \PHPStan\Reflection\MethodReflection|\PHPStan\Reflection\FunctionReflection $reflection
+     * @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\New_ $node
      * @return \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\New_
      */
-    private function processRemoveNamedArgument($reflection, \PhpParser\Node $node, array $args)
+    private function processRemoveNamedArgument($reflection, $node, array $args)
     {
         /** @var Arg[] $newArgs */
         $newArgs = [];

rules/EarlyReturn/Rector/If_/RemoveAlwaysElseRector.php

@@ -109,9 +109,9 @@ CODE_SAMPLE
         return $statements;
     }
     /**
-     * @param If_|ElseIf_ $node
+     * @param \PhpParser\Node\Stmt\If_|\PhpParser\Node\Stmt\ElseIf_ $node
      */
-    private function doesLastStatementBreakFlow(\PhpParser\Node $node) : bool
+    private function doesLastStatementBreakFlow($node) : bool
     {
         $lastStmt = \end($node->stmts);
         return !($lastStmt instanceof \PhpParser\Node\Stmt\Return_ || $lastStmt instanceof \PhpParser\Node\Stmt\Throw_ || $lastStmt instanceof \PhpParser\Node\Stmt\Continue_ || $lastStmt instanceof \PhpParser\Node\Stmt\Expression && $lastStmt->expr instanceof \PhpParser\Node\Expr\Exit_);

rules/MockeryToProphecy/Collector/MockVariableCollector.php

@@ -3,7 +3,6 @@
 declare (strict_types=1);
 namespace Rector\MockeryToProphecy\Collector;
 
-use PhpParser\Node;
 use PhpParser\Node\Expr\Assign;
 use PhpParser\Node\Expr\FuncCall;
 use PhpParser\Node\Expr\StaticCall;
@@ -27,10 +26,10 @@ final class MockVariableCollector
         $this->valueResolver = $valueResolver;
     }
     /**
-     * @param FuncCall|StaticCall $node
      * @return array<string, class-string>
+     * @param \PhpParser\Node\Expr\FuncCall|\PhpParser\Node\Expr\StaticCall $node
      */
-    public function collectMockVariableName(\PhpParser\Node $node) : array
+    public function collectMockVariableName($node) : array
     {
         $mockVariableTypesByNames = [];
         $parentNode = $node->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::PARENT_NODE);

rules/Naming/Matcher/CallMatcher.php

@@ -12,10 +12,10 @@ use PhpParser\Node\Stmt\Foreach_;
 final class CallMatcher
 {
     /**
-     * @param Assign|Foreach_ $node
      * @return FuncCall|StaticCall|MethodCall|null
+     * @param \PhpParser\Node\Expr\Assign|\PhpParser\Node\Stmt\Foreach_ $node
      */
-    public function matchCall(\PhpParser\Node $node) : ?\PhpParser\Node
+    public function matchCall($node) : ?\PhpParser\Node
     {
         if ($node->expr instanceof \PhpParser\Node\Expr\MethodCall) {
             return $node->expr;

rules/Naming/Naming/ExpectedNameResolver.php

@@ -102,9 +102,9 @@ final class ExpectedNameResolver
         return $expectedName->getName();
     }
     /**
-     * @param MethodCall|StaticCall|FuncCall $expr
+     * @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\FuncCall $expr
      */
-    public function resolveForCall(\PhpParser\Node\Expr $expr) : ?string
+    public function resolveForCall($expr) : ?string
     {
         if ($this->isDynamicNameCall($expr)) {
             return null;
@@ -135,9 +135,9 @@ final class ExpectedNameResolver
         return null;
     }
     /**
-     * @param MethodCall|StaticCall|FuncCall $expr
+     * @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\FuncCall $expr
      */
-    public function resolveForForeach(\PhpParser\Node\Expr $expr) : ?string
+    public function resolveForForeach($expr) : ?string
     {
         if ($this->isDynamicNameCall($expr)) {
             return null;
@@ -170,9 +170,9 @@ final class ExpectedNameResolver
         return $expectedNameFromMethodName->getSingularized();
     }
     /**
-     * @param MethodCall|StaticCall|FuncCall $expr
+     * @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\FuncCall $expr
      */
-    private function isDynamicNameCall(\PhpParser\Node\Expr $expr) : bool
+    private function isDynamicNameCall($expr) : bool
     {
         if ($expr->name instanceof \PhpParser\Node\Expr\StaticCall) {
             return \true;

rules/Naming/Naming/VariableNaming.php

@@ -198,9 +198,9 @@ final class VariableNaming
         return $varName . \ucfirst($propertyName);
     }
     /**
-     * @param MethodCall|NullsafeMethodCall|StaticCall $node
+     * @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\NullsafeMethodCall|\PhpParser\Node\Expr\StaticCall $node
      */
-    private function resolveFromMethodCall(\PhpParser\Node $node) : ?string
+    private function resolveFromMethodCall($node) : ?string
     {
         if ($node->name instanceof \PhpParser\Node\Expr\MethodCall) {
             return $this->resolveFromMethodCall($node->name);

rules/Naming/NamingConvention/NamingConventionAnalyzer.php

@@ -4,7 +4,6 @@ declare (strict_types=1);
 namespace Rector\Naming\NamingConvention;
 
 use RectorPrefix20210629\Nette\Utils\Strings;
-use PhpParser\Node\Expr;
 use PhpParser\Node\Expr\FuncCall;
 use PhpParser\Node\Expr\MethodCall;
 use PhpParser\Node\Expr\StaticCall;
@@ -25,10 +24,9 @@ final class NamingConventionAnalyzer
      * $someNameSuffix = $this->getSomeName();
      * $prefixSomeName = $this->getSomeName();
      * $someName = $this->getSomeName();
-     *
+     * @param \PhpParser\Node\Expr\FuncCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\MethodCall $expr
-     * @param FuncCall|StaticCall|MethodCall $expr
      */
-    public function isCallMatchingVariableName(\PhpParser\Node\Expr $expr, string $currentName, string $expectedName) : bool
+    public function isCallMatchingVariableName($expr, string $currentName, string $expectedName) : bool
     {
         // skip "$call = $method->call();" based conventions
         $callName = $this->nodeNameResolver->getName($expr->name);

rules/Naming/Rector/Assign/RenameVariableToMatchMethodCallReturnTypeRector.php

@@ -4,7 +4,6 @@ declare (strict_types=1);
 namespace Rector\Naming\Rector\Assign;
 
 use PhpParser\Node;
-use PhpParser\Node\Expr;
 use PhpParser\Node\Expr\Assign;
 use PhpParser\Node\Expr\FuncCall;
 use PhpParser\Node\Expr\MethodCall;
@@ -144,9 +143,9 @@ CODE_SAMPLE
         return $node;
     }
     /**
-     * @param FuncCall|StaticCall|MethodCall $callNode
+     * @param \PhpParser\Node\Expr\FuncCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\MethodCall $callNode
      */
-    private function isMultipleCall(\PhpParser\Node $callNode) : bool
+    private function isMultipleCall($callNode) : bool
     {
         $parentNode = $callNode->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::PARENT_NODE);
         $callNodeClass = \get_class($callNode);
@@ -191,9 +190,9 @@ CODE_SAMPLE
         $this->variableRenamer->renameVariableInFunctionLike($variableAndCallAssign->getFunctionLike(), $variableAndCallAssign->getVariableName(), $expectedName, $variableAndCallAssign->getAssign());
     }
     /**
-     * @param StaticCall|MethodCall|FuncCall $expr
+     * @param \PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\FuncCall $expr
      */
-    private function isClassTypeWithChildren(\PhpParser\Node\Expr $expr) : bool
+    private function isClassTypeWithChildren($expr) : bool
     {
         $callStaticType = $this->getStaticType($expr);
         $callStaticType = $this->typeUnwrapper->unwrapNullableType($callStaticType);

rules/Order/Rector/Class_/OrderPrivateMethodsByUseRector.php

@@ -103,9 +103,9 @@ CODE_SAMPLE
         return $node;
     }
     /**
-     * @param Class_|Trait_ $classLike
+     * @param \PhpParser\Node\Stmt\Class_|\PhpParser\Node\Stmt\Trait_ $classLike
      */
-    private function getSortedAndOriginalClassMethods(\PhpParser\Node\Stmt\ClassLike $classLike) : \Rector\Order\ValueObject\SortedClassMethodsAndOriginalClassMethods
+    private function getSortedAndOriginalClassMethods($classLike) : \Rector\Order\ValueObject\SortedClassMethodsAndOriginalClassMethods
     {
         return new \Rector\Order\ValueObject\SortedClassMethodsAndOriginalClassMethods($this->getLocalPrivateMethodCallOrder($classLike), $this->resolvePrivateClassMethods($classLike));
     }

rules/PHPOffice/Rector/StaticCall/AddRemovedDefaultValuesRector.php

@@ -69,10 +69,10 @@ CODE_SAMPLE
         return $node;
     }
     /**
-     * @param StaticCall|MethodCall $node
      * @param array<int, mixed> $defaultValuesByPosition
+     * @param \PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\MethodCall $node
      */
-    private function refactorArgs(\PhpParser\Node $node, array $defaultValuesByPosition) : void
+    private function refactorArgs($node, array $defaultValuesByPosition) : void
     {
         foreach ($defaultValuesByPosition as $position => $defaultValue) {
             // value is already set
@@ -90,9 +90,9 @@ CODE_SAMPLE
         }
     }
     /**
-     * @param StaticCall|MethodCall $node
+     * @param \PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\MethodCall $node
      */
-    private function isCallerObjectType(\PhpParser\Node $node, \PHPStan\Type\ObjectType $objectType) : bool
+    private function isCallerObjectType($node, \PHPStan\Type\ObjectType $objectType) : bool
     {
         return $this->isObjectType($node instanceof \PhpParser\Node\Expr\MethodCall ? $node->var : $node->class, $objectType);
     }

rules/PSR4/Rector/Namespace_/MultipleClassFileToPsr4ClassesRector.php

@@ -141,9 +141,9 @@ CODE_SAMPLE
         return $nodeToReturn;
     }
     /**
-     * @param Namespace_|FileWithoutNamespace $mainNode
+     * @param \PhpParser\Node\Stmt\Namespace_|\Rector\Core\PhpParser\Node\CustomNode\FileWithoutNamespace $mainNode
      */
-    private function printNewNodes(\PhpParser\Node\Stmt\ClassLike $classLike, \PhpParser\Node $mainNode) : void
+    private function printNewNodes(\PhpParser\Node\Stmt\ClassLike $classLike, $mainNode) : void
     {
         $smartFileInfo = $this->file->getSmartFileInfo();
         $declares = [];

rules/Php54/Rector/Break_/RemoveZeroBreakContinueRector.php

@@ -6,7 +6,6 @@ namespace Rector\Php54\Rector\Break_;
 use PhpParser\Node;
 use PhpParser\Node\Expr\Variable;
 use PhpParser\Node\Scalar\LNumber;
-use PhpParser\Node\Stmt;
 use PhpParser\Node\Stmt\Break_;
 use PhpParser\Node\Stmt\Continue_;
 use PHPStan\Type\Constant\ConstantIntegerType;
@@ -87,9 +86,9 @@ CODE_SAMPLE
         return null;
     }
     /**
-     * @param Break_|Continue_ $stmt
+     * @param \PhpParser\Node\Stmt\Break_|\PhpParser\Node\Stmt\Continue_ $stmt
      */
-    private function processVariableNum(\PhpParser\Node\Stmt $stmt, \PhpParser\Node\Expr\Variable $numVariable) : ?\PhpParser\Node
+    private function processVariableNum($stmt, \PhpParser\Node\Expr\Variable $numVariable) : ?\PhpParser\Node
     {
         $staticType = $this->getStaticType($numVariable);
         if ($staticType instanceof \PHPStan\Type\ConstantType) {

rules/Php71/Rector/Assign/AssignArrayToStringRector.php

@@ -99,9 +99,9 @@ CODE_SAMPLE
         return $assign;
     }
     /**
-     * @param PropertyFetch|StaticPropertyFetch $propertyFetchExpr
+     * @param \PhpParser\Node\Expr\PropertyFetch|\PhpParser\Node\Expr\StaticPropertyFetch $propertyFetchExpr
      */
-    private function refactorPropertyFetch(\PhpParser\Node\Expr $propertyFetchExpr) : bool
+    private function refactorPropertyFetch($propertyFetchExpr) : bool
     {
         foreach ($this->emptyStringProperties as $emptyStringProperty) {
             if (!$this->nodeNameResolver->areNamesEqual($emptyStringProperty, $propertyFetchExpr)) {
@@ -113,9 +113,9 @@ CODE_SAMPLE
         return \false;
     }
     /**
-     * @param Variable|PropertyFetch|StaticPropertyFetch|Expr $expr
+     * @param \PhpParser\Node\Expr\Variable|\PhpParser\Node\Expr\PropertyFetch|\PhpParser\Node\Expr\StaticPropertyFetch|\PhpParser\Node\Expr $expr
      */
-    private function processVariable(\PhpParser\Node\Expr\Assign $assign, \PhpParser\Node\Expr $expr) : bool
+    private function processVariable(\PhpParser\Node\Expr\Assign $assign, $expr) : bool
     {
         if ($this->shouldSkipVariable($expr)) {
             return \true;

rules/Php74/Rector/LNumber/AddLiteralSeparatorToNumberRector.php

@@ -107,9 +107,9 @@ CODE_SAMPLE
         return $node;
     }
     /**
-     * @param LNumber|DNumber $node
+     * @param \PhpParser\Node\Scalar\LNumber|\PhpParser\Node\Scalar\DNumber $node
      */
-    private function shouldSkip(\PhpParser\Node $node, string $numericValueAsString) : bool
+    private function shouldSkip($node, string $numericValueAsString) : bool
     {
         /** @var int $startToken */
         $startToken = $node->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::START_TOKEN_POSITION);

rules/Php74/Rector/Property/TypedPropertyRector.php

@@ -176,9 +176,9 @@ CODE_SAMPLE
         return \true;
     }
     /**
-     * @param Name|NullableType|PhpParserUnionType $node
+     * @param \PhpParser\Node\Name|\PhpParser\Node\NullableType|PhpParserUnionType $node
      */
-    private function shouldSkipNonClassLikeType(\PhpParser\Node $node) : bool
+    private function shouldSkipNonClassLikeType($node) : bool
     {
         // unwrap nullable type
         if ($node instanceof \PhpParser\Node\NullableType) {

rules/Php80/Rector/FunctionLike/UnionTypesRector.php

@@ -112,9 +112,6 @@ CODE_SAMPLE
             return;
         }
         foreach ($functionLike->getParams() as $param) {
-            if ($param->type !== null) {
-                continue;
-            }
             /** @var string $paramName */
             $paramName = $this->getName($param->var);
             $paramType = $phpDocInfo->getParamType($paramName);

rules/Php80/Rector/NotIdentical/StrContainsRector.php

@@ -4,7 +4,6 @@ declare (strict_types=1);
 namespace Rector\Php80\Rector\NotIdentical;
 
 use PhpParser\Node;
-use PhpParser\Node\Expr;
 use PhpParser\Node\Expr\BinaryOp\Identical;
 use PhpParser\Node\Expr\BinaryOp\NotIdentical;
 use PhpParser\Node\Expr\BooleanNot;
@@ -69,9 +68,9 @@ CODE_SAMPLE
         return $funcCall;
     }
     /**
-     * @param Identical|NotIdentical $expr
+     * @param \PhpParser\Node\Expr\BinaryOp\Identical|\PhpParser\Node\Expr\BinaryOp\NotIdentical $expr
      */
-    private function matchIdenticalOrNotIdenticalToFalse(\PhpParser\Node\Expr $expr) : ?\PhpParser\Node\Expr\FuncCall
+    private function matchIdenticalOrNotIdenticalToFalse($expr) : ?\PhpParser\Node\Expr\FuncCall
     {
         if ($this->valueResolver->isFalse($expr->left)) {
             if (!$expr->right instanceof \PhpParser\Node\Expr\FuncCall) {

rules/Privatization/NodeManipulator/VisibilityManipulator.php

@@ -43,16 +43,16 @@ final class VisibilityManipulator
         $node->flags -= \PhpParser\Node\Stmt\Class_::MODIFIER_STATIC;
     }
     /**
-     * @param Class_|ClassMethod $node
+     * @param \PhpParser\Node\Stmt\Class_|\PhpParser\Node\Stmt\ClassMethod $node
      */
-    public function makeFinal(\PhpParser\Node $node) : void
+    public function makeFinal($node) : void
     {
         $this->addVisibilityFlag($node, \Rector\Core\ValueObject\Visibility::FINAL);
     }
     /**
-     * @param Class_|ClassMethod $node
+     * @param \PhpParser\Node\Stmt\Class_|\PhpParser\Node\Stmt\ClassMethod $node
      */
-    public function makeNonFinal(\PhpParser\Node $node) : void
+    public function makeNonFinal($node) : void
     {
         if (!$node->isFinal()) {
             return;
@@ -61,10 +61,9 @@ final class VisibilityManipulator
     }
     /**
      * This way "abstract", "static", "final" are kept
-     *
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Property|\PhpParser\Node\Stmt\ClassConst $node
-     * @param ClassMethod|Property|ClassConst $node
      */
-    public function removeVisibility(\PhpParser\Node $node) : void
+    public function removeVisibility($node) : void
     {
         $this->ensureIsClassMethodOrProperty($node, __METHOD__);
         // no modifier
@@ -82,31 +81,31 @@ final class VisibilityManipulator
         }
     }
     /**
-     * @param ClassMethod|Property|ClassConst $node
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Property|\PhpParser\Node\Stmt\ClassConst $node
      */
-    public function changeNodeVisibility(\PhpParser\Node $node, int $visibility) : void
+    public function changeNodeVisibility($node, int $visibility) : void
     {
         \RectorPrefix20210629\Webmozart\Assert\Assert::oneOf($visibility, [\Rector\Core\ValueObject\Visibility::PUBLIC, \Rector\Core\ValueObject\Visibility::PROTECTED, \Rector\Core\ValueObject\Visibility::PRIVATE, \Rector\Core\ValueObject\Visibility::STATIC, \Rector\Core\ValueObject\Visibility::ABSTRACT, \Rector\Core\ValueObject\Visibility::FINAL]);
         $this->replaceVisibilityFlag($node, $visibility);
     }
     /**
-     * @param ClassMethod|Property|ClassConst $node
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Property|\PhpParser\Node\Stmt\ClassConst $node
      */
-    public function makePublic(\PhpParser\Node $node) : void
+    public function makePublic($node) : void
     {
         $this->replaceVisibilityFlag($node, \Rector\Core\ValueObject\Visibility::PUBLIC);
     }
     /**
-     * @param ClassMethod|Property|ClassConst $node
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Property|\PhpParser\Node\Stmt\ClassConst $node
      */
-    public function makeProtected(\PhpParser\Node $node) : void
+    public function makeProtected($node) : void
     {
         $this->replaceVisibilityFlag($node, \Rector\Core\ValueObject\Visibility::PROTECTED);
     }
     /**
-     * @param ClassMethod|Property|ClassConst $node
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Property|\PhpParser\Node\Stmt\ClassConst $node
      */
-    public function makePrivate(\PhpParser\Node $node) : void
+    public function makePrivate($node) : void
     {
         $this->replaceVisibilityFlag($node, \Rector\Core\ValueObject\Visibility::PRIVATE);
     }
@@ -115,9 +114,9 @@ final class VisibilityManipulator
         $class->flags -= \PhpParser\Node\Stmt\Class_::MODIFIER_FINAL;
     }
     /**
-     * @param Class_|ClassMethod|Property|ClassConst $node
+     * @param \PhpParser\Node\Stmt\Class_|\PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Property|\PhpParser\Node\Stmt\ClassConst $node
      */
-    private function addVisibilityFlag(\PhpParser\Node $node, int $visibility) : void
+    private function addVisibilityFlag($node, int $visibility) : void
     {
         $this->ensureIsClassMethodOrProperty($node, __METHOD__);
         $node->flags |= $visibility;
@@ -132,9 +131,9 @@ final class VisibilityManipulator
         throw new \Rector\Core\Exception\InvalidNodeTypeException(\sprintf('"%s" only accepts "%s" types. "%s" given.', $location, \implode('", "', self::ALLOWED_NODE_TYPES), \get_class($node)));
     }
     /**
-     * @param ClassMethod|Property|ClassConst $node
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Property|\PhpParser\Node\Stmt\ClassConst $node
      */
-    private function replaceVisibilityFlag(\PhpParser\Node $node, int $visibility) : void
+    private function replaceVisibilityFlag($node, int $visibility) : void
     {
         $isStatic = $node instanceof \PhpParser\Node\Stmt\ClassMethod && $node->isStatic();
         if ($isStatic) {

rules/Removing/Rector/ClassMethod/ArgumentRemoverRector.php

@@ -72,9 +72,9 @@ CODE_SAMPLE
         $this->removedArguments = $removedArguments;
     }
     /**
-     * @param ClassMethod|StaticCall|MethodCall $node
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\MethodCall $node
      */
-    private function processPosition(\PhpParser\Node $node, \Rector\Removing\ValueObject\ArgumentRemover $argumentRemover) : void
+    private function processPosition($node, \Rector\Removing\ValueObject\ArgumentRemover $argumentRemover) : void
     {
         if ($argumentRemover->getValue() === null) {
             if ($node instanceof \PhpParser\Node\Expr\MethodCall || $node instanceof \PhpParser\Node\Expr\StaticCall) {
@@ -101,9 +101,9 @@ CODE_SAMPLE
         }
     }
     /**
-     * @param ClassMethod|StaticCall|MethodCall $node
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\MethodCall $node
      */
-    private function removeByName(\PhpParser\Node $node, int $position, string $name) : void
+    private function removeByName($node, int $position, string $name) : void
     {
         if ($node instanceof \PhpParser\Node\Expr\MethodCall || $node instanceof \PhpParser\Node\Expr\StaticCall) {
             if (isset($node->args[$position]) && $this->isName($node->args[$position], $name)) {

rules/Renaming/NodeManipulator/IdentifierManipulator.php

@@ -53,9 +53,9 @@ final class IdentifierManipulator
         $node->name = new \PhpParser\Node\Identifier($newName);
     }
     /**
-     * @param ClassConstFetch|MethodCall|PropertyFetch|StaticCall|ClassMethod $node
+     * @param \PhpParser\Node\Expr\ClassConstFetch|\PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\PropertyFetch|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Stmt\ClassMethod $node
      */
-    private function resolveOldMethodName(\PhpParser\Node $node) : ?string
+    private function resolveOldMethodName($node) : ?string
     {
         if ($node instanceof \PhpParser\Node\Expr\StaticCall || $node instanceof \PhpParser\Node\Expr\MethodCall) {
             return $this->nodeNameResolver->getName($node->name);

rules/Renaming/Rector/FileWithoutNamespace/PseudoNamespaceToNamespaceRector.php

@@ -129,10 +129,10 @@ CODE_SAMPLE
         return $stmts;
     }
     /**
-     * @param Name|Identifier $node
      * @return Name|Identifier
+     * @param \PhpParser\Node\Name|\PhpParser\Node\Identifier $node
      */
-    private function processNameOrIdentifier(\PhpParser\Node $node) : ?\PhpParser\Node
+    private function processNameOrIdentifier($node) : ?\PhpParser\Node
     {
         // no name → skip
         if ($node->toString() === '') {

rules/Renaming/Rector/MethodCall/RenameMethodRector.php

@@ -105,9 +105,9 @@ CODE_SAMPLE
         $this->methodCallRenameCollector->addMethodCallRenames($methodCallRenames);
     }
     /**
-     * @param MethodCall|StaticCall|ClassMethod $node
+     * @param \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Stmt\ClassMethod $node
      */
-    private function skipClassMethod(\PhpParser\Node $node, \Rector\Renaming\Contract\MethodCallRenameInterface $methodCallRename) : bool
+    private function skipClassMethod($node, \Rector\Renaming\Contract\MethodCallRenameInterface $methodCallRename) : bool
     {
         if (!$node instanceof \PhpParser\Node\Stmt\ClassMethod) {
             return \false;

rules/Transform/NodeAnalyzer/FuncCallStaticCallToMethodCallAnalyzer.php

@@ -6,7 +6,6 @@ namespace Rector\Transform\NodeAnalyzer;
 use PhpParser\Node\Expr\MethodCall;
 use PhpParser\Node\Expr\PropertyFetch;
 use PhpParser\Node\Expr\Variable;
-use PhpParser\Node\FunctionLike;
 use PhpParser\Node\Stmt\Class_;
 use PhpParser\Node\Stmt\ClassMethod;
 use PhpParser\Node\Stmt\Function_;
@@ -53,10 +52,10 @@ final class FuncCallStaticCallToMethodCallAnalyzer
         $this->propertyAdder = $propertyAdder;
     }
     /**
-     * @param ClassMethod|Function_ $functionLike
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
      * @return \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\PropertyFetch|\PhpParser\Node\Expr\Variable
      */
-    public function matchTypeProvidingExpr(\PhpParser\Node\Stmt\Class_ $class, \PhpParser\Node\FunctionLike $functionLike, \PHPStan\Type\ObjectType $objectType)
+    public function matchTypeProvidingExpr(\PhpParser\Node\Stmt\Class_ $class, $functionLike, \PHPStan\Type\ObjectType $objectType)
     {
         $expr = $this->typeProvidingExprFromClassResolver->resolveTypeProvidingExprFromClass($class, $functionLike, $objectType);
         if ($expr !== null) {
@@ -70,9 +69,9 @@ final class FuncCallStaticCallToMethodCallAnalyzer
         return $this->propertyFetchFactory->createFromType($objectType);
     }
     /**
-     * @param ClassMethod|Function_ $functionLike
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
      */
-    private function addClassMethodParamForVariable(\PhpParser\Node\Expr\Variable $variable, \PHPStan\Type\ObjectType $objectType, \PhpParser\Node\FunctionLike $functionLike) : void
+    private function addClassMethodParamForVariable(\PhpParser\Node\Expr\Variable $variable, \PHPStan\Type\ObjectType $objectType, $functionLike) : void
     {
         /** @var string $variableName */
         $variableName = $this->nodeNameResolver->getName($variable);

rules/Transform/NodeTypeAnalyzer/TypeProvidingExprFromClassResolver.php

@@ -51,10 +51,10 @@ final class TypeProvidingExprFromClassResolver
         $this->propertyNaming = $propertyNaming;
     }
     /**
-     * @param ClassMethod|Function_ $functionLike
      * @return MethodCall|PropertyFetch|Variable|null
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
      */
-    public function resolveTypeProvidingExprFromClass(\PhpParser\Node\Stmt\Class_ $class, \PhpParser\Node\FunctionLike $functionLike, \PHPStan\Type\ObjectType $objectType) : ?\PhpParser\Node\Expr
+    public function resolveTypeProvidingExprFromClass(\PhpParser\Node\Stmt\Class_ $class, $functionLike, \PHPStan\Type\ObjectType $objectType) : ?\PhpParser\Node\Expr
     {
         $className = $class->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::CLASS_NAME);
         if ($className === null) {

rules/Transform/Rector/FileWithoutNamespace/FunctionToStaticMethodRector.php

@@ -134,9 +134,9 @@ CODE_SAMPLE
         return $stmts;
     }
     /**
-     * @param Namespace_|FileWithoutNamespace $node
+     * @param \PhpParser\Node\Stmt\Namespace_|\Rector\Core\PhpParser\Node\CustomNode\FileWithoutNamespace $node
      */
-    private function printStaticMethodClass(\Symplify\SmartFileSystem\SmartFileInfo $smartFileInfo, string $shortClassName, \PhpParser\Node $node, \PhpParser\Node\Stmt\Class_ $class) : void
+    private function printStaticMethodClass(\Symplify\SmartFileSystem\SmartFileInfo $smartFileInfo, string $shortClassName, $node, \PhpParser\Node\Stmt\Class_ $class) : void
     {
         $classFileDestination = $smartFileInfo->getPath() . \DIRECTORY_SEPARATOR . $shortClassName . '.php';
         $nodesToPrint = [$this->resolveNodeToPrint($node, $class)];
@@ -144,10 +144,10 @@ CODE_SAMPLE
         $this->removedAndAddedFilesCollector->addAddedFile($addedFileWithNodes);
     }
     /**
-     * @param Namespace_|FileWithoutNamespace $node
+     * @param \PhpParser\Node\Stmt\Namespace_|\Rector\Core\PhpParser\Node\CustomNode\FileWithoutNamespace $node
      * @return \PhpParser\Node\Stmt\Namespace_|\PhpParser\Node\Stmt\Class_
      */
-    private function resolveNodeToPrint(\PhpParser\Node $node, \PhpParser\Node\Stmt\Class_ $class)
+    private function resolveNodeToPrint($node, \PhpParser\Node\Stmt\Class_ $class)
     {
         if ($node instanceof \PhpParser\Node\Stmt\Namespace_) {
             return new \PhpParser\Node\Stmt\Namespace_($node->name, [$class]);

rules/TypeDeclaration/ChildPopulator/ChildParamPopulator.php

@@ -3,7 +3,6 @@
 declare (strict_types=1);
 namespace Rector\TypeDeclaration\ChildPopulator;
 
-use PhpParser\Node\FunctionLike;
 use PhpParser\Node\Stmt\Class_;
 use PhpParser\Node\Stmt\ClassLike;
 use PhpParser\Node\Stmt\ClassMethod;
@@ -42,9 +41,9 @@ final class ChildParamPopulator
     }
     /**
      * Add typehint to all children
-     * @param ClassMethod|Function_ $functionLike
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
      */
-    public function populateChildClassMethod(\PhpParser\Node\FunctionLike $functionLike, int $position, \PHPStan\Type\Type $paramType) : void
+    public function populateChildClassMethod($functionLike, int $position, \PHPStan\Type\Type $paramType) : void
     {
         if (!$functionLike instanceof \PhpParser\Node\Stmt\ClassMethod) {
             return;

rules/TypeDeclaration/PhpDocParser/NonInformativeReturnTagRemover.php

@@ -3,7 +3,6 @@
 declare (strict_types=1);
 namespace Rector\TypeDeclaration\PhpDocParser;
 
-use PhpParser\Node\FunctionLike;
 use PhpParser\Node\Stmt\ClassMethod;
 use PhpParser\Node\Stmt\Function_;
 use PHPStan\PhpDocParser\Ast\PhpDoc\ReturnTagValueNode;
@@ -49,9 +48,9 @@ final class NonInformativeReturnTagRemover
         $this->typeChecker = $typeChecker;
     }
     /**
-     * @param ClassMethod|Function_ $functionLike
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
      */
-    public function removeReturnTagIfNotUseful(\PhpParser\Node\FunctionLike $functionLike) : void
+    public function removeReturnTagIfNotUseful($functionLike) : void
     {
         $phpDocInfo = $this->phpDocInfoFactory->createFromNodeOrEmpty($functionLike);
         $returnTagValueNode = $phpDocInfo->getReturnTagValue();

rules/TypeDeclaration/PhpParserTypeAnalyzer.php

@@ -20,10 +20,10 @@ final class PhpParserTypeAnalyzer
         $this->staticTypeMapper = $staticTypeMapper;
     }
     /**
-     * @param Name|NullableType|UnionType|Identifier $possibleSubtype
+     * @param \PhpParser\Node\Name|\PhpParser\Node\NullableType|\PhpParser\Node\UnionType|\PhpParser\Node\Identifier $possibleSubtype
-     * @param Name|NullableType|UnionType|Identifier $possibleParentType
+     * @param \PhpParser\Node\Name|\PhpParser\Node\NullableType|\PhpParser\Node\UnionType|\PhpParser\Node\Identifier $possibleParentType
      */
-    public function isCovariantSubtypeOf(\PhpParser\Node $possibleSubtype, \PhpParser\Node $possibleParentType) : bool
+    public function isCovariantSubtypeOf($possibleSubtype, $possibleParentType) : bool
     {
         // skip until PHP 8 is out
         if ($this->isUnionType($possibleSubtype, $possibleParentType)) {

rules/TypeDeclaration/Rector/ClassMethod/ReturnNeverTypeRector.php

@@ -5,7 +5,6 @@ namespace Rector\TypeDeclaration\Rector\ClassMethod;
 
 use PhpParser\Node;
 use PhpParser\Node\Expr\Yield_;
-use PhpParser\Node\FunctionLike;
 use PhpParser\Node\Name;
 use PhpParser\Node\Stmt;
 use PhpParser\Node\Stmt\ClassMethod;
@@ -114,9 +113,9 @@ CODE_SAMPLE
         return $node->returnType && $this->isName($node->returnType, 'never');
     }
     /**
-     * @param ClassMethod|Function_ $functionLike
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
      */
-    private function resolveHasNeverFuncCall(\PhpParser\Node\FunctionLike $functionLike) : bool
+    private function resolveHasNeverFuncCall($functionLike) : bool
     {
         $hasNeverType = \false;
         foreach ((array) $functionLike->stmts as $stmt) {

rules/TypeDeclaration/Rector/ClassMethod/ReturnTypeFromStrictTypedCallRector.php

@@ -110,10 +110,10 @@ CODE_SAMPLE
         return null;
     }
     /**
-     * @param ClassMethod|Function_|Closure $node
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_|\PhpParser\Node\Expr\Closure $node
      * @return \PhpParser\Node\Expr\Closure|\PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_
      */
-    private function processSingleUnionType(\PhpParser\Node $node, \PHPStan\Type\UnionType $unionType, \PhpParser\Node\NullableType $nullableType)
+    private function processSingleUnionType($node, \PHPStan\Type\UnionType $unionType, \PhpParser\Node\NullableType $nullableType)
     {
         $types = $unionType->getTypes();
         $returnType = $types[0] instanceof \PHPStan\Type\ObjectType && $types[1] instanceof \PHPStan\Type\NullType ? new \PhpParser\Node\NullableType(new \PhpParser\Node\Name\FullyQualified($types[0]->getClassName())) : $nullableType;

rules/TypeDeclaration/Rector/FunctionLike/ParamTypeDeclarationRector.php

@@ -141,9 +141,9 @@ CODE_SAMPLE
         return null;
     }
     /**
-     * @param ClassMethod|Function_ $functionLike
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
      */
-    private function refactorParam(\PhpParser\Node\Param $param, \PhpParser\Node\FunctionLike $functionLike, int $position) : void
+    private function refactorParam(\PhpParser\Node\Param $param, $functionLike, int $position) : void
     {
         if ($this->shouldSkipParam($param, $functionLike)) {
             return;

rules/TypeDeclaration/Rector/FunctionLike/ReturnTypeDeclarationRector.php

@@ -139,9 +139,9 @@ CODE_SAMPLE
         return $this->processType($node, $inferedReturnType);
     }
     /**
-     * @param ClassMethod|Function_ $node
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $node
      */
-    private function processType(\PhpParser\Node $node, \PHPStan\Type\Type $inferedType) : ?\PhpParser\Node
+    private function processType($node, \PHPStan\Type\Type $inferedType) : ?\PhpParser\Node
     {
         $inferredReturnNode = $this->staticTypeMapper->mapPHPStanTypeToPhpParserNode($inferedType, \Rector\PHPStanStaticTypeMapper\ValueObject\TypeKind::KIND_RETURN);
         // nothing to change in PHP code
@@ -171,9 +171,9 @@ CODE_SAMPLE
         return $this->vendorLockResolver->isReturnChangeVendorLockedIn($classMethod);
     }
     /**
-     * @param ClassMethod|Function_ $functionLike
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
      */
-    private function shouldSkipInferredReturnNode(\PhpParser\Node\FunctionLike $functionLike) : bool
+    private function shouldSkipInferredReturnNode($functionLike) : bool
     {
         // already overridden by previous populateChild() method run
         if ($functionLike->returnType === null) {
@@ -182,9 +182,9 @@ CODE_SAMPLE
         return (bool) $functionLike->returnType->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::DO_NOT_CHANGE);
     }
     /**
-     * @param ClassMethod|Function_ $functionLike
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
      */
-    private function shouldSkipExistingReturnType(\PhpParser\Node\FunctionLike $functionLike, \PHPStan\Type\Type $inferedType) : bool
+    private function shouldSkipExistingReturnType($functionLike, \PHPStan\Type\Type $inferedType) : bool
     {
         if ($functionLike->returnType === null) {
             return \false;
@@ -199,10 +199,10 @@ CODE_SAMPLE
         return $this->isNullableTypeSubType($currentType, $inferedType);
     }
     /**
-     * @param ClassMethod|Function_ $functionLike
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
-     * @param Name|NullableType|PhpParserUnionType $inferredReturnNode
+     * @param \PhpParser\Node\Name|\PhpParser\Node\NullableType|PhpParserUnionType $inferredReturnNode
      */
-    private function addReturnType(\PhpParser\Node\FunctionLike $functionLike, \PhpParser\Node $inferredReturnNode) : void
+    private function addReturnType($functionLike, $inferredReturnNode) : void
     {
         if ($this->isExternalVoid($functionLike, $inferredReturnNode)) {
             return;
@@ -222,10 +222,10 @@ CODE_SAMPLE
         }
     }
     /**
-     * @param ClassMethod|Function_ $functionLike
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
-     * @param Name|NullableType|PhpParserUnionType $inferredReturnNode
+     * @param \PhpParser\Node\Name|\PhpParser\Node\NullableType|PhpParserUnionType $inferredReturnNode
      */
-    private function isExternalVoid(\PhpParser\Node\FunctionLike $functionLike, \PhpParser\Node $inferredReturnNode) : bool
+    private function isExternalVoid($functionLike, $inferredReturnNode) : bool
     {
         $classLike = $functionLike->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::CLASS_NODE);
         if (!$classLike instanceof \PhpParser\Node\Stmt\Class_) {

rules/TypeDeclaration/TypeAlreadyAddedChecker/ReturnTypeAlreadyAddedChecker.php

@@ -4,8 +4,6 @@ declare (strict_types=1);
 namespace Rector\TypeDeclaration\TypeAlreadyAddedChecker;
 
 use Iterator;
-use PhpParser\Node;
-use PhpParser\Node\FunctionLike;
 use PhpParser\Node\Identifier;
 use PhpParser\Node\Name;
 use PhpParser\Node\NullableType;
@@ -51,9 +49,9 @@ final class ReturnTypeAlreadyAddedChecker
         $this->nodeComparator = $nodeComparator;
     }
     /**
-     * @param ClassMethod|Function_ $functionLike
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Stmt\Function_ $functionLike
      */
-    public function isSameOrBetterReturnTypeAlreadyAdded(\PhpParser\Node\FunctionLike $functionLike, \PHPStan\Type\Type $returnType) : bool
+    public function isSameOrBetterReturnTypeAlreadyAdded($functionLike, \PHPStan\Type\Type $returnType) : bool
     {
         $nodeReturnType = $functionLike->returnType;
         /** @param Identifier|Name|NullableType|PhpParserUnionType|null $returnTypeNode */
@@ -92,9 +90,9 @@ final class ReturnTypeAlreadyAddedChecker
         return $nodeContentWithoutPreslash === $className;
     }
     /**
-     * @param Identifier|Name|NullableType|PhpParserUnionType $returnTypeNode
+     * @param \PhpParser\Node\Identifier|\PhpParser\Node\Name|\PhpParser\Node\NullableType|PhpParserUnionType $returnTypeNode
      */
-    private function isArrayIterableIteratorCoType(\PhpParser\Node $returnTypeNode, \PHPStan\Type\Type $returnType) : bool
+    private function isArrayIterableIteratorCoType($returnTypeNode, \PHPStan\Type\Type $returnType) : bool
     {
         if (!$this->nodeNameResolver->isNames($returnTypeNode, self::FOREACHABLE_TYPES)) {
             return \false;
@@ -102,9 +100,9 @@ final class ReturnTypeAlreadyAddedChecker
         return $this->isStaticTypeIterable($returnType);
     }
     /**
-     * @param Identifier|Name|NullableType|PhpParserUnionType $returnTypeNode
+     * @param \PhpParser\Node\Identifier|\PhpParser\Node\Name|\PhpParser\Node\NullableType|PhpParserUnionType $returnTypeNode
      */
-    private function isUnionCoType(\PhpParser\Node $returnTypeNode, \PHPStan\Type\Type $type) : bool
+    private function isUnionCoType($returnTypeNode, \PHPStan\Type\Type $type) : bool
     {
         if (!$type instanceof \PHPStan\Type\UnionType) {
             return \false;

rules/TypeDeclaration/TypeInferer/SilentVoidResolver.php

@@ -5,7 +5,6 @@ namespace Rector\TypeDeclaration\TypeInferer;
 
 use PhpParser\Node\Expr\Closure;
 use PhpParser\Node\Expr\Yield_;
-use PhpParser\Node\FunctionLike;
 use PhpParser\Node\Stmt;
 use PhpParser\Node\Stmt\Class_;
 use PhpParser\Node\Stmt\ClassMethod;
@@ -66,9 +65,9 @@ final class SilentVoidResolver
         return \true;
     }
     /**
-     * @param ClassMethod|Closure|Function_ $functionLike
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Expr\Closure|\PhpParser\Node\Stmt\Function_ $functionLike
      */
-    public function hasSilentVoid(\PhpParser\Node\FunctionLike $functionLike) : bool
+    public function hasSilentVoid($functionLike) : bool
     {
         if ($this->hasStmtsAlwaysReturn((array) $functionLike->stmts)) {
             return \false;
@@ -132,9 +131,9 @@ final class SilentVoidResolver
     }
     /**
      * @see https://phpstan.org/writing-php-code/phpdoc-types#bottom-type
-     * @param ClassMethod|Closure|Function_ $functionLike
+     * @param \PhpParser\Node\Stmt\ClassMethod|\PhpParser\Node\Expr\Closure|\PhpParser\Node\Stmt\Function_ $functionLike
      */
-    private function hasNeverType(\PhpParser\Node\FunctionLike $functionLike) : bool
+    private function hasNeverType($functionLike) : bool
     {
         return $this->betterNodeFinder->hasInstancesOf($functionLike, [\PhpParser\Node\Stmt\Throw_::class]);
     }

src/Application/VersionResolver.php

@@ -16,11 +16,11 @@ final class VersionResolver
     /**
      * @var string
      */
-    public const PACKAGE_VERSION = '2a394c750f518a33d56a0aa80fa2addf6ff1c140';
+    public const PACKAGE_VERSION = 'dfd048342b88db3c2adcf20ec701a9fd9a4e2319';
     /**
      * @var string
      */
-    public const RELEASE_DATE = '2021-06-29 15:25:57';
+    public const RELEASE_DATE = '2021-06-29 16:11:40';
     public static function resolvePackageVersion() : string
     {
         $process = new \RectorPrefix20210629\Symfony\Component\Process\Process(['git', 'log', '--pretty="%H"', '-n1', 'HEAD'], __DIR__);

src/NodeAnalyzer/PropertyFetchAnalyzer.php

@@ -4,7 +4,6 @@ declare (strict_types=1);
 namespace Rector\Core\NodeAnalyzer;
 
 use PhpParser\Node;
-use PhpParser\Node\Expr;
 use PhpParser\Node\Expr\Assign;
 use PhpParser\Node\Expr\MethodCall;
 use PhpParser\Node\Expr\PropertyFetch;
@@ -71,9 +70,9 @@ final class PropertyFetchAnalyzer
         });
     }
     /**
-     * @param PropertyFetch|StaticPropertyFetch $expr
+     * @param \PhpParser\Node\Expr\PropertyFetch|\PhpParser\Node\Expr\StaticPropertyFetch $expr
      */
-    public function isPropertyToSelf(\PhpParser\Node\Expr $expr) : bool
+    public function isPropertyToSelf($expr) : bool
     {
         if ($expr instanceof \PhpParser\Node\Expr\PropertyFetch && !$this->nodeNameResolver->isName($expr->var, 'this')) {
             return \false;

src/NodeManipulator/ClassInsertManipulator.php

@@ -34,9 +34,9 @@ final class ClassInsertManipulator
         $this->nodeNameResolver = $nodeNameResolver;
     }
     /**
-     * @param ClassMethod|Property|ClassConst|ClassMethod $stmt
+     * @param \PhpParser\Node\Stmt\Property|\PhpParser\Node\Stmt\ClassConst|\PhpParser\Node\Stmt\ClassMethod $stmt
      */
-    public function addAsFirstMethod(\PhpParser\Node\Stmt\Class_ $class, \PhpParser\Node\Stmt $stmt) : void
+    public function addAsFirstMethod(\PhpParser\Node\Stmt\Class_ $class, $stmt) : void
     {
         if ($this->isSuccessToInsertBeforeFirstMethod($class, $stmt)) {
             return;

src/NodeManipulator/ClassManipulator.php

@@ -6,7 +6,6 @@ namespace Rector\Core\NodeManipulator;
 use PhpParser\Node\Name;
 use PhpParser\Node\Name\FullyQualified;
 use PhpParser\Node\Stmt\Class_;
-use PhpParser\Node\Stmt\ClassLike;
 use PhpParser\Node\Stmt\Interface_;
 use PhpParser\Node\Stmt\Property;
 use PhpParser\Node\Stmt\Trait_;
@@ -36,10 +35,10 @@ final class ClassManipulator
     }
     /**
      * @deprecated
-     * @param Class_|Trait_ $classLike
      * @return array<string, Name>
+     * @param \PhpParser\Node\Stmt\Class_|\PhpParser\Node\Stmt\Trait_ $classLike
      */
-    public function getUsedTraits(\PhpParser\Node\Stmt\ClassLike $classLike) : array
+    public function getUsedTraits($classLike) : array
     {
         $usedTraits = [];
         foreach ($classLike->getTraitUses() as $traitUse) {
@@ -111,10 +110,10 @@ final class ClassManipulator
         }
     }
     /**
-     * @param Class_|Interface_ $classLike
      * @return string[]
+     * @param \PhpParser\Node\Stmt\Class_|\PhpParser\Node\Stmt\Interface_ $classLike
      */
-    public function getClassLikeNodeParentInterfaceNames(\PhpParser\Node\Stmt\ClassLike $classLike) : array
+    public function getClassLikeNodeParentInterfaceNames($classLike) : array
     {
         if ($classLike instanceof \PhpParser\Node\Stmt\Class_) {
             return $this->nodeNameResolver->getNames($classLike->implements);

src/NodeManipulator/MagicPropertyFetchAnalyzer.php

@@ -4,7 +4,6 @@ declare (strict_types=1);
 namespace Rector\Core\NodeManipulator;
 
 use PhpParser\Node;
-use PhpParser\Node\Expr;
 use PhpParser\Node\Expr\PropertyFetch;
 use PhpParser\Node\Expr\StaticPropertyFetch;
 use PHPStan\Analyser\Scope;
@@ -42,9 +41,9 @@ final class MagicPropertyFetchAnalyzer
         $this->reflectionProvider = $reflectionProvider;
     }
     /**
-     * @param PropertyFetch|Node\Expr\StaticPropertyFetch $expr
+     * @param \PhpParser\Node\Expr\PropertyFetch|\PhpParser\Node\Expr\StaticPropertyFetch $expr
      */
-    public function isMagicOnType(\PhpParser\Node\Expr $expr, \PHPStan\Type\Type $type) : bool
+    public function isMagicOnType($expr, \PHPStan\Type\Type $type) : bool
     {
         $varNodeType = $this->nodeTypeResolver->resolve($expr);
         if ($varNodeType instanceof \PHPStan\Type\ErrorType) {
@@ -63,9 +62,9 @@ final class MagicPropertyFetchAnalyzer
         return !$this->hasPublicProperty($expr, $nodeName);
     }
     /**
-     * @param PropertyFetch|StaticPropertyFetch $expr
+     * @param \PhpParser\Node\Expr\PropertyFetch|\PhpParser\Node\Expr\StaticPropertyFetch $expr
      */
-    private function hasPublicProperty(\PhpParser\Node\Expr $expr, string $propertyName) : bool
+    private function hasPublicProperty($expr, string $propertyName) : bool
     {
         $scope = $expr->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::SCOPE);
         if (!$scope instanceof \PHPStan\Analyser\Scope) {

src/NodeManipulator/PropertyManipulator.php

@@ -109,9 +109,9 @@ final class PropertyManipulator
         return \false;
     }
     /**
-     * @param PropertyFetch|StaticPropertyFetch $expr
+     * @param \PhpParser\Node\Expr\PropertyFetch|\PhpParser\Node\Expr\StaticPropertyFetch $expr
      */
-    private function isChangeableContext(\PhpParser\Node\Expr $expr) : bool
+    private function isChangeableContext($expr) : bool
     {
         $parent = $expr->getAttribute(\Rector\NodeTypeResolver\Node\AttributeKey::PARENT_NODE);
         if (!$parent instanceof \PhpParser\Node) {

vendor/autoload.php

@@ -4,4 +4,4 @@
 
 require_once __DIR__ . '/composer/autoload_real.php';
 
-return ComposerAutoloaderInit21b95b602ec0f7bd9066f339873ca708::getLoader();
+return ComposerAutoloaderInitfb379d69a16f3d9bc4af0d6d72567f2a::getLoader();

vendor/composer/autoload_real.php

@@ -2,7 +2,7 @@
 
 // autoload_real.php @generated by Composer
 
-class ComposerAutoloaderInit21b95b602ec0f7bd9066f339873ca708
+class ComposerAutoloaderInitfb379d69a16f3d9bc4af0d6d72567f2a
 {
     private static $loader;
 
@@ -22,15 +22,15 @@ class ComposerAutoloaderInit21b95b602ec0f7bd9066f339873ca708
             return self::$loader;
         }
 
-        spl_autoload_register(array('ComposerAutoloaderInit21b95b602ec0f7bd9066f339873ca708', 'loadClassLoader'), true, true);
+        spl_autoload_register(array('ComposerAutoloaderInitfb379d69a16f3d9bc4af0d6d72567f2a', 'loadClassLoader'), true, true);
         self::$loader = $loader = new \Composer\Autoload\ClassLoader(\dirname(\dirname(__FILE__)));
-        spl_autoload_unregister(array('ComposerAutoloaderInit21b95b602ec0f7bd9066f339873ca708', 'loadClassLoader'));
+        spl_autoload_unregister(array('ComposerAutoloaderInitfb379d69a16f3d9bc4af0d6d72567f2a', 'loadClassLoader'));
 
         $useStaticLoader = PHP_VERSION_ID >= 50600 && !defined('HHVM_VERSION') && (!function_exists('zend_loader_file_encoded') || !zend_loader_file_encoded());
         if ($useStaticLoader) {
             require __DIR__ . '/autoload_static.php';
 
-            call_user_func(\Composer\Autoload\ComposerStaticInit21b95b602ec0f7bd9066f339873ca708::getInitializer($loader));
+            call_user_func(\Composer\Autoload\ComposerStaticInitfb379d69a16f3d9bc4af0d6d72567f2a::getInitializer($loader));
         } else {
             $classMap = require __DIR__ . '/autoload_classmap.php';
             if ($classMap) {
@@ -42,19 +42,19 @@ class ComposerAutoloaderInit21b95b602ec0f7bd9066f339873ca708
         $loader->register(true);
 
         if ($useStaticLoader) {
-            $includeFiles = Composer\Autoload\ComposerStaticInit21b95b602ec0f7bd9066f339873ca708::$files;
+            $includeFiles = Composer\Autoload\ComposerStaticInitfb379d69a16f3d9bc4af0d6d72567f2a::$files;
         } else {
             $includeFiles = require __DIR__ . '/autoload_files.php';
         }
         foreach ($includeFiles as $fileIdentifier => $file) {
-            composerRequire21b95b602ec0f7bd9066f339873ca708($fileIdentifier, $file);
+            composerRequirefb379d69a16f3d9bc4af0d6d72567f2a($fileIdentifier, $file);
         }
 
         return $loader;
     }
 }
 
-function composerRequire21b95b602ec0f7bd9066f339873ca708($fileIdentifier, $file)
+function composerRequirefb379d69a16f3d9bc4af0d6d72567f2a($fileIdentifier, $file)
 {
     if (empty($GLOBALS['__composer_autoload_files'][$fileIdentifier])) {
         require $file;

vendor/composer/autoload_static.php

@@ -4,7 +4,7 @@
 
 namespace Composer\Autoload;
 
-class ComposerStaticInit21b95b602ec0f7bd9066f339873ca708
+class ComposerStaticInitfb379d69a16f3d9bc4af0d6d72567f2a
 {
     public static $files = array (
         'a4a119a56e50fbb293281d9a48007e0e' => __DIR__ . '/..' . '/symfony/polyfill-php80/bootstrap.php',
@@ -3838,9 +3838,9 @@ class ComposerStaticInit21b95b602ec0f7bd9066f339873ca708
     public static function getInitializer(ClassLoader $loader)
     {
         return \Closure::bind(function () use ($loader) {
-            $loader->prefixLengthsPsr4 = ComposerStaticInit21b95b602ec0f7bd9066f339873ca708::$prefixLengthsPsr4;
+            $loader->prefixLengthsPsr4 = ComposerStaticInitfb379d69a16f3d9bc4af0d6d72567f2a::$prefixLengthsPsr4;
-            $loader->prefixDirsPsr4 = ComposerStaticInit21b95b602ec0f7bd9066f339873ca708::$prefixDirsPsr4;
+            $loader->prefixDirsPsr4 = ComposerStaticInitfb379d69a16f3d9bc4af0d6d72567f2a::$prefixDirsPsr4;
-            $loader->classMap = ComposerStaticInit21b95b602ec0f7bd9066f339873ca708::$classMap;
+            $loader->classMap = ComposerStaticInitfb379d69a16f3d9bc4af0d6d72567f2a::$classMap;
 
         }, null, ClassLoader::class);
     }

vendor/scoper-autoload.php

@@ -21,8 +21,8 @@ if (!class_exists('SomeTestCase', false) && !interface_exists('SomeTestCase', fa
 if (!class_exists('CheckoutEntityFactory', false) && !interface_exists('CheckoutEntityFactory', false) && !trait_exists('CheckoutEntityFactory', false)) {
     spl_autoload_call('RectorPrefix20210629\CheckoutEntityFactory');
 }
-if (!class_exists('ComposerAutoloaderInit21b95b602ec0f7bd9066f339873ca708', false) && !interface_exists('ComposerAutoloaderInit21b95b602ec0f7bd9066f339873ca708', false) && !trait_exists('ComposerAutoloaderInit21b95b602ec0f7bd9066f339873ca708', false)) {
+if (!class_exists('ComposerAutoloaderInitfb379d69a16f3d9bc4af0d6d72567f2a', false) && !interface_exists('ComposerAutoloaderInitfb379d69a16f3d9bc4af0d6d72567f2a', false) && !trait_exists('ComposerAutoloaderInitfb379d69a16f3d9bc4af0d6d72567f2a', false)) {
-    spl_autoload_call('RectorPrefix20210629\ComposerAutoloaderInit21b95b602ec0f7bd9066f339873ca708');
+    spl_autoload_call('RectorPrefix20210629\ComposerAutoloaderInitfb379d69a16f3d9bc4af0d6d72567f2a');
 }
 if (!class_exists('Doctrine\Inflector\Inflector', false) && !interface_exists('Doctrine\Inflector\Inflector', false) && !trait_exists('Doctrine\Inflector\Inflector', false)) {
     spl_autoload_call('RectorPrefix20210629\Doctrine\Inflector\Inflector');
@@ -3320,9 +3320,9 @@ if (!function_exists('print_node')) {
         return \RectorPrefix20210629\print_node(...func_get_args());
     }
 }
-if (!function_exists('composerRequire21b95b602ec0f7bd9066f339873ca708')) {
+if (!function_exists('composerRequirefb379d69a16f3d9bc4af0d6d72567f2a')) {
-    function composerRequire21b95b602ec0f7bd9066f339873ca708() {
+    function composerRequirefb379d69a16f3d9bc4af0d6d72567f2a() {
-        return \RectorPrefix20210629\composerRequire21b95b602ec0f7bd9066f339873ca708(...func_get_args());
+        return \RectorPrefix20210629\composerRequirefb379d69a16f3d9bc4af0d6d72567f2a(...func_get_args());
     }
 }
 if (!function_exists('parseArgs')) {